diff --git a/.buildkite/run-repository.sh b/.buildkite/run-repository.sh
index ce9344e8d..04d4440f0 100755
--- a/.buildkite/run-repository.sh
+++ b/.buildkite/run-repository.sh
@@ -21,6 +21,7 @@ echo -e "\033[34;1mINFO:\033[0m TEST_SUITE ${TEST_SUITE}\033[0m"
 echo -e "\033[34;1mINFO:\033[0m NOX_SESSION ${NOX_SESSION}\033[0m"
 echo -e "\033[34;1mINFO:\033[0m PYTHON_VERSION ${PYTHON_VERSION}\033[0m"
 echo -e "\033[34;1mINFO:\033[0m PYTHON_CONNECTION_CLASS ${PYTHON_CONNECTION_CLASS}\033[0m"
+echo -e "\033[34;1mINFO:\033[0m ES_YAML_TESTS_BRANCH ${ES_YAML_TESTS_BRANCH}\033[0m"
 
 echo -e "\033[1m>>>>> Build [elastic/elasticsearch-py container] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>\033[0m"
 
@@ -42,6 +43,7 @@ docker run \
   --env "ELASTICSEARCH_URL=${elasticsearch_url}" \
   --env "TEST_SUITE=${TEST_SUITE}" \
   --env "PYTHON_CONNECTION_CLASS=${PYTHON_CONNECTION_CLASS}" \
+  --env "ES_YAML_TESTS_BRANCH=${ES_YAML_TESTS_BRANCH}" \
   --env "TEST_TYPE=server" \
   --env "FORCE_COLOR=1" \
   --name elasticsearch-py \
diff --git a/.buildkite/run-tests b/.buildkite/run-tests
index 5d6b38039..c1b8f4733 100755
--- a/.buildkite/run-tests
+++ b/.buildkite/run-tests
@@ -9,6 +9,10 @@ export STACK_VERSION="${STACK_VERSION:=8.0.0-SNAPSHOT}"
 export TEST_SUITE="${TEST_SUITE:=platinum}"
 export PYTHON_VERSION="${PYTHON_VERSION:=3.13}"
 export PYTHON_CONNECTION_CLASS="${PYTHON_CONNECTION_CLASS:=urllib3}"
+export ES_YAML_TESTS_BRANCH="${BUILDKITE_PULL_REQUEST_BASE_BRANCH}"
+if [[ ! -n "$ES_YAML_TESTS_BRANCH" ]]; then
+    export ES_YAML_TESTS_BRANCH="${BUILDKITE_BRANCH}"
+fi
 
 script_path=$(dirname $(realpath -s $0))
 source $script_path/functions/imports.sh
diff --git a/.github/make.sh b/.github/make.sh
index 79d785957..4a363e524 100755
--- a/.github/make.sh
+++ b/.github/make.sh
@@ -11,12 +11,13 @@
 #
 # Targets:
 # ---------------------------
-# assemble <VERSION> : build client artefacts with version
-# bump     <VERSION> : bump client internals to version
-# codegen  <VERSION> : generate endpoints
-# docsgen  <VERSION> : generate documentation
-# examplegen         : generate the doc examples
-# clean              : clean workspace
+# assemble <VERSION>   : build client artefacts with version
+# bump     <VERSION>   : bump client internals to version
+# bumpmatrix <VERSION> : bump stack version in test matrix to version
+# codegen  <VERSION>   : generate endpoints
+# docsgen  <VERSION>   : generate documentation
+# examplegen           : generate the doc examples
+# clean                : clean workspace
 #
 # ------------------------------------------------------- #
 
@@ -24,7 +25,7 @@
 # Bootstrap
 # ------------------------------------------------------- #
 
-script_path=$(dirname "$(realpath -s "$0")")
+script_path=$(dirname "$(realpath "$0")")
 repo=$(realpath "$script_path/../")
 
 # shellcheck disable=SC1090
@@ -100,6 +101,15 @@ case $CMD in
         # VERSION is BRANCH here for now
         TASK_ARGS=("$VERSION")
         ;;
+    bumpmatrix)
+        if [ -v $VERSION ]; then
+            echo -e "\033[31;1mTARGET: bumpmatrix -> missing version parameter\033[0m"
+            exit 1
+        fi
+        echo -e "\033[36;1mTARGET: bump stack in test matrix to version $VERSION\033[0m"
+        TASK=bumpmatrix
+        TASK_ARGS=("$VERSION")
+        ;;
     *)
         echo -e "\nUsage:\n\t $CMD is not supported right now\n"
         exit 1
@@ -160,6 +170,13 @@ if [[ "$CMD" == "bump" ]]; then
   exit 0
 fi
 
+if [[ "$CMD" == "bumpmatrix" ]]; then
+  TEST_CONFIG_FILE=.buildkite/pipeline.yml
+  sed -E -i.bak 's/[0-9]+\.[0-9]+\.[0-9]+-SNAPSHOT/'$VERSION'/g' $TEST_CONFIG_FILE
+  rm ${TEST_CONFIG_FILE}.bak
+  exit 0
+fi
+
 if [[ "$CMD" == "codegen" ]]; then
   docker run \
      --rm -v $repo:/code/elasticsearch-py \
diff --git a/.github/workflows/docs-preview.yml b/.github/workflows/docs-preview.yml
deleted file mode 100644
index 40d7b7208..000000000
--- a/.github/workflows/docs-preview.yml
+++ /dev/null
@@ -1,20 +0,0 @@
----
-name: docs-preview
-
-on:
-  pull_request_target:
-    types: [opened]
-
-permissions:
-  pull-requests: write
-
-jobs:
-  doc-preview-pr:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: elastic/docs/.github/actions/docs-preview@master
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          repo: ${{ github.event.repository.name }}
-          preview-path: 'guide/en/elasticsearch/client/python-api/index.html'
-          pr: ${{ github.event.pull_request.number }}
diff --git a/CHANGELOG.md b/CHANGELOG.md
index fb156ae2a..df468b466 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1 +1 @@
-See: https://www.elastic.co/guide/en/elasticsearch/client/python-api/master/release-notes.html
+See: https://www.elastic.co/guide/en/elasticsearch/client/python-api/current/release-notes.html
diff --git a/README.md b/README.md
index eb242a90c..11d1b8259 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,5 @@
 <p align="center">
-    <img src="https://github.com/elastic/elasticsearch-py/raw/main/docs/logo-elastic-glyph-color.svg" width="20%" alt="Elastic logo" />
+    <img src="https://github.com/elastic/elasticsearch-py/raw/main/docs/images/logo-elastic-glyph-color.svg" width="20%" alt="Elastic logo" />
 </p>
 
 # Elasticsearch Python Client
@@ -63,24 +63,23 @@ of the getting started documentation.
 
 ## Compatibility
 
-Language clients are forward compatible; meaning that the clients support
-communicating with greater or equal minor versions of Elasticsearch without
-breaking. It does not mean that the clients automatically support new features
-of newer Elasticsearch versions; it is only possible after a release of a new
-client version. For example, a 8.12 client version won't automatically support
-the new features of the 8.13 version of Elasticsearch, the 8.13 client version
-is required for that. Elasticsearch language clients are only backwards
-compatible with default distributions and without guarantees made.
+Language clients are _forward compatible:_ each client version works with equivalent and later minor versions of Elasticsearch without breaking.
 
-| Elasticsearch Version | Elasticsearch-Python Branch | Supported |
-| --------------------- | ------------------------ | --------- |
-| main                  | main                     |           |
-| 8.x                   | 8.x                      | 8.x       |
-| 7.x                   | 7.x                      | 7.17      |
+Compatibility does not imply full feature parity. New Elasticsearch features are supported only in equivalent client versions. For example, an 8.12 client fully supports Elasticsearch 8.12 features and works with 8.13 without breaking; however, it does not support new Elasticsearch 8.13 features. An 8.13 client fully supports Elasticsearch 8.13 features.
 
+| Elasticsearch version | elasticsearch-py branch |
+| --- | --- |
+| main | main |
+| 9.x | 9.x |
+| 9.x | 8.x |
+| 8.x | 8.x |
 
-If you have a need to have multiple versions installed at the same time older
-versions are also released as ``elasticsearch7`` and ``elasticsearch8``.
+Elasticsearch language clients are also _backward compatible_ across minor versions &mdash; with default distributions and without guarantees.
+
+> [!TIP]
+> To upgrade to a new major version, first upgrade Elasticsearch, then upgrade the Python Elasticsearch client.
+
+If you need to work with multiple client versions, note that older versions are also released as `elasticsearch7` and `elasticsearch8`.
 
 
 ## Documentation
diff --git a/docs/docset.yml b/docs/docset.yml
index 882aea405..b4185d296 100644
--- a/docs/docset.yml
+++ b/docs/docset.yml
@@ -7,482 +7,4 @@ toc:
   - toc: reference
   - toc: release-notes
 subs:
-  ref:   "https://www.elastic.co/guide/en/elasticsearch/reference/current"
-  ref-bare:   "https://www.elastic.co/guide/en/elasticsearch/reference"
-  ref-8x:   "https://www.elastic.co/guide/en/elasticsearch/reference/8.1"
-  ref-80:   "https://www.elastic.co/guide/en/elasticsearch/reference/8.0"
-  ref-7x:   "https://www.elastic.co/guide/en/elasticsearch/reference/7.17"
-  ref-70:   "https://www.elastic.co/guide/en/elasticsearch/reference/7.0"
-  ref-60:   "https://www.elastic.co/guide/en/elasticsearch/reference/6.0"
-  ref-64:   "https://www.elastic.co/guide/en/elasticsearch/reference/6.4"
-  xpack-ref:   "https://www.elastic.co/guide/en/x-pack/6.2"
-  logstash-ref:   "https://www.elastic.co/guide/en/logstash/current"
-  kibana-ref:   "https://www.elastic.co/guide/en/kibana/current"
-  kibana-ref-all:   "https://www.elastic.co/guide/en/kibana"
-  beats-ref-root:   "https://www.elastic.co/guide/en/beats"
-  beats-ref:   "https://www.elastic.co/guide/en/beats/libbeat/current"
-  beats-ref-60:   "https://www.elastic.co/guide/en/beats/libbeat/6.0"
-  beats-ref-63:   "https://www.elastic.co/guide/en/beats/libbeat/6.3"
-  beats-devguide:   "https://www.elastic.co/guide/en/beats/devguide/current"
-  auditbeat-ref:   "https://www.elastic.co/guide/en/beats/auditbeat/current"
-  packetbeat-ref:   "https://www.elastic.co/guide/en/beats/packetbeat/current"
-  metricbeat-ref:   "https://www.elastic.co/guide/en/beats/metricbeat/current"
-  filebeat-ref:   "https://www.elastic.co/guide/en/beats/filebeat/current"
-  functionbeat-ref:   "https://www.elastic.co/guide/en/beats/functionbeat/current"
-  winlogbeat-ref:   "https://www.elastic.co/guide/en/beats/winlogbeat/current"
-  heartbeat-ref:   "https://www.elastic.co/guide/en/beats/heartbeat/current"
-  journalbeat-ref:   "https://www.elastic.co/guide/en/beats/journalbeat/current"
-  ingest-guide:   "https://www.elastic.co/guide/en/ingest/current"
-  fleet-guide:   "https://www.elastic.co/guide/en/fleet/current"
-  apm-guide-ref:   "https://www.elastic.co/guide/en/apm/guide/current"
-  apm-guide-7x:   "https://www.elastic.co/guide/en/apm/guide/7.17"
-  apm-app-ref:   "https://www.elastic.co/guide/en/kibana/current"
-  apm-agents-ref:   "https://www.elastic.co/guide/en/apm/agent"
-  apm-android-ref:   "https://www.elastic.co/guide/en/apm/agent/android/current"
-  apm-py-ref:   "https://www.elastic.co/guide/en/apm/agent/python/current"
-  apm-py-ref-3x:   "https://www.elastic.co/guide/en/apm/agent/python/3.x"
-  apm-node-ref-index:   "https://www.elastic.co/guide/en/apm/agent/nodejs"
-  apm-node-ref:   "https://www.elastic.co/guide/en/apm/agent/nodejs/current"
-  apm-node-ref-1x:   "https://www.elastic.co/guide/en/apm/agent/nodejs/1.x"
-  apm-rum-ref:   "https://www.elastic.co/guide/en/apm/agent/rum-js/current"
-  apm-ruby-ref:   "https://www.elastic.co/guide/en/apm/agent/ruby/current"
-  apm-java-ref:   "https://www.elastic.co/guide/en/apm/agent/java/current"
-  apm-go-ref:   "https://www.elastic.co/guide/en/apm/agent/go/current"
-  apm-dotnet-ref:   "https://www.elastic.co/guide/en/apm/agent/dotnet/current"
-  apm-php-ref:   "https://www.elastic.co/guide/en/apm/agent/php/current"
-  apm-ios-ref:   "https://www.elastic.co/guide/en/apm/agent/swift/current"
-  apm-lambda-ref:   "https://www.elastic.co/guide/en/apm/lambda/current"
-  apm-attacher-ref:   "https://www.elastic.co/guide/en/apm/attacher/current"
-  docker-logging-ref:   "https://www.elastic.co/guide/en/beats/loggingplugin/current"
-  esf-ref:   "https://www.elastic.co/guide/en/esf/current"
-  kinesis-firehose-ref:   "https://www.elastic.co/guide/en/kinesis/%7B%7Bkinesis_version%7D%7D"
-  estc-welcome-current:   "https://www.elastic.co/guide/en/starting-with-the-elasticsearch-platform-and-its-solutions/current"
-  estc-welcome:   "https://www.elastic.co/guide/en/starting-with-the-elasticsearch-platform-and-its-solutions/current"
-  estc-welcome-all:   "https://www.elastic.co/guide/en/starting-with-the-elasticsearch-platform-and-its-solutions"
-  hadoop-ref:   "https://www.elastic.co/guide/en/elasticsearch/hadoop/current"
-  stack-ref:   "https://www.elastic.co/guide/en/elastic-stack/current"
-  stack-ref-67:   "https://www.elastic.co/guide/en/elastic-stack/6.7"
-  stack-ref-68:   "https://www.elastic.co/guide/en/elastic-stack/6.8"
-  stack-ref-70:   "https://www.elastic.co/guide/en/elastic-stack/7.0"
-  stack-ref-80:   "https://www.elastic.co/guide/en/elastic-stack/8.0"
-  stack-ov:   "https://www.elastic.co/guide/en/elastic-stack-overview/current"
-  stack-gs:   "https://www.elastic.co/guide/en/elastic-stack-get-started/current"
-  stack-gs-current:   "https://www.elastic.co/guide/en/elastic-stack-get-started/current"
-  javaclient:   "https://www.elastic.co/guide/en/elasticsearch/client/java-api/current"
-  java-api-client:   "https://www.elastic.co/guide/en/elasticsearch/client/java-api-client/current"
-  java-rest:   "https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current"
-  jsclient:   "https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current"
-  jsclient-current:   "https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current"
-  es-ruby-client:   "https://www.elastic.co/guide/en/elasticsearch/client/ruby-api/current"
-  es-dotnet-client:   "https://www.elastic.co/guide/en/elasticsearch/client/net-api/current"
-  es-php-client:   "https://www.elastic.co/guide/en/elasticsearch/client/php-api/current"
-  es-python-client:   "https://www.elastic.co/guide/en/elasticsearch/client/python-api/current"
-  defguide:   "https://www.elastic.co/guide/en/elasticsearch/guide/2.x"
-  painless:   "https://www.elastic.co/guide/en/elasticsearch/painless/current"
-  plugins:   "https://www.elastic.co/guide/en/elasticsearch/plugins/current"
-  plugins-8x:   "https://www.elastic.co/guide/en/elasticsearch/plugins/8.1"
-  plugins-7x:   "https://www.elastic.co/guide/en/elasticsearch/plugins/7.17"
-  plugins-6x:   "https://www.elastic.co/guide/en/elasticsearch/plugins/6.8"
-  glossary:   "https://www.elastic.co/guide/en/elastic-stack-glossary/current"
-  upgrade_guide:   "https://www.elastic.co/products/upgrade_guide"
-  blog-ref:   "https://www.elastic.co/blog/"
-  curator-ref:   "https://www.elastic.co/guide/en/elasticsearch/client/curator/current"
-  curator-ref-current:   "https://www.elastic.co/guide/en/elasticsearch/client/curator/current"
-  metrics-ref:   "https://www.elastic.co/guide/en/metrics/current"
-  metrics-guide:   "https://www.elastic.co/guide/en/metrics/guide/current"
-  logs-ref:   "https://www.elastic.co/guide/en/logs/current"
-  logs-guide:   "https://www.elastic.co/guide/en/logs/guide/current"
-  uptime-guide:   "https://www.elastic.co/guide/en/uptime/current"
-  observability-guide:   "https://www.elastic.co/guide/en/observability/current"
-  observability-guide-all:   "https://www.elastic.co/guide/en/observability"
-  siem-guide:   "https://www.elastic.co/guide/en/siem/guide/current"
-  security-guide:   "https://www.elastic.co/guide/en/security/current"
-  security-guide-all:   "https://www.elastic.co/guide/en/security"
-  endpoint-guide:   "https://www.elastic.co/guide/en/endpoint/current"
-  sql-odbc:   "https://www.elastic.co/guide/en/elasticsearch/sql-odbc/current"
-  ecs-ref:   "https://www.elastic.co/guide/en/ecs/current"
-  ecs-logging-ref:   "https://www.elastic.co/guide/en/ecs-logging/overview/current"
-  ecs-logging-go-logrus-ref:   "https://www.elastic.co/guide/en/ecs-logging/go-logrus/current"
-  ecs-logging-go-zap-ref:   "https://www.elastic.co/guide/en/ecs-logging/go-zap/current"
-  ecs-logging-go-zerolog-ref:   "https://www.elastic.co/guide/en/ecs-logging/go-zap/current"
-  ecs-logging-java-ref:   "https://www.elastic.co/guide/en/ecs-logging/java/current"
-  ecs-logging-dotnet-ref:   "https://www.elastic.co/guide/en/ecs-logging/dotnet/current"
-  ecs-logging-nodejs-ref:   "https://www.elastic.co/guide/en/ecs-logging/nodejs/current"
-  ecs-logging-php-ref:   "https://www.elastic.co/guide/en/ecs-logging/php/current"
-  ecs-logging-python-ref:   "https://www.elastic.co/guide/en/ecs-logging/python/current"
-  ecs-logging-ruby-ref:   "https://www.elastic.co/guide/en/ecs-logging/ruby/current"
-  ml-docs:   "https://www.elastic.co/guide/en/machine-learning/current"
-  eland-docs:   "https://www.elastic.co/guide/en/elasticsearch/client/eland/current"
-  eql-ref:   "https://eql.readthedocs.io/en/latest/query-guide"
-  extendtrial:   "https://www.elastic.co/trialextension"
-  wikipedia:   "https://en.wikipedia.org/wiki"
-  forum:   "https://discuss.elastic.co/"
-  xpack-forum:   "https://discuss.elastic.co/c/50-x-pack"
-  security-forum:   "https://discuss.elastic.co/c/x-pack/shield"
-  watcher-forum:   "https://discuss.elastic.co/c/x-pack/watcher"
-  monitoring-forum:   "https://discuss.elastic.co/c/x-pack/marvel"
-  graph-forum:   "https://discuss.elastic.co/c/x-pack/graph"
-  apm-forum:   "https://discuss.elastic.co/c/apm"
-  enterprise-search-ref:   "https://www.elastic.co/guide/en/enterprise-search/current"
-  app-search-ref:   "https://www.elastic.co/guide/en/app-search/current"
-  workplace-search-ref:   "https://www.elastic.co/guide/en/workplace-search/current"
-  enterprise-search-node-ref:   "https://www.elastic.co/guide/en/enterprise-search-clients/enterprise-search-node/current"
-  enterprise-search-php-ref:   "https://www.elastic.co/guide/en/enterprise-search-clients/php/current"
-  enterprise-search-python-ref:   "https://www.elastic.co/guide/en/enterprise-search-clients/python/current"
-  enterprise-search-ruby-ref:   "https://www.elastic.co/guide/en/enterprise-search-clients/ruby/current"
-  elastic-maps-service:   "https://maps.elastic.co/"
-  integrations-docs:   "https://docs.elastic.co/en/integrations"
-  integrations-devguide:   "https://www.elastic.co/guide/en/integrations-developer/current"
-  time-units:   "https://www.elastic.co/guide/en/elasticsearch/reference/current/api-conventions.html#time-units"
-  byte-units:   "https://www.elastic.co/guide/en/elasticsearch/reference/current/api-conventions.html#byte-units"
-  apm-py-ref-v:   "https://www.elastic.co/guide/en/apm/agent/python/current"
-  apm-node-ref-v:   "https://www.elastic.co/guide/en/apm/agent/nodejs/current"
-  apm-rum-ref-v:   "https://www.elastic.co/guide/en/apm/agent/rum-js/current"
-  apm-ruby-ref-v:   "https://www.elastic.co/guide/en/apm/agent/ruby/current"
-  apm-java-ref-v:   "https://www.elastic.co/guide/en/apm/agent/java/current"
-  apm-go-ref-v:   "https://www.elastic.co/guide/en/apm/agent/go/current"
-  apm-ios-ref-v:   "https://www.elastic.co/guide/en/apm/agent/swift/current"
-  apm-dotnet-ref-v:   "https://www.elastic.co/guide/en/apm/agent/dotnet/current"
-  apm-php-ref-v:   "https://www.elastic.co/guide/en/apm/agent/php/current"
-  ecloud:   "Elastic Cloud"
-  esf:   "Elastic Serverless Forwarder"
-  ess:   "Elasticsearch Service"
-  ece:   "Elastic Cloud Enterprise"
-  eck:   "Elastic Cloud on Kubernetes"
-  serverless-full:   "Elastic Cloud Serverless"
-  serverless-short:   "Serverless"
-  es-serverless:   "Elasticsearch Serverless"
-  es3:   "Elasticsearch Serverless"
-  obs-serverless:   "Elastic Observability Serverless"
-  sec-serverless:   "Elastic Security Serverless"
-  serverless-docs:   "https://docs.elastic.co/serverless"
-  cloud:   "https://www.elastic.co/guide/en/cloud/current"
-  ess-utm-params:   "?page=docs&placement=docs-body"
-  ess-baymax:   "?page=docs&placement=docs-body"
-  ess-trial:   "https://cloud.elastic.co/registration?page=docs&placement=docs-body"
-  ess-product:   "https://www.elastic.co/cloud/elasticsearch-service?page=docs&placement=docs-body"
-  ess-console:   "https://cloud.elastic.co/?page=docs&placement=docs-body"
-  ess-console-name:   "Elasticsearch Service Console"
-  ess-deployments:   "https://cloud.elastic.co/deployments?page=docs&placement=docs-body"
-  ece-ref:   "https://www.elastic.co/guide/en/cloud-enterprise/current"
-  eck-ref:   "https://www.elastic.co/guide/en/cloud-on-k8s/current"
-  ess-leadin:   "You can run Elasticsearch on your own hardware or use our hosted Elasticsearch Service that is available on AWS, GCP, and Azure. https://cloud.elastic.co/registration{ess-utm-params}[Try the Elasticsearch Service for free]."
-  ess-leadin-short:   "Our hosted Elasticsearch Service is available on AWS, GCP, and Azure, and you can https://cloud.elastic.co/registration{ess-utm-params}[try it for free]."
-  ess-icon:   "image:https://doc-icons.s3.us-east-2.amazonaws.com/logo_cloud.svg[link=\"https://cloud.elastic.co/registration%7Bess-utm-params%7D/", title=\"Supported on Elasticsearch Service\"]"
-  ece-icon:   "image:https://doc-icons.s3.us-east-2.amazonaws.com/logo_cloud_ece.svg[link=\"https://cloud.elastic.co/registration%7Bess-utm-params%7D/", title=\"Supported on Elastic Cloud Enterprise\"]"
-  cloud-only:   "This feature is designed for indirect use by https://cloud.elastic.co/registration{ess-utm-params}[Elasticsearch Service], https://www.elastic.co/guide/en/cloud-enterprise/{ece-version-link}[Elastic Cloud Enterprise], and https://www.elastic.co/guide/en/cloud-on-k8s/current[Elastic Cloud on Kubernetes]. Direct use is not supported."
-  ess-setting-change:   "image:https://doc-icons.s3.us-east-2.amazonaws.com/logo_cloud.svg[link=\"{ess-trial}\", title=\"Supported on {ess}\"] indicates a change to a supported https://www.elastic.co/guide/en/cloud/current/ec-add-user-settings.html[user setting] for Elasticsearch Service."
-  ess-skip-section:   "If you use Elasticsearch Service, skip this section. Elasticsearch Service handles these changes for you."
-  api-cloud:   "https://www.elastic.co/docs/api/doc/cloud"
-  api-ece:   "https://www.elastic.co/docs/api/doc/cloud-enterprise"
-  api-kibana-serverless:   "https://www.elastic.co/docs/api/doc/serverless"
-  es-feature-flag:   "This feature is in development and not yet available for use. This documentation is provided for informational purposes only."
-  es-ref-dir:   "'{{elasticsearch-root}}/docs/reference'"
-  apm-app:   "APM app"
-  uptime-app:   "Uptime app"
-  synthetics-app:   "Synthetics app"
-  logs-app:   "Logs app"
-  metrics-app:   "Metrics app"
-  infrastructure-app:   "Infrastructure app"
-  siem-app:   "SIEM app"
-  security-app:   "Elastic Security app"
-  ml-app:   "Machine Learning"
-  dev-tools-app:   "Dev Tools"
-  ingest-manager-app:   "Ingest Manager"
-  stack-manage-app:   "Stack Management"
-  stack-monitor-app:   "Stack Monitoring"
-  alerts-ui:   "Alerts and Actions"
-  rules-ui:   "Rules"
-  rac-ui:   "Rules and Connectors"
-  connectors-ui:   "Connectors"
-  connectors-feature:   "Actions and Connectors"
-  stack-rules-feature:   "Stack Rules"
-  user-experience:   "User Experience"
-  ems:   "Elastic Maps Service"
-  ems-init:   "EMS"
-  hosted-ems:   "Elastic Maps Server"
-  ipm-app:   "Index Pattern Management"
-  ingest-pipelines:   "ingest pipelines"
-  ingest-pipelines-app:   "Ingest Pipelines"
-  ingest-pipelines-cap:   "Ingest pipelines"
-  ls-pipelines:   "Logstash pipelines"
-  ls-pipelines-app:   "Logstash Pipelines"
-  maint-windows:   "maintenance windows"
-  maint-windows-app:   "Maintenance Windows"
-  maint-windows-cap:   "Maintenance windows"
-  custom-roles-app:   "Custom Roles"
-  data-source:   "data view"
-  data-sources:   "data views"
-  data-source-caps:   "Data View"
-  data-sources-caps:   "Data Views"
-  data-source-cap:   "Data view"
-  data-sources-cap:   "Data views"
-  project-settings:   "Project settings"
-  manage-app:   "Management"
-  index-manage-app:   "Index Management"
-  data-views-app:   "Data Views"
-  rules-app:   "Rules"
-  saved-objects-app:   "Saved Objects"
-  tags-app:   "Tags"
-  api-keys-app:   "API keys"
-  transforms-app:   "Transforms"
-  connectors-app:   "Connectors"
-  files-app:   "Files"
-  reports-app:   "Reports"
-  maps-app:   "Maps"
-  alerts-app:   "Alerts"
-  crawler:   "Enterprise Search web crawler"
-  ents:   "Enterprise Search"
-  app-search-crawler:   "App Search web crawler"
-  agent:   "Elastic Agent"
-  agents:   "Elastic Agents"
-  fleet:   "Fleet"
-  fleet-server:   "Fleet Server"
-  integrations-server:   "Integrations Server"
-  ingest-manager:   "Ingest Manager"
-  ingest-management:   "ingest management"
-  package-manager:   "Elastic Package Manager"
-  integrations:   "Integrations"
-  package-registry:   "Elastic Package Registry"
-  artifact-registry:   "Elastic Artifact Registry"
-  aws:   "AWS"
-  stack:   "Elastic Stack"
-  xpack:   "X-Pack"
   es:   "Elasticsearch"
-  kib:   "Kibana"
-  esms:   "Elastic Stack Monitoring Service"
-  esms-init:   "ESMS"
-  ls:   "Logstash"
-  beats:   "Beats"
-  auditbeat:   "Auditbeat"
-  filebeat:   "Filebeat"
-  heartbeat:   "Heartbeat"
-  metricbeat:   "Metricbeat"
-  packetbeat:   "Packetbeat"
-  winlogbeat:   "Winlogbeat"
-  functionbeat:   "Functionbeat"
-  journalbeat:   "Journalbeat"
-  es-sql:   "Elasticsearch SQL"
-  esql:   "ES|QL"
-  elastic-agent:   "Elastic Agent"
-  k8s:   "Kubernetes"
-  log-driver-long:   "Elastic Logging Plugin for Docker"
-  security:   "X-Pack security"
-  security-features:   "security features"
-  operator-feature:   "operator privileges feature"
-  es-security-features:   "Elasticsearch security features"
-  stack-security-features:   "Elastic Stack security features"
-  endpoint-sec:   "Endpoint Security"
-  endpoint-cloud-sec:   "Endpoint and Cloud Security"
-  elastic-defend:   "Elastic Defend"
-  elastic-sec:   "Elastic Security"
-  elastic-endpoint:   "Elastic Endpoint"
-  swimlane:   "Swimlane"
-  sn:   "ServiceNow"
-  sn-itsm:   "ServiceNow ITSM"
-  sn-itom:   "ServiceNow ITOM"
-  sn-sir:   "ServiceNow SecOps"
-  jira:   "Jira"
-  ibm-r:   "IBM Resilient"
-  webhook:   "Webhook"
-  webhook-cm:   "Webhook - Case Management"
-  opsgenie:   "Opsgenie"
-  bedrock:   "Amazon Bedrock"
-  gemini:   "Google Gemini"
-  hive:   "TheHive"
-  monitoring:   "X-Pack monitoring"
-  monitor-features:   "monitoring features"
-  stack-monitor-features:   "Elastic Stack monitoring features"
-  watcher:   "Watcher"
-  alert-features:   "alerting features"
-  reporting:   "X-Pack reporting"
-  report-features:   "reporting features"
-  graph:   "X-Pack graph"
-  graph-features:   "graph analytics features"
-  searchprofiler:   "Search Profiler"
-  xpackml:   "X-Pack machine learning"
-  ml:   "machine learning"
-  ml-cap:   "Machine learning"
-  ml-init:   "ML"
-  ml-features:   "machine learning features"
-  stack-ml-features:   "Elastic Stack machine learning features"
-  ccr:   "cross-cluster replication"
-  ccr-cap:   "Cross-cluster replication"
-  ccr-init:   "CCR"
-  ccs:   "cross-cluster search"
-  ccs-cap:   "Cross-cluster search"
-  ccs-init:   "CCS"
-  ilm:   "index lifecycle management"
-  ilm-cap:   "Index lifecycle management"
-  ilm-init:   "ILM"
-  dlm:   "data lifecycle management"
-  dlm-cap:   "Data lifecycle management"
-  dlm-init:   "DLM"
-  search-snap:   "searchable snapshot"
-  search-snaps:   "searchable snapshots"
-  search-snaps-cap:   "Searchable snapshots"
-  slm:   "snapshot lifecycle management"
-  slm-cap:   "Snapshot lifecycle management"
-  slm-init:   "SLM"
-  rollup-features:   "data rollup features"
-  ipm:   "index pattern management"
-  ipm-cap:   "Index pattern"
-  rollup:   "rollup"
-  rollup-cap:   "Rollup"
-  rollups:   "rollups"
-  rollups-cap:   "Rollups"
-  rollup-job:   "rollup job"
-  rollup-jobs:   "rollup jobs"
-  rollup-jobs-cap:   "Rollup jobs"
-  dfeed:   "datafeed"
-  dfeeds:   "datafeeds"
-  dfeed-cap:   "Datafeed"
-  dfeeds-cap:   "Datafeeds"
-  ml-jobs:   "machine learning jobs"
-  ml-jobs-cap:   "Machine learning jobs"
-  anomaly-detect:   "anomaly detection"
-  anomaly-detect-cap:   "Anomaly detection"
-  anomaly-job:   "anomaly detection job"
-  anomaly-jobs:   "anomaly detection jobs"
-  anomaly-jobs-cap:   "Anomaly detection jobs"
-  dataframe:   "data frame"
-  dataframes:   "data frames"
-  dataframe-cap:   "Data frame"
-  dataframes-cap:   "Data frames"
-  watcher-transform:   "payload transform"
-  watcher-transforms:   "payload transforms"
-  watcher-transform-cap:   "Payload transform"
-  watcher-transforms-cap:   "Payload transforms"
-  transform:   "transform"
-  transforms:   "transforms"
-  transform-cap:   "Transform"
-  transforms-cap:   "Transforms"
-  dataframe-transform:   "transform"
-  dataframe-transform-cap:   "Transform"
-  dataframe-transforms:   "transforms"
-  dataframe-transforms-cap:   "Transforms"
-  dfanalytics-cap:   "Data frame analytics"
-  dfanalytics:   "data frame analytics"
-  dataframe-analytics-config:   "'{dataframe} analytics config'"
-  dfanalytics-job:   "'{dataframe} analytics job'"
-  dfanalytics-jobs:   "'{dataframe} analytics jobs'"
-  dfanalytics-jobs-cap:   "'{dataframe-cap} analytics jobs'"
-  cdataframe:   "continuous data frame"
-  cdataframes:   "continuous data frames"
-  cdataframe-cap:   "Continuous data frame"
-  cdataframes-cap:   "Continuous data frames"
-  cdataframe-transform:   "continuous transform"
-  cdataframe-transforms:   "continuous transforms"
-  cdataframe-transforms-cap:   "Continuous transforms"
-  ctransform:   "continuous transform"
-  ctransform-cap:   "Continuous transform"
-  ctransforms:   "continuous transforms"
-  ctransforms-cap:   "Continuous transforms"
-  oldetection:   "outlier detection"
-  oldetection-cap:   "Outlier detection"
-  olscore:   "outlier score"
-  olscores:   "outlier scores"
-  fiscore:   "feature influence score"
-  evaluatedf-api:   "evaluate {dataframe} analytics API"
-  evaluatedf-api-cap:   "Evaluate {dataframe} analytics API"
-  binarysc:   "binary soft classification"
-  binarysc-cap:   "Binary soft classification"
-  regression:   "regression"
-  regression-cap:   "Regression"
-  reganalysis:   "regression analysis"
-  reganalysis-cap:   "Regression analysis"
-  depvar:   "dependent variable"
-  feature-var:   "feature variable"
-  feature-vars:   "feature variables"
-  feature-vars-cap:   "Feature variables"
-  classification:   "classification"
-  classification-cap:   "Classification"
-  classanalysis:   "classification analysis"
-  classanalysis-cap:   "Classification analysis"
-  infer-cap:   "Inference"
-  infer:   "inference"
-  lang-ident-cap:   "Language identification"
-  lang-ident:   "language identification"
-  data-viz:   "Data Visualizer"
-  file-data-viz:   "File Data Visualizer"
-  feat-imp:   "feature importance"
-  feat-imp-cap:   "Feature importance"
-  nlp:   "natural language processing"
-  nlp-cap:   "Natural language processing"
-  apm-agent:   "APM agent"
-  apm-go-agent:   "Elastic APM Go agent"
-  apm-go-agents:   "Elastic APM Go agents"
-  apm-ios-agent:   "Elastic APM iOS agent"
-  apm-ios-agents:   "Elastic APM iOS agents"
-  apm-java-agent:   "Elastic APM Java agent"
-  apm-java-agents:   "Elastic APM Java agents"
-  apm-dotnet-agent:   "Elastic APM .NET agent"
-  apm-dotnet-agents:   "Elastic APM .NET agents"
-  apm-node-agent:   "Elastic APM Node.js agent"
-  apm-node-agents:   "Elastic APM Node.js agents"
-  apm-php-agent:   "Elastic APM PHP agent"
-  apm-php-agents:   "Elastic APM PHP agents"
-  apm-py-agent:   "Elastic APM Python agent"
-  apm-py-agents:   "Elastic APM Python agents"
-  apm-ruby-agent:   "Elastic APM Ruby agent"
-  apm-ruby-agents:   "Elastic APM Ruby agents"
-  apm-rum-agent:   "Elastic APM Real User Monitoring (RUM) JavaScript agent"
-  apm-rum-agents:   "Elastic APM RUM JavaScript agents"
-  apm-lambda-ext:   "Elastic APM AWS Lambda extension"
-  project-monitors:   "project monitors"
-  project-monitors-cap:   "Project monitors"
-  private-location:   "Private Location"
-  private-locations:   "Private Locations"
-  pwd:   "YOUR_PASSWORD"
-  esh:   "ES-Hadoop"
-  default-dist:   "default distribution"
-  oss-dist:   "OSS-only distribution"
-  observability:   "Observability"
-  api-request-title:   "Request"
-  api-prereq-title:   "Prerequisites"
-  api-description-title:   "Description"
-  api-path-parms-title:   "Path parameters"
-  api-query-parms-title:   "Query parameters"
-  api-request-body-title:   "Request body"
-  api-response-codes-title:   "Response codes"
-  api-response-body-title:   "Response body"
-  api-example-title:   "Example"
-  api-examples-title:   "Examples"
-  api-definitions-title:   "Properties"
-  multi-arg:   "†footnoteref:[multi-arg,This parameter accepts multiple arguments.]"
-  multi-arg-ref:   "†footnoteref:[multi-arg]"
-  yes-icon:   "image:https://doc-icons.s3.us-east-2.amazonaws.com/icon-yes.png[Yes,20,15]"
-  no-icon:   "image:https://doc-icons.s3.us-east-2.amazonaws.com/icon-no.png[No,20,15]"
-  es-repo:   "https://github.com/elastic/elasticsearch/"
-  es-issue:   "https://github.com/elastic/elasticsearch/issues/"
-  es-pull:   "https://github.com/elastic/elasticsearch/pull/"
-  es-commit:   "https://github.com/elastic/elasticsearch/commit/"
-  kib-repo:   "https://github.com/elastic/kibana/"
-  kib-issue:   "https://github.com/elastic/kibana/issues/"
-  kibana-issue:   "'{kib-repo}issues/'"
-  kib-pull:   "https://github.com/elastic/kibana/pull/"
-  kibana-pull:   "'{kib-repo}pull/'"
-  kib-commit:   "https://github.com/elastic/kibana/commit/"
-  ml-repo:   "https://github.com/elastic/ml-cpp/"
-  ml-issue:   "https://github.com/elastic/ml-cpp/issues/"
-  ml-pull:   "https://github.com/elastic/ml-cpp/pull/"
-  ml-commit:   "https://github.com/elastic/ml-cpp/commit/"
-  apm-repo:   "https://github.com/elastic/apm-server/"
-  apm-issue:   "https://github.com/elastic/apm-server/issues/"
-  apm-pull:   "https://github.com/elastic/apm-server/pull/"
-  kibana-blob:   "https://github.com/elastic/kibana/blob/current/"
-  apm-get-started-ref:   "https://www.elastic.co/guide/en/apm/get-started/current"
-  apm-server-ref:   "https://www.elastic.co/guide/en/apm/server/current"
-  apm-server-ref-v:   "https://www.elastic.co/guide/en/apm/server/current"
-  apm-server-ref-m:   "https://www.elastic.co/guide/en/apm/server/master"
-  apm-server-ref-62:   "https://www.elastic.co/guide/en/apm/server/6.2"
-  apm-server-ref-64:   "https://www.elastic.co/guide/en/apm/server/6.4"
-  apm-server-ref-70:   "https://www.elastic.co/guide/en/apm/server/7.0"
-  apm-overview-ref-v:   "https://www.elastic.co/guide/en/apm/get-started/current"
-  apm-overview-ref-70:   "https://www.elastic.co/guide/en/apm/get-started/7.0"
-  apm-overview-ref-m:   "https://www.elastic.co/guide/en/apm/get-started/master"
-  infra-guide:   "https://www.elastic.co/guide/en/infrastructure/guide/current"
-  a-data-source:   "a data view"
-  icon-bug:   "pass:[<span class=\"eui-icon icon-bug\"></span>]"
-  icon-checkInCircleFilled:   "pass:[<span class=\"eui-icon icon-checkInCircleFilled\"></span>]"
-  icon-warningFilled:   "pass:[<span class=\"eui-icon icon-warningFilled\"></span>]"
diff --git a/docs/images/logo-elastic-glyph-color.svg b/docs/images/logo-elastic-glyph-color.svg
new file mode 100644
index 000000000..bfc5bfb6a
--- /dev/null
+++ b/docs/images/logo-elastic-glyph-color.svg
@@ -0,0 +1,16 @@
+<svg width="205" height="204" viewBox="0 0 205 204" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_1178_2)">
+<path d="M204.58 106.744C204.603 98.4365 202.056 90.3256 197.289 83.5226C192.521 76.7196 185.766 71.5575 177.95 68.7437C178.661 65.1202 179.02 61.4363 179.02 57.7437C179.015 45.5282 175.137 33.6288 167.945 23.7553C160.752 13.8817 150.615 6.54212 138.99 2.79108C127.365 -0.95996 114.849 -0.929399 103.242 2.87837C91.6356 6.68615 81.5344 14.0751 74.3903 23.9837C69.1179 19.9113 62.6636 17.6651 56.0021 17.5844C49.3406 17.5036 42.8337 19.5926 37.4641 23.536C32.0946 27.4793 28.1539 33.0628 26.2374 39.4431C24.3208 45.8235 24.5325 52.6542 26.8403 58.9037C19.0148 61.7531 12.2486 66.929 7.45072 73.7362C2.6528 80.5433 0.0529206 88.6558 0.000313645 96.9837C-0.0326102 105.33 2.52727 113.48 7.32627 120.309C12.1253 127.138 18.9265 132.307 26.7903 135.104C25.1677 143.453 25.4123 152.057 27.5064 160.301C29.6005 168.544 33.4924 176.222 38.903 182.784C44.3136 189.347 51.1089 194.631 58.8019 198.258C66.495 201.885 74.8951 203.765 83.4003 203.764C92.5559 203.772 101.581 201.59 109.722 197.402C117.863 193.213 124.884 187.138 130.2 179.684C135.455 183.802 141.912 186.091 148.588 186.201C155.264 186.312 161.793 184.238 167.181 180.295C172.569 176.353 176.522 170.758 178.437 164.362C180.352 157.965 180.125 151.119 177.79 144.864C185.623 142.013 192.394 136.832 197.193 130.016C201.992 123.201 204.587 115.079 204.63 106.744" fill="white"/>
+<path d="M80.4304 87.7437L125.2 108.154L170.36 68.5837C172.647 57.1747 170.923 45.326 165.48 35.0418C160.036 24.7576 151.208 16.6692 140.487 12.1447C129.767 7.62016 117.813 6.9373 106.647 10.2116C95.4817 13.4859 85.7895 20.5163 79.2104 30.1137L71.6904 69.1137L80.4304 87.7437Z" fill="#FEC514"/>
+<path d="M34.1005 135.154C31.7687 146.616 33.4787 158.533 38.9397 168.877C44.4007 179.221 53.2757 187.355 64.0559 191.896C74.836 196.436 86.856 197.103 98.0722 193.783C109.288 190.463 119.009 183.36 125.581 173.684L133.031 134.844L123.031 115.844L78.1405 95.3438L34.1005 135.154Z" fill="#02BCB7"/>
+<path d="M33.7903 57.6838L64.4903 64.9238L71.2103 30.0437C67.0362 26.8839 61.9516 25.1598 56.7165 25.129C51.4814 25.0981 46.3769 26.7623 42.1659 29.8727C37.9549 32.9831 34.8636 37.3728 33.3539 42.3856C31.8442 47.3984 31.9973 52.7652 33.7903 57.6838Z" fill="#F04E98"/>
+<path d="M31.1505 64.9837C24.5185 67.1748 18.727 71.3643 14.5705 76.9775C10.4141 82.5907 8.09631 89.3525 7.93527 96.3353C7.77423 103.318 9.7778 110.179 13.6711 115.978C17.5643 121.777 23.1566 126.229 29.6805 128.724L72.6805 89.8137L64.7905 72.9837L31.1505 64.9837Z" fill="#1BA9F5"/>
+<path d="M133.44 173.684C137.012 176.435 141.284 178.128 145.77 178.572C150.256 179.016 154.777 178.191 158.818 176.193C162.859 174.195 166.259 171.103 168.63 167.269C171.001 163.434 172.248 159.012 172.23 154.504C172.243 151.636 171.749 148.789 170.77 146.094L140.12 138.924L133.44 173.684Z" fill="#9ADC30"/>
+<path d="M139.68 130.894L173.43 138.784C180.166 136.513 186.025 132.197 190.191 126.437C194.357 120.678 196.622 113.762 196.67 106.654C196.664 99.8008 194.573 93.112 190.676 87.4751C186.779 81.8383 181.259 77.5201 174.85 75.0938L130.72 113.764L139.68 130.894Z" fill="#0B64DD"/>
+</g>
+<defs>
+<clipPath id="clip0_1178_2">
+<rect width="205" height="204" fill="white"/>
+</clipPath>
+</defs>
+</svg>
diff --git a/docs/reference/async.md b/docs/reference/async.md
index f205d3807..70e8949d5 100644
--- a/docs/reference/async.md
+++ b/docs/reference/async.md
@@ -34,8 +34,7 @@ async def main():
     )
     print(resp)
 
-loop = asyncio.get_event_loop()
-loop.run_until_complete(main())
+asyncio.run(main())
 ```
 
 All APIs that are available under the sync client are also available under the async client.
diff --git a/docs/reference/client-helpers.md b/docs/reference/client-helpers.md
index 02ab4e026..08f480e23 100644
--- a/docs/reference/client-helpers.md
+++ b/docs/reference/client-helpers.md
@@ -5,14 +5,14 @@ mapped_pages:
 
 # Client helpers [client-helpers]
 
-You can find here a collection of simple helper functions that abstract some specifics of the raw API. For detailed examples, refer to [this page](https://elasticsearch-py.readthedocs.io/en/stable/helpers.md).
+You can find here a collection of simple helper functions that abstract some specifics of the raw API.
 
 
 ## Bulk helpers [bulk-helpers]
 
 There are several helpers for the bulk API since its requirement for specific formatting and other considerations can make it cumbersome if used directly.
 
-All bulk helpers accept an instance of `{{es}}` class and an iterable `action` (any iterable, can also be a generator, which is ideal in most cases since it allows you to index large datasets without the need of loading them into memory).
+All bulk helpers accept an instance of `Elasticsearch` class and an iterable `action` (any iterable, can also be a generator, which is ideal in most cases since it allows you to index large datasets without the need of loading them into memory).
 
 The items in the iterable `action` should be the documents we wish to index in several formats. The most common one is the same as returned by `search()`, for example:
 
diff --git a/docs/reference/connecting.md b/docs/reference/connecting.md
index aefc50b1f..27f7fecbc 100644
--- a/docs/reference/connecting.md
+++ b/docs/reference/connecting.md
@@ -352,6 +352,6 @@ def main(request: func.HttpRequest) -> func.HttpResponse:
 Resources used to assess these recommendations:
 
 * [GCP Cloud Functions: Tips & Tricks](https://cloud.google.com/functions/docs/bestpractices/tips#use_global_variables_to_reuse_objects_in_future_invocations)
-* [Best practices for working with AWS Lambda functions](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.md)
+* [Best practices for working with AWS Lambda functions](https://docs.aws.amazon.com/lambda/latest/dg/best-practices.html)
 * [Azure Functions Python developer guide](https://docs.microsoft.com/en-us/azure/azure-functions/functions-reference-python?tabs=azurecli-linux%2Capplication-level#global-variables)
-* [AWS Lambda: Comparing the effect of global scope](https://docs.aws.amazon.com/lambda/latest/operatorguide/global-scope.md)
+* [AWS Lambda: Comparing the effect of global scope](https://docs.aws.amazon.com/lambda/latest/operatorguide/global-scope.html)
diff --git a/docs/reference/_configuration.md b/docs/reference/dsl_configuration.md
similarity index 100%
rename from docs/reference/_configuration.md
rename to docs/reference/dsl_configuration.md
diff --git a/docs/reference/_examples.md b/docs/reference/dsl_examples.md
similarity index 100%
rename from docs/reference/_examples.md
rename to docs/reference/dsl_examples.md
diff --git a/docs/reference/_how_to_guides.md b/docs/reference/dsl_how_to_guides.md
similarity index 78%
rename from docs/reference/_how_to_guides.md
rename to docs/reference/dsl_how_to_guides.md
index 08e16b28c..5f0884c3c 100644
--- a/docs/reference/_how_to_guides.md
+++ b/docs/reference/dsl_how_to_guides.md
@@ -23,7 +23,7 @@ The `Search` object represents the entire search request:
 * additional parameters
 * associated client
 
-The API is designed to be chainable. With the exception of the aggregations functionality this means that the `Search` object is immutable -all changes to the object will result in a shallow copy being created which contains the changes. This means you can safely pass the `Search` object to foreign code without fear of it modifying your objects as long as it sticks to the `Search` object APIs.
+The API is designed to be chainable. With the exception of the aggregations functionality this means that the `Search` object is immutable -all changes to the object will result in a shallow copy being created which contains the changes. You can safely pass the `Search` object to foreign code without fear of it modifying your objects as long as it sticks to the `Search` object APIs.
 
 You can pass an instance of the [elasticsearch client](https://elasticsearch-py.readthedocs.io/) when instantiating the `Search` object:
 
@@ -51,7 +51,7 @@ All methods return a *copy* of the object, making it safe to pass to outside cod
 The API is chainable, allowing you to combine multiple method calls in one statement:
 
 ```python
-s = Search().using(client).query("match", title="python")
+s = Search().using(client).query(Match("title", "python"))
 ```
 
 To send the request to Elasticsearch:
@@ -67,9 +67,9 @@ for hit in s:
     print(hit.title)
 ```
 
-Search results will be cached. Subsequent calls to `execute` or trying to iterate over an already executed `Search` object will not trigger additional requests being sent to Elasticsearch. To force a request specify `ignore_cache=True` when calling `execute`.
+Search results will be cached. Subsequent calls to `execute` or trying to iterate over an already executed `Search` object will not trigger additional requests being sent to Elasticsearch. To force a new request to be issued specify `ignore_cache=True` when calling `execute`.
 
-For debugging purposes you can serialize the `Search` object to a `dict` explicitly:
+For debugging purposes you can serialize the `Search` object to a `dict` with the raw Elasticsearch request:
 
 ```python
 print(s.to_dict())
@@ -79,33 +79,38 @@ print(s.to_dict())
 
 You can delete the documents matching a search by calling `delete` on the `Search` object instead of `execute` like this:
 
+```python
+s = Search(index='i').query(Match("title", "python"))
+response = s.delete()
+```
+
+To pass [deletion parameters](https://elasticsearch-py.readthedocs.io/en/latest/api/elasticsearch.html#elasticsearch.Elasticsearch.delete_by_query)
+in your query, you can add them by calling ``params`` on the ``Search`` object before ``delete`` like this:
+
 ```python
 s = Search(index='i').query("match", title="python")
+s = s.params(ignore_unavailable=False, wait_for_completion=True)
 response = s.delete()
 ```
 
 
 #### Queries [_queries]
 
-The library provides classes for all Elasticsearch query types. Pass all the parameters as keyword arguments. The classes accept any keyword arguments, the dsl then takes all arguments passed to the constructor and serializes them as top-level keys in the resulting dictionary (and thus the resulting json being sent to elasticsearch). This means that there is a clear one-to-one mapping between the raw query and its equivalent in the DSL:
+The `elasticsearch.dsl.query` module provides classes for all Elasticsearch query types. These classes accept keyword arguments in their constructors, which are serialized to the appropriate format to be sent to Elasticsearch. There is a clear one-to-one mapping between the raw query and its equivalent class-based version:
 
 ```python
-from elasticsearch.dsl.query import MultiMatch, Match
+>>> from elasticsearch.dsl.query import MultiMatch, Match
 
-# {"multi_match": {"query": "python django", "fields": ["title", "body"]}}
-MultiMatch(query='python django', fields=['title', 'body'])
+>>> q = MultiMatch(query='python django', fields=['title', 'body'])
+>>> q.to_dict()
+{'multi_match': {'query': 'python django', 'fields': ['title', 'body']}}
 
-# {"match": {"title": {"query": "web framework", "type": "phrase"}}}
-Match(title={"query": "web framework", "type": "phrase"})
+>>> q = Match("title", {"query": "web framework", "type": "phrase"})
+>>> q.to_dict()
+{'match': {'title': {'query': 'web framework', 'type': 'phrase'}}}
 ```
 
-::::{note}
-In some cases this approach is not possible due to python’s restriction on identifiers - for example if your field is called `@timestamp`. In that case you have to fall back to unpacking a dictionary: `Range(*+ {'@timestamp': {'lt': 'now'}})`
-
-::::
-
-
-You can use the `Q` shortcut to construct the instance using a name with parameters or the raw `dict`:
+An alternative to the class-based queries is to use the `Q` shortcut, passing a query name followed by its parameters, or the raw query as a `dict`:
 
 ```python
 from elasticsearch.dsl import Q
@@ -114,20 +119,20 @@ Q("multi_match", query='python django', fields=['title', 'body'])
 Q({"multi_match": {"query": "python django", "fields": ["title", "body"]}})
 ```
 
-To add the query to the `Search` object, use the `.query()` method:
+To add a query to the `Search` object, use the `.query()` method. This works with class-based or `Q` queries:
 
 ```python
 q = Q("multi_match", query='python django', fields=['title', 'body'])
 s = s.query(q)
 ```
 
-The method also accepts all the parameters as the `Q` shortcut:
+As a shortcut the `query()` method also accepts all the parameters of the `Q` shortcut directly:
 
 ```python
 s = s.query("multi_match", query='python django', fields=['title', 'body'])
 ```
 
-If you already have a query object, or a `dict` representing one, you can just override the query used in the `Search` object:
+If you already have a query object, or a `dict` representing one, you can assign it to the `query` attribute of a `Search` object to add it to it, replacing any previously configured queries:
 
 ```python
 s.query = Q('bool', must=[Q('match', title='python'), Q('match', body='best')])
@@ -136,7 +141,7 @@ s.query = Q('bool', must=[Q('match', title='python'), Q('match', body='best')])
 
 #### Dotted fields [_dotted_fields]
 
-Sometimes you want to refer to a field within another field, either as a multi-field (`title.keyword`) or in a structured `json` document like `address.city`. To make it easier, the `Q` shortcut (as well as the `query`, `filter`, and `exclude` methods on `Search` class) allows you to use `_+` (double underscore) in place of a dot in a keyword argument:
+Sometimes you want to refer to a field within another field, either as a multi-field (`title.keyword`) or in a structured `json` document like `address.city`. This is not a problem when using class-based queries, but when working without classes it is often required to pass field names as keyword arguments. To make this easier, you can use `__` (double underscore) in place of a dot in a keyword argument:
 
 ```python
 s = Search()
@@ -144,7 +149,7 @@ s = s.filter('term', category__keyword='Python')
 s = s.query('match', address__city='prague')
 ```
 
-Alternatively you can always fall back to python’s kwarg unpacking if you prefer:
+Alternatively you can use Python’s keyword argument unpacking:
 
 ```python
 s = Search()
@@ -155,20 +160,23 @@ s = s.query('match', **{'address.city': 'prague'})
 
 #### Query combination [_query_combination]
 
-Query objects can be combined using logical operators:
+Query objects can be combined using logical operators `|`, `&` and `~`:
 
 ```python
-Q("match", title='python') | Q("match", title='django')
-# {"bool": {"should": [...]}}
+>>> q = Match("title", "python") | Match("title", "django")
+>>> q.to_dict()
+{'bool': {'should': [{'match': {'title': 'python'}}, {'match': {'title': 'django'}}]}}
 
-Q("match", title='python') & Q("match", title='django')
-# {"bool": {"must": [...]}}
+>>> q = Match("title", "python") & Match("title", "django")
+>>> q.to_dict()
+{'bool': {'must': [{'match': {'title': 'python'}}, {'match': {'title': 'django'}}]}}
 
-~Q("match", title="python")
-# {"bool": {"must_not": [...]}}
+>>> q = ~Match("title", "python")
+>>> q.to_dict()
+{'bool': {'must_not': [{'match': {'title': 'python'}}]}}
 ```
 
-When you call the `.query()` method multiple times, the `&` operator will be used internally:
+When you call the `.query()` method multiple times, the `&` operator will be used internally to combine all the queries:
 
 ```python
 s = s.query().query()
@@ -193,48 +201,64 @@ s = Search().query(q)
 If you want to add a query in a [filter context](docs-content://explore-analyze/query-filter/languages/querydsl.md) you can use the `filter()` method to make things easier:
 
 ```python
+from elasticsearch.dsl.query import Terms
+
 s = Search()
-s = s.filter('terms', tags=['search', 'python'])
+s = s.filter(Terms("tags", ['search', 'python']))
 ```
 
 Behind the scenes this will produce a `Bool` query and place the specified `terms` query into its `filter` branch, making it equivalent to:
 
 ```python
+from elasticsearch.dsl.query import Terms, Bool
+
 s = Search()
-s = s.query('bool', filter=[Q('terms', tags=['search', 'python'])])
+s = s.query(Bool(filter=[Terms("tags", ["search", "python"])]))
 ```
 
-If you want to use the post_filter element for faceted navigation, use the `.post_filter()` method.
+If you want to use the `post_filter` element for faceted navigation, use the `.post_filter()` method.
 
-You can also `exclude()` items from your query like this:
+The `exclude()` method works like `filter()`, but it applies the query as negated:
 
 ```python
 s = Search()
-s = s.exclude('terms', tags=['search', 'python'])
+s = s.exclude(Terms("tags", ['search', 'python']))
 ```
 
-which is shorthand for: `s = s.query('bool', filter=[~Q('terms', tags=['search', 'python'])])`
+which is shorthand for:
+
+```python
+s = s.query(Bool(filter=[~Terms("tags", ["search", "python"])]))
+```
 
 
 #### Aggregations [_aggregations]
 
-To define an aggregation, you can use the `A` shortcut:
+As with queries, there are classes that represent each aggregation type, all accessible through the `elasticsearch.dsl.aggs` module:
+
+```python
+from elasticsearch.dsl import aggs
+
+a = aggs.Terms(field="tags")
+# {"terms": {"field": "tags"}}
+```
+
+It is also possible to define an aggregation using the `A` shortcut:
 
 ```python
 from elasticsearch.dsl import A
 
 A('terms', field='tags')
-# {"terms": {"field": "tags"}}
 ```
 
 To nest aggregations, you can use the `.bucket()`, `.metric()` and `.pipeline()` methods:
 
 ```python
-a = A('terms', field='category')
+a = aggs.Terms(field="category")
 # {'terms': {'field': 'category'}}
 
-a.metric('clicks_per_category', 'sum', field='clicks')\
-    .bucket('tags_per_category', 'terms', field='tags')
+a.metric("clicks_per_category", aggs.Sum(field="clicks")) \
+    .bucket("tags_per_category", aggs.Terms(field="tags"))
 # {
 #   'terms': {'field': 'category'},
 #   'aggs': {
@@ -248,8 +272,8 @@ To add aggregations to the `Search` object, use the `.aggs` property, which acts
 
 ```python
 s = Search()
-a = A('terms', field='category')
-s.aggs.bucket('category_terms', a)
+a = aggs.Terms(field="category")
+s.aggs.bucket("category_terms", a)
 # {
 #   'aggs': {
 #     'category_terms': {
@@ -265,10 +289,10 @@ or
 
 ```python
 s = Search()
-s.aggs.bucket('articles_per_day', 'date_histogram', field='publish_date', interval='day')\
-    .metric('clicks_per_day', 'sum', field='clicks')\
-    .pipeline('moving_click_average', 'moving_avg', buckets_path='clicks_per_day')\
-    .bucket('tags_per_day', 'terms', field='tags')
+s.aggs.bucket("articles_per_day", aggs.DateHistogram(field="publish_date", interval="day")) \
+    .metric("clicks_per_day", aggs.Sum(field="clicks")) \
+    .pipeline("moving_click_average", aggs.MovingAvg(buckets_path="clicks_per_day")) \
+    .bucket("tags_per_day", aggs.Terms(field="tags"))
 
 s.to_dict()
 # {
@@ -290,9 +314,9 @@ You can access an existing bucket by its name:
 ```python
 s = Search()
 
-s.aggs.bucket('per_category', 'terms', field='category')
-s.aggs['per_category'].metric('clicks_per_category', 'sum', field='clicks')
-s.aggs['per_category'].bucket('tags_per_category', 'terms', field='tags')
+s.aggs.bucket("per_category", aggs.Terms(field="category"))
+s.aggs["per_category"].metric("clicks_per_category", aggs.Sum(field="clicks"))
+s.aggs["per_category"].bucket("tags_per_category", aggs.Terms(field="tags"))
 ```
 
 ::::{note}
@@ -301,7 +325,7 @@ When chaining multiple aggregations, there is a difference between what `.bucket
 ::::
 
 
-As opposed to other methods on the `Search` objects, defining aggregations is done in-place (does not return a copy).
+As opposed to other methods on the `Search` objects, aggregations are defined in-place, without returning a new copy.
 
 
 #### K-Nearest Neighbor Searches [_k_nearest_neighbor_searches]
@@ -348,7 +372,7 @@ s = s.sort()
 
 #### Pagination [_pagination]
 
-To specify the from/size parameters, use the Python slicing API:
+To specify the from/size parameters, apply the standard Python slicing operator on the `Search` instance:
 
 ```python
 s = s[10:20]
@@ -417,7 +441,7 @@ The first argument is the name of the suggestions (name under which it will be r
 To collapse search results use the `collapse` method on your `Search` object:
 
 ```python
-s = Search().query("match", message="GET /search")
+s = Search().query(Match("message", "GET /search"))
 # collapse results by user_id
 s = s.collapse("user_id")
 ```
@@ -526,11 +550,11 @@ If you want to inspect the contents of the `response` objects, just use its `to_
 
 #### Hits [_hits]
 
-To access to the hits returned by the search, access the `hits` property or just iterate over the `Response` object:
+To access the hits returned by the search, use the `hits` property or just iterate over the `Response` object:
 
 ```python
 response = s.execute()
-print('Total %d hits found.' % response.hits.total)
+print(f"Total {response.hits.total} hits found.")
 for h in response:
     print(h.title, h.body)
 ```
@@ -549,8 +573,7 @@ The individual hits is wrapped in a convenience class that allows attribute acce
 ```python
 response = s.execute()
 h = response.hits[0]
-print('/%s/%s/%s returned with score %f' % (
-    h.meta.index, h.meta.doc_type, h.meta.id, h.meta.score))
+print(f"/{h.meta.index}/{h.meta.doc_type}/{h.meta.id} returned with score {h.meta.score}")
 ```
 
 ::::{note}
@@ -577,11 +600,12 @@ If you need to execute multiple searches at the same time you can use the `Multi
 
 ```python
 from elasticsearch.dsl import MultiSearch, Search
+from elasticsearch.dsl.query import Term
 
 ms = MultiSearch(index='blogs')
 
-ms = ms.add(Search().filter('term', tags='python'))
-ms = ms.add(Search().filter('term', tags='elasticsearch'))
+ms = ms.add(Search().filter(Term("tags", "python")))
+ms = ms.add(Search().filter(Term("tags", 'elasticsearch')))
 
 responses = ms.execute()
 
@@ -653,9 +677,9 @@ class Post(Document):
 
 #### Data types [_data_types]
 
-The `Document` instances use native python types like `str` and `datetime`. In case of `Object` or `Nested` fields an instance of the `InnerDoc` subclass is used, as in the `add_comment` method in the above example where we are creating an instance of the `Comment` class.
+The `Document` instances use native python types such as `str` and `datetime` for its attributes. In case of `Object` or `Nested` fields an instance of the `InnerDoc` subclass is used, as in the `add_comment` method in the above example, where we are creating an instance of the `Comment` class.
 
-There are some specific types that were created as part of this library to make working with some field types easier, for example the `Range` object used in any of the [range fields](elasticsearch://reference/elasticsearch/mapping-reference/range.md):
+There are some specific types that were created to make working with some field types easier, for example the `Range` object used in any of the [range fields](elasticsearch://reference/elasticsearch/mapping-reference/range.md):
 
 ```python
 from elasticsearch.dsl import Document, DateRange, Keyword, Range
@@ -664,7 +688,6 @@ class RoomBooking(Document):
     room = Keyword()
     dates = DateRange()
 
-
 rb = RoomBooking(
   room='Conference Room II',
   dates=Range(
@@ -700,7 +723,7 @@ class Post(Document):
 
 It is important to note that when using `Field` subclasses such as `Text`, `Date` and `Boolean`, they must be given in the right-side of an assignment, as shown in examples above. Using these classes as type hints will result in errors.
 
-Python types are mapped to their corresponding field type according to the following table:
+Python types are mapped to their corresponding field types according to the following table:
 
 | Python type | DSL field |
 | --- | --- |
@@ -740,18 +763,18 @@ class Post(Document):
     comments: List[Comment]  # same as comments = Nested(Comment, required=True)
 ```
 
-Unfortunately it is impossible to have Python type hints that uniquely identify every possible Elasticsearch field type. To choose a field type that is different than the ones in the table above, the field instance can be added explicitly as a right-side assignment in the field declaration. The next example creates a field that is typed as `Optional[str]`, but is mapped to `Keyword` instead of `Text`:
+Unfortunately it is impossible to have Python type hints that uniquely identify every possible Elasticsearch field type. To choose a field type that is different than the one that is assigned according to the table above, the desired field instance can be added explicitly as a right-side assignment in the field declaration. The next example creates a field that is typed as `Optional[str]`, but is mapped to `Keyword` instead of `Text`:
 
 ```python
 class MyDocument(Document):
     category: Optional[str] = Keyword()
 ```
 
-This form can also be used when additional options need to be given to initialize the field, such as when using custom analyzer settings or changing the `required` default:
+This form can also be used when additional options need to be given to initialize the field, such as when using custom analyzer settings:
 
 ```python
 class Comment(InnerDoc):
-    content: str = Text(analyzer='snowball', required=True)
+    content: str = Text(analyzer='snowball')
 ```
 
 When using type hints as above, subclasses of `Document` and `InnerDoc` inherit some of the behaviors associated with Python dataclasses, as defined by [PEP 681](https://peps.python.org/pep-0681/) and the [dataclass_transform decorator](https://typing.readthedocs.io/en/latest/spec/dataclasses.html#dataclass-transform). To add per-field dataclass options such as `default` or `default_factory`, the `mapped_field()` wrapper can be used on the right side of a typed field declaration:
@@ -761,12 +784,12 @@ class MyDocument(Document):
     title: str = mapped_field(default="no title")
     created_at: datetime = mapped_field(default_factory=datetime.now)
     published: bool = mapped_field(default=False)
-    category: str = mapped_field(Keyword(required=True), default="general")
+    category: str = mapped_field(Keyword(), default="general")
 ```
 
 When using the `mapped_field()` wrapper function, an explicit field type instance can be passed as a first positional argument, as the `category` field does in the example above.
 
-Static type checkers such as [mypy](https://mypy-lang.org/) and [pyright](https://github.com/microsoft/pyright) can use the type hints and the dataclass-specific options added to the `mapped_field()` function to improve type inference and provide better real-time suggestions in IDEs.
+Static type checkers such as [mypy](https://mypy-lang.org/) and [pyright](https://github.com/microsoft/pyright) can use the type hints and the dataclass-specific options added to the `mapped_field()` function to improve type inference and provide better real-time code completion and suggestions in IDEs.
 
 One situation in which type checkers can’t infer the correct type is when using fields as class attributes. Consider the following example:
 
@@ -804,7 +827,7 @@ The `InstrumentedField` objects returned when fields are accessed as class attri
 s = MyDocument.search().sort(-MyDocument.created_at, MyDocument.title)
 ```
 
-When specifying sorting order, the `{{plus}}` and `-` unary operators can be used on the class field attributes to indicate ascending and descending order.
+When specifying sorting order, the `+` and `-` unary operators can be used on the class field attributes to indicate ascending and descending order.
 
 Finally, the `ClassVar` annotation can be used to define a regular class attribute that should not be mapped to the Elasticsearch index:
 
@@ -812,9 +835,8 @@ Finally, the `ClassVar` annotation can be used to define a regular class attribu
 from typing import ClassVar
 
 class MyDoc(Document):
-  title: M[str] created_at: M[datetime] =
-  mapped_field(default_factory=datetime.now) my_var:
-  ClassVar[str] # regular class variable, ignored by Elasticsearch
+    title: M[str] created_at: M[datetime] = mapped_field(default_factory=datetime.now)
+    my_var: ClassVar[str]  # regular class variable, ignored by Elasticsearch
 ```
 
 
@@ -1050,13 +1072,13 @@ You can use standard Python inheritance to extend models, this can be useful in
 
 ```python
 class User(InnerDoc):
-    username = Text(fields={'keyword': Keyword()})
-    email = Text()
+    username: str = mapped_field(Text(fields={'keyword': Keyword()}))
+    email: str
 
 class BaseDocument(Document):
-    created_by = Object(User)
-    created_date = Date()
-    last_updated = Date()
+    created_by: User
+    created_date: datetime
+    last_updated: datetime
 
     def save(**kwargs):
         if not self.created_date:
@@ -1101,7 +1123,7 @@ blogs.document(Post)
 # can also be used as class decorator when defining the Document
 @blogs.document
 class Post(Document):
-    title = Text()
+    title: str
 
 # You can attach custom analyzers to the index
 
@@ -1138,9 +1160,15 @@ dev_blogs.setting(number_of_shards=1)
 
 #### IndexTemplate [index-template]
 
-The DSL module also exposes an option to manage [index templates](docs-content://manage-data/data-store/templates.md) in elasticsearch using the `IndexTemplate` class which has very similar API to `Index`.
+The DSL module also exposes an option to manage [index templates](docs-content://manage-data/data-store/templates.md) in elasticsearch using the `ComposableIndexTemplate` and `IndexTemplate` classes, which have very similar API to `Index`.
 
-Once an index template is saved in elasticsearch it’s contents will be automatically applied to new indices (existing indices are completely unaffected by templates) that match the template pattern (any index starting with `blogs-` in our example), even if the index is created automatically upon indexing a document into that index.
+::::{note}
+Composable index templates should be always be preferred over the legacy index templates, since the latter are deprecated.
+
+::::
+
+
+Once an index template is saved in Elasticsearch its contents will be automatically applied to new indices (existing indices are completely unaffected by templates) that match the template pattern (any index starting with `blogs-` in our example), even if the index is created automatically upon indexing a document into that index.
 
 Potential workflow for a set of time based indices governed by a single template:
 
@@ -1151,14 +1179,11 @@ from elasticsearch.dsl import Document, Date, Text
 
 
 class Log(Document):
-    content = Text()
-    timestamp = Date()
+    content: str
+    timestamp: datetime
 
     class Index:
         name = "logs-*"
-        settings = {
-          "number_of_shards": 2
-        }
 
     def save(self, **kwargs):
         # assign now if no timestamp given
@@ -1170,7 +1195,7 @@ class Log(Document):
         return super().save(**kwargs)
 
 # once, as part of application setup, during deploy/migrations:
-logs = Log._index.as_template('logs', order=0)
+logs = Log._index.as_composable_template('logs', priority=100)
 logs.save()
 
 # to perform search across all logs:
@@ -1184,12 +1209,6 @@ search = Log.search()
 
 The library comes with a simple abstraction aimed at helping you develop faceted navigation for your data.
 
-::::{note}
-This API is experimental and will be subject to change. Any feedback is welcome.
-
-::::
-
-
 ### Configuration [_configuration_2]
 
 You can provide several configuration options (as class attributes) when declaring a `FacetedSearch` subclass:
@@ -1316,7 +1335,7 @@ All methods return a *copy* of the object, making it safe to pass to outside cod
 The API is chainable, allowing you to combine multiple method calls in one statement:
 
 ```python
-ubq = UpdateByQuery().using(client).query("match", title="python")
+ubq = UpdateByQuery().using(client).query(Match("title", python"))
 ```
 
 To send the request to Elasticsearch:
@@ -1406,6 +1425,127 @@ print(response.took)
 If you want to inspect the contents of the `response` objects, just use its `to_dict` method to get access to the raw data for pretty printing.
 
 
+## ES|QL Queries
+
+When working with `Document` classes, you can use the ES|QL query language to retrieve documents. For this you can use the `esql_from()` and `esql_execute()` methods available to all sub-classes of `Document`.
+
+Consider the following `Employee` document definition:
+
+```python
+from elasticsearch.dsl import Document, InnerDoc, M
+
+class Address(InnerDoc):
+    address: M[str]
+    city: M[str]
+    zip_code: M[str]
+
+class Employee(Document):
+    emp_no: M[int]
+    first_name: M[str]
+    last_name: M[str]
+    height: M[float]
+    still_hired: M[bool]
+    address: M[Address]
+
+    class Index:
+        name = 'employees'
+```
+
+The `esql_from()` method creates a base ES|QL query for the index associated with the document class. The following example creates a base query for the `Employee` class:
+
+```python
+query = Employee.esql_from()
+```
+
+This query includes a `FROM` command with the index name, and a `KEEP` command that retrieves all the document attributes.
+
+To execute this query and receive the results, you can pass the query to the `esql_execute()` method:
+
+```python
+for emp in Employee.esql_execute(query):
+    print(f"{emp.name} from {emp.address.city} is {emp.height:.2f}m tall")
+```
+
+In this example, the `esql_execute()` class method runs the query and returns all the documents in the index, up to the maximum of 1000 results allowed by ES|QL. Here is a possible output from this example:
+
+```
+Kevin Macias from North Robert is 1.60m tall
+Drew Harris from Boltonshire is 1.68m tall
+Julie Williams from Maddoxshire is 1.99m tall
+Christopher Jones from Stevenbury is 1.98m tall
+Anthony Lopez from Port Sarahtown is 2.42m tall
+Tricia Stone from North Sueshire is 2.39m tall
+Katherine Ramirez from Kimberlyton is 1.83m tall
+...
+```
+
+To search for specific documents you can extend the base query with additional ES|QL commands that narrow the search criteria. The next example searches for documents that include only employees that are taller than 2 meters, sorted by their last name. It also limits the results to 4 people:
+
+```python
+query = (
+    Employee.esql_from()
+    .where(Employee.height > 2)
+    .sort(Employee.last_name)
+    .limit(4)
+)
+```
+
+When running this query with the same for-loop shown above, possible results would be:
+
+```
+Michael Adkins from North Stacey is 2.48m tall
+Kimberly Allen from Toddside is 2.24m tall
+Crystal Austin from East Michaelchester is 2.30m tall
+Rebecca Berger from Lake Adrianside is 2.40m tall
+```
+
+### Additional fields
+
+ES|QL provides a few ways to add new fields to a query, for example through the `EVAL` command. The following example shows a query that adds an evaluated field:
+
+```python
+from elasticsearch.esql import E, functions
+
+query = (
+    Employee.esql_from()
+    .eval(height_cm=functions.round(Employee.height * 100))
+    .where(E("height_cm") >= 200)
+    .sort(Employee.last_name)
+    .limit(10)
+)
+```
+
+In this example we are adding the height in centimeters to the query, calculated from the `height` document field, which is in meters. The `height_cm` calculated field is available to use in other query clauses, and in particular is referenced in `where()` in this example. Note how the new field is given as `E("height_cm")` in this clause. The `E()` wrapper tells the query builder that the argument is an ES|QL field name and not a string literal. This is done automatically for document fields that are given as class attributes, such as `Employee.height` in the `eval()`. The `E()` wrapper is only needed for fields that are not in the document.
+
+By default, the `esql_execute()` method returns only document instances. To receive any additional fields that are not part of the document in the query results, the `return_additional=True` argument can be passed to it, and then the results are returned as tuples with the document as first element, and a dictionary with the additional fields as second element:
+
+```python
+for emp, additional in Employee.esql_execute(query, return_additional=True):
+    print(emp.name, additional)
+```
+
+Example output from the query given above:
+
+```
+Michael Adkins {'height_cm': 248.0}
+Kimberly Allen {'height_cm': 224.0}
+Crystal Austin {'height_cm': 230.0}
+Rebecca Berger {'height_cm': 240.0}
+Katherine Blake {'height_cm': 214.0}
+Edward Butler {'height_cm': 246.0}
+Steven Carlson {'height_cm': 242.0}
+Mark Carter {'height_cm': 240.0}
+Joseph Castillo {'height_cm': 229.0}
+Alexander Cohen {'height_cm': 245.0}
+```
+
+### Missing fields
+
+The base query returned by the `esql_from()` method includes a `KEEP` command with the complete list of fields that are part of the document. If any subsequent clauses added to the query remove fields that are part of the document, then the `esql_execute()` method will raise an exception, because it will not be able construct complete document instances to return as results.
+
+To prevent errors, it is recommended that the `keep()` and `drop()` clauses are not used when working with `Document` instances.
+
+If a query has missing fields, it can be forced to execute without errors by passing the `ignore_missing_fields=True` argument to `esql_execute()`. When this option is used, returned documents will have any missing fields set to `None`.
 
 ## Using asyncio with Elasticsearch Python DSL [asyncio]
 
@@ -1444,8 +1584,9 @@ Use the `AsyncSearch` class to perform asynchronous searches.
 
 ```python
 from elasticsearch.dsl import AsyncSearch
+from elasticsearch.dsl.query import Match
 
-s = AsyncSearch().query("match", title="python")
+s = AsyncSearch().query(Match("title", "python"))
 async for hit in s:
     print(hit.title)
 ```
@@ -1453,7 +1594,7 @@ async for hit in s:
 Instead of using the `AsyncSearch` object as an asynchronous iterator, you can explicitly call the `execute()` method to get a `Response` object.
 
 ```python
-s = AsyncSearch().query("match", title="python")
+s = AsyncSearch().query(Match("title", "python"))
 response = await s.execute()
 for hit in response:
     print(hit.title)
@@ -1463,11 +1604,12 @@ An `AsyncMultiSearch` is available as well.
 
 ```python
 from elasticsearch.dsl import AsyncMultiSearch
+from elasticsearch.dsl.query import Term
 
 ms = AsyncMultiSearch(index='blogs')
 
-ms = ms.add(AsyncSearch().filter('term', tags='python'))
-ms = ms.add(AsyncSearch().filter('term', tags='elasticsearch'))
+ms = ms.add(AsyncSearch().filter(Term("tags", "python")))
+ms = ms.add(AsyncSearch().filter(Term("tags", "elasticsearch")))
 
 responses = await ms.execute()
 
diff --git a/docs/reference/dsl_migrating.md b/docs/reference/dsl_migrating.md
new file mode 100644
index 000000000..ef4bd9f23
--- /dev/null
+++ b/docs/reference/dsl_migrating.md
@@ -0,0 +1,35 @@
+# Migrating from the `elasticsearch-dsl` package  [_migrating_from_elasticsearch_dsl_package]
+
+In the past the Elasticsearch Python DSL module was distributed as a standalone package called `elasticsearch-dsl`. This package is now deprecated, since all its functionality has been integrated into the main Python client. We recommend all developers to migrate their applications and eliminate their dependency on the `elasticsearch-dsl` package.
+
+To migrate your application, all references to `elasticsearch_dsl` as a top-level package must be changed to `elasticsearch.dsl`. In other words, the underscore from the package name should be replaced by a period.
+
+Here are a few examples:
+
+```python
+# from:
+from elasticsearch_dsl import Date, Document, InnerDoc, Text, connections
+# to:
+from elasticsearch.dsl import Date, Document, InnerDoc, Text, connections
+
+# from:
+from elasticsearch_dsl.query import MultiMatch
+# to:
+from elasticsearch.dsl.query import MultiMatch
+
+# from:
+import elasticsearch_dsl as dsl
+# to:
+from elasticsearch import dsl
+
+# from:
+import elasticsearch_dsl
+# to:
+from elasticsearch import dsl as elasticsearch_dsl
+
+# from:
+import elasticsearch_dsl
+# to:
+from elasticsearch import dsl
+# and replace all references to "elasticsearch_dsl" in the code with "dsl"
+```
diff --git a/docs/reference/_tutorials.md b/docs/reference/dsl_tutorials.md
similarity index 79%
rename from docs/reference/_tutorials.md
rename to docs/reference/dsl_tutorials.md
index 7b72bc04e..16224a13f 100644
--- a/docs/reference/_tutorials.md
+++ b/docs/reference/dsl_tutorials.md
@@ -47,17 +47,17 @@ Let’s rewrite the example using the DSL module:
 
 ```python
 from elasticsearch import Elasticsearch
-from elasticsearch.dsl import Search
+from elasticsearch.dsl import Search, query, aggs
 
 client = Elasticsearch("https://localhost:9200/")
 
 s = Search(using=client, index="my-index") \
-    .filter("term", category="search") \
-    .query("match", title="python")   \
-    .exclude("match", description="beta")
+    .query(query.Match("title", "python"))   \
+    .filter(query.Term("category", "search")) \
+    .exclude(query.Match("description", "beta"))
 
-s.aggs.bucket('per_tag', 'terms', field='tags') \
-    .metric('max_lines', 'max', field='lines')
+s.aggs.bucket('per_tag', aggs.Terms(field="tags")) \
+    .metric('max_lines', aggs.Max(field='lines'))
 
 response = s.execute()
 
@@ -68,9 +68,9 @@ for tag in response.aggregations.per_tag.buckets:
     print(tag.key, tag.max_lines.value)
 ```
 
-As you see, the library took care of:
+As you see, the DSL module took care of:
 
-* creating appropriate `Query` objects by name (eq. "match")
+* creating appropriate `Query` objects from classes
 * composing queries into a compound `bool` query
 * putting the `term` query in a filter context of the `bool` query
 * providing a convenient access to response data
@@ -83,17 +83,17 @@ Let’s have a simple Python class representing an article in a blogging system:
 
 ```python
 from datetime import datetime
-from elasticsearch.dsl import Document, Date, Integer, Keyword, Text, connections
+from elasticsearch.dsl import Document, Date, Integer, Keyword, Text, connections, mapped_field
 
 # Define a default Elasticsearch client
 connections.create_connection(hosts="https://localhost:9200/")
 
 class Article(Document):
-    title = Text(analyzer='snowball', fields={'raw': Keyword()})
-    body = Text(analyzer='snowball')
-    tags = Keyword()
-    published_from = Date()
-    lines = Integer()
+    title: str = mapped_field(Text(analyzer='snowball', fields={'raw': Keyword()}))
+    body: str = mapped_field(Text(analyzer='snowball'))
+    tags: list[str] = mapped_field(Keyword())
+    published_from: datetime
+    lines: int
 
     class Index:
         name = 'blog'
@@ -101,7 +101,7 @@ class Article(Document):
           "number_of_shards": 2,
         }
 
-    def save(self, ** kwargs):
+    def save(self, **kwargs):
         self.lines = len(self.body.split())
         return super(Article, self).save(** kwargs)
 
@@ -127,7 +127,7 @@ print(connections.get_connection().cluster.health())
 In this example you can see:
 
 * providing a default connection
-* defining fields with mapping configuration
+* defining fields with Python type hints and additional mapping configuration when necessary
 * setting index name
 * defining custom methods
 * overriding the built-in `.save()` method to hook into the persistence life cycle
@@ -141,12 +141,6 @@ You can see more in the `persistence` chapter.
 
 If you have your `Document`s defined you can very easily create a faceted search class to simplify searching and filtering.
 
-::::{note}
-This feature is experimental and may be subject to change.
-
-::::
-
-
 ```python
 from elasticsearch.dsl import FacetedSearch, TermsFacet, DateHistogramFacet
 
@@ -208,11 +202,12 @@ Using the DSL, we can now express this query as such:
 ```python
 from elasticsearch import Elasticsearch
 from elasticsearch.dsl import Search, UpdateByQuery
+from elasticsearch.dsl.query import Match
 
 client = Elasticsearch()
 ubq = UpdateByQuery(using=client, index="my-index") \
-      .query("match", title="python")   \
-      .exclude("match", description="beta") \
+      .query(Match("title", "python"))   \
+      .exclude(Match("description", "beta")) \
       .script(source="ctx._source.likes++", lang="painless")
 
 response = ubq.execute()
@@ -221,6 +216,20 @@ response = ubq.execute()
 As you can see, the `Update By Query` object provides many of the savings offered by the `Search` object, and additionally allows one to update the results of the search based on a script assigned in the same manner.
 
 
+## ES|QL Queries
+
+The DSL module features an integration with the ES|QL query builder, consisting of two methods available in all `Document` sub-classes: `esql_from()` and `esql_execute()`. Using the `Article` document from above, we can search for up to ten articles that include `"world"` in their titles with the following ES|QL query:
+
+```python
+from elasticsearch.esql import functions
+
+query = Article.esql_from().where(functions.match(Article.title, 'world')).limit(10)
+for a in Article.esql_execute(query):
+    print(a.title)
+```
+
+Review the [ES|QL Query Builder section](esql-query-builder.md) to learn more about building ES|QL queries in Python.
+
 ## Migration from the standard client [_migration_from_the_standard_client]
 
 You don’t have to port your entire application to get the benefits of the DSL module, you can start gradually by creating a `Search` object from your existing `dict`, modifying it using the API and serializing it back to a `dict`:
@@ -232,7 +241,7 @@ body = {...} # insert complicated query here
 s = Search.from_dict(body)
 
 # Add some filters, aggregations, queries, ...
-s.filter("term", tags="python")
+s.filter(query.Term("tags", "python"))
 
 # Convert back to dict to plug back into existing code
 body = s.to_dict()
diff --git a/docs/reference/elasticsearch-dsl.md b/docs/reference/elasticsearch-dsl.md
index 4030e232d..ad72cb1fe 100644
--- a/docs/reference/elasticsearch-dsl.md
+++ b/docs/reference/elasticsearch-dsl.md
@@ -9,11 +9,12 @@ Elasticsearch DSL is a module of the official Python client that aims to help wi
 
 ```python
 from elasticsearch.dsl import Search
+from elasticsearch.dsl.query import Match, Term
 
 s = Search(index="my-index") \
-    .filter("term", category="search") \
-    .query("match", title="python")   \
-    .exclude("match", description="beta")
+    .query(Match("title", "python")) \
+    .filter(Term("category", "search")) \
+    .exclude(Match("description", "beta"))
 for hit in s:
     print(hit.title)
 ```
@@ -22,12 +23,13 @@ Or with asynchronous Python:
 
 ```python
 from elasticsearch.dsl import AsyncSearch
+from elasticsearch.dsl.query import Match, Term
 
 async def run_query():
     s = AsyncSearch(index="my-index") \
-        .filter("term", category="search") \
-        .query("match", title="python")   \
-        .exclude("match", description="beta")
+        .query(Match("title", "python")) \
+        .filter(Term("category", "search")) \
+        .exclude(Match("description", "beta"))
     async for hit in s:
         print(hit.title)
 ```
diff --git a/docs/reference/esql-pandas.md b/docs/reference/esql-pandas.md
index 506ea6579..5e7e0c886 100644
--- a/docs/reference/esql-pandas.md
+++ b/docs/reference/esql-pandas.md
@@ -355,7 +355,7 @@ You can now analyze the data with Pandas or you can also continue transforming t
 
 ## Analyze the data with Pandas [analyze-data]
 
-In the next example, the [STATS …​ BY](elasticsearch://reference/query-languages/esql/esql-commands.md#esql-stats-by) command is utilized to count how many employees are speaking a given language. The results are sorted with the `languages` column using [SORT](elasticsearch://reference/query-languages/esql/esql-commands.md#esql-sort):
+In the next example, the [STATS … BY](elasticsearch://reference/query-languages/esql/commands/processing-commands.md#esql-stats-by) command is utilized to count how many employees are speaking a given language. The results are sorted with the `languages` column using [SORT](elasticsearch://reference/query-languages/esql/commands/processing-commands.md#esql-sort):
 
 ```python
 response = client.esql.query(
diff --git a/docs/reference/esql-query-builder.md b/docs/reference/esql-query-builder.md
new file mode 100644
index 000000000..7ef9a0960
--- /dev/null
+++ b/docs/reference/esql-query-builder.md
@@ -0,0 +1,260 @@
+# ES|QL Query Builder
+
+::::{warning}
+This functionality is in technical preview and may be changed or removed in a future release. Elastic will work to fix any issues, but features in technical preview are not subject to the support SLA of official GA features.
+::::
+
+The ES|QL Query Builder allows you to construct ES|QL queries using Python syntax. Consider the following example:
+
+```python
+>>> from elasticsearch.esql import ESQL
+>>> query = (
+    ESQL.from_("employees")
+    .sort("emp_no")
+    .keep("first_name", "last_name", "height")
+    .eval(height_feet="height * 3.281", height_cm="height * 100")
+    .limit(3)
+)
+```
+
+You can then see the assembled ES|QL query by printing the resulting query object:
+
+```python
+>>> print(query)
+FROM employees
+| SORT emp_no
+| KEEP first_name, last_name, height
+| EVAL height_feet = height * 3.281, height_cm = height * 100
+| LIMIT 3
+```
+
+To execute this query, you can pass it to the `client.esql.query()` endpoint:
+
+```python
+>>> from elasticsearch import Elasticsearch
+>>> client = Elasticsearch(hosts=[os.environ['ELASTICSEARCH_URL']])
+>>> response = client.esql.query(query=query)
+```
+
+The response body contains a `columns` attribute with the list of columns included in the results, and a `values` attribute with the list of results for the query, each given as a list of column values. Here is a possible response body returned by the example query given above:
+
+```python
+>>> from pprint import pprint
+>>> pprint(response.body)
+{'columns': [{'name': 'first_name', 'type': 'text'},
+             {'name': 'last_name', 'type': 'text'},
+             {'name': 'height', 'type': 'double'},
+             {'name': 'height_feet', 'type': 'double'},
+             {'name': 'height_cm', 'type': 'double'}],
+ 'is_partial': False,
+ 'took': 11,
+ 'values': [['Adrian', 'Wells', 2.424, 7.953144, 242.4],
+            ['Aaron', 'Gonzalez', 1.584, 5.1971, 158.4],
+            ['Miranda', 'Kramer', 1.55, 5.08555, 155]]}
+```
+
+## Creating an ES|QL query
+
+To construct an ES|QL query you start from one of the ES|QL source commands:
+
+### `ESQL.from_`
+
+The `FROM` command selects the indices, data streams or aliases to be queried.
+
+Examples:
+
+```python
+from elasticsearch.esql import ESQL
+
+# FROM employees
+query1 = ESQL.from_("employees")
+
+# FROM <logs-{now/d}>
+query2 = ESQL.from_("<logs-{now/d}>")
+
+# FROM employees-00001, other-employees-*
+query3 = ESQL.from_("employees-00001", "other-employees-*")
+
+# FROM cluster_one:employees-00001, cluster_two:other-employees-*
+query4 = ESQL.from_("cluster_one:employees-00001", "cluster_two:other-employees-*")
+
+# FROM employees METADATA _id
+query5 = ESQL.from_("employees").metadata("_id")
+```
+
+Note how in the last example the optional `METADATA` clause of the `FROM` command is added as a chained method.
+
+### `ESQL.row`
+
+The `ROW` command produces a row with one or more columns, with the values that you specify.
+
+Examples:
+
+```python
+from elasticsearch.esql import ESQL, functions
+
+# ROW a = 1, b = "two", c = null
+query1 = ESQL.row(a=1, b="two", c=None)
+
+# ROW a = [1, 2]
+query2 = ESQL.row(a=[1, 2])
+
+# ROW a = ROUND(1.23, 0)
+query3 = ESQL.row(a=functions.round(1.23, 0))
+```
+
+### `ESQL.show`
+
+The `SHOW` command returns information about the deployment and its capabilities.
+
+Example:
+
+```python
+from elasticsearch.esql import ESQL
+
+# SHOW INFO
+query = ESQL.show("INFO")
+```
+
+## Adding processing commands
+
+Once you have a query object, you can add one or more processing commands to it. The following
+example shows how to create a query that uses the `WHERE` and `LIMIT` commands to filter the
+results:
+
+```python
+from elasticsearch.esql import ESQL
+
+# FROM employees
+# | WHERE still_hired == true
+# | LIMIT 10
+query = ESQL.from_("employees").where("still_hired == true").limit(10)
+```
+
+For a complete list of available commands, review the methods of the [`ESQLBase` class](https://elasticsearch-py.readthedocs.io/en/stable/esql.html) in the Elasticsearch Python API documentation.
+
+## Creating ES|QL Expressions and Conditions
+
+The ES|QL query builder for Python provides two ways to create expressions and conditions in ES|QL queries.
+
+The simplest option is to provide all ES|QL expressions and conditionals as strings. The following example uses this approach to add two calculated columns to the results using the `EVAL` command:
+
+```python
+from elasticsearch.esql import ESQL
+
+# FROM employees
+# | SORT emp_no
+# | KEEP first_name, last_name, height
+# | EVAL height_feet = height * 3.281, height_cm = height * 100
+query = (
+    ESQL.from_("employees")
+    .sort("emp_no")
+    .keep("first_name", "last_name", "height")
+    .eval(height_feet="height * 3.281", height_cm="height * 100")
+)
+```
+
+A more advanced alternative is to replace the strings with Python expressions, which are automatically translated to ES|QL when the query object is rendered to a string. The following example is functionally equivalent to the one above:
+
+```python
+from elasticsearch.esql import ESQL, E
+
+# FROM employees
+# | SORT emp_no
+# | KEEP first_name, last_name, height
+# | EVAL height_feet = height * 3.281, height_cm = height * 100
+query = (
+    ESQL.from_("employees")
+    .sort("emp_no")
+    .keep("first_name", "last_name", "height")
+    .eval(height_feet=E("height") * 3.281, height_cm=E("height") * 100)
+)
+```
+
+Here the `E()` helper function is used as a wrapper to the column name that initiates an ES|QL expression. The `E()` function transforms the given column into an ES|QL expression that can be modified with Python operators.
+
+Here is a second example, which uses a conditional expression in the `WHERE` command:
+
+```python
+from elasticsearch.esql import ESQL
+
+# FROM employees
+# | KEEP first_name, last_name, height
+# | WHERE first_name == "Larry"
+query = (
+    ESQL.from_("employees")
+    .keep("first_name", "last_name", "height")
+    .where('first_name == "Larry"')
+)
+```
+
+Using Python syntax, the condition can be rewritten as follows:
+
+```python
+from elasticsearch.esql import ESQL, E
+
+# FROM employees
+# | KEEP first_name, last_name, height
+# | WHERE first_name == "Larry"
+query = (
+    ESQL.from_("employees")
+    .keep("first_name", "last_name", "height")
+    .where(E("first_name") == "Larry")
+)
+```
+
+### Preventing injection attacks
+
+ES|QL, like most query languages, is vulnerable to [code injection attacks](https://en.wikipedia.org/wiki/Code_injection) if untrusted data provided by users is added to a query. To eliminate this risk, ES|QL allows untrusted data to be given separately from the query as parameters.
+
+Continuing with the example above, let's assume that the application needs a `find_employee_by_name()` function that searches for the name given as an argument. If this argument is received by the application from users, then it is considered untrusted and should not be added to the query directly. Here is how to code the function in a secure manner:
+
+```python
+def find_employee_by_name(name):
+    query = (
+        ESQL.from_("employees")
+        .keep("first_name", "last_name", "height")
+        .where(E("first_name") == E("?"))
+    )
+    return client.esql.query(query=query, params=[name])
+```
+
+Here the part of the query in which the untrusted data needs to be inserted is replaced with a parameter, which in ES|QL is defined by the question mark. When using Python expressions, the parameter must be given as `E("?")` so that it is treated as an expression and not as a literal string.
+
+The list of values given in the `params` argument to the query endpoint are assigned in order to the parameters defined in the query.
+
+## Using ES|QL functions
+
+The ES|QL language includes a rich set of functions that can be used in expressions and conditionals. These can be included in expressions given as strings, as shown in the example below:
+
+```python
+from elasticsearch.esql import ESQL
+
+# FROM employees
+# | KEEP first_name, last_name, height
+# | WHERE LENGTH(first_name) < 4"
+query = (
+    ESQL.from_("employees")
+    .keep("first_name", "last_name", "height")
+    .where("LENGTH(first_name) < 4")
+)
+```
+
+All available ES|QL functions have Python wrappers in the `elasticsearch.esql.functions` module, which can be used when building expressions using Python syntax. Below is the example above coded using Python syntax:
+
+```python
+from elasticsearch.esql import ESQL, functions
+
+# FROM employees
+# | KEEP first_name, last_name, height
+# | WHERE LENGTH(first_name) < 4"
+query = (
+    ESQL.from_("employees")
+    .keep("first_name", "last_name", "height")
+    .where(functions.length(E("first_name")) < 4)
+)
+```
+
+Note that arguments passed to functions are assumed to be literals. When passing field names, parameters or other ES|QL expressions, it is necessary to wrap them with the `E()` helper function so that they are interpreted correctly.
+
+You can find the complete list of available functions in the Python client's [ES|QL API reference documentation](https://elasticsearch-py.readthedocs.io/en/stable/esql.html#module-elasticsearch.esql.functions).
diff --git a/docs/reference/getting-started.md b/docs/reference/getting-started.md
index df413e836..54fce4ec3 100644
--- a/docs/reference/getting-started.md
+++ b/docs/reference/getting-started.md
@@ -41,15 +41,11 @@ client = Elasticsearch(
 
 Your Elasticsearch endpoint can be found on the **My deployment** page of your deployment:
 
-:::{image} ../images/es-endpoint.jpg
-:alt: Finding Elasticsearch endpoint
-:::
+![Finding Elasticsearch endpoint](images/es-endpoint.jpg)
 
 You can generate an API key on the **Management** page under Security.
 
-:::{image} ../images/create-api-key.png
-:alt: Create API key
-:::
+![Create API key](images/create-api-key.png)
 
 For other connection options, refer to the [*Connecting*](/reference/connecting.md) section.
 
diff --git a/docs/images/create-api-key.png b/docs/reference/images/create-api-key.png
similarity index 100%
rename from docs/images/create-api-key.png
rename to docs/reference/images/create-api-key.png
diff --git a/docs/images/es-endpoint.jpg b/docs/reference/images/es-endpoint.jpg
similarity index 100%
rename from docs/images/es-endpoint.jpg
rename to docs/reference/images/es-endpoint.jpg
diff --git a/docs/images/otel-waterfall-retry.png b/docs/reference/images/otel-waterfall-retry.png
similarity index 100%
rename from docs/images/otel-waterfall-retry.png
rename to docs/reference/images/otel-waterfall-retry.png
diff --git a/docs/images/otel-waterfall-with-http.png b/docs/reference/images/otel-waterfall-with-http.png
similarity index 100%
rename from docs/images/otel-waterfall-with-http.png
rename to docs/reference/images/otel-waterfall-with-http.png
diff --git a/docs/images/otel-waterfall-without-http.png b/docs/reference/images/otel-waterfall-without-http.png
similarity index 100%
rename from docs/images/otel-waterfall-without-http.png
rename to docs/reference/images/otel-waterfall-without-http.png
diff --git a/docs/reference/images/python-example.png b/docs/reference/images/python-example.png
new file mode 100644
index 000000000..3eaee6d02
Binary files /dev/null and b/docs/reference/images/python-example.png differ
diff --git a/docs/reference/index.md b/docs/reference/index.md
index 99282dec2..6046d7801 100644
--- a/docs/reference/index.md
+++ b/docs/reference/index.md
@@ -6,7 +6,7 @@ mapped_pages:
 
 # Python [overview]
 
-This is the official low-level Python client for {{es}}. Its goal is to provide common ground for all {{es}}-related code in Python. For this reason, the client is designed to be unopinionated and extendable. An API reference is available on [Read the Docs](https://elasticsearch-py.readthedocs.io).
+This is the official Python client for {{es}}. Its goal is to provide common ground for all {{es}}-related code in Python. For this reason, the client is designed to be unopinionated and extendable. API reference documentation for this client is available on [Read the Docs](https://elasticsearch-py.readthedocs.io).
 
 
 ## Example use [_example_use]
@@ -46,7 +46,7 @@ The client’s features include:
 * Thread safety
 * Pluggable architecture
 
-The client also contains a convenient set of [helpers](https://elasticsearch-py.readthedocs.org/en/master/helpers.md) for some of the more engaging tasks like bulk indexing and reindexing.
+The client also contains a convenient set of [helpers](client-helpers.md) for some of the more engaging tasks like bulk indexing and reindexing.
 
 
 ## Elasticsearch Python DSL [_elasticsearch_python_dsl]
@@ -56,12 +56,21 @@ For a higher level access with more limited scope, have a look at the DSL module
 
 ## Compatibility [_compatibility]
 
-Language clients are forward compatible; meaning that the clients support communicating with greater or equal minor versions of {{es}} without breaking. It does not mean that the clients automatically support new features of newer {{es}} versions; it is only possible after a release of a new client version. For example, a 8.12 client version won’t automatically support the new features of the 8.13 version of {{es}}, the 8.13 client version is required for that. {{es}} language clients are only backwards compatible with default distributions and without guarantees made.
+Language clients are _forward compatible:_ each client version works with equivalent and later minor versions of {{es}} without breaking. 
 
-| Elasticsearch version | elasticsearch-py branch | Supported |
-| --- | --- | --- |
-| main | main |  |
-| 8.x | 8.x | 8.x |
-| 7.x | 7.x | 7.17 |
+Compatibility does not imply full feature parity. New {{es}} features are supported only in equivalent client versions. For example, an 8.12 client fully supports {{es}} 8.12 features and works with 8.13 without breaking; however, it does not support new {{es}} 8.13 features. An 8.13 client fully supports {{es}} 8.13 features.
 
-If you have a need to have multiple versions installed at the same time older versions are also released as `elasticsearch7` and `elasticsearch8`.
+| Elasticsearch version | elasticsearch-py branch |
+| --- | --- |
+| main | main |
+| 9.x | 9.x |
+| 9.x | 8.x |
+| 8.x | 8.x |
+
+{{es}} language clients are also _backward compatible_ across minor versions &mdash; with default distributions and without guarantees. 
+
+:::{tip}
+To upgrade to a new major version, first upgrade {{es}}, then upgrade the Python {{es}} client.
+:::
+
+If you need to work with multiple client versions, note that older versions are also released as `elasticsearch7` and `elasticsearch8`.
diff --git a/docs/reference/opentelemetry.md b/docs/reference/opentelemetry.md
index fb117d505..d2dbb5482 100644
--- a/docs/reference/opentelemetry.md
+++ b/docs/reference/opentelemetry.md
@@ -9,24 +9,18 @@ You can use [OpenTelemetry](https://opentelemetry.io/) to monitor the performanc
 
 The native instrumentation in the Python client follows the [OpenTelemetry Semantic Conventions for {{es}}](https://opentelemetry.io/docs/specs/semconv/database/elasticsearch/). In particular, the instrumentation in the client covers the logical layer of {{es}} requests. A single span per request is created that is processed by the service through the Python client. The following image shows a trace that records the handling of two different {{es}} requests: an `info` request and a `search` request.
 
-:::{image} ../images/otel-waterfall-without-http.png
-:alt: Distributed trace with Elasticsearch spans
-:class: screenshot
-:::
+% TO DO: Use `:class: screenshot`
+![Distributed trace with Elasticsearch spans](images/otel-waterfall-without-http.png)
 
 Usually, OpenTelemetry auto-instrumentation modules come with instrumentation support for HTTP-level communication. In this case, in addition to the logical {{es}} client requests, spans will be captured for the physical HTTP requests emitted by the client. The following image shows a trace with both, {{es}} spans (in blue) and the corresponding HTTP-level spans (in red) after having installed the ``opentelemetry-instrumentation-urllib3`` package:
 
-:::{image} ../images/otel-waterfall-with-http.png
-:alt: Distributed trace with Elasticsearch spans
-:class: screenshot
-:::
+% TO DO: Use `:class: screenshot`
+![Distributed trace with Elasticsearch spans](images/otel-waterfall-with-http.png)
 
 Advanced Python client behavior such as nodes round-robin and request retries are revealed through the combination of logical {{es}} spans and the physical HTTP spans. The following example shows a `search` request in a scenario with two nodes:
 
-:::{image} ../images/otel-waterfall-retry.png
-:alt: Distributed trace with Elasticsearch spans
-:class: screenshot
-:::
+% TO DO: Use `:class: screenshot`
+![Distributed trace with Elasticsearch spans](images/otel-waterfall-retry.png)
 
 The first node is unavailable and results in an HTTP error, while the retry to the second node succeeds. Both HTTP requests are subsumed by the logical {{es}} request span (in blue).
 
@@ -41,7 +35,7 @@ When using the [manual Python OpenTelemetry instrumentation](https://opentelemet
 
 ## Comparison with community instrumentation [_comparison_with_community_instrumentation]
 
-The [commmunity OpenTelemetry Elasticsearch instrumentation](https://opentelemetry-python-contrib.readthedocs.io/en/latest/instrumentation/elasticsearch/elasticsearch.md) also instruments the client and sends OpenTelemetry traces, but was developed before the OpenTelemetry Semantic Conventions for {{es}}, so the traces attributes are inconsistent with other OpenTelemetry Elasticsearch client instrumentations. To avoid tracing the same requests twice, make sure to use only one instrumentation, either by uninstalling the opentelemetry-instrumentation-elasticsearch Python package or by [disabling the native instrumentation](#opentelemetry-config-enable).
+The [commmunity OpenTelemetry Elasticsearch instrumentation](https://opentelemetry-python-contrib.readthedocs.io/en/latest/instrumentation/elasticsearch/elasticsearch.html) also instruments the client and sends OpenTelemetry traces, but was developed before the OpenTelemetry Semantic Conventions for {{es}}, so the traces attributes are inconsistent with other OpenTelemetry Elasticsearch client instrumentations. To avoid tracing the same requests twice, make sure to use only one instrumentation, either by uninstalling the opentelemetry-instrumentation-elasticsearch Python package or by [disabling the native instrumentation](#opentelemetry-config-enable).
 
 
 ### Configuring the OpenTelemetry instrumentation [_configuring_the_opentelemetry_instrumentation]
diff --git a/docs/reference/querying.md b/docs/reference/querying.md
new file mode 100644
index 000000000..a4946d340
--- /dev/null
+++ b/docs/reference/querying.md
@@ -0,0 +1,104 @@
+# Querying
+
+The Python Elasticsearch client provides several ways to send queries to Elasticsearch. This document explains the details of how to construct and execute queries using the client. This document does not cover the DSL module.
+
+## From API URLs to function calls
+
+Elasticsearch APIs are grouped by namespaces.
+
+ * There's the global namespace, with APIs like the Search API (`GET _search`) or the Index API (`PUT /<target>/_doc/<_id>` and related endpoints).
+ * Then there are all the other namespaces, such as:
+   * Indices with APIs like the Create index API (`PUT /my-index`),
+   * ES|QL with the Run an ES|QL query API (`POST /_async`),
+   * and so on.
+
+As a result, when you know which namespace and function you need, you can call the function. Assuming that `client` is an Elasticsearch instance, here is how you would call the examples from above:
+
+* Global namespace: `client.search(...)` and `client.index(...)`
+* Other namespaces:
+  * Indices: `client.indices.create(...)`
+  * ES|QL: `client.esql.query(...)`
+
+How can you figure out the namespace?
+
+* The [Elasticsearch API docs](https://www.elastic.co/docs/api/doc/elasticsearch/) can help, even though the tags it uses do not fully map to namespaces.
+* You can also use the client documentation, by:
+  * browsing the [Elasticsearch API Reference](https://elasticsearch-py.readthedocs.io/en/stable/api.html) page, or
+  * searching for your endpoint using [Read the Docs](https://elasticsearch-py.readthedocs.io/) search, which is powered by Elasticsearch!
+* Finally, for Elasticsearch 8.x, most examples in the [Elasticsearch guide](https://www.elastic.co/guide/en/elasticsearch/reference/current/index.html) are also available in Python. (This is still a work in progress for Elasticsearch 9.x.) In the example below, `client.ingest.put_pipeline(...)` is the function that calls the "Create or update a pipeline" API.
+
+
+![Python code example in the Elasticsearch guide](images/python-example.png)
+
+## Parameters
+
+Now that you know which functions to call, the next step is parameters. To avoid ambiguity, the Python Elasticsearch client mandates keyword arguments. To give an example, let's look at the ["Create an index" API](https://elasticsearch-py.readthedocs.io/en/stable/api/indices.html#elasticsearch.client.IndicesClient.create). There's only one required parameter, `index`, so the minimal form looks like this:
+
+```python
+from elasticsearch import Elasticsearch
+
+client = Elasticsearch("http://localhost:9200/", api_key="...")
+
+client.indices.create(index="my-index")
+```
+
+You can also use other parameters, including the first level of body parameters, such as:
+
+```python
+resp = client.indices.create(
+    index="logs",
+    aliases={"logs-alias": {}},
+    mappings={"name": {"type": "text"}},
+)
+print(resp)
+```
+
+In this case, the client will send to Elasticsearch the following JSON body:
+
+```console
+PUT /logs
+{
+    "aliases": {"logs-alias": {}},
+    "mappings": {"name": {"type": "text"}}
+}
+```
+
+## Unknown parameters or APIs
+
+Like other clients, the Python Elasticsearch client is generated from the [Elasticsearch specification](https://github.com/elastic/elasticsearch-specification). While we strive to keep it up to date, it is not (yet!) perfect, and sometimes body parameters are missing. In this case, you can specify the body directly, as follows:
+
+```python
+resp = client.indices.create(
+    index="logs",
+    body={
+        "aliases": {"logs-alias": {}},
+        "mappings": {"name": {"type": "text"}},
+        "missing_parameter": "foo",
+    }
+)
+print(resp)
+```
+
+In the event where an API is missing, you need to use the low-level `perform_request` function:
+
+```python
+resp = client.perform_request(
+    "PUT",
+    "/logs"
+    index="logs",
+    headers={"content-type": "application/json", "accept": "application/json"},
+    body={
+        "aliases": {"logs-alias": {}},
+        "mappings": {"name": {"type": "text"}},
+        "missing_parameter": "foo",
+    }
+)
+print(resp)
+```
+
+One benefit of this function is that it lets you use arbitrary headers, such as the `es-security-runas-user` header used to [impersonate users](https://www.elastic.co/guide/en/elasticsearch/reference/current/run-as-privilege.html).
+
+
+## Options
+
+You can specify options such as request timeouts or retries using the `.options()` API, see the [Configuration](./configuration.md) page for details.
\ No newline at end of file
diff --git a/docs/reference/toc.yml b/docs/reference/toc.yml
index 8de284050..7e26b7274 100644
--- a/docs/reference/toc.yml
+++ b/docs/reference/toc.yml
@@ -4,6 +4,8 @@ toc:
   - file: installation.md
   - file: connecting.md
   - file: configuration.md
+  - file: querying.md
+  - file: esql-query-builder.md
   - file: async.md
   - file: integrations.md
     children:
@@ -12,8 +14,9 @@ toc:
   - file: examples.md
   - file: elasticsearch-dsl.md
     children:
-      - file: _configuration.md
-      - file: _tutorials.md
-      - file: _how_to_guides.md
-      - file: _examples.md
-  - file: client-helpers.md
\ No newline at end of file
+      - file: dsl_configuration.md
+      - file: dsl_tutorials.md
+      - file: dsl_how_to_guides.md
+      - file: dsl_examples.md
+      - file: dsl_migrating.md
+  - file: client-helpers.md
diff --git a/docs/release-notes/breaking-changes.md b/docs/release-notes/breaking-changes.md
index b79d3cb96..0a354b9ce 100644
--- a/docs/release-notes/breaking-changes.md
+++ b/docs/release-notes/breaking-changes.md
@@ -1,14 +1,11 @@
 ---
-navigation_title: "Elasticsearch Python Client"
+navigation_title: "Breaking changes"
 ---
 
 # Elasticsearch Python Client breaking changes [elasticsearch-python-client-breaking-changes]
-Before you upgrade, carefully review the Elasticsearch Python Client breaking changes and take the necessary steps to mitigate any issues. 
-
-To learn how to upgrade, check out <uprade docs>.
+Breaking changes can impact your Elastic applications, potentially disrupting normal operations. Before you upgrade, carefully review the Elasticsearch Python Client breaking changes and take the necessary steps to mitigate any issues. To learn how to upgrade, check [Upgrade](docs-content://deploy-manage/upgrade.md).
 
 % ## Next version [elasticsearch-python-client-nextversion-breaking-changes]
-% **Release date:** Month day, year
 
 % ::::{dropdown} Title of breaking change 
 % Description of the breaking change.
@@ -17,12 +14,40 @@ To learn how to upgrade, check out <uprade docs>.
 % **Action**<br> Steps for mitigating deprecation impact.
 % ::::
 
-% ## 9.0.0 [elasticsearch-python-client-900-breaking-changes]
-% **Release date:** March 25, 2025
+## 9.0.0 [elasticsearch-python-client-900-breaking-changes]
 
-% ::::{dropdown} Title of breaking change 
-% Description of the breaking change.
-% For more information, check [PR #](PR link).
-% **Impact**<br> Impact of the breaking change.
-% **Action**<br> Steps for mitigating deprecation impact.
-% ::::
\ No newline at end of file
+::::{dropdown} Remove deprecated Elasticsearch() options
+The `timeout`, `randomize_hosts`, `host_info_callback`, `sniffer_timeout`, `sniff_on_connection_fail` and `maxsize` parameters were deprecated in elasticsearch-py 8.0 and are now removed from `Elasticsearch.__init__()`.
+For more information, check [PR #2840](https://github.com/elastic/elasticsearch-py/pull/2840).
+
+**Impact**<br> These parameters were removed in favor of more descriptive versions. Using any of these parameters will prevent instantiating the Elasticsearch client.
+
+**Action**<br> These parameters can be replaced as follows:
+ * `timeout` is now `request_timeout`
+ * `randomize_hosts` is now `randomize_nodes_in_pool`
+ * `host_info_callback` is now `sniffed_node_callback`
+ * `sniffer_timeout` is now `min_delay_between_sniffing`
+ * `sniff_on_connection_fail` is now `sniff_on_node_failure`
+ * `maxsize` is now `connections_per_node`
+::::
+
+::::{dropdown} Remove deprecated url_prefix and use_ssl host keys
+When instantiating a new client, `hosts` can be specified as a dictionary. The `url_prefix` and `use_ssl` keys are no longer allowed.
+For more information, check [PR #2797](https://github.com/elastic/elasticsearch-py/pull/2797).
+
+**Impact**<br>
+Using any of these parameters will prevent instantiating the Elasticsearch client.
+
+**Action**<br>
+The parameters can be replaced as follows:
+ * `use_ssl` isn't needed, as a scheme is required since elasticsearch-py 8.0 (`http` or `https`)
+ * `url_prefix` should be replaced with `path_prefix`, which is more descriptive. This functionality allows you to deploy Elasticsearch under a specific path, such as `http://host:port/path/to/elasticsearch`, instead of the default root path (`http://host:port/`)
+::::
+
+::::{dropdown} Remove APIs
+Elasticsearch 9 removed the kNN search and Unfreeze index APIs.
+
+**Action**<br>
+ * The kNN search API has been replaced by the `knn` option in the search API since Elasticsearch 8.4.
+ * The Unfreeze index API was deprecated in Elasticsearch 7.14 and has been removed in Elasticsearch 9.
+ ::::
diff --git a/docs/release-notes/deprecations.md b/docs/release-notes/deprecations.md
index 1b9bfbb74..3f3fa82a6 100644
--- a/docs/release-notes/deprecations.md
+++ b/docs/release-notes/deprecations.md
@@ -1,14 +1,13 @@
 ---
-navigation_title: "Elasticsearch Python Client"
+navigation_title: "Deprecations"
 ---
 
 # Elasticsearch Python Client deprecations [elasticsearch-python-client-deprecations]
-Review the deprecated functionality for your Elasticsearch Python Client version. While deprecations have no immediate impact, we strongly encourage you update your implementation after you upgrade.
+Over time, certain Elastic functionality becomes outdated and is replaced or removed. To help with the transition, Elastic deprecates functionality for a period before removal, giving you time to update your applications.
 
-To learn how to upgrade, check out <uprade docs>.
+Review the deprecated functionality for Elasticsearch Python Client. While deprecations have no immediate impact, we strongly encourage you update your implementation after you upgrade. To learn how to upgrade, check out [Upgrade](docs-content://deploy-manage/upgrade.md).
 
 % ## Next version [elasticsearch-python-client-versionnext-deprecations]
-% **Release date:** Month day, year
 
 % ::::{dropdown} Deprecation title
 % Description of the deprecation.
@@ -18,7 +17,6 @@ To learn how to upgrade, check out <uprade docs>.
 % ::::
 
 % ## 9.0.0 [elasticsearch-python-client-900-deprecations]
-% **Release date:** March 25, 2025
 
 % ::::{dropdown} Deprecation title
 % Description of the deprecation.
diff --git a/docs/release-notes/index.md b/docs/release-notes/index.md
index 156625560..5c25e8633 100644
--- a/docs/release-notes/index.md
+++ b/docs/release-notes/index.md
@@ -1,27 +1,150 @@
 ---
 navigation_title: "Elasticsearch Python Client"
+mapped_pages:
+  - https://www.elastic.co/guide/en/elasticsearch/client/python-api/current/release-notes.html
 ---
 
 # Elasticsearch Python Client release notes [elasticsearch-python-client-release-notes]
 
-Review the changes, fixes, and more in each version of Elasticsearch Python Client. 
+Review the changes, fixes, and more in each version of Elasticsearch Python Client.
 
 To check for security updates, go to [Security announcements for the Elastic stack](https://discuss.elastic.co/c/announcements/security-announcements/31).
 
-% Release notes include only features, enhancements, and fixes. Add breaking changes, deprecations, and known issues to the applicable release notes sections. 
+% Release notes include only features, enhancements, and fixes. Add breaking changes, deprecations, and known issues to the applicable release notes sections.
 
-% ## version.next [felasticsearch-python-client-next-release-notes]
-% **Release date:** Month day, year
+% ## version.next [elasticsearch-python-client-next-release-notes]
 
 % ### Features and enhancements [elasticsearch-python-client-next-features-enhancements]
-% * 
+% *
 
 % ### Fixes [elasticsearch-python-client-next-fixes]
-% * 
+## 9.0.4 (2025-09-11)
 
-## 9.0.0 [elasticsearch-python-client-900-release-notes]
-**Release date:** March 25, 2025
+* ES|QL query builder integration with the DSL module ([#3058](https://github.com/elastic/elasticsearch-py/pull/3058))
+* ES|QL query builder robustness fixes ([#3017](https://github.com/elastic/elasticsearch-py/pull/3017))
+* Fix ES|QL `multi_match()` signature ([#3052](https://github.com/elastic/elasticsearch-py/pull/3052))
 
-### Features and enhancements [elasticsearch-python-client-900-features-enhancements]
+API
+* Add support for ES|QL query builder objects to ES|QL Query and Async Query APIs
+* Add Transform Set Upgrade Mode API
+* Fix type of `fields` parameter of Term Vectors API to array of strings
+* Fix type of `params` parameter of SQL Query API to array
 
-### Fixes [elasticsearch-python-client-900-fixes]
\ No newline at end of file
+DSL
+* Preserve the `skip_empty` setting in `to_dict()` recursive serializations ([#3041](https://github.com/elastic/elasticsearch-py/pull/3041))
+* Add `primary` attribute to `ShardFailure` type
+* Fix type of `key` attribute of `ArrayPercentilesItem` to float
+                  
+
+## 9.0.3 (2025-07-30)
+
+Enhancements
+
+* ES|QL query builder (technical preview) ([#2997](https://github.com/elastic/elasticsearch-py/pull/2997))
+* Add option to disable accurate reporting of file and line location in warnings (Fixes #3003) ([#3006](https://github.com/elastic/elasticsearch-py/pull/3006))
+
+APIs
+
+* Remove `if_primary_term`, `if_seq_no` and `op_type` from Create API
+* Remove `stored_fields` from Get Source API
+* Remove `master_timeout` from Ingest Get Ip Location Database API
+* Remove `application`, `priviledge` and `username` from the Security Get User API
+* Rename `type_query_string` to `type` in License Post Start Trial API
+* Add `require_data_stream` to Index API
+* Add `settings_filter` to Cluster Get Component Template API
+* Add `cause` to Cluster Put Component Template API
+* Add `ccs_minimize_roundtrips` to EQL Search API
+* Add `keep_alive` and `keep_on_completion` to ES|QL Async Query API
+* Add `format` to ES|QL Async Query Get API
+* Add `allow_no_indices`, `expand_wildcards` and `ignore_available` to Indices Recovery API
+* Add `timeout` to all Inference Put APIs
+* Add `refresh` to Security Get User Profile API
+* Add `wait_for_completion` to the Snapshot Delete API
+
+DSL
+
+* Handle lists in `copy_to` field option correctly (Fixes #2992) ([#2993](https://github.com/elastic/elasticsearch-py/pull/2993))
+* Add `key` to FiltersBucket type
+
+
+
+## 9.0.2 (2025-06-05) [elasticsearch-python-client-902-release-notes]
+
+### DSL
+
+* Add `rescore_vector` to `DenseVectorIndexOptions`
+
+
+## 9.0.1 (2025-04-28) [elasticsearch-python-client-901-release-notes]
+
+### Features and enhancements [elasticsearch-python-client-901-features-enhancements]
+
+* Surface caused_by in ApiError ([#2932](https://github.com/elastic/elasticsearch-py/pull/2932))
+* Clarify Elasticsearch 9.x compatibility ([#2928](https://github.com/elastic/elasticsearch-py/pull/2928))
+* Reorganize Sphinx docs to only include reference pages ([#2776](https://github.com/elastic/elasticsearch-py/pull/2776))
+
+
+## 9.0.0 (2025-04-15) [elasticsearch-python-client-900-release-notes]
+
+:::{tip}
+Upgrade to Elasticsearch 9 before using elasticsearch-py 9.0.0 or later. Using elasticsearch-py 9.0.0 on an Elasticsearch 8 server will fail.
+Since language clients are forward-compatible, you should first upgrade Elasticsearch, then the Elasticsearch client. See the [compatibility documentation](/reference/index.md#_compatibility) for more details.
+:::
+
+### Breaking changes
+
+* Remove deprecated `Elasticsearch()` options ([#2840](https://github.com/elastic/elasticsearch-py/pull/2840))
+* Remove deprecated `url_prefix` and `use_ssl` options ([#2797](https://github.com/elastic/elasticsearch-py/pull/2797))
+
+See the [breaking changes page](breaking-changes.md) for more details.
+
+### Enhancements
+
+* Merge [`elasticsearch-dsl-py`](https://github.com/elastic/elasticsearch-dsl-py/) _ package ([#2736](https://github.com/elastic/elasticsearch-py/pull/2736))
+* Add Python DSL documentation ([#2761](https://github.com/elastic/elasticsearch-py/pull/2761))
+* Autogenerate DSL field classes from schema ([#2780](https://github.com/elastic/elasticsearch-py/pull/2780))
+* Improve DSL documentation examples with class-based queries and type hints ([#2857](https://github.com/elastic/elasticsearch-py/pull/2857))
+* Document the use of `param()` in Python DSL methods ([#2861](https://github.com/elastic/elasticsearch-py/pull/2861))
+* Migrate documentation from AsciiDoc to Markdown format ([#2806](https://github.com/elastic/elasticsearch-py/pull/2806))
+* Document use of sub-clients ([#2798](https://github.com/elastic/elasticsearch-py/pull/2798))
+* Document how to make API calls ([#2843](https://github.com/elastic/elasticsearch-py/pull/2843))
+* Fix `simulate` sub-client documentation ([#2749](https://github.com/elastic/elasticsearch-py/pull/2749))
+
+### APIs
+
+* Remove deprecated `/_knn_search` API
+* Remove Unfreeze an index API
+* Remove `min_compatible_shard_node` from Search and Async Search Submit APIs
+* Remove local parameter from cat alias, Alias exists, and Get alias APIs
+* Remove `verbose` from Index segments API
+* Remove `include_model_definition` from Get trained model configuration info API
+* Remove `wait_for_active_shards` from experimental Get field usage stats API
+* Support soft-deletes in connectors:
+  * Add `hard` to Delete connector API
+  * Add `include_deleted` to Get and List Connector APIs
+* Add `master_timeout` to Migrate to data tiers routing APIs
+* Add `master_timeout` to the Alias exists and Get alias APIs.
+* Add `expand_wildcards` to Create snapshot API
+* Rename incorrect `access_token` to `token` in Logout of OpenID Connect API
+* Add inference APIs: Alibaba Cloud AI Search, Amazon Bedrock, Anthropic, Azure AI Studio, Azure OpenAI, Cohere, Elastic Inference Service (EIS), Elasticsearch, ELSER, Google AI Studio, Google Vertex AI, Hugging Face, Jina AI, Mistral, OpenAI, and Voyage AI
+* Add Elastic Inference Service (EIS) chat completion API
+* Add Reindex legacy backing indices APIs
+* Add Create an index from a source index API
+* Add `include_source_on_error` to Create, Index, Update and Bulk APIs
+* Add Stop async ES|QL query API
+* Add `timeout` to Resolve Cluster API
+* Add `adaptive_allocations` body field to Start and Update a trained model deployment API
+* Rename `index_template_subtitutions` to `index_template_substitutions` in Simulate data ingestion API
+* Add `if_primary_term`, `if_seq_no`, `op_type`, `require_alias` and `require_data_stream` to Create API
+* Add `max_concurrent_shard_requests` to Open point in time API
+* Add `local` and `flat_settings` to Check index templates API
+* Add `reopen` to Update index settings API
+* Add `resource` to Reload search analyzer API
+* Add `lazy` to Roll over to a new index API
+* Add `cause` and `create` to Simulate index template APIs
+* Add inference APIs: Alibaba Cloud AI Search, Amazon Bedrock, Anthropic, Azure AI Studio, Azure OpenAI, Cohere, Elasticsearch, ELSER, Google AI Studio, Google Vertex AI, Hugging Face, Jina AI, Mistral, OpenAI, and Voyage AI
+
+### DSL
+ * Add `ignore_malformed`, `script`,  `on_script_error` and `time_series_dimension` to Boolean field
+ * Add `index` to GeoShape field
+ * Add `search_inference_id` to SemanticText field
diff --git a/docs/release-notes/known-issues.md b/docs/release-notes/known-issues.md
index da93abb27..465030552 100644
--- a/docs/release-notes/known-issues.md
+++ b/docs/release-notes/known-issues.md
@@ -1,5 +1,5 @@
 ---
-navigation_title: "Elasticsearch Python Client"
+navigation_title: "Known issues"
 
 ---
 
diff --git a/docs/sphinx/api_helpers.rst b/docs/sphinx/api_helpers.rst
new file mode 100644
index 000000000..31d5b241d
--- /dev/null
+++ b/docs/sphinx/api_helpers.rst
@@ -0,0 +1,26 @@
+.. _helpers:
+
+Helpers
+=======
+
+.. py:module:: elasticsearch.helpers
+
+Streaming Bulk
+--------------
+.. autofunction:: streaming_bulk
+
+Parallel Bulk
+-------------
+.. autofunction:: parallel_bulk
+
+Bulk
+----
+.. autofunction:: bulk
+
+Scan
+----
+.. autofunction:: scan
+
+Reindex
+-------
+.. autofunction:: reindex
diff --git a/docs/sphinx/async.rst b/docs/sphinx/async.rst
deleted file mode 100644
index 22a49b312..000000000
--- a/docs/sphinx/async.rst
+++ /dev/null
@@ -1,237 +0,0 @@
-Using asyncio with Elasticsearch
-================================
-
- .. py:module:: elasticsearch
-    :no-index:
-
-The ``elasticsearch`` package supports async/await with
-`asyncio <https://docs.python.org/3/library/asyncio.html>`_ and `aiohttp <https://docs.aiohttp.org>`_.
-You can either install ``aiohttp`` directly or use the ``[async]`` extra:
-
- .. code-block:: bash
-
-    $ python -m pip install elasticsearch aiohttp
-
-    # - OR -
-
-    $ python -m pip install elasticsearch[async]
-
-Getting Started with Async
---------------------------
-
-After installation all async API endpoints are available via :class:`~elasticsearch.AsyncElasticsearch`
-and are used in the same way as other APIs, just with an extra ``await``:
-
- .. code-block:: python
-
-    import asyncio
-    from elasticsearch import AsyncElasticsearch
-
-    client = AsyncElasticsearch()
-
-    async def main():
-        resp = await client.search(
-            index="documents",
-            body={"query": {"match_all": {}}},
-            size=20,
-        )
-        print(resp)
-
-    loop = asyncio.get_event_loop()
-    loop.run_until_complete(main())
-
-All APIs that are available under the sync client are also available under the async client.
-
-ASGI Applications and Elastic APM
----------------------------------
-
-`ASGI <https://asgi.readthedocs.io>`_ (Asynchronous Server Gateway Interface) is a new way to
-serve Python web applications making use of async I/O to achieve better performance.
-Some examples of ASGI frameworks include FastAPI, Django 3.0+, and Starlette.
-If you're using one of these frameworks along with Elasticsearch then you
-should be using :py:class:`~elasticsearch.AsyncElasticsearch` to avoid blocking
-the event loop with synchronous network calls for optimal performance.
-
-`Elastic APM <https://www.elastic.co/guide/en/apm/agent/python/current/index.html>`_
-also supports tracing of async Elasticsearch queries just the same as
-synchronous queries. For an example on how to configure ``AsyncElasticsearch`` with
-a popular ASGI framework `FastAPI <https://fastapi.tiangolo.com/>`_ and APM tracing
-there is a `pre-built example <https://github.com/elastic/elasticsearch-py/tree/master/examples/fastapi-apm>`_
-in the ``examples/fastapi-apm`` directory.
-
-Frequently Asked Questions
---------------------------
-
-ValueError when initializing ``AsyncElasticsearch``?
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-If when trying to use ``AsyncElasticsearch`` you receive ``ValueError: You must
-have 'aiohttp' installed to use AiohttpHttpNode`` you should ensure that you
-have ``aiohttp`` installed in your environment (check with ``$ python -m pip
-freeze | grep aiohttp``). Otherwise, async support won't be available.
-
-What about the ``elasticsearch-async`` package?
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Previously asyncio was supported separately via the `elasticsearch-async <https://github.com/elastic/elasticsearch-py-async>`_
-package. The ``elasticsearch-async`` package has been deprecated in favor of
-``AsyncElasticsearch`` provided by the ``elasticsearch`` package
-in v7.8 and onwards.
-
-Receiving 'Unclosed client session / connector' warning?
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-This warning is created by ``aiohttp`` when an open HTTP connection is
-garbage collected. You'll typically run into this when closing your application.
-To resolve the issue ensure that :meth:`~elasticsearch.AsyncElasticsearch.close`
-is called before the :py:class:`~elasticsearch.AsyncElasticsearch` instance is garbage collected.
-
-For example if using FastAPI that might look like this:
-
- .. code-block:: python
-
-    import os
-    from contextlib import asynccontextmanager
-
-    from fastapi import FastAPI
-    from elasticsearch import AsyncElasticsearch
-
-    ELASTICSEARCH_URL = os.environ["ELASTICSEARCH_URL"]
-    client = None
-
-    @asynccontextmanager
-    async def lifespan(app: FastAPI):
-        global client
-        client = AsyncElasticsearch(ELASTICSEARCH_URL)
-        yield
-        await client.close()
-
-    app = FastAPI(lifespan=lifespan)
-
-    @app.get("/")
-    async def main():
-        return await client.info()
-
-You can run this example by saving it to ``main.py`` and executing
-``ELASTICSEARCH_URL=http://localhost:9200 uvicorn main:app``.
-
-
-Async Helpers
--------------
-
-Async variants of all helpers are available in ``elasticsearch.helpers``
-and are all prefixed with ``async_*``. You'll notice that these APIs
-are identical to the ones in the sync :ref:`helpers` documentation.
-
-All async helpers that accept an iterator or generator also accept async iterators
-and async generators.
-
- .. py:module:: elasticsearch.helpers
-    :no-index:
-
-Bulk and Streaming Bulk
-~~~~~~~~~~~~~~~~~~~~~~~
-
- .. autofunction:: async_bulk
-
- .. code-block:: python
-
-    import asyncio
-    from elasticsearch import AsyncElasticsearch
-    from elasticsearch.helpers import async_bulk
-
-    client = AsyncElasticsearch()
-
-    async def gendata():
-        mywords = ['foo', 'bar', 'baz']
-        for word in mywords:
-            yield {
-                "_index": "mywords",
-                "doc": {"word": word},
-            }
-
-    async def main():
-        await async_bulk(client, gendata())
-
-    loop = asyncio.get_event_loop()
-    loop.run_until_complete(main())
-
- .. autofunction:: async_streaming_bulk
-
- .. code-block:: python
-
-    import asyncio
-    from elasticsearch import AsyncElasticsearch
-    from elasticsearch.helpers import async_streaming_bulk
-
-    client = AsyncElasticsearch()
-
-    async def gendata():
-        mywords = ['foo', 'bar', 'baz']
-        for word in mywords:
-            yield {
-                "_index": "mywords",
-                "word": word,
-            }
-
-    async def main():
-        async for ok, result in async_streaming_bulk(client, gendata()):
-            action, result = result.popitem()
-            if not ok:
-                print("failed to %s document %s" % ())
-
-    loop = asyncio.get_event_loop()
-    loop.run_until_complete(main())
-
-Scan
-~~~~
-
- .. autofunction:: async_scan
-
- .. code-block:: python
-
-    import asyncio
-    from elasticsearch import AsyncElasticsearch
-    from elasticsearch.helpers import async_scan
-
-    client = AsyncElasticsearch()
-
-    async def main():
-        async for doc in async_scan(
-            client=client,
-            query={"query": {"match": {"title": "python"}}},
-            index="orders-*"
-        ):
-            print(doc)
-
-    loop = asyncio.get_event_loop()
-    loop.run_until_complete(main())
-
-Reindex
-~~~~~~~
-
- .. autofunction:: async_reindex
-
-
-API Reference
--------------
-
- .. py:module:: elasticsearch
-    :no-index:
-
-The API of :class:`~elasticsearch.AsyncElasticsearch` is nearly identical
-to the API of :class:`~elasticsearch.Elasticsearch` with the exception that
-every API call like :py:func:`~elasticsearch.AsyncElasticsearch.search` is
-an ``async`` function and requires an ``await`` to properly return the response
-body.
-
-AsyncElasticsearch
-~~~~~~~~~~~~~~~~~~
-
- .. note::
-
-    To reference Elasticsearch APIs that are namespaced like ``.indices.create()``
-    refer to the sync API reference. These APIs are identical between sync and async.
-
- .. autoclass:: AsyncElasticsearch
-   :members:
diff --git a/docs/sphinx/async_api_helpers.rst b/docs/sphinx/async_api_helpers.rst
new file mode 100644
index 000000000..61dbb5c24
--- /dev/null
+++ b/docs/sphinx/async_api_helpers.rst
@@ -0,0 +1,29 @@
+Async Helpers
+=============
+
+Async variants of all helpers are available in ``elasticsearch.helpers``
+and are all prefixed with ``async_*``. You'll notice that these APIs
+are identical to the ones in the sync :ref:`helpers` documentation.
+
+All async helpers that accept an iterator or generator also accept async iterators
+and async generators.
+
+ .. py:module:: elasticsearch.helpers
+    :no-index:
+
+Streaming Bulk
+--------------
+ .. autofunction:: async_streaming_bulk
+
+Bulk
+----
+ .. autofunction:: async_bulk
+
+Scan
+----
+ .. autofunction:: async_scan
+
+Reindex
+-------
+ .. autofunction:: async_reindex
+
diff --git a/docs/sphinx/async_dsl.rst b/docs/sphinx/async_dsl.rst
new file mode 100644
index 000000000..89ac8565d
--- /dev/null
+++ b/docs/sphinx/async_dsl.rst
@@ -0,0 +1,49 @@
+.. _async_dsl:
+
+Async DSL
+=========
+
+.. py:module:: elasticsearch.dsl
+   :no-index:
+
+Search
+------
+.. autoclass:: AsyncSearch
+   :inherited-members:
+   :members:
+
+Multi-Search
+------------
+.. autoclass:: AsyncMultiSearch
+   :inherited-members:
+   :members:
+
+Document
+--------
+.. autoclass:: AsyncDocument
+   :inherited-members:
+   :members:
+
+Index
+-----
+.. autoclass:: AsyncIndex
+   :inherited-members:
+   :members:
+
+Mapping
+-------
+.. autoclass:: AsyncMapping
+   :inherited-members:
+   :members:
+
+Faceted Search
+--------------
+.. autoclass:: AsyncFacetedSearch
+   :inherited-members:
+   :members:
+
+Update by Query
+---------------
+.. autoclass:: AsyncUpdateByQuery
+   :inherited-members:
+   :members:
diff --git a/docs/sphinx/async_es_api.rst b/docs/sphinx/async_es_api.rst
new file mode 100644
index 000000000..d4acf2ff0
--- /dev/null
+++ b/docs/sphinx/async_es_api.rst
@@ -0,0 +1,15 @@
+Async Elasticsearch API
+=======================
+
+ .. py:module:: elasticsearch
+    :no-index:
+
+ .. note::
+
+    To reference Elasticsearch APIs that are namespaced like ``.indices.create()``
+    refer to the sync API reference. These APIs are identical between sync and async.
+
+Elasticsearch
+-------------
+ .. autoclass:: AsyncElasticsearch
+   :members:
diff --git a/docs/sphinx/dsl.rst b/docs/sphinx/dsl.rst
new file mode 100644
index 000000000..08ab3c935
--- /dev/null
+++ b/docs/sphinx/dsl.rst
@@ -0,0 +1,49 @@
+.. _dsl:
+
+DSL
+===
+
+.. py:module:: elasticsearch.dsl
+
+Search
+------
+.. autoclass:: Search
+   :inherited-members:
+   :members:
+
+Multi-Search
+------------
+.. autoclass:: MultiSearch
+   :inherited-members:
+   :members:
+
+Document
+--------
+.. autoclass:: Document
+   :inherited-members:
+   :members:
+
+Index
+-----
+.. autoclass:: Index
+   :inherited-members:
+   :members:
+
+Mapping
+-------
+.. autoclass:: Mapping
+   :inherited-members:
+   :members:
+
+Faceted Search
+--------------
+.. autoclass:: FacetedSearch
+   :inherited-members:
+   :members:
+
+Update by Query
+---------------
+.. autoclass:: UpdateByQuery
+   :inherited-members:
+   :members:
+
diff --git a/docs/sphinx/api.rst b/docs/sphinx/es_api.rst
similarity index 95%
rename from docs/sphinx/api.rst
rename to docs/sphinx/es_api.rst
index 61d3214e6..d246ec6f5 100644
--- a/docs/sphinx/api.rst
+++ b/docs/sphinx/es_api.rst
@@ -1,7 +1,7 @@
 .. _api:
 
-Elasticsearch API Reference
-===========================
+Elasticsearch API
+=================
 
 All the API calls map the raw REST API as closely as possible, including the
 distinction between required and optional arguments to the calls. Keyword
diff --git a/docs/sphinx/esql.rst b/docs/sphinx/esql.rst
new file mode 100644
index 000000000..1104b5b97
--- /dev/null
+++ b/docs/sphinx/esql.rst
@@ -0,0 +1,100 @@
+ES|QL Query Builder
+===================
+
+Commands
+--------
+
+.. autoclass:: elasticsearch.esql.ESQL
+   :inherited-members:
+   :members:
+
+.. autoclass:: elasticsearch.esql.esql.ESQLBase
+   :inherited-members:
+   :members:
+   :exclude-members: __init__
+
+.. autoclass:: elasticsearch.esql.esql.From
+   :members:
+   :exclude-members: __init__
+
+.. autoclass:: elasticsearch.esql.esql.Row
+   :members:
+   :exclude-members: __init__
+
+.. autoclass:: elasticsearch.esql.esql.Show
+   :members:
+   :exclude-members: __init__
+
+.. autoclass:: elasticsearch.esql.esql.ChangePoint
+   :members:
+   :exclude-members: __init__
+
+.. autoclass:: elasticsearch.esql.esql.Completion
+   :members:
+   :exclude-members: __init__
+
+.. autoclass:: elasticsearch.esql.esql.Dissect
+   :members:
+   :exclude-members: __init__
+
+.. autoclass:: elasticsearch.esql.esql.Drop
+   :members:
+   :exclude-members: __init__
+
+.. autoclass:: elasticsearch.esql.esql.Enrich
+   :members:
+   :exclude-members: __init__
+
+.. autoclass:: elasticsearch.esql.esql.Eval
+   :members:
+   :exclude-members: __init__
+
+.. autoclass:: elasticsearch.esql.esql.Fork
+   :members:
+   :exclude-members: __init__
+
+.. autoclass:: elasticsearch.esql.esql.Grok
+   :members:
+   :exclude-members: __init__
+
+.. autoclass:: elasticsearch.esql.esql.Keep
+   :members:
+   :exclude-members: __init__
+
+.. autoclass:: elasticsearch.esql.esql.Limit
+   :members:
+   :exclude-members: __init__
+
+.. autoclass:: elasticsearch.esql.esql.LookupJoin
+   :members:
+   :exclude-members: __init__
+
+.. autoclass:: elasticsearch.esql.esql.MvExpand
+   :members:
+   :exclude-members: __init__
+
+.. autoclass:: elasticsearch.esql.esql.Rename
+   :members:
+   :exclude-members: __init__
+
+.. autoclass:: elasticsearch.esql.esql.Sample
+   :members:
+   :exclude-members: __init__
+
+.. autoclass:: elasticsearch.esql.esql.Sort
+   :members:
+   :exclude-members: __init__
+
+.. autoclass:: elasticsearch.esql.esql.Stats
+   :members:
+   :exclude-members: __init__
+
+.. autoclass:: elasticsearch.esql.esql.Where
+   :members:
+   :exclude-members: __init__
+
+Functions
+---------
+
+.. automodule:: elasticsearch.esql.functions
+   :members:
diff --git a/docs/sphinx/helpers.rst b/docs/sphinx/helpers.rst
deleted file mode 100644
index 3390958a8..000000000
--- a/docs/sphinx/helpers.rst
+++ /dev/null
@@ -1,146 +0,0 @@
-.. _helpers:
-
-Helpers
-=======
-
-Collection of simple helper functions that abstract some specifics of the raw API.
-
-Connecting
-----------
-
-.. code-block:: python
-
-    from elasticsearch import Elasticsearch
-    
-    client = Elasticsearch("https://.../", api_key="YOUR_API_KEY")
-
-
-Bulk helpers
-------------
-
-There are several helpers for the ``bulk`` API since its requirement for
-specific formatting and other considerations can make it cumbersome if used directly.
-
-All bulk helpers accept an instance of ``Elasticsearch`` class and an iterable
-``actions`` (any iterable, can also be a generator, which is ideal in most
-cases since it will allow you to index large datasets without the need of
-loading them into memory).
-
-The items in the ``action`` iterable should be the documents we wish to index
-in several formats. The most common one is the same  as returned by
-:meth:`~elasticsearch.Elasticsearch.search`, for example:
-
-.. code:: python
-
-    {
-        '_index': 'index-name',
-        '_id': 42,
-        '_routing': 5,
-        'pipeline': 'my-ingest-pipeline',
-        '_source': {
-            "title": "Hello World!",
-            "body": "..."
-        }
-    }
-
-Alternatively, if `_source` is not present, it will pop all metadata fields
-from the doc and use the rest as the document data:
-
-.. code:: python
-
-    {
-        "_id": 42,
-        "_routing": 5,
-        "title": "Hello World!",
-        "body": "..."
-    }
-
-The :meth:`~elasticsearch.Elasticsearch.bulk` api accepts ``index``, ``create``,
-``delete``, and ``update`` actions. Use the ``_op_type`` field to specify an
-action (``_op_type`` defaults to ``index``):
-
-.. code:: python
-
-    {
-        '_op_type': 'delete',
-        '_index': 'index-name',
-        '_id': 42,
-    }
-    {
-        '_op_type': 'update',
-        '_index': 'index-name',
-        '_id': 42,
-        'doc': {'question': 'The life, universe and everything.'}
-    }
-
-
-Example:
-~~~~~~~~
-
-Lets say we have an iterable of data. Lets say a list of words called ``mywords``
-and we want to index those words into individual documents where the structure of the
-document is like ``{"word": "<myword>"}``.
-
-.. code:: python
-
-    from elasticsearch.helpers import bulk
-
-    def gendata():
-        mywords = ['foo', 'bar', 'baz']
-        for word in mywords:
-            yield {
-                "_index": "mywords",
-                "word": word,
-            }
-
-    bulk(client, gendata())
-
-
-For a more complete and complex example please take a look at
-https://github.com/elastic/elasticsearch-py/blob/main/examples/bulk-ingest
-
-The :meth:`~elasticsearch.Elasticsearch.parallel_bulk` api is a wrapper around the :meth:`~elasticsearch.Elasticsearch.bulk` api to provide threading. :meth:`~elasticsearch.Elasticsearch.parallel_bulk` returns a generator which must be consumed to produce results.
-
-To see the results use:
-
-.. code:: python
-
-    for success, info in parallel_bulk(...):
-    if not success:
-        print('A document failed:', info)
-        
-If you don't care about the results, you can use deque from collections:
-
-.. code:: python
-
-    from collections import deque
-    deque(parallel_bulk(...), maxlen=0)
-
-.. note::
-
-    When reading raw json strings from a file, you can also pass them in
-    directly (without decoding to dicts first). In that case, however, you lose
-    the ability to specify anything (index, op_type and even id) on a per-record
-    basis, all documents will just be sent to elasticsearch to be indexed
-    as-is.
-
-
-.. py:module:: elasticsearch.helpers
-
-.. autofunction:: streaming_bulk
-
-.. autofunction:: parallel_bulk
-
-.. autofunction:: bulk
-
-
-Scan
-----
-
-.. autofunction:: scan
-
-
-Reindex
--------
-
-.. autofunction:: reindex
diff --git a/docs/sphinx/index.rst b/docs/sphinx/index.rst
index 70ab257d3..afbdf0aef 100644
--- a/docs/sphinx/index.rst
+++ b/docs/sphinx/index.rst
@@ -1,140 +1,29 @@
 Python Elasticsearch Client
 ===========================
 
-Official low-level client for Elasticsearch. Its goal is to provide common
-ground for all Elasticsearch-related code in Python; because of this it tries
-to be opinion-free and very extendable.
+Welcome to the API documentation of the official Python client for Elasticsearch!
+The goal of this client is to provide common ground for all Elasticsearch-related
+code in Python; because of this it tries to be opinion-free and very extendable.
 
-`Download the latest version of Elasticsearch <https://www.elastic.co/downloads/elasticsearch>`_
-or
-`sign-up <https://cloud.elastic.co/registration?elektra=en-ess-sign-up-page>`_
-for a free trial of Elastic Cloud.
-
-
-Installation
-------------
-
-Install the ``elasticsearch`` package with `pip
-<https://pypi.org/project/elasticsearch>`_:
-
-.. code-block:: console
-
-    $ python -m pip install elasticsearch
-
-If your application uses async/await in Python you can install with
-the ``async`` extra:
-
-.. code-block:: console
-
-    $ python -m pip install elasticsearch[async]
-
-Read more about `how to use asyncio with this project <async.html>`_.
-
-
-Compatibility
--------------
-
-Language clients are forward compatible; meaning that the clients support
-communicating with greater or equal minor versions of Elasticsearch without
-breaking. It does not mean that the clients automatically support new features
-of newer Elasticsearch versions; it is only possible after a release of a new
-client version. For example, a 8.12 client version won't automatically support
-the new features of the 8.13 version of Elasticsearch, the 8.13 client version
-is required for that. Elasticsearch language clients are only backwards
-compatible with default distributions and without guarantees made.
-
-+-----------------------+-------------------------+-----------+
-| Elasticsearch version | elasticsearch-py branch | Supported |
-+=======================+=========================+===========+
-| main                  | main                    |           |
-+-----------------------+-------------------------+-----------+
-| 8.x                   | 8.x                     | 8.x       |
-+-----------------------+-------------------------+-----------+
-| 7.x                   | 7.x                     | 7.17      |
-+-----------------------+-------------------------+-----------+
-
-If you need multiple versions installed at the same time, versions are
-also released, such as ``elasticsearch7`` and ``elasticsearch8``.
-
-
-Example Usage
--------------
-
-.. code-block:: python
-
-    from datetime import datetime
-    from elasticsearch import Elasticsearch
-
-    client = Elasticsearch("http://localhost:9200/", api_key="YOUR_API_KEY")
-
-    doc = {
-        "author": "kimchy",
-        "text": "Elasticsearch: cool. bonsai cool.",
-        "timestamp": datetime.now(),
-    }
-    resp = client.index(index="test-index", id=1, document=doc)
-    print(resp["result"])
-
-    resp = client.get(index="test-index", id=1)
-    print(resp["_source"])
-
-    client.indices.refresh(index="test-index")
-
-    resp = client.search(index="test-index", query={"match_all": {}})
-    print("Got {} hits:".format(resp["hits"]["total"]["value"]))
-    for hit in resp["hits"]["hits"]:
-        print("{timestamp} {author} {text}".format(**hit["_source"]))
-
-See more examples in the :ref:`quickstart` page.
-
-
-
-Features
---------
-
-This client was designed as very thin wrapper around Elasticsearch's REST API to
-allow for maximum flexibility. This means that there are no opinions in this
-client; it also means that some of the APIs are a little cumbersome to use from
-Python. We have created some :ref:`helpers` to help with this issue as well as
-a more high level library (`elasticsearch-dsl`_) on top of this one to provide
-a more convenient way of working with Elasticsearch.
-
-
-
-Elasticsearch-DSL
------------------
-
-For a more high level client library with more limited scope, have a look at
-`elasticsearch-dsl`_ - a more pythonic library sitting on top of
-``elasticsearch-py``.
-
-`elasticsearch-dsl`_ provides a more convenient and idiomatic way to write and manipulate
-`queries`_ by mirroring the terminology and structure of Elasticsearch JSON DSL
-while exposing the whole range of the DSL from Python
-either directly using defined classes or a queryset-like expressions.
-
-It also provides an optional `persistence layer`_ for working with documents as
-Python objects in an ORM-like fashion: defining mappings, retrieving and saving
-documents, wrapping the document data in user-defined classes.
-
-.. _elasticsearch-dsl: https://elasticsearch-dsl.readthedocs.io/
-.. _queries: https://elasticsearch-dsl.readthedocs.io/en/latest/search_dsl.html
-.. _persistence layer: https://elasticsearch-dsl.readthedocs.io/en/latest/persistence.html#doctype
+High-level documentation for this client is `also available <https://www.elastic.co/docs/reference/elasticsearch/clients/python>`_.
 
+.. toctree::
+   :maxdepth: 2 
 
-Contents
---------
+   es_api
+   esql
+   dsl
+   api_helpers
+   exceptions
 
 .. toctree::
-   :maxdepth: 3
+   :caption: Async
+   :maxdepth: 2
+
+   async_es_api
+   async_dsl
+   async_api_helpers
 
-   quickstart
-   interactive
-   api
-   exceptions
-   async
-   helpers
-   Release Notes <https://www.elastic.co/guide/en/elasticsearch/client/python-api/current/release-notes.html>
 
 License
 -------
diff --git a/docs/sphinx/interactive.rst b/docs/sphinx/interactive.rst
deleted file mode 100644
index 257d2aad1..000000000
--- a/docs/sphinx/interactive.rst
+++ /dev/null
@@ -1,107 +0,0 @@
-.. _interactive:
-
-Interactive examples 
-====================
-
-The `elasticsearch-labs <https://github.com/elastic/elasticsearch-labs>`_ repo contains interactive and executable `Python notebooks <https://github.com/elastic/elasticsearch-labs/tree/main/notebooks>`_, sample apps, and resources for testing out Elasticsearch, using the Python client.
-These examples are mainly focused on vector search, hybrid search and generative AI use cases, but you'll also find examples of basic operations like creating index mappings and performing lexical search.
-
-Search notebooks
-----------------
-
-The `Search <https://github.com/elastic/elasticsearch-labs/tree/main/notebooks/search>`_ folder is a good place to start if you're new to Elasticsearch.
-This folder contains a number of notebooks that demonstrate the fundamentals of Elasticsearch, like indexing vectors, running lexical, semantic and *hybrid* searches, and more.
-
-The following notebooks are available:
-
-0. `Quick start <https://github.com/elastic/elasticsearch-labs/blob/main/notebooks/search/00-quick-start.ipynb>`_
-1. `Keyword, querying, filtering <https://github.com/elastic/elasticsearch-labs/blob/main/notebooks/search/01-keyword-querying-filtering.ipynb>`_
-2. `Hybrid search <https://github.com/elastic/elasticsearch-labs/blob/main/notebooks/search/02-hybrid-search.ipynb>`_
-3. `Semantic search with ELSER <https://github.com/elastic/elasticsearch-labs/blob/main/notebooks/search/03-ELSER.ipynb>`_
-4. `Multilingual semantic search <https://github.com/elastic/elasticsearch-labs/blob/main/notebooks/search/04-multilingual.ipynb>`_
-5. `Query rules <https://github.com/elastic/elasticsearch-labs/blob/main/notebooks/search/05-query-rules.ipynb>`_
-6. `Synonyms API quick start <https://github.com/elastic/elasticsearch-labs/blob/main/notebooks/search/06-synonyms-api.ipynb>`_
-
-Here's a brief overview of what you'll learn in each notebook.
-
-Quick start
-^^^^^^^^^^^
-
-In  the `00-quick-start.ipynb <https://github.com/elastic/elasticsearch-labs/blob/main/notebooks/search/00-quick-start.ipynb>`_ notebook you'll learn how to:
-
-- Use the Elasticsearch Python client for various operations.
-- Create and define an index for a sample dataset with ``dense_vector`` fields.
-- Transform book titles into embeddings using `Sentence Transformers <https://www.sbert.net>`_ and index them into Elasticsearch.
-- Perform k-nearest neighbors (knn) semantic searches.
-- Integrate traditional text-based search with semantic search, for a hybrid search system.
-- Use reciprocal rank fusion (RRF) to intelligently combine search results from different retrieval systems.
-
-Keyword, querying, filtering
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-In the `01-keyword-querying-filtering.ipynb <https://github.com/elastic/elasticsearch-labs/blob/main/notebooks/search/01-keyword-querying-filtering.ipynb>`_ notebook, you'll learn how to:
-
-- Use `query and filter contexts <https://www.elastic.co/guide/en/elasticsearch/reference/current/query-filter-context.html>`_ to search and filter documents in Elasticsearch.
-- Execute full-text searches with ``match`` and ``multi-match`` queries.
-- Query and filter documents based on ``text``, ``number``, ``date``, or ``boolean`` values.
-- Run multi-field searches using the ``multi-match`` query.
-- Prioritize specific fields in the ``multi-match`` query for tailored results.
-
-Hybrid search
-^^^^^^^^^^^^^
-
-In the `02-hybrid-search.ipynb <https://github.com/elastic/elasticsearch-labs/blob/main/notebooks/search/02-hybrid-search.ipynb>`_ notebook, you'll learn how to:
-
-- Combine results of traditional text-based search with semantic search, for a hybrid search system.
-- Transform fields in the sample dataset into embeddings using the Sentence Transformer model and index them into Elasticsearch.
-- Use the `RRF API <https://www.elastic.co/guide/en/elasticsearch/reference/current/rrf.html#rrf-api>`_ to combine the results of a ``match`` query and a ``kNN`` semantic search.
-- Walk through a super simple toy example that demonstrates, step by step, how RRF ranking works.
-
-Semantic search with ELSER
-^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-In the `03-ELSER.ipynb <https://github.com/elastic/elasticsearch-labs/blob/main/notebooks/search/03-ELSER.ipynb>`_ notebook, you'll learn how to:
-
-- Use the Elastic Learned Sparse Encoder (ELSER) for text expansion-powered semantic search, out of the box — without training, fine-tuning, or embeddings generation.
-- Download and deploy the ELSER model in your Elastic environment.
-- Create an Elasticsearch index named `search-movies` with specific mappings and index a dataset of movie descriptions.
-- Create an ingest pipeline containing an inference processor for ELSER model execution.
-- Reindex the data from `search-movies` into another index, `elser-movies`, using the ELSER pipeline for text expansion.
-- Observe the results of running the documents through the model by inspecting the additional terms it adds to documents, which enhance searchability.
-- Perform simple keyword searches on the `elser-movies` index to assess the impact of ELSER's text expansion.
-- Execute ELSER-powered semantic searches using the ``text_expansion`` query.
-
-Multilingual semantic search
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-In the `04-multilingual.ipynb <https://github.com/elastic/elasticsearch-labs/blob/main/notebooks/search/04-multilingual.ipynb>`_ notebook, you'll learn how to:
-
-- Use a multilingual embedding model for semantic search across languages.
-- Transform fields in the sample dataset into embeddings using the Sentence Transformer model and index them into Elasticsearch.
-- Use filtering with a ``kNN`` semantic search.
-- Walk through a super simple toy example that demonstrates, step by step, how multilingual search works across languages, and within non-English languages.
-
-Query rules
-^^^^^^^^^^^
-
-In the `05-query-rules.ipynb <https://github.com/elastic/elasticsearch-labs/blob/main/notebooks/search/05-query-rules.ipynb>`_ notebook, you'll learn how to:
-
-- Use the query rules management APIs to create and edit promotional rules based on contextual queries.
-- Apply these query rules by using the ``rule_query`` in Query DSL.
-
-Synonyms API quick start
-^^^^^^^^^^^^^^^^^^^^^^^^
-
-In the `06-synonyms-api.ipynb <https://github.com/elastic/elasticsearch-labs/blob/main/notebooks/search/06-synonyms-api.ipynb>`_ notebook, you'll learn how to:
-
-- Use the synonyms management API to create a synonyms set to enhance your search recall.
-- Configure an index to use search-time synonyms.
-- Update synonyms in real time.
-- Run queries that are enhanced by synonyms.
-
-Other notebooks
----------------
-
-- `Generative AI <https://github.com/elastic/elasticsearch-labs/tree/main/notebooks/generative-ai>`_. Notebooks that demonstrate various use cases for Elasticsearch as the retrieval engine and vector store for LLM-powered applications.
-- `Integrations <https://github.com/elastic/elasticsearch-labs/blob/main/notebooks/integrations>`_. Notebooks that demonstrate how to integrate popular services and projects with Elasticsearch, including OpenAI, Hugging Face, and LlamaIndex
-- `Langchain <https://github.com/elastic/elasticsearch-labs/tree/main/notebooks/langchain>`_. Notebooks that demonstrate how to integrate Elastic with LangChain, a framework for developing applications powered by language models.
diff --git a/docs/sphinx/quickstart.rst b/docs/sphinx/quickstart.rst
deleted file mode 100644
index f7e527858..000000000
--- a/docs/sphinx/quickstart.rst
+++ /dev/null
@@ -1,167 +0,0 @@
-.. _quickstart:
-
-Quickstart
-==========
-
-This guide shows you how to install the Elasticsearch Python client and perform basic
-operations like indexing or searching documents.
-
-Requirements
-------------
-
-- `Python <https://www.python.org/>`_ 3.8 or newer
-- `pip <https://pip.pypa.io/en/stable/>`_
-
-
-Installation
-------------
-
-To install the client, run the following command:
-
-.. code-block:: console
-
-    $ python -m pip install elasticsearch
-
-
-Connecting
-----------
-
-You can connect to Elastic Cloud using an API key and the Cloud ID.
-
-.. code-block:: python
-
-    from elasticsearch import Elasticsearch
-
-    client = Elasticsearch(cloud_id="YOUR_CLOUD_ID", api_key="YOUR_API_KEY")
-
-Your Cloud ID can be found on the **My deployment** page of your deployment 
-under **Cloud ID**.
-
-You can generate an API key on the **Management** page under Security.
-
-.. image:: _static/images/create-api-key.png
-
-Confirm that the connection was successful.
-
-.. code-block:: python
-
-    print(client.info())
-
-Using the client
-----------------
-
-Time to use Elasticsearch! This section walks you through the most important 
-operations of Elasticsearch. The following examples assume that the Python 
-client was instantiated as above.
-
-Create an index with mappings
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-This is how you create the `my_index` index.
-Optionally, you can first define the expected types of your features with a custom mapping.
-
-.. code-block:: python
-
-    mappings = {
-        "properties": {
-            "foo": {"type": "text"},
-            "bar": {
-                "type": "text",
-                "fields": {
-                    "keyword": {
-                        "type": "keyword",
-                        "ignore_above": 256,
-                    }
-                },
-            },
-        }
-    }
-
-    client.indices.create(index="my_index", mappings=mappings)
-
-Indexing documents
-^^^^^^^^^^^^^^^^^^
-
-This indexes a document with the index API:
-
-.. code-block:: python
-
-    client.index(
-        index="my_index",
-        id="my_document_id",
-        document={
-            "foo": "foo",
-            "bar": "bar",
-        },
-    )
-
-You can also index multiple documents at once with the bulk helper function:
-
-.. code-block:: python
-
-    from elasticsearch import helpers
-
-    def generate_docs():
-        for i in range(10):
-            yield {
-                "_index": "my_index",
-                "foo": f"foo {i}",
-                "bar": "bar",
-            }
-            
-    helpers.bulk(client, generate_docs())
-
-These helpers are the recommended way to perform bulk ingestion. While it is also possible to perform bulk ingestion using ``client.bulk`` directly, the helpers handle retries, ingesting chunk by chunk and more. See the :ref:`helpers` page for more details.
-
-Getting documents
-^^^^^^^^^^^^^^^^^
-
-You can get documents by using the following code:
-
-.. code-block:: python
-    
-    client.get(index="my_index", id="my_document_id")
-
-
-Searching documents
-^^^^^^^^^^^^^^^^^^^
-
-This is how you can create a single match query with the Python client: 
-
-
-.. code-block:: python
-
-    client.search(index="my_index", query={"match": {"foo": {"query": "foo"}}})
-
-
-Updating documents
-^^^^^^^^^^^^^^^^^^
-
-This is how you can update a document, for example to add a new field:
-
-.. code-block:: python
-
-    client.update(
-        index="my_index",
-        id="my_document_id",
-        doc={
-            "foo": "bar",
-            "new_field": "new value",
-        },
-    )
-
-
-Deleting documents
-^^^^^^^^^^^^^^^^^^
-
-.. code-block:: python
-    
-    client.delete(index="my_index", id="my_document_id")
-
-
-Deleting an index
-^^^^^^^^^^^^^^^^^
-
-.. code-block:: python
-    
-    client.indices.delete(index="my_index")
diff --git a/elasticsearch/_async/client/__init__.py b/elasticsearch/_async/client/__init__.py
index 98d006405..69b2ad886 100644
--- a/elasticsearch/_async/client/__init__.py
+++ b/elasticsearch/_async/client/__init__.py
@@ -18,7 +18,6 @@
 
 import logging
 import typing as t
-import warnings
 
 from elastic_transport import (
     AsyncTransport,
@@ -181,37 +180,13 @@ def __init__(
             t.Callable[[t.Dict[str, t.Any], NodeConfig], t.Optional[NodeConfig]]
         ] = None,
         meta_header: t.Union[DefaultType, bool] = DEFAULT,
-        timeout: t.Union[DefaultType, None, float] = DEFAULT,
-        randomize_hosts: t.Union[DefaultType, bool] = DEFAULT,
-        host_info_callback: t.Optional[
-            t.Callable[
-                [t.Dict[str, t.Any], t.Dict[str, t.Union[str, int]]],
-                t.Optional[t.Dict[str, t.Union[str, int]]],
-            ]
-        ] = None,
-        sniffer_timeout: t.Union[DefaultType, None, float] = DEFAULT,
-        sniff_on_connection_fail: t.Union[DefaultType, bool] = DEFAULT,
         http_auth: t.Union[DefaultType, t.Any] = DEFAULT,
-        maxsize: t.Union[DefaultType, int] = DEFAULT,
         # Internal use only
         _transport: t.Optional[AsyncTransport] = None,
     ) -> None:
         if hosts is None and cloud_id is None and _transport is None:
             raise ValueError("Either 'hosts' or 'cloud_id' must be specified")
 
-        if timeout is not DEFAULT:
-            if request_timeout is not DEFAULT:
-                raise ValueError(
-                    "Can't specify both 'timeout' and 'request_timeout', "
-                    "instead only specify 'request_timeout'"
-                )
-            warnings.warn(
-                "The 'timeout' parameter is deprecated in favor of 'request_timeout'",
-                category=DeprecationWarning,
-                stacklevel=2,
-            )
-            request_timeout = timeout
-
         if serializer is not None:
             if serializers is not DEFAULT:
                 raise ValueError(
@@ -220,58 +195,6 @@ def __init__(
                 )
             serializers = {default_mimetype: serializer}
 
-        if randomize_hosts is not DEFAULT:
-            if randomize_nodes_in_pool is not DEFAULT:
-                raise ValueError(
-                    "Can't specify both 'randomize_hosts' and 'randomize_nodes_in_pool', "
-                    "instead only specify 'randomize_nodes_in_pool'"
-                )
-            warnings.warn(
-                "The 'randomize_hosts' parameter is deprecated in favor of 'randomize_nodes_in_pool'",
-                category=DeprecationWarning,
-                stacklevel=2,
-            )
-            randomize_nodes_in_pool = randomize_hosts
-
-        if sniffer_timeout is not DEFAULT:
-            if min_delay_between_sniffing is not DEFAULT:
-                raise ValueError(
-                    "Can't specify both 'sniffer_timeout' and 'min_delay_between_sniffing', "
-                    "instead only specify 'min_delay_between_sniffing'"
-                )
-            warnings.warn(
-                "The 'sniffer_timeout' parameter is deprecated in favor of 'min_delay_between_sniffing'",
-                category=DeprecationWarning,
-                stacklevel=2,
-            )
-            min_delay_between_sniffing = sniffer_timeout
-
-        if sniff_on_connection_fail is not DEFAULT:
-            if sniff_on_node_failure is not DEFAULT:
-                raise ValueError(
-                    "Can't specify both 'sniff_on_connection_fail' and 'sniff_on_node_failure', "
-                    "instead only specify 'sniff_on_node_failure'"
-                )
-            warnings.warn(
-                "The 'sniff_on_connection_fail' parameter is deprecated in favor of 'sniff_on_node_failure'",
-                category=DeprecationWarning,
-                stacklevel=2,
-            )
-            sniff_on_node_failure = sniff_on_connection_fail
-
-        if maxsize is not DEFAULT:
-            if connections_per_node is not DEFAULT:
-                raise ValueError(
-                    "Can't specify both 'maxsize' and 'connections_per_node', "
-                    "instead only specify 'connections_per_node'"
-                )
-            warnings.warn(
-                "The 'maxsize' parameter is deprecated in favor of 'connections_per_node'",
-                category=DeprecationWarning,
-                stacklevel=2,
-            )
-            connections_per_node = maxsize
-
         # Setting min_delay_between_sniffing=True implies sniff_before_requests=True
         if min_delay_between_sniffing is not DEFAULT:
             sniff_before_requests = True
@@ -293,22 +216,7 @@ def __init__(
             )
 
         sniff_callback = None
-        if host_info_callback is not None:
-            if sniffed_node_callback is not None:
-                raise ValueError(
-                    "Can't specify both 'host_info_callback' and 'sniffed_node_callback', "
-                    "instead only specify 'sniffed_node_callback'"
-                )
-            warnings.warn(
-                "The 'host_info_callback' parameter is deprecated in favor of 'sniffed_node_callback'",
-                category=DeprecationWarning,
-                stacklevel=2,
-            )
-
-            sniff_callback = create_sniff_callback(
-                host_info_callback=host_info_callback
-            )
-        elif sniffed_node_callback is not None:
+        if sniffed_node_callback is not None:
             sniff_callback = create_sniff_callback(
                 sniffed_node_callback=sniffed_node_callback
             )
@@ -700,6 +608,7 @@ async def bulk(
           <li>JavaScript: Check out <code>client.helpers.*</code></li>
           <li>.NET: Check out <code>BulkAllObservable</code></li>
           <li>PHP: Check out bulk indexing.</li>
+          <li>Ruby: Check out <code>Elasticsearch::Helpers::BulkHelper</code></li>
           </ul>
           <p><strong>Submitting bulk requests with cURL</strong></p>
           <p>If you're providing text file input to <code>curl</code>, you must use the <code>--data-binary</code> flag instead of plain <code>-d</code>.
@@ -729,9 +638,11 @@ async def bulk(
           Imagine a <code>_bulk?refresh=wait_for</code> request with three documents in it that happen to be routed to different shards in an index with five shards.
           The request will only wait for those three shards to refresh.
           The other two shards that make up the index do not participate in the <code>_bulk</code> request at all.</p>
+          <p>You might want to disable the refresh interval temporarily to improve indexing throughput for large bulk requests.
+          Refer to the linked documentation for step-by-step instructions using the index settings API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-bulk>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-bulk>`_
 
         :param operations:
         :param index: The name of the data stream, index, or index alias to perform bulk
@@ -856,7 +767,7 @@ async def clear_scroll(
           Clear the search context and results for a scrolling search.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-clear-scroll>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-clear-scroll>`_
 
         :param scroll_id: The scroll IDs to clear. To clear all scroll IDs, use `_all`.
         """
@@ -913,7 +824,7 @@ async def close_point_in_time(
           However, keeping points in time has a cost; close them as soon as they are no longer required for search requests.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-open-point-in-time>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-open-point-in-time>`_
 
         :param id: The ID of the point-in-time.
         """
@@ -997,7 +908,7 @@ async def count(
           This means that replicas increase the scalability of the count.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-count>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-count>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases to
             search. It supports wildcards (`*`). To search all data streams and indices,
@@ -1127,6 +1038,8 @@ async def create(
         refresh: t.Optional[
             t.Union[bool, str, t.Literal["false", "true", "wait_for"]]
         ] = None,
+        require_alias: t.Optional[bool] = None,
+        require_data_stream: t.Optional[bool] = None,
         routing: t.Optional[str] = None,
         timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         version: t.Optional[int] = None,
@@ -1194,7 +1107,7 @@ async def create(
           The <code>_shards</code> section of the API response reveals the number of shard copies on which replication succeeded and failed.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-create>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-create>`_
 
         :param index: The name of the data stream or index to target. If the target doesn't
             exist and matches the name or wildcard (`*`) pattern of an index template
@@ -1214,6 +1127,9 @@ async def create(
         :param refresh: If `true`, Elasticsearch refreshes the affected shards to make
             this operation visible to search. If `wait_for`, it waits for a refresh to
             make this operation visible to search. If `false`, it does nothing with refreshes.
+        :param require_alias: If `true`, the destination must be an index alias.
+        :param require_data_stream: If `true`, the request's actions must target a data
+            stream (existing or to be created).
         :param routing: A custom value that is used to route operations to a specific
             shard.
         :param timeout: The period the request waits for the following operations: automatic
@@ -1262,6 +1178,10 @@ async def create(
             __query["pretty"] = pretty
         if refresh is not None:
             __query["refresh"] = refresh
+        if require_alias is not None:
+            __query["require_alias"] = require_alias
+        if require_data_stream is not None:
+            __query["require_data_stream"] = require_data_stream
         if routing is not None:
             __query["routing"] = routing
         if timeout is not None:
@@ -1338,7 +1258,7 @@ async def delete(
           It then gets redirected into the primary shard within that ID group and replicated (if needed) to shard replicas within that ID group.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-delete>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-delete>`_
 
         :param index: The name of the target index.
         :param id: A unique identifier for the document.
@@ -1407,7 +1327,7 @@ async def delete(
         )
 
     @_rewrite_parameters(
-        body_fields=("max_docs", "query", "slice"),
+        body_fields=("max_docs", "query", "slice", "sort"),
         parameter_aliases={"from": "from_"},
     )
     async def delete_by_query(
@@ -1451,7 +1371,12 @@ async def delete_by_query(
         ] = None,
         slice: t.Optional[t.Mapping[str, t.Any]] = None,
         slices: t.Optional[t.Union[int, t.Union[str, t.Literal["auto"]]]] = None,
-        sort: t.Optional[t.Sequence[str]] = None,
+        sort: t.Optional[
+            t.Union[
+                t.Sequence[t.Union[str, t.Mapping[str, t.Any]]],
+                t.Union[str, t.Mapping[str, t.Any]],
+            ]
+        ] = None,
         stats: t.Optional[t.Sequence[str]] = None,
         terminate_after: t.Optional[int] = None,
         timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
@@ -1527,7 +1452,7 @@ async def delete_by_query(
           The get task status API will continue to list the delete by query task until this task checks that it has been cancelled and terminates itself.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-delete-by-query>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-delete-by-query>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases to
             search. It supports wildcards (`*`). To search all data streams or indices,
@@ -1553,7 +1478,7 @@ async def delete_by_query(
             If the request can target data streams, this argument determines whether
             wildcard expressions match hidden data streams. It supports comma-separated
             values, such as `open,hidden`.
-        :param from_: Starting offset (default: 0)
+        :param from_: Skips the specified number of documents.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
         :param lenient: If `true`, format-based query failures (such as providing text
@@ -1583,7 +1508,7 @@ async def delete_by_query(
         :param slice: Slice the request manually using the provided slice ID and total
             number of slices.
         :param slices: The number of slices this task should be divided into.
-        :param sort: A comma-separated list of `<field>:<direction>` pairs.
+        :param sort: A sort object that specifies the order of deleted documents.
         :param stats: The specific `tag` of the request for logging and statistical purposes.
         :param terminate_after: The maximum number of documents to collect for each shard.
             If a query reaches this limit, Elasticsearch terminates the query early.
@@ -1673,8 +1598,6 @@ async def delete_by_query(
             __query["search_type"] = search_type
         if slices is not None:
             __query["slices"] = slices
-        if sort is not None:
-            __query["sort"] = sort
         if stats is not None:
             __query["stats"] = stats
         if terminate_after is not None:
@@ -1694,6 +1617,8 @@ async def delete_by_query(
                 __body["query"] = query
             if slice is not None:
                 __body["slice"] = slice
+            if sort is not None:
+                __body["sort"] = sort
         __headers = {"accept": "application/json", "content-type": "application/json"}
         return await self.perform_request(  # type: ignore[return-value]
             "POST",
@@ -1724,7 +1649,7 @@ async def delete_by_query_rethrottle(
           Rethrottling that speeds up the query takes effect immediately but rethrotting that slows down the query takes effect after completing the current batch to prevent scroll timeouts.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-delete-by-query-rethrottle>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-delete-by-query-rethrottle>`_
 
         :param task_id: The ID for the task.
         :param requests_per_second: The throttle for this request in sub-requests per
@@ -1774,7 +1699,7 @@ async def delete_script(
           Deletes a stored script or search template.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-delete-script>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-delete-script>`_
 
         :param id: The identifier for the stored script or search template.
         :param master_timeout: The period to wait for a connection to the master node.
@@ -1858,7 +1783,7 @@ async def exists(
           Elasticsearch cleans up deleted documents in the background as you continue to index more data.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-get>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-get>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases. It
             supports wildcards (`*`).
@@ -1981,7 +1906,7 @@ async def exists_source(
           <p>A document's source is not available if it is disabled in the mapping.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-get>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-get>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases. It
             supports wildcards (`*`).
@@ -2087,7 +2012,7 @@ async def explain(
           It computes a score explanation for a query and a specific document.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-explain>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-explain>`_
 
         :param index: Index names that are used to limit the request. Only a single index
             name can be provided to this parameter.
@@ -2222,7 +2147,7 @@ async def field_caps(
           For example, a runtime field with a type of keyword is returned the same as any other field that belongs to the <code>keyword</code> family.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-field-caps>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-field-caps>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (*). To target all data streams
@@ -2383,12 +2308,12 @@ async def get(
           Elasticsearch cleans up deleted documents in the background as you continue to index more data.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-get>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-get>`_
 
         :param index: The name of the index that contains the document.
         :param id: A unique document identifier.
         :param force_synthetic_source: Indicates whether the request forces synthetic
-            `_source`. Use this paramater to test if the mapping supports synthetic `_source`
+            `_source`. Use this parameter to test if the mapping supports synthetic `_source`
             and to get a sense of the worst case performance. Fetches with this parameter
             enabled will be slower than enabling synthetic source natively in the index.
         :param preference: The node or shard the operation should be performed on. By
@@ -2419,8 +2344,8 @@ async def get(
         :param stored_fields: A comma-separated list of stored fields to return as part
             of a hit. If no fields are specified, no stored fields are included in the
             response. If this field is specified, the `_source` parameter defaults to
-            `false`. Only leaf fields can be retrieved with the `stored_field` option.
-            Object fields can't be returned;​if specified, the request fails.
+            `false`. Only leaf fields can be retrieved with the `stored_fields` option.
+            Object fields can't be returned; if specified, the request fails.
         :param version: The version number for concurrency control. It must match the
             current version of the document for the request to succeed.
         :param version_type: The version type.
@@ -2490,7 +2415,7 @@ async def get_script(
           Retrieves a stored script or search template.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-get-script>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-get-script>`_
 
         :param id: The identifier for the stored script or search template.
         :param master_timeout: The period to wait for the master node. If the master
@@ -2539,7 +2464,7 @@ async def get_script_context(
           <p>Get a list of supported script contexts and their methods.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-get-script-context>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-get-script-context>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_script_context"
@@ -2578,7 +2503,7 @@ async def get_script_languages(
           <p>Get a list of available script types, languages, and contexts.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-get-script-languages>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-get-script-languages>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_script_language"
@@ -2624,7 +2549,6 @@ async def get_source(
         source: t.Optional[t.Union[bool, t.Union[str, t.Sequence[str]]]] = None,
         source_excludes: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         source_includes: t.Optional[t.Union[str, t.Sequence[str]]] = None,
-        stored_fields: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         version: t.Optional[int] = None,
         version_type: t.Optional[
             t.Union[str, t.Literal["external", "external_gte", "force", "internal"]]
@@ -2643,7 +2567,7 @@ async def get_source(
           </code></pre>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-get>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-get>`_
 
         :param index: The name of the index that contains the document.
         :param id: A unique document identifier.
@@ -2661,8 +2585,6 @@ async def get_source(
             the response.
         :param source_includes: A comma-separated list of source fields to include in
             the response.
-        :param stored_fields: A comma-separated list of stored fields to return as part
-            of a hit.
         :param version: The version number for concurrency control. It must match the
             current version of the document for the request to succeed.
         :param version_type: The version type.
@@ -2696,8 +2618,6 @@ async def get_source(
             __query["_source_excludes"] = source_excludes
         if source_includes is not None:
             __query["_source_includes"] = source_includes
-        if stored_fields is not None:
-            __query["stored_fields"] = stored_fields
         if version is not None:
             __query["version"] = version
         if version_type is not None:
@@ -2743,7 +2663,7 @@ async def health_report(
           When setting up automated polling of the API for health status, set verbose to false to disable the more expensive analysis logic.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-health-report>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-health-report>`_
 
         :param feature: A feature of the cluster, as returned by the top-level health
             report API.
@@ -2806,6 +2726,7 @@ async def index(
             t.Union[bool, str, t.Literal["false", "true", "wait_for"]]
         ] = None,
         require_alias: t.Optional[bool] = None,
+        require_data_stream: t.Optional[bool] = None,
         routing: t.Optional[str] = None,
         timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         version: t.Optional[int] = None,
@@ -2908,7 +2829,7 @@ async def index(
           </code></pre>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-create>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-create>`_
 
         :param index: The name of the data stream or index to target. If the target doesn't
             exist and matches the name or wildcard (`*`) pattern of an index template
@@ -2941,6 +2862,8 @@ async def index(
             this operation visible to search. If `wait_for`, it waits for a refresh to
             make this operation visible to search. If `false`, it does nothing with refreshes.
         :param require_alias: If `true`, the destination must be an index alias.
+        :param require_data_stream: If `true`, the request's actions must target a data
+            stream (existing or to be created).
         :param routing: A custom value that is used to route operations to a specific
             shard.
         :param timeout: The period the request waits for the following operations: automatic
@@ -3002,6 +2925,8 @@ async def index(
             __query["refresh"] = refresh
         if require_alias is not None:
             __query["require_alias"] = require_alias
+        if require_data_stream is not None:
+            __query["require_data_stream"] = require_data_stream
         if routing is not None:
             __query["routing"] = routing
         if timeout is not None:
@@ -3037,10 +2962,11 @@ async def info(
         .. raw:: html
 
           <p>Get cluster info.
-          Get basic build, version, and cluster information.</p>
+          Get basic build, version, and cluster information.
+          ::: In Serverless, this API is retained for backward compatibility only. Some response fields, such as the version number, should be ignored.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/group/endpoint-info>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/group/endpoint-info>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/"
@@ -3063,127 +2989,6 @@ async def info(
             path_parts=__path_parts,
         )
 
-    @_rewrite_parameters(
-        body_fields=(
-            "knn",
-            "docvalue_fields",
-            "fields",
-            "filter",
-            "source",
-            "stored_fields",
-        ),
-        parameter_aliases={"_source": "source"},
-    )
-    @_stability_warning(Stability.EXPERIMENTAL)
-    async def knn_search(
-        self,
-        *,
-        index: t.Union[str, t.Sequence[str]],
-        knn: t.Optional[t.Mapping[str, t.Any]] = None,
-        docvalue_fields: t.Optional[t.Sequence[t.Mapping[str, t.Any]]] = None,
-        error_trace: t.Optional[bool] = None,
-        fields: t.Optional[t.Union[str, t.Sequence[str]]] = None,
-        filter: t.Optional[
-            t.Union[t.Mapping[str, t.Any], t.Sequence[t.Mapping[str, t.Any]]]
-        ] = None,
-        filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
-        human: t.Optional[bool] = None,
-        pretty: t.Optional[bool] = None,
-        routing: t.Optional[str] = None,
-        source: t.Optional[t.Union[bool, t.Mapping[str, t.Any]]] = None,
-        stored_fields: t.Optional[t.Union[str, t.Sequence[str]]] = None,
-        body: t.Optional[t.Dict[str, t.Any]] = None,
-    ) -> ObjectApiResponse[t.Any]:
-        """
-        .. raw:: html
-
-          <p>Run a knn search.</p>
-          <p>NOTE: The kNN search API has been replaced by the <code>knn</code> option in the search API.</p>
-          <p>Perform a k-nearest neighbor (kNN) search on a dense_vector field and return the matching documents.
-          Given a query vector, the API finds the k closest vectors and returns those documents as search hits.</p>
-          <p>Elasticsearch uses the HNSW algorithm to support efficient kNN search.
-          Like most kNN algorithms, HNSW is an approximate method that sacrifices result accuracy for improved search speed.
-          This means the results returned are not always the true k closest neighbors.</p>
-          <p>The kNN search API supports restricting the search using a filter.
-          The search will return the top k documents that also match the filter query.</p>
-          <p>A kNN search response has the exact same structure as a search API response.
-          However, certain sections have a meaning specific to kNN search:</p>
-          <ul>
-          <li>The document <code>_score</code> is determined by the similarity between the query and document vector.</li>
-          <li>The <code>hits.total</code> object contains the total number of nearest neighbor candidates considered, which is <code>num_candidates * num_shards</code>. The <code>hits.total.relation</code> will always be <code>eq</code>, indicating an exact value.</li>
-          </ul>
-
-
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/knn-search-api.html>`_
-
-        :param index: A comma-separated list of index names to search; use `_all` or
-            to perform the operation on all indices.
-        :param knn: The kNN query to run.
-        :param docvalue_fields: The request returns doc values for field names matching
-            these patterns in the `hits.fields` property of the response. It accepts
-            wildcard (`*`) patterns.
-        :param fields: The request returns values for field names matching these patterns
-            in the `hits.fields` property of the response. It accepts wildcard (`*`)
-            patterns.
-        :param filter: A query to filter the documents that can match. The kNN search
-            will return the top `k` documents that also match this filter. The value
-            can be a single query or a list of queries. If `filter` isn't provided, all
-            documents are allowed to match.
-        :param routing: A comma-separated list of specific routing values.
-        :param source: Indicates which source fields are returned for matching documents.
-            These fields are returned in the `hits._source` property of the search response.
-        :param stored_fields: A list of stored fields to return as part of a hit. If
-            no fields are specified, no stored fields are included in the response. If
-            this field is specified, the `_source` parameter defaults to `false`. You
-            can pass `_source: true` to return both source fields and stored fields in
-            the search response.
-        """
-        if index in SKIP_IN_PATH:
-            raise ValueError("Empty value passed for parameter 'index'")
-        if knn is None and body is None:
-            raise ValueError("Empty value passed for parameter 'knn'")
-        __path_parts: t.Dict[str, str] = {"index": _quote(index)}
-        __path = f'/{__path_parts["index"]}/_knn_search'
-        __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 routing is not None:
-            __query["routing"] = routing
-        if not __body:
-            if knn is not None:
-                __body["knn"] = knn
-            if docvalue_fields is not None:
-                __body["docvalue_fields"] = docvalue_fields
-            if fields is not None:
-                __body["fields"] = fields
-            if filter is not None:
-                __body["filter"] = filter
-            if source is not None:
-                __body["_source"] = source
-            if stored_fields is not None:
-                __body["stored_fields"] = stored_fields
-        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="knn_search",
-            path_parts=__path_parts,
-        )
-
     @_rewrite_parameters(
         body_fields=("docs", "ids"),
         parameter_aliases={
@@ -3230,7 +3035,7 @@ async def mget(
           You can include the <code>stored_fields</code> query parameter in the request URI to specify the defaults to use when there are no per-document instructions.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-mget>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-mget>`_
 
         :param index: Name of the index to retrieve documents from when `ids` are specified,
             or when a document in the `docs` array does not specify an index.
@@ -3365,7 +3170,7 @@ async def msearch(
           When sending requests to this endpoint the <code>Content-Type</code> header should be set to <code>application/x-ndjson</code>.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-msearch>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-msearch>`_
 
         :param searches:
         :param index: Comma-separated list of data streams, indices, and index aliases
@@ -3392,7 +3197,8 @@ async def msearch(
             computationally expensive named queries on a large number of hits may add
             significant overhead.
         :param max_concurrent_searches: Maximum number of concurrent searches the multi
-            search API can execute.
+            search API can execute. Defaults to `max(1, (# of data nodes * min(search
+            thread pool size, 10)))`.
         :param max_concurrent_shard_requests: Maximum number of concurrent shard requests
             that each sub-search request executes per node.
         :param pre_filter_shard_size: Defines a threshold that enforces a pre-filter
@@ -3511,7 +3317,7 @@ async def msearch_template(
           </code></pre>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-msearch-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-msearch-template>`_
 
         :param search_templates:
         :param index: A comma-separated list of data streams, indices, and aliases to
@@ -3616,7 +3422,7 @@ async def mtermvectors(
           The mapping used is determined by the specified <code>_index</code>.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-mtermvectors>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-mtermvectors>`_
 
         :param index: The name of the index that contains the documents.
         :param docs: An array of existing or artificial documents.
@@ -3720,6 +3526,7 @@ async def open_point_in_time(
         human: t.Optional[bool] = None,
         ignore_unavailable: t.Optional[bool] = None,
         index_filter: t.Optional[t.Mapping[str, t.Any]] = None,
+        max_concurrent_shard_requests: t.Optional[int] = None,
         preference: t.Optional[str] = None,
         pretty: t.Optional[bool] = None,
         routing: t.Optional[str] = None,
@@ -3756,7 +3563,7 @@ async def open_point_in_time(
           You can check how many point-in-times (that is, search contexts) are open with the nodes stats API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-open-point-in-time>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-open-point-in-time>`_
 
         :param index: A comma-separated list of index names to open point in time; use
             `_all` or empty string to perform the operation on all indices
@@ -3769,12 +3576,13 @@ async def open_point_in_time(
         :param expand_wildcards: The type of index that wildcard patterns can match.
             If the request can target data streams, this argument determines whether
             wildcard expressions match hidden data streams. It supports comma-separated
-            values, such as `open,hidden`. Valid values are: `all`, `open`, `closed`,
-            `hidden`, `none`.
+            values, such as `open,hidden`.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
         :param index_filter: Filter indices if the provided query rewrites to `match_none`
             on every shard.
+        :param max_concurrent_shard_requests: Maximum number of concurrent shard requests
+            that each sub-search request executes per node.
         :param preference: The node or shard the operation should be performed on. By
             default, it is random.
         :param routing: A custom value that is used to route operations to a specific
@@ -3802,6 +3610,8 @@ async def open_point_in_time(
             __query["human"] = human
         if ignore_unavailable is not None:
             __query["ignore_unavailable"] = ignore_unavailable
+        if max_concurrent_shard_requests is not None:
+            __query["max_concurrent_shard_requests"] = max_concurrent_shard_requests
         if preference is not None:
             __query["preference"] = preference
         if pretty is not None:
@@ -3850,7 +3660,7 @@ async def put_script(
           Creates or updates a stored script or search template.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-put-script>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-put-script>`_
 
         :param id: The identifier for the stored script or search template. It must be
             unique within the cluster.
@@ -3940,7 +3750,7 @@ async def rank_eval(
           <p>Evaluate the quality of ranked search results over a set of typical search queries.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-rank-eval>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-rank-eval>`_
 
         :param requests: A set of typical search requests, together with their provided
             ratings.
@@ -4066,113 +3876,17 @@ async def reindex(
           In this case, the response includes a count of the version conflicts that were encountered.
           Note that the handling of other error types is unaffected by the <code>conflicts</code> property.
           Additionally, if you opt to count version conflicts, the operation could attempt to reindex more documents from the source than <code>max_docs</code> until it has successfully indexed <code>max_docs</code> documents into the target or it has gone through every document in the source query.</p>
-          <p>NOTE: The reindex API makes no effort to handle ID collisions.
-          The last document written will &quot;win&quot; but the order isn't usually predictable so it is not a good idea to rely on this behavior.
-          Instead, make sure that IDs are unique by using a script.</p>
-          <p><strong>Running reindex asynchronously</strong></p>
-          <p>If the request contains <code>wait_for_completion=false</code>, Elasticsearch performs some preflight checks, launches the request, and returns a task you can use to cancel or get the status of the task.
-          Elasticsearch creates a record of this task as a document at <code>_tasks/&lt;task_id&gt;</code>.</p>
-          <p><strong>Reindex from multiple sources</strong></p>
-          <p>If you have many sources to reindex it is generally better to reindex them one at a time rather than using a glob pattern to pick up multiple sources.
-          That way you can resume the process if there are any errors by removing the partially completed source and starting over.
-          It also makes parallelizing the process fairly simple: split the list of sources to reindex and run each list in parallel.</p>
-          <p>For example, you can use a bash script like this:</p>
-          <pre><code>for index in i1 i2 i3 i4 i5; do
-            curl -HContent-Type:application/json -XPOST localhost:9200/_reindex?pretty -d'{
-              &quot;source&quot;: {
-                &quot;index&quot;: &quot;'$index'&quot;
-              },
-              &quot;dest&quot;: {
-                &quot;index&quot;: &quot;'$index'-reindexed&quot;
-              }
-            }'
-          done
-          </code></pre>
-          <p><strong>Throttling</strong></p>
-          <p>Set <code>requests_per_second</code> to any positive decimal number (<code>1.4</code>, <code>6</code>, <code>1000</code>, for example) to throttle the rate at which reindex issues batches of index operations.
-          Requests are throttled by padding each batch with a wait time.
-          To turn off throttling, set <code>requests_per_second</code> to <code>-1</code>.</p>
-          <p>The throttling is done by waiting between batches so that the scroll that reindex uses internally can be given a timeout that takes into account the padding.
-          The padding time is the difference between the batch size divided by the <code>requests_per_second</code> and the time spent writing.
-          By default the batch size is <code>1000</code>, so if <code>requests_per_second</code> is set to <code>500</code>:</p>
-          <pre><code>target_time = 1000 / 500 per second = 2 seconds
-          wait_time = target_time - write_time = 2 seconds - .5 seconds = 1.5 seconds
-          </code></pre>
-          <p>Since the batch is issued as a single bulk request, large batch sizes cause Elasticsearch to create many requests and then wait for a while before starting the next set.
-          This is &quot;bursty&quot; instead of &quot;smooth&quot;.</p>
-          <p><strong>Slicing</strong></p>
-          <p>Reindex supports sliced scroll to parallelize the reindexing process.
-          This parallelization can improve efficiency and provide a convenient way to break the request down into smaller parts.</p>
-          <p>NOTE: Reindexing from remote clusters does not support manual or automatic slicing.</p>
-          <p>You can slice a reindex request manually by providing a slice ID and total number of slices to each request.
-          You can also let reindex automatically parallelize by using sliced scroll to slice on <code>_id</code>.
-          The <code>slices</code> parameter specifies the number of slices to use.</p>
-          <p>Adding <code>slices</code> to the reindex request just automates the manual process, creating sub-requests which means it has some quirks:</p>
+          <p>It's recommended to reindex on indices with a green status. Reindexing can fail when a node shuts down or crashes.</p>
           <ul>
-          <li>You can see these requests in the tasks API. These sub-requests are &quot;child&quot; tasks of the task for the request with slices.</li>
-          <li>Fetching the status of the task for the request with <code>slices</code> only contains the status of completed slices.</li>
-          <li>These sub-requests are individually addressable for things like cancellation and rethrottling.</li>
-          <li>Rethrottling the request with <code>slices</code> will rethrottle the unfinished sub-request proportionally.</li>
-          <li>Canceling the request with <code>slices</code> will cancel each sub-request.</li>
-          <li>Due to the nature of <code>slices</code>, each sub-request won't get a perfectly even portion of the documents. All documents will be addressed, but some slices may be larger than others. Expect larger slices to have a more even distribution.</li>
-          <li>Parameters like <code>requests_per_second</code> and <code>max_docs</code> on a request with <code>slices</code> are distributed proportionally to each sub-request. Combine that with the previous point about distribution being uneven and you should conclude that using <code>max_docs</code> with <code>slices</code> might not result in exactly <code>max_docs</code> documents being reindexed.</li>
-          <li>Each sub-request gets a slightly different snapshot of the source, though these are all taken at approximately the same time.</li>
+          <li>When requested with <code>wait_for_completion=true</code> (default), the request fails if the node shuts down.</li>
+          <li>When requested with <code>wait_for_completion=false</code>, a task id is returned, for use with the task management APIs. The task may disappear or fail if the node shuts down.
+          When retrying a failed reindex operation, it might be necessary to set <code>conflicts=proceed</code> or to first delete the partial destination index.
+          Additionally, dry runs, checking disk space, and fetching index recovery information can help address the root cause.</li>
           </ul>
-          <p>If slicing automatically, setting <code>slices</code> to <code>auto</code> will choose a reasonable number for most indices.
-          If slicing manually or otherwise tuning automatic slicing, use the following guidelines.</p>
-          <p>Query performance is most efficient when the number of slices is equal to the number of shards in the index.
-          If that number is large (for example, <code>500</code>), choose a lower number as too many slices will hurt performance.
-          Setting slices higher than the number of shards generally does not improve efficiency and adds overhead.</p>
-          <p>Indexing performance scales linearly across available resources with the number of slices.</p>
-          <p>Whether query or indexing performance dominates the runtime depends on the documents being reindexed and cluster resources.</p>
-          <p><strong>Modify documents during reindexing</strong></p>
-          <p>Like <code>_update_by_query</code>, reindex operations support a script that modifies the document.
-          Unlike <code>_update_by_query</code>, the script is allowed to modify the document's metadata.</p>
-          <p>Just as in <code>_update_by_query</code>, you can set <code>ctx.op</code> to change the operation that is run on the destination.
-          For example, set <code>ctx.op</code> to <code>noop</code> if your script decides that the document doesn’t have to be indexed in the destination. This &quot;no operation&quot; will be reported in the <code>noop</code> counter in the response body.
-          Set <code>ctx.op</code> to <code>delete</code> if your script decides that the document must be deleted from the destination.
-          The deletion will be reported in the <code>deleted</code> counter in the response body.
-          Setting <code>ctx.op</code> to anything else will return an error, as will setting any other field in <code>ctx</code>.</p>
-          <p>Think of the possibilities! Just be careful; you are able to change:</p>
-          <ul>
-          <li><code>_id</code></li>
-          <li><code>_index</code></li>
-          <li><code>_version</code></li>
-          <li><code>_routing</code></li>
-          </ul>
-          <p>Setting <code>_version</code> to <code>null</code> or clearing it from the <code>ctx</code> map is just like not sending the version in an indexing request.
-          It will cause the document to be overwritten in the destination regardless of the version on the target or the version type you use in the reindex API.</p>
-          <p><strong>Reindex from remote</strong></p>
-          <p>Reindex supports reindexing from a remote Elasticsearch cluster.
-          The <code>host</code> parameter must contain a scheme, host, port, and optional path.
-          The <code>username</code> and <code>password</code> parameters are optional and when they are present the reindex operation will connect to the remote Elasticsearch node using basic authentication.
-          Be sure to use HTTPS when using basic authentication or the password will be sent in plain text.
-          There are a range of settings available to configure the behavior of the HTTPS connection.</p>
-          <p>When using Elastic Cloud, it is also possible to authenticate against the remote cluster through the use of a valid API key.
-          Remote hosts must be explicitly allowed with the <code>reindex.remote.whitelist</code> setting.
-          It can be set to a comma delimited list of allowed remote host and port combinations.
-          Scheme is ignored; only the host and port are used.
-          For example:</p>
-          <pre><code>reindex.remote.whitelist: [otherhost:9200, another:9200, 127.0.10.*:9200, localhost:*&quot;]
-          </code></pre>
-          <p>The list of allowed hosts must be configured on any nodes that will coordinate the reindex.
-          This feature should work with remote clusters of any version of Elasticsearch.
-          This should enable you to upgrade from any version of Elasticsearch to the current version by reindexing from a cluster of the old version.</p>
-          <p>WARNING: Elasticsearch does not support forward compatibility across major versions.
-          For example, you cannot reindex from a 7.x cluster into a 6.x cluster.</p>
-          <p>To enable queries sent to older versions of Elasticsearch, the <code>query</code> parameter is sent directly to the remote host without validation or modification.</p>
-          <p>NOTE: Reindexing from remote clusters does not support manual or automatic slicing.</p>
-          <p>Reindexing from a remote server uses an on-heap buffer that defaults to a maximum size of 100mb.
-          If the remote index includes very large documents you'll need to use a smaller batch size.
-          It is also possible to set the socket read timeout on the remote connection with the <code>socket_timeout</code> field and the connection timeout with the <code>connect_timeout</code> field.
-          Both default to 30 seconds.</p>
-          <p><strong>Configuring SSL parameters</strong></p>
-          <p>Reindex from remote supports configurable SSL settings.
-          These must be specified in the <code>elasticsearch.yml</code> file, with the exception of the secure settings, which you add in the Elasticsearch keystore.
-          It is not possible to configure SSL in the body of the reindex request.</p>
-
-
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-reindex>`_
+          <p>Refer to the linked documentation for examples of how to reindex documents.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-reindex>`_
 
         :param dest: The destination you are copying to.
         :param source: The source you are copying from.
@@ -4296,7 +4010,7 @@ async def reindex_rethrottle(
           This behavior prevents scroll timeouts.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-reindex>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-reindex>`_
 
         :param task_id: The task identifier, which can be found by using the tasks API.
         :param requests_per_second: The throttle for this request in sub-requests per
@@ -4342,7 +4056,7 @@ async def render_search_template(
         human: t.Optional[bool] = None,
         params: t.Optional[t.Mapping[str, t.Any]] = None,
         pretty: t.Optional[bool] = None,
-        source: t.Optional[str] = None,
+        source: t.Optional[t.Union[str, t.Mapping[str, t.Any]]] = None,
         body: t.Optional[t.Dict[str, t.Any]] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
@@ -4352,7 +4066,7 @@ async def render_search_template(
           <p>Render a search template as a search request body.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-render-search-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-render-search-template>`_
 
         :param id: The ID of the search template to render. If no `source` is specified,
             this or the `id` request body parameter is required.
@@ -4446,7 +4160,7 @@ async def scripts_painless_execute(
           <p>Each context requires a script, but additional parameters depend on the context you're using for that script.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/painless/master/painless-execute-api.html>`_
+        `<https://www.elastic.co/docs/reference/scripting-languages/painless/painless-api-examples>`_
 
         :param context: The context that the script should run in. NOTE: Result ordering
             in the field contexts is not guaranteed.
@@ -4519,7 +4233,7 @@ async def scroll(
           <p>IMPORTANT: Results from a scrolling search reflect the state of the index at the time of the initial search request. Subsequent indexing or document changes only affect later search and scroll requests.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-scroll>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-scroll>`_
 
         :param scroll_id: The scroll ID of the search.
         :param rest_total_hits_as_int: If true, the API response’s hit.total property
@@ -4724,7 +4438,7 @@ async def search(
           This situation can occur because the splitting criterion is based on Lucene document IDs, which are not stable across changes to the index.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-search>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-search>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases to
             search. It supports wildcards (`*`). To search all data streams and indices,
@@ -4803,7 +4517,8 @@ async def search(
             limit the impact of the search on the cluster in order to limit the number
             of concurrent shard requests.
         :param min_score: The minimum `_score` for matching documents. Documents with
-            a lower `_score` are not included in the search results.
+            a lower `_score` are not included in search results and results collected
+            by aggregations.
         :param pit: Limit the search to a point in time (PIT). If you provide a PIT,
             you cannot specify an `<index>` in the request path.
         :param post_filter: Use the `post_filter` parameter to filter search results.
@@ -4830,11 +4545,11 @@ async def search(
             of the specified nodes are available, select shards from any available node
             using the default method. * `_prefer_nodes:<node-id>,<node-id>` to if possible,
             run the search on the specified nodes IDs. If not, select shards using the
-            default method. `_shards:<shard>,<shard>` to run the search only on the specified
-            shards. You can combine this value with other `preference` values. However,
-            the `_shards` value must come first. For example: `_shards:2,3|_local`. `<custom-string>`
-            (any string that does not start with `_`) to route searches with the same
-            `<custom-string>` to the same shards in the same order.
+            default method. * `_shards:<shard>,<shard>` to run the search only on the
+            specified shards. You can combine this value with other `preference` values.
+            However, the `_shards` value must come first. For example: `_shards:2,3|_local`.
+            * `<custom-string>` (any string that does not start with `_`) to route searches
+            with the same `<custom-string>` to the same shards in the same order.
         :param profile: Set to `true` to return detailed timing information about the
             execution of individual components in a search request. NOTE: This is a debugging
             tool and adds significant overhead to search execution.
@@ -5170,51 +4885,6 @@ async def search_mvt(
           <li>Optionally, a <code>geo_bounds</code> aggregation on the <code>&lt;field&gt;</code>. The search only includes this aggregation if the <code>exact_bounds</code> parameter is <code>true</code>.</li>
           <li>If the optional parameter <code>with_labels</code> is <code>true</code>, the internal search will include a dynamic runtime field that calls the <code>getLabelPosition</code> function of the geometry doc value. This enables the generation of new point features containing suggested geometry labels, so that, for example, multi-polygons will have only one label.</li>
           </ul>
-          <p>For example, Elasticsearch may translate a vector tile search API request with a <code>grid_agg</code> argument of <code>geotile</code> and an <code>exact_bounds</code> argument of <code>true</code> into the following search</p>
-          <pre><code>GET my-index/_search
-          {
-            &quot;size&quot;: 10000,
-            &quot;query&quot;: {
-              &quot;geo_bounding_box&quot;: {
-                &quot;my-geo-field&quot;: {
-                  &quot;top_left&quot;: {
-                    &quot;lat&quot;: -40.979898069620134,
-                    &quot;lon&quot;: -45
-                  },
-                  &quot;bottom_right&quot;: {
-                    &quot;lat&quot;: -66.51326044311186,
-                    &quot;lon&quot;: 0
-                  }
-                }
-              }
-            },
-            &quot;aggregations&quot;: {
-              &quot;grid&quot;: {
-                &quot;geotile_grid&quot;: {
-                  &quot;field&quot;: &quot;my-geo-field&quot;,
-                  &quot;precision&quot;: 11,
-                  &quot;size&quot;: 65536,
-                  &quot;bounds&quot;: {
-                    &quot;top_left&quot;: {
-                      &quot;lat&quot;: -40.979898069620134,
-                      &quot;lon&quot;: -45
-                    },
-                    &quot;bottom_right&quot;: {
-                      &quot;lat&quot;: -66.51326044311186,
-                      &quot;lon&quot;: 0
-                    }
-                  }
-                }
-              },
-              &quot;bounds&quot;: {
-                &quot;geo_bounds&quot;: {
-                  &quot;field&quot;: &quot;my-geo-field&quot;,
-                  &quot;wrap_longitude&quot;: false
-                }
-              }
-            }
-          }
-          </code></pre>
           <p>The API returns results as a binary Mapbox vector tile.
           Mapbox vector tiles are encoded as Google Protobufs (PBF). By default, the tile contains three layers:</p>
           <ul>
@@ -5469,9 +5139,10 @@ async def search_mvt(
           Some cells may intersect more than one vector tile.
           To compute the H3 resolution for each precision, Elasticsearch compares the average density of hexagonal bins at each resolution with the average density of tile bins at each zoom level.
           Elasticsearch uses the H3 resolution that is closest to the corresponding geotile density.</p>
+          <p>Learn how to use the vector tile search API with practical examples in the <a href="https://www.elastic.co/docs/reference/elasticsearch/rest-apis/vector-tile-search">Vector tile search examples</a> guide.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-search-mvt>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-search-mvt>`_
 
         :param index: Comma-separated list of data streams, indices, or aliases to search
         :param field: Field containing geospatial data to return
@@ -5645,7 +5316,7 @@ async def search_shards(
           <p>If the Elasticsearch security features are enabled, you must have the <code>view_index_metadata</code> or <code>manage</code> index privilege for the target data stream, index, or alias.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-search-shards>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-search-shards>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases to
             search. It supports wildcards (`*`). To search all data streams and indices,
@@ -5658,7 +5329,7 @@ async def search_shards(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
         :param local: If `true`, the request retrieves information from the local node
@@ -5746,7 +5417,7 @@ async def search_template(
         search_type: t.Optional[
             t.Union[str, t.Literal["dfs_query_then_fetch", "query_then_fetch"]]
         ] = None,
-        source: t.Optional[str] = None,
+        source: t.Optional[t.Union[str, t.Mapping[str, t.Any]]] = None,
         typed_keys: t.Optional[bool] = None,
         body: t.Optional[t.Dict[str, t.Any]] = None,
     ) -> ObjectApiResponse[t.Any]:
@@ -5756,7 +5427,7 @@ async def search_template(
           <p>Run a search with a search template.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-search-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-search-template>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases to
             search. It supports wildcards (`*`).
@@ -5770,8 +5441,7 @@ async def search_template(
         :param expand_wildcards: The type of index that wildcard patterns can match.
             If the request can target data streams, this argument determines whether
             wildcard expressions match hidden data streams. Supports comma-separated
-            values, such as `open,hidden`. Valid values are: `all`, `open`, `closed`,
-            `hidden`, `none`.
+            values, such as `open,hidden`.
         :param explain: If `true`, returns detailed information about score calculation
             as part of each hit. If you specify both this and the `explain` query parameter,
             the API uses only the query parameter.
@@ -5899,7 +5569,7 @@ async def terms_enum(
           </blockquote>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-terms-enum>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-terms-enum>`_
 
         :param index: A comma-separated list of data streams, indices, and index aliases
             to search. Wildcard (`*`) expressions are supported. To search all data streams
@@ -5969,7 +5639,20 @@ async def terms_enum(
         )
 
     @_rewrite_parameters(
-        body_fields=("doc", "filter", "per_field_analyzer"),
+        body_fields=(
+            "doc",
+            "field_statistics",
+            "fields",
+            "filter",
+            "offsets",
+            "payloads",
+            "per_field_analyzer",
+            "positions",
+            "routing",
+            "term_statistics",
+            "version",
+            "version_type",
+        ),
     )
     async def termvectors(
         self,
@@ -5979,7 +5662,7 @@ async def termvectors(
         doc: t.Optional[t.Mapping[str, t.Any]] = None,
         error_trace: t.Optional[bool] = None,
         field_statistics: t.Optional[bool] = None,
-        fields: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        fields: t.Optional[t.Sequence[str]] = None,
         filter: t.Optional[t.Mapping[str, t.Any]] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         human: t.Optional[bool] = None,
@@ -6032,10 +5715,11 @@ async def termvectors(
           The information is only retrieved for the shard the requested document resides in.
           The term and field statistics are therefore only useful as relative measures whereas the absolute numbers have no meaning in this context.
           By default, when requesting term vectors of artificial documents, a shard to get the statistics from is randomly selected.
-          Use <code>routing</code> only to hit a particular shard.</p>
+          Use <code>routing</code> only to hit a particular shard.
+          Refer to the linked documentation for detailed examples of how to use this API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-termvectors>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-termvectors>`_
 
         :param index: The name of the index that contains the document.
         :param id: A unique identifier for the document.
@@ -6046,9 +5730,9 @@ async def termvectors(
             (the sum of document frequencies for all terms in this field). * The sum
             of total term frequencies (the sum of total term frequencies of each term
             in this field).
-        :param fields: A comma-separated list or wildcard expressions of fields to include
-            in the statistics. It is used as the default list unless a specific field
-            list is provided in the `completion_fields` or `fielddata_fields` parameters.
+        :param fields: A list of fields to include in the statistics. It is used as the
+            default list unless a specific field list is provided in the `completion_fields`
+            or `fielddata_fields` parameters.
         :param filter: Filter terms based on their tf-idf scores. This could be useful
             in order find out a good characteristic vector of a document. This feature
             works in a similar manner to the second phase of the More Like This Query.
@@ -6086,41 +5770,41 @@ async def termvectors(
         __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 field_statistics is not None:
-            __query["field_statistics"] = field_statistics
-        if fields is not None:
-            __query["fields"] = fields
         if filter_path is not None:
             __query["filter_path"] = filter_path
         if human is not None:
             __query["human"] = human
-        if offsets is not None:
-            __query["offsets"] = offsets
-        if payloads is not None:
-            __query["payloads"] = payloads
-        if positions is not None:
-            __query["positions"] = positions
         if preference is not None:
             __query["preference"] = preference
         if pretty is not None:
             __query["pretty"] = pretty
         if realtime is not None:
             __query["realtime"] = realtime
-        if routing is not None:
-            __query["routing"] = routing
-        if term_statistics is not None:
-            __query["term_statistics"] = term_statistics
-        if version is not None:
-            __query["version"] = version
-        if version_type is not None:
-            __query["version_type"] = version_type
         if not __body:
             if doc is not None:
                 __body["doc"] = doc
+            if field_statistics is not None:
+                __body["field_statistics"] = field_statistics
+            if fields is not None:
+                __body["fields"] = fields
             if filter is not None:
                 __body["filter"] = filter
+            if offsets is not None:
+                __body["offsets"] = offsets
+            if payloads is not None:
+                __body["payloads"] = payloads
             if per_field_analyzer is not None:
                 __body["per_field_analyzer"] = per_field_analyzer
+            if positions is not None:
+                __body["positions"] = positions
+            if routing is not None:
+                __body["routing"] = routing
+            if term_statistics is not None:
+                __body["term_statistics"] = term_statistics
+            if version is not None:
+                __body["version"] = version
+            if version_type is not None:
+                __body["version_type"] = version_type
         if not __body:
             __body = None  # type: ignore[assignment]
         __headers = {"accept": "application/json"}
@@ -6203,10 +5887,11 @@ async def update(
           </ul>
           <p>The document must still be reindexed, but using this API removes some network roundtrips and reduces chances of version conflicts between the GET and the index operation.</p>
           <p>The <code>_source</code> field must be enabled to use this API.
-          In addition to <code>_source</code>, you can access the following variables through the <code>ctx</code> map: <code>_index</code>, <code>_type</code>, <code>_id</code>, <code>_version</code>, <code>_routing</code>, and <code>_now</code> (the current timestamp).</p>
+          In addition to <code>_source</code>, you can access the following variables through the <code>ctx</code> map: <code>_index</code>, <code>_type</code>, <code>_id</code>, <code>_version</code>, <code>_routing</code>, and <code>_now</code> (the current timestamp).
+          For usage examples such as partial updates, upserts, and scripted updates, see the External documentation.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-update>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-update>`_
 
         :param index: The name of the target index. By default, the index is created
             automatically if it doesn't exist.
@@ -6396,6 +6081,24 @@ async def update_by_query(
           A bulk update request is performed for each batch of matching documents.
           Any query or update failures cause the update by query request to fail and the failures are shown in the response.
           Any update requests that completed successfully still stick, they are not rolled back.</p>
+          <p><strong>Refreshing shards</strong></p>
+          <p>Specifying the <code>refresh</code> parameter refreshes all shards once the request completes.
+          This is different to the update API's <code>refresh</code> parameter, which causes only the shard
+          that received the request to be refreshed. Unlike the update API, it does not support
+          <code>wait_for</code>.</p>
+          <p><strong>Running update by query asynchronously</strong></p>
+          <p>If the request contains <code>wait_for_completion=false</code>, Elasticsearch
+          performs some preflight checks, launches the request, and returns a
+          <a href="https://www.elastic.co/docs/api/doc/elasticsearch/group/endpoint-tasks">task</a> you can use to cancel or get the status of the task.
+          Elasticsearch creates a record of this task as a document at <code>.tasks/task/${taskId}</code>.</p>
+          <p><strong>Waiting for active shards</strong></p>
+          <p><code>wait_for_active_shards</code> controls how many copies of a shard must be active
+          before proceeding with the request. See <a href="https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-create#operation-create-wait_for_active_shards"><code>wait_for_active_shards</code></a>
+          for details. <code>timeout</code> controls how long each write request waits for unavailable
+          shards to become available. Both work exactly the way they work in the
+          <a href="https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-bulk">Bulk API</a>. Update by query uses scrolled searches, so you can also
+          specify the <code>scroll</code> parameter to control how long it keeps the search context
+          alive, for example <code>?scroll=10m</code>. The default is 5 minutes.</p>
           <p><strong>Throttling update requests</strong></p>
           <p>To control the rate at which update by query issues batches of update operations, you can set <code>requests_per_second</code> to any positive decimal number.
           This pads each batch with a wait time to throttle the rate.
@@ -6430,21 +6133,11 @@ async def update_by_query(
           <li>Query performance is most efficient when the number of slices is equal to the number of shards in the index or backing index. If that number is large (for example, 500), choose a lower number as too many slices hurts performance. Setting slices higher than the number of shards generally does not improve efficiency and adds overhead.</li>
           <li>Update performance scales linearly across available resources with the number of slices.</li>
           </ul>
-          <p>Whether query or update performance dominates the runtime depends on the documents being reindexed and cluster resources.</p>
-          <p><strong>Update the document source</strong></p>
-          <p>Update by query supports scripts to update the document source.
-          As with the update API, you can set <code>ctx.op</code> to change the operation that is performed.</p>
-          <p>Set <code>ctx.op = &quot;noop&quot;</code> if your script decides that it doesn't have to make any changes.
-          The update by query operation skips updating the document and increments the <code>noop</code> counter.</p>
-          <p>Set <code>ctx.op = &quot;delete&quot;</code> if your script decides that the document should be deleted.
-          The update by query operation deletes the document and increments the <code>deleted</code> counter.</p>
-          <p>Update by query supports only <code>index</code>, <code>noop</code>, and <code>delete</code>.
-          Setting <code>ctx.op</code> to anything else is an error.
-          Setting any other field in <code>ctx</code> is an error.
-          This API enables you to only modify the source of matching documents; you cannot move them.</p>
-
-
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-update-by-query>`_
+          <p>Whether query or update performance dominates the runtime depends on the documents being reindexed and cluster resources.
+          Refer to the linked documentation for examples of how to update documents using the <code>_update_by_query</code> API:</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-update-by-query>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases to
             search. It supports wildcards (`*`). To search all data streams or indices,
@@ -6469,9 +6162,8 @@ async def update_by_query(
         :param expand_wildcards: The type of index that wildcard patterns can match.
             If the request can target data streams, this argument determines whether
             wildcard expressions match hidden data streams. It supports comma-separated
-            values, such as `open,hidden`. Valid values are: `all`, `open`, `closed`,
-            `hidden`, `none`.
-        :param from_: Starting offset (default: 0)
+            values, such as `open,hidden`.
+        :param from_: Skips the specified number of documents.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
         :param lenient: If `true`, format-based query failures (such as providing text
@@ -6664,7 +6356,7 @@ async def update_by_query_rethrottle(
           Rethrottling that speeds up the query takes effect immediately but rethrotting that slows down the query takes effect after completing the current batch to prevent scroll timeouts.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-update-by-query-rethrottle>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-update-by-query-rethrottle>`_
 
         :param task_id: The ID for the task.
         :param requests_per_second: The throttle for this request in sub-requests per
diff --git a/elasticsearch/_async/client/_base.py b/elasticsearch/_async/client/_base.py
index dd0b0f44e..4e49e7156 100644
--- a/elasticsearch/_async/client/_base.py
+++ b/elasticsearch/_async/client/_base.py
@@ -174,7 +174,7 @@ async def sniff_callback(
                     "GET",
                     "/_nodes/_all/http",
                     headers={
-                        "accept": "application/vnd.elasticsearch+json; compatible-with=8"
+                        "accept": "application/vnd.elasticsearch+json; compatible-with=9"
                     },
                     request_timeout=(
                         sniff_options.sniff_timeout
@@ -298,7 +298,6 @@ async def _perform_request(
         def mimetype_header_to_compat(header: str) -> None:
             # Converts all parts of a Accept/Content-Type headers
             # from application/X -> application/vnd.elasticsearch+X
-            nonlocal request_headers
             mimetype = request_headers.get(header, None)
             if mimetype:
                 request_headers[header] = _COMPAT_MIMETYPE_RE.sub(
diff --git a/elasticsearch/_async/client/async_search.py b/elasticsearch/_async/client/async_search.py
index b667d9463..7b7a76144 100644
--- a/elasticsearch/_async/client/async_search.py
+++ b/elasticsearch/_async/client/async_search.py
@@ -44,7 +44,7 @@ async def delete(
           If the Elasticsearch security features are enabled, the deletion of a specific async search is restricted to: the authenticated user that submitted the original search request; users that have the <code>cancel_task</code> cluster privilege.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-async-search-submit>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-async-search-submit>`_
 
         :param id: A unique identifier for the async search.
         """
@@ -94,7 +94,7 @@ async def get(
           If the Elasticsearch security features are enabled, access to the results of a specific async search is restricted to the user or API key that submitted it.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-async-search-submit>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-async-search-submit>`_
 
         :param id: A unique identifier for the async search.
         :param keep_alive: The length of time that the async search should be available
@@ -164,7 +164,7 @@ async def status(
           </ul>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-async-search-submit>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-async-search-submit>`_
 
         :param id: A unique identifier for the async search.
         :param keep_alive: The length of time that the async search needs to be available.
@@ -345,7 +345,7 @@ async def submit(
           The maximum allowed size for a stored async search response can be set by changing the <code>search.max_async_search_response_size</code> cluster level setting.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-async-search-submit>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-async-search-submit>`_
 
         :param index: A comma-separated list of index names to search; use `_all` or
             empty string to perform the operation on all indices
@@ -401,7 +401,7 @@ async def submit(
             limit the impact of the search on the cluster in order to limit the number
             of concurrent shard requests
         :param min_score: Minimum _score for matching documents. Documents with a lower
-            _score are not included in the search results.
+            _score are not included in search results and results collected by aggregations.
         :param pit: Limits the search to a point in time (PIT). If you provide a PIT,
             you cannot specify an <index> in the request path.
         :param post_filter:
diff --git a/elasticsearch/_async/client/autoscaling.py b/elasticsearch/_async/client/autoscaling.py
index 5b41caa38..f0a3dd1a9 100644
--- a/elasticsearch/_async/client/autoscaling.py
+++ b/elasticsearch/_async/client/autoscaling.py
@@ -44,7 +44,7 @@ async def delete_autoscaling_policy(
           <p>NOTE: This feature is designed for indirect use by Elasticsearch Service, Elastic Cloud Enterprise, and Elastic Cloud on Kubernetes. Direct use is not supported.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-autoscaling-delete-autoscaling-policy>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-autoscaling-delete-autoscaling-policy>`_
 
         :param name: the name of the autoscaling policy
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -104,7 +104,7 @@ async def get_autoscaling_capacity(
           Do not use this information to make autoscaling decisions.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-autoscaling-get-autoscaling-capacity>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-autoscaling-get-autoscaling-capacity>`_
 
         :param master_timeout: Period to wait for a connection to the master node. If
             no response is received before the timeout expires, the request fails and
@@ -151,7 +151,7 @@ async def get_autoscaling_policy(
           <p>NOTE: This feature is designed for indirect use by Elasticsearch Service, Elastic Cloud Enterprise, and Elastic Cloud on Kubernetes. Direct use is not supported.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-autoscaling-get-autoscaling-capacity>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-autoscaling-get-autoscaling-capacity>`_
 
         :param name: the name of the autoscaling policy
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -206,7 +206,7 @@ async def put_autoscaling_policy(
           <p>NOTE: This feature is designed for indirect use by Elasticsearch Service, Elastic Cloud Enterprise, and Elastic Cloud on Kubernetes. Direct use is not supported.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-autoscaling-put-autoscaling-policy>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-autoscaling-put-autoscaling-policy>`_
 
         :param name: the name of the autoscaling policy
         :param policy:
diff --git a/elasticsearch/_async/client/cat.py b/elasticsearch/_async/client/cat.py
index 299ee83ac..5a1040a65 100644
--- a/elasticsearch/_async/client/cat.py
+++ b/elasticsearch/_async/client/cat.py
@@ -47,7 +47,34 @@ async def aliases(
         ] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "alias",
+                            "filter",
+                            "index",
+                            "is_write_index",
+                            "routing.index",
+                            "routing.search",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "alias",
+                        "filter",
+                        "index",
+                        "is_write_index",
+                        "routing.index",
+                        "routing.search",
+                    ],
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
@@ -64,7 +91,7 @@ async def aliases(
           <p>IMPORTANT: CAT APIs are only intended for human consumption using the command line or the Kibana console. They are not intended for use by applications. For application consumption, use the aliases API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-aliases>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-aliases>`_
 
         :param name: A comma-separated list of aliases to retrieve. Supports wildcards
             (`*`). To retrieve all aliases, omit this parameter or use `*` or `_all`.
@@ -74,7 +101,8 @@ async def aliases(
             values, such as `open,hidden`.
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param master_timeout: The period to wait for a connection to the master node.
@@ -137,7 +165,48 @@ async def allocation(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "disk.avail",
+                            "disk.indices",
+                            "disk.indices.forecast",
+                            "disk.percent",
+                            "disk.total",
+                            "disk.used",
+                            "host",
+                            "ip",
+                            "node",
+                            "node.role",
+                            "shards",
+                            "shards.undesired",
+                            "write_load.forecast",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "disk.avail",
+                        "disk.indices",
+                        "disk.indices.forecast",
+                        "disk.percent",
+                        "disk.total",
+                        "disk.used",
+                        "host",
+                        "ip",
+                        "node",
+                        "node.role",
+                        "shards",
+                        "shards.undesired",
+                        "write_load.forecast",
+                    ],
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
@@ -154,14 +223,15 @@ async def allocation(
           <p>IMPORTANT: CAT APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-allocation>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-allocation>`_
 
         :param node_id: A comma-separated list of node identifiers or names used to limit
             the returned information.
         :param bytes: The unit used to display byte values.
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param local: If `true`, the request computes the list of selected nodes from
@@ -224,7 +294,36 @@ async def component_templates(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "alias_count",
+                            "included_in",
+                            "mapping_count",
+                            "metadata_count",
+                            "name",
+                            "settings_count",
+                            "version",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "alias_count",
+                        "included_in",
+                        "mapping_count",
+                        "metadata_count",
+                        "name",
+                        "settings_count",
+                        "version",
+                    ],
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
@@ -243,13 +342,14 @@ async def component_templates(
           They are not intended for use by applications. For application consumption, use the get component template API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-component-templates>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-component-templates>`_
 
         :param name: The name of the component template. It accepts wildcard expressions.
             If it is omitted, all component templates are returned.
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param local: If `true`, the request computes the list of selected nodes from
@@ -310,7 +410,12 @@ async def count(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[t.Union[str, t.Literal["count", "epoch", "timestamp"]]],
+                t.Union[str, t.Literal["count", "epoch", "timestamp"]],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         pretty: t.Optional[bool] = None,
@@ -327,14 +432,15 @@ async def count(
           They are not intended for use by applications. For application consumption, use the count API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-count>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-count>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases used
             to limit the request. It supports wildcards (`*`). To target all data streams
             and indices, omit this parameter or use `*` or `_all`.
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param s: List of columns that determine how the table should be sorted. Sorting
@@ -389,7 +495,14 @@ async def fielddata(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[str, t.Literal["field", "host", "id", "ip", "node", "size"]]
+                ],
+                t.Union[str, t.Literal["field", "host", "id", "ip", "node", "size"]],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         pretty: t.Optional[bool] = None,
@@ -405,14 +518,15 @@ async def fielddata(
           They are not intended for use by applications. For application consumption, use the nodes stats API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-fielddata>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-fielddata>`_
 
         :param fields: Comma-separated list of fields used to limit returned information.
             To retrieve all fields, omit this parameter.
         :param bytes: The unit used to display byte values.
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param s: List of columns that determine how the table should be sorted. Sorting
@@ -465,7 +579,52 @@ async def health(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "active_shards_percent",
+                            "cluster",
+                            "epoch",
+                            "init",
+                            "max_task_wait_time",
+                            "node.data",
+                            "node.total",
+                            "pending_tasks",
+                            "pri",
+                            "relo",
+                            "shards",
+                            "status",
+                            "timestamp",
+                            "unassign",
+                            "unassign.pri",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "active_shards_percent",
+                        "cluster",
+                        "epoch",
+                        "init",
+                        "max_task_wait_time",
+                        "node.data",
+                        "node.total",
+                        "pending_tasks",
+                        "pri",
+                        "relo",
+                        "shards",
+                        "status",
+                        "timestamp",
+                        "unassign",
+                        "unassign.pri",
+                    ],
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         pretty: t.Optional[bool] = None,
@@ -491,11 +650,12 @@ async def health(
           You also can use the API to track the recovery of a large cluster over a longer period of time.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-health>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-health>`_
 
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param s: List of columns that determine how the table should be sorted. Sorting
@@ -549,7 +709,7 @@ async def help(self) -> TextApiResponse:
           <p>Get help for the CAT APIs.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/group/endpoint-cat>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/group/endpoint-cat>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_cat"
@@ -583,8 +743,319 @@ async def indices(
         ] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
-        health: t.Optional[t.Union[str, t.Literal["green", "red", "yellow"]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "bulk.avg_size_in_bytes",
+                            "bulk.avg_time",
+                            "bulk.total_operations",
+                            "bulk.total_size_in_bytes",
+                            "bulk.total_time",
+                            "completion.size",
+                            "creation.date",
+                            "creation.date.string",
+                            "dataset.size",
+                            "dense_vector.value_count",
+                            "docs.count",
+                            "docs.deleted",
+                            "fielddata.evictions",
+                            "fielddata.memory_size",
+                            "flush.total",
+                            "flush.total_time",
+                            "get.current",
+                            "get.exists_time",
+                            "get.exists_total",
+                            "get.missing_time",
+                            "get.missing_total",
+                            "get.time",
+                            "get.total",
+                            "health",
+                            "index",
+                            "indexing.delete_current",
+                            "indexing.delete_time",
+                            "indexing.delete_total",
+                            "indexing.index_current",
+                            "indexing.index_failed",
+                            "indexing.index_failed_due_to_version_conflict",
+                            "indexing.index_time",
+                            "indexing.index_total",
+                            "memory.total",
+                            "merges.current",
+                            "merges.current_docs",
+                            "merges.current_size",
+                            "merges.total",
+                            "merges.total_docs",
+                            "merges.total_size",
+                            "merges.total_time",
+                            "pri",
+                            "pri.bulk.avg_size_in_bytes",
+                            "pri.bulk.avg_time",
+                            "pri.bulk.total_operations",
+                            "pri.bulk.total_size_in_bytes",
+                            "pri.bulk.total_time",
+                            "pri.completion.size",
+                            "pri.dense_vector.value_count",
+                            "pri.fielddata.evictions",
+                            "pri.fielddata.memory_size",
+                            "pri.flush.total",
+                            "pri.flush.total_time",
+                            "pri.get.current",
+                            "pri.get.exists_time",
+                            "pri.get.exists_total",
+                            "pri.get.missing_time",
+                            "pri.get.missing_total",
+                            "pri.get.time",
+                            "pri.get.total",
+                            "pri.indexing.delete_current",
+                            "pri.indexing.delete_time",
+                            "pri.indexing.delete_total",
+                            "pri.indexing.index_current",
+                            "pri.indexing.index_failed",
+                            "pri.indexing.index_failed_due_to_version_conflict",
+                            "pri.indexing.index_time",
+                            "pri.indexing.index_total",
+                            "pri.memory.total",
+                            "pri.merges.current",
+                            "pri.merges.current_docs",
+                            "pri.merges.current_size",
+                            "pri.merges.total",
+                            "pri.merges.total_docs",
+                            "pri.merges.total_size",
+                            "pri.merges.total_time",
+                            "pri.query_cache.evictions",
+                            "pri.query_cache.memory_size",
+                            "pri.refresh.external_time",
+                            "pri.refresh.external_total",
+                            "pri.refresh.listeners",
+                            "pri.refresh.time",
+                            "pri.refresh.total",
+                            "pri.request_cache.evictions",
+                            "pri.request_cache.hit_count",
+                            "pri.request_cache.memory_size",
+                            "pri.request_cache.miss_count",
+                            "pri.search.fetch_current",
+                            "pri.search.fetch_time",
+                            "pri.search.fetch_total",
+                            "pri.search.open_contexts",
+                            "pri.search.query_current",
+                            "pri.search.query_time",
+                            "pri.search.query_total",
+                            "pri.search.scroll_current",
+                            "pri.search.scroll_time",
+                            "pri.search.scroll_total",
+                            "pri.segments.count",
+                            "pri.segments.fixed_bitset_memory",
+                            "pri.segments.index_writer_memory",
+                            "pri.segments.memory",
+                            "pri.segments.version_map_memory",
+                            "pri.sparse_vector.value_count",
+                            "pri.store.size",
+                            "pri.suggest.current",
+                            "pri.suggest.time",
+                            "pri.suggest.total",
+                            "pri.warmer.current",
+                            "pri.warmer.total",
+                            "pri.warmer.total_time",
+                            "query_cache.evictions",
+                            "query_cache.memory_size",
+                            "refresh.external_time",
+                            "refresh.external_total",
+                            "refresh.listeners",
+                            "refresh.time",
+                            "refresh.total",
+                            "rep",
+                            "request_cache.evictions",
+                            "request_cache.hit_count",
+                            "request_cache.memory_size",
+                            "request_cache.miss_count",
+                            "search.fetch_current",
+                            "search.fetch_time",
+                            "search.fetch_total",
+                            "search.open_contexts",
+                            "search.query_current",
+                            "search.query_time",
+                            "search.query_total",
+                            "search.scroll_current",
+                            "search.scroll_time",
+                            "search.scroll_total",
+                            "segments.count",
+                            "segments.fixed_bitset_memory",
+                            "segments.index_writer_memory",
+                            "segments.memory",
+                            "segments.version_map_memory",
+                            "sparse_vector.value_count",
+                            "status",
+                            "store.size",
+                            "suggest.current",
+                            "suggest.time",
+                            "suggest.total",
+                            "uuid",
+                            "warmer.current",
+                            "warmer.total",
+                            "warmer.total_time",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "bulk.avg_size_in_bytes",
+                        "bulk.avg_time",
+                        "bulk.total_operations",
+                        "bulk.total_size_in_bytes",
+                        "bulk.total_time",
+                        "completion.size",
+                        "creation.date",
+                        "creation.date.string",
+                        "dataset.size",
+                        "dense_vector.value_count",
+                        "docs.count",
+                        "docs.deleted",
+                        "fielddata.evictions",
+                        "fielddata.memory_size",
+                        "flush.total",
+                        "flush.total_time",
+                        "get.current",
+                        "get.exists_time",
+                        "get.exists_total",
+                        "get.missing_time",
+                        "get.missing_total",
+                        "get.time",
+                        "get.total",
+                        "health",
+                        "index",
+                        "indexing.delete_current",
+                        "indexing.delete_time",
+                        "indexing.delete_total",
+                        "indexing.index_current",
+                        "indexing.index_failed",
+                        "indexing.index_failed_due_to_version_conflict",
+                        "indexing.index_time",
+                        "indexing.index_total",
+                        "memory.total",
+                        "merges.current",
+                        "merges.current_docs",
+                        "merges.current_size",
+                        "merges.total",
+                        "merges.total_docs",
+                        "merges.total_size",
+                        "merges.total_time",
+                        "pri",
+                        "pri.bulk.avg_size_in_bytes",
+                        "pri.bulk.avg_time",
+                        "pri.bulk.total_operations",
+                        "pri.bulk.total_size_in_bytes",
+                        "pri.bulk.total_time",
+                        "pri.completion.size",
+                        "pri.dense_vector.value_count",
+                        "pri.fielddata.evictions",
+                        "pri.fielddata.memory_size",
+                        "pri.flush.total",
+                        "pri.flush.total_time",
+                        "pri.get.current",
+                        "pri.get.exists_time",
+                        "pri.get.exists_total",
+                        "pri.get.missing_time",
+                        "pri.get.missing_total",
+                        "pri.get.time",
+                        "pri.get.total",
+                        "pri.indexing.delete_current",
+                        "pri.indexing.delete_time",
+                        "pri.indexing.delete_total",
+                        "pri.indexing.index_current",
+                        "pri.indexing.index_failed",
+                        "pri.indexing.index_failed_due_to_version_conflict",
+                        "pri.indexing.index_time",
+                        "pri.indexing.index_total",
+                        "pri.memory.total",
+                        "pri.merges.current",
+                        "pri.merges.current_docs",
+                        "pri.merges.current_size",
+                        "pri.merges.total",
+                        "pri.merges.total_docs",
+                        "pri.merges.total_size",
+                        "pri.merges.total_time",
+                        "pri.query_cache.evictions",
+                        "pri.query_cache.memory_size",
+                        "pri.refresh.external_time",
+                        "pri.refresh.external_total",
+                        "pri.refresh.listeners",
+                        "pri.refresh.time",
+                        "pri.refresh.total",
+                        "pri.request_cache.evictions",
+                        "pri.request_cache.hit_count",
+                        "pri.request_cache.memory_size",
+                        "pri.request_cache.miss_count",
+                        "pri.search.fetch_current",
+                        "pri.search.fetch_time",
+                        "pri.search.fetch_total",
+                        "pri.search.open_contexts",
+                        "pri.search.query_current",
+                        "pri.search.query_time",
+                        "pri.search.query_total",
+                        "pri.search.scroll_current",
+                        "pri.search.scroll_time",
+                        "pri.search.scroll_total",
+                        "pri.segments.count",
+                        "pri.segments.fixed_bitset_memory",
+                        "pri.segments.index_writer_memory",
+                        "pri.segments.memory",
+                        "pri.segments.version_map_memory",
+                        "pri.sparse_vector.value_count",
+                        "pri.store.size",
+                        "pri.suggest.current",
+                        "pri.suggest.time",
+                        "pri.suggest.total",
+                        "pri.warmer.current",
+                        "pri.warmer.total",
+                        "pri.warmer.total_time",
+                        "query_cache.evictions",
+                        "query_cache.memory_size",
+                        "refresh.external_time",
+                        "refresh.external_total",
+                        "refresh.listeners",
+                        "refresh.time",
+                        "refresh.total",
+                        "rep",
+                        "request_cache.evictions",
+                        "request_cache.hit_count",
+                        "request_cache.memory_size",
+                        "request_cache.miss_count",
+                        "search.fetch_current",
+                        "search.fetch_time",
+                        "search.fetch_total",
+                        "search.open_contexts",
+                        "search.query_current",
+                        "search.query_time",
+                        "search.query_total",
+                        "search.scroll_current",
+                        "search.scroll_time",
+                        "search.scroll_total",
+                        "segments.count",
+                        "segments.fixed_bitset_memory",
+                        "segments.index_writer_memory",
+                        "segments.memory",
+                        "segments.version_map_memory",
+                        "sparse_vector.value_count",
+                        "status",
+                        "store.size",
+                        "suggest.current",
+                        "suggest.time",
+                        "suggest.total",
+                        "uuid",
+                        "warmer.current",
+                        "warmer.total",
+                        "warmer.total_time",
+                    ],
+                ],
+            ]
+        ] = None,
+        health: t.Optional[
+            t.Union[str, t.Literal["green", "red", "unavailable", "unknown", "yellow"]]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         include_unloaded_segments: t.Optional[bool] = None,
@@ -616,7 +1087,7 @@ async def indices(
           They are not intended for use by applications. For application consumption, use an index endpoint.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-indices>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-indices>`_
 
         :param index: Comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (`*`). To target all data streams
@@ -625,7 +1096,8 @@ async def indices(
         :param expand_wildcards: The type of index that wildcard patterns can match.
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param health: The health status used to limit returned indices. By default,
             the response includes indices of any health status.
         :param help: When set to `true` will output available columns. This option can't
@@ -697,7 +1169,12 @@ async def master(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[t.Union[str, t.Literal["host", "id", "ip", "node"]]],
+                t.Union[str, t.Literal["host", "id", "ip", "node"]],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
@@ -714,11 +1191,12 @@ async def master(
           <p>IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the nodes info API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-master>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-master>`_
 
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param local: If `true`, the request computes the list of selected nodes from
@@ -892,7 +1370,7 @@ async def ml_data_frame_analytics(
           application consumption, use the get data frame analytics jobs statistics API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-ml-data-frame-analytics>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-ml-data-frame-analytics>`_
 
         :param id: The ID of the data frame analytics to fetch
         :param allow_no_match: Whether to ignore if a wildcard expression matches no
@@ -1060,7 +1538,7 @@ async def ml_datafeeds(
           application consumption, use the get datafeed statistics API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-ml-datafeeds>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-ml-datafeeds>`_
 
         :param datafeed_id: A numerical character string that uniquely identifies the
             datafeed.
@@ -1426,7 +1904,7 @@ async def ml_jobs(
           application consumption, use the get anomaly detection job statistics API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-ml-jobs>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-ml-jobs>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param allow_no_match: Specifies what to do when the request: * Contains wildcard
@@ -1611,7 +2089,7 @@ async def ml_trained_models(
           application consumption, use the get trained models statistics API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-ml-trained-models>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-ml-trained-models>`_
 
         :param model_id: A unique identifier for the trained model.
         :param allow_no_match: Specifies what to do when the request: contains wildcard
@@ -1687,7 +2165,24 @@ async def nodeattrs(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "attr", "host", "id", "ip", "node", "pid", "port", "value"
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "attr", "host", "id", "ip", "node", "pid", "port", "value"
+                    ],
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
@@ -1704,11 +2199,12 @@ async def nodeattrs(
           IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the nodes info API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-nodeattrs>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-nodeattrs>`_
 
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param local: If `true`, the request computes the list of selected nodes from
@@ -1767,7 +2263,200 @@ async def nodes(
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
         full_id: t.Optional[t.Union[bool, str]] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "build",
+                            "completion.size",
+                            "cpu",
+                            "disk.avail",
+                            "disk.total",
+                            "disk.used",
+                            "disk.used_percent",
+                            "fielddata.evictions",
+                            "fielddata.memory_size",
+                            "file_desc.current",
+                            "file_desc.max",
+                            "file_desc.percent",
+                            "flush.total",
+                            "flush.total_time",
+                            "get.current",
+                            "get.exists_time",
+                            "get.exists_total",
+                            "get.missing_time",
+                            "get.missing_total",
+                            "get.time",
+                            "get.total",
+                            "heap.current",
+                            "heap.max",
+                            "heap.percent",
+                            "http_address",
+                            "id",
+                            "indexing.delete_current",
+                            "indexing.delete_time",
+                            "indexing.delete_total",
+                            "indexing.index_current",
+                            "indexing.index_failed",
+                            "indexing.index_failed_due_to_version_conflict",
+                            "indexing.index_time",
+                            "indexing.index_total",
+                            "ip",
+                            "jdk",
+                            "load_15m",
+                            "load_1m",
+                            "load_5m",
+                            "mappings.total_count",
+                            "mappings.total_estimated_overhead_in_bytes",
+                            "master",
+                            "merges.current",
+                            "merges.current_docs",
+                            "merges.current_size",
+                            "merges.total",
+                            "merges.total_docs",
+                            "merges.total_size",
+                            "merges.total_time",
+                            "name",
+                            "node.role",
+                            "pid",
+                            "port",
+                            "query_cache.evictions",
+                            "query_cache.hit_count",
+                            "query_cache.memory_size",
+                            "query_cache.miss_count",
+                            "ram.current",
+                            "ram.max",
+                            "ram.percent",
+                            "refresh.time",
+                            "refresh.total",
+                            "request_cache.evictions",
+                            "request_cache.hit_count",
+                            "request_cache.memory_size",
+                            "request_cache.miss_count",
+                            "script.cache_evictions",
+                            "script.compilations",
+                            "search.fetch_current",
+                            "search.fetch_time",
+                            "search.fetch_total",
+                            "search.open_contexts",
+                            "search.query_current",
+                            "search.query_time",
+                            "search.query_total",
+                            "search.scroll_current",
+                            "search.scroll_time",
+                            "search.scroll_total",
+                            "segments.count",
+                            "segments.fixed_bitset_memory",
+                            "segments.index_writer_memory",
+                            "segments.memory",
+                            "segments.version_map_memory",
+                            "shard_stats.total_count",
+                            "suggest.current",
+                            "suggest.time",
+                            "suggest.total",
+                            "uptime",
+                            "version",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "build",
+                        "completion.size",
+                        "cpu",
+                        "disk.avail",
+                        "disk.total",
+                        "disk.used",
+                        "disk.used_percent",
+                        "fielddata.evictions",
+                        "fielddata.memory_size",
+                        "file_desc.current",
+                        "file_desc.max",
+                        "file_desc.percent",
+                        "flush.total",
+                        "flush.total_time",
+                        "get.current",
+                        "get.exists_time",
+                        "get.exists_total",
+                        "get.missing_time",
+                        "get.missing_total",
+                        "get.time",
+                        "get.total",
+                        "heap.current",
+                        "heap.max",
+                        "heap.percent",
+                        "http_address",
+                        "id",
+                        "indexing.delete_current",
+                        "indexing.delete_time",
+                        "indexing.delete_total",
+                        "indexing.index_current",
+                        "indexing.index_failed",
+                        "indexing.index_failed_due_to_version_conflict",
+                        "indexing.index_time",
+                        "indexing.index_total",
+                        "ip",
+                        "jdk",
+                        "load_15m",
+                        "load_1m",
+                        "load_5m",
+                        "mappings.total_count",
+                        "mappings.total_estimated_overhead_in_bytes",
+                        "master",
+                        "merges.current",
+                        "merges.current_docs",
+                        "merges.current_size",
+                        "merges.total",
+                        "merges.total_docs",
+                        "merges.total_size",
+                        "merges.total_time",
+                        "name",
+                        "node.role",
+                        "pid",
+                        "port",
+                        "query_cache.evictions",
+                        "query_cache.hit_count",
+                        "query_cache.memory_size",
+                        "query_cache.miss_count",
+                        "ram.current",
+                        "ram.max",
+                        "ram.percent",
+                        "refresh.time",
+                        "refresh.total",
+                        "request_cache.evictions",
+                        "request_cache.hit_count",
+                        "request_cache.memory_size",
+                        "request_cache.miss_count",
+                        "script.cache_evictions",
+                        "script.compilations",
+                        "search.fetch_current",
+                        "search.fetch_time",
+                        "search.fetch_total",
+                        "search.open_contexts",
+                        "search.query_current",
+                        "search.query_time",
+                        "search.query_total",
+                        "search.scroll_current",
+                        "search.scroll_time",
+                        "search.scroll_total",
+                        "segments.count",
+                        "segments.fixed_bitset_memory",
+                        "segments.index_writer_memory",
+                        "segments.memory",
+                        "segments.version_map_memory",
+                        "shard_stats.total_count",
+                        "suggest.current",
+                        "suggest.time",
+                        "suggest.total",
+                        "uptime",
+                        "version",
+                    ],
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         include_unloaded_segments: t.Optional[bool] = None,
@@ -1787,23 +2476,24 @@ async def nodes(
           IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the nodes info API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-nodes>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-nodes>`_
 
         :param bytes: The unit used to display byte values.
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
         :param full_id: If `true`, return the full node ID. If `false`, return the shortened
             node ID.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param include_unloaded_segments: If true, the response includes information
             from segments that are not loaded into memory.
-        :param master_timeout: Period to wait for a connection to the master node.
-        :param s: List of columns that determine how the table should be sorted. Sorting
-            defaults to ascending and can be changed by setting `:asc` or `:desc` as
-            a suffix to the column name.
-        :param time: Unit used to display time values.
+        :param master_timeout: The period to wait for a connection to the master node.
+        :param s: A comma-separated list of column names or aliases that determines the
+            sort order. Sorting defaults to ascending and can be changed by setting `:asc`
+            or `:desc` as a suffix to the column name.
+        :param time: The unit used to display time values.
         :param v: When set to `true` will enable verbose output.
         """
         __path_parts: t.Dict[str, str] = {}
@@ -1854,7 +2544,19 @@ async def pending_tasks(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal["insertOrder", "priority", "source", "timeInQueue"],
+                    ]
+                ],
+                t.Union[
+                    str, t.Literal["insertOrder", "priority", "source", "timeInQueue"]
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
@@ -1874,11 +2576,12 @@ async def pending_tasks(
           IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the pending cluster tasks API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-pending-tasks>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-pending-tasks>`_
 
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param local: If `true`, the request computes the list of selected nodes from
@@ -1936,7 +2639,19 @@ async def plugins(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal["component", "description", "id", "name", "version"],
+                    ]
+                ],
+                t.Union[
+                    str, t.Literal["component", "description", "id", "name", "version"]
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         include_bootstrap: t.Optional[bool] = None,
@@ -1954,11 +2669,12 @@ async def plugins(
           IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the nodes info API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-plugins>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-plugins>`_
 
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param include_bootstrap: Include bootstrap plugins in the response
@@ -2022,7 +2738,74 @@ async def recovery(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "bytes",
+                            "bytes_percent",
+                            "bytes_recovered",
+                            "bytes_total",
+                            "files",
+                            "files_percent",
+                            "files_recovered",
+                            "files_total",
+                            "index",
+                            "repository",
+                            "shard",
+                            "snapshot",
+                            "source_host",
+                            "source_node",
+                            "stage",
+                            "start_time",
+                            "start_time_millis",
+                            "stop_time",
+                            "stop_time_millis",
+                            "target_host",
+                            "target_node",
+                            "time",
+                            "translog_ops",
+                            "translog_ops_percent",
+                            "translog_ops_recovered",
+                            "type",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "bytes",
+                        "bytes_percent",
+                        "bytes_recovered",
+                        "bytes_total",
+                        "files",
+                        "files_percent",
+                        "files_recovered",
+                        "files_total",
+                        "index",
+                        "repository",
+                        "shard",
+                        "snapshot",
+                        "source_host",
+                        "source_node",
+                        "stage",
+                        "start_time",
+                        "start_time_millis",
+                        "stop_time",
+                        "stop_time_millis",
+                        "target_host",
+                        "target_node",
+                        "time",
+                        "translog_ops",
+                        "translog_ops_percent",
+                        "translog_ops_recovered",
+                        "type",
+                    ],
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         pretty: t.Optional[bool] = None,
@@ -2042,7 +2825,7 @@ async def recovery(
           IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the index recovery API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-recovery>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-recovery>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (`*`). To target all data streams
@@ -2053,13 +2836,14 @@ async def recovery(
             shard recoveries.
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
-        :param s: List of columns that determine how the table should be sorted. Sorting
-            defaults to ascending and can be changed by setting `:asc` or `:desc` as
-            a suffix to the column name.
-        :param time: Unit used to display time values.
+        :param s: A comma-separated list of column names or aliases that determines the
+            sort order. Sorting defaults to ascending and can be changed by setting `:asc`
+            or `:desc` as a suffix to the column name.
+        :param time: The unit used to display time values.
         :param v: When set to `true` will enable verbose output.
         """
         __path_parts: t.Dict[str, str]
@@ -2130,7 +2914,7 @@ async def repositories(
           IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the get snapshot repository API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-repositories>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-repositories>`_
 
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
@@ -2193,7 +2977,52 @@ async def segments(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "committed",
+                            "compound",
+                            "docs.count",
+                            "docs.deleted",
+                            "generation",
+                            "id",
+                            "index",
+                            "ip",
+                            "prirep",
+                            "searchable",
+                            "segment",
+                            "shard",
+                            "size",
+                            "size.memory",
+                            "version",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "committed",
+                        "compound",
+                        "docs.count",
+                        "docs.deleted",
+                        "generation",
+                        "id",
+                        "index",
+                        "ip",
+                        "prirep",
+                        "searchable",
+                        "segment",
+                        "shard",
+                        "size",
+                        "size.memory",
+                        "version",
+                    ],
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
@@ -2211,7 +3040,7 @@ async def segments(
           IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the index segments API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-segments>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-segments>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (`*`). To target all data streams
@@ -2219,7 +3048,8 @@ async def segments(
         :param bytes: The unit used to display byte values.
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param local: If `true`, the request computes the list of selected nodes from
@@ -2227,9 +3057,9 @@ async def segments(
             from the cluster state of the master node. In both cases the coordinating
             node will send requests for further information to each selected node.
         :param master_timeout: Period to wait for a connection to the master node.
-        :param s: List of columns that determine how the table should be sorted. Sorting
-            defaults to ascending and can be changed by setting `:asc` or `:desc` as
-            a suffix to the column name.
+        :param s: A comma-separated list of column names or aliases that determines the
+            sort order. Sorting defaults to ascending and can be changed by setting `:asc`
+            or `:desc` as a suffix to the column name.
         :param v: When set to `true` will enable verbose output.
         """
         __path_parts: t.Dict[str, str]
@@ -2285,7 +3115,162 @@ async def shards(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "completion.size",
+                            "dataset.size",
+                            "dense_vector.value_count",
+                            "docs",
+                            "dsparse_vector.value_count",
+                            "fielddata.evictions",
+                            "fielddata.memory_size",
+                            "flush.total",
+                            "flush.total_time",
+                            "get.current",
+                            "get.exists_time",
+                            "get.exists_total",
+                            "get.missing_time",
+                            "get.missing_total",
+                            "get.time",
+                            "get.total",
+                            "id",
+                            "index",
+                            "indexing.delete_current",
+                            "indexing.delete_time",
+                            "indexing.delete_total",
+                            "indexing.index_current",
+                            "indexing.index_failed",
+                            "indexing.index_failed_due_to_version_conflict",
+                            "indexing.index_time",
+                            "indexing.index_total",
+                            "ip",
+                            "merges.current",
+                            "merges.current_docs",
+                            "merges.current_size",
+                            "merges.total",
+                            "merges.total_docs",
+                            "merges.total_size",
+                            "merges.total_time",
+                            "node",
+                            "prirep",
+                            "query_cache.evictions",
+                            "query_cache.memory_size",
+                            "recoverysource.type",
+                            "refresh.time",
+                            "refresh.total",
+                            "search.fetch_current",
+                            "search.fetch_time",
+                            "search.fetch_total",
+                            "search.open_contexts",
+                            "search.query_current",
+                            "search.query_time",
+                            "search.query_total",
+                            "search.scroll_current",
+                            "search.scroll_time",
+                            "search.scroll_total",
+                            "segments.count",
+                            "segments.fixed_bitset_memory",
+                            "segments.index_writer_memory",
+                            "segments.memory",
+                            "segments.version_map_memory",
+                            "seq_no.global_checkpoint",
+                            "seq_no.local_checkpoint",
+                            "seq_no.max",
+                            "shard",
+                            "state",
+                            "store",
+                            "suggest.current",
+                            "suggest.time",
+                            "suggest.total",
+                            "sync_id",
+                            "unassigned.at",
+                            "unassigned.details",
+                            "unassigned.for",
+                            "unassigned.reason",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "completion.size",
+                        "dataset.size",
+                        "dense_vector.value_count",
+                        "docs",
+                        "dsparse_vector.value_count",
+                        "fielddata.evictions",
+                        "fielddata.memory_size",
+                        "flush.total",
+                        "flush.total_time",
+                        "get.current",
+                        "get.exists_time",
+                        "get.exists_total",
+                        "get.missing_time",
+                        "get.missing_total",
+                        "get.time",
+                        "get.total",
+                        "id",
+                        "index",
+                        "indexing.delete_current",
+                        "indexing.delete_time",
+                        "indexing.delete_total",
+                        "indexing.index_current",
+                        "indexing.index_failed",
+                        "indexing.index_failed_due_to_version_conflict",
+                        "indexing.index_time",
+                        "indexing.index_total",
+                        "ip",
+                        "merges.current",
+                        "merges.current_docs",
+                        "merges.current_size",
+                        "merges.total",
+                        "merges.total_docs",
+                        "merges.total_size",
+                        "merges.total_time",
+                        "node",
+                        "prirep",
+                        "query_cache.evictions",
+                        "query_cache.memory_size",
+                        "recoverysource.type",
+                        "refresh.time",
+                        "refresh.total",
+                        "search.fetch_current",
+                        "search.fetch_time",
+                        "search.fetch_total",
+                        "search.open_contexts",
+                        "search.query_current",
+                        "search.query_time",
+                        "search.query_total",
+                        "search.scroll_current",
+                        "search.scroll_time",
+                        "search.scroll_total",
+                        "segments.count",
+                        "segments.fixed_bitset_memory",
+                        "segments.index_writer_memory",
+                        "segments.memory",
+                        "segments.version_map_memory",
+                        "seq_no.global_checkpoint",
+                        "seq_no.local_checkpoint",
+                        "seq_no.max",
+                        "shard",
+                        "state",
+                        "store",
+                        "suggest.current",
+                        "suggest.time",
+                        "suggest.total",
+                        "sync_id",
+                        "unassigned.at",
+                        "unassigned.details",
+                        "unassigned.for",
+                        "unassigned.reason",
+                    ],
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
@@ -2305,7 +3290,7 @@ async def shards(
           IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-shards>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-shards>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (`*`). To target all data streams
@@ -2316,11 +3301,11 @@ async def shards(
         :param h: List of columns to appear in the response. Supports simple wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
-        :param master_timeout: Period to wait for a connection to the master node.
-        :param s: List of columns that determine how the table should be sorted. Sorting
-            defaults to ascending and can be changed by setting `:asc` or `:desc` as
-            a suffix to the column name.
-        :param time: Unit used to display time values.
+        :param master_timeout: The period to wait for a connection to the master node.
+        :param s: A comma-separated list of column names or aliases that determines the
+            sort order. Sorting defaults to ascending and can be changed by setting `:asc`
+            or `:desc` as a suffix to the column name.
+        :param time: The unit used to display time values.
         :param v: When set to `true` will enable verbose output.
         """
         __path_parts: t.Dict[str, str]
@@ -2373,7 +3358,48 @@ async def snapshots(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "duration",
+                            "end_epoch",
+                            "end_time",
+                            "failed_shards",
+                            "id",
+                            "indices",
+                            "reason",
+                            "repository",
+                            "start_epoch",
+                            "start_time",
+                            "status",
+                            "successful_shards",
+                            "total_shards",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "duration",
+                        "end_epoch",
+                        "end_time",
+                        "failed_shards",
+                        "id",
+                        "indices",
+                        "reason",
+                        "repository",
+                        "start_epoch",
+                        "start_time",
+                        "status",
+                        "successful_shards",
+                        "total_shards",
+                    ],
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         ignore_unavailable: t.Optional[bool] = None,
@@ -2394,14 +3420,15 @@ async def snapshots(
           IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the get snapshot API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-snapshots>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-snapshots>`_
 
         :param repository: A comma-separated list of snapshot repositories used to limit
             the request. Accepts wildcard expressions. `_all` returns all repositories.
             If any repository fails during the request, Elasticsearch returns an error.
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param ignore_unavailable: If `true`, the response does not include information
@@ -2465,7 +3492,52 @@ async def tasks(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "action",
+                            "id",
+                            "ip",
+                            "node",
+                            "node_id",
+                            "parent_task_id",
+                            "port",
+                            "running_time",
+                            "running_time_ns",
+                            "start_time",
+                            "task_id",
+                            "timestamp",
+                            "type",
+                            "version",
+                            "x_opaque_id",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "action",
+                        "id",
+                        "ip",
+                        "node",
+                        "node_id",
+                        "parent_task_id",
+                        "port",
+                        "running_time",
+                        "running_time_ns",
+                        "start_time",
+                        "task_id",
+                        "timestamp",
+                        "type",
+                        "version",
+                        "x_opaque_id",
+                    ],
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         nodes: t.Optional[t.Sequence[str]] = None,
@@ -2487,14 +3559,15 @@ async def tasks(
           IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the task management API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-tasks>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-tasks>`_
 
         :param actions: The task action names, which are used to limit the response.
         :param detailed: If `true`, the response includes detailed information about
             shard recoveries.
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param nodes: Unique node identifiers, which are used to limit the response.
@@ -2563,7 +3636,24 @@ async def templates(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "composed_of", "index_patterns", "name", "order", "version"
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "composed_of", "index_patterns", "name", "order", "version"
+                    ],
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
@@ -2581,13 +3671,14 @@ async def templates(
           IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the get index template API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-templates>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-templates>`_
 
         :param name: The name of the template to return. Accepts wildcard expressions.
             If omitted, all templates are returned.
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param local: If `true`, the request computes the list of selected nodes from
@@ -2648,7 +3739,62 @@ async def thread_pool(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "active",
+                            "completed",
+                            "core",
+                            "ephemeral_id",
+                            "host",
+                            "ip",
+                            "keep_alive",
+                            "largest",
+                            "max",
+                            "name",
+                            "node_id",
+                            "node_name",
+                            "pid",
+                            "pool_size",
+                            "port",
+                            "queue",
+                            "queue_size",
+                            "rejected",
+                            "size",
+                            "type",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "active",
+                        "completed",
+                        "core",
+                        "ephemeral_id",
+                        "host",
+                        "ip",
+                        "keep_alive",
+                        "largest",
+                        "max",
+                        "name",
+                        "node_id",
+                        "node_name",
+                        "pid",
+                        "pool_size",
+                        "port",
+                        "queue",
+                        "queue_size",
+                        "rejected",
+                        "size",
+                        "type",
+                    ],
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
@@ -2669,7 +3815,7 @@ async def thread_pool(
           IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the nodes info API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-thread-pool>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-thread-pool>`_
 
         :param thread_pool_patterns: A comma-separated list of thread pool names used
             to limit the request. Accepts wildcard expressions.
@@ -2682,10 +3828,10 @@ async def thread_pool(
             the local cluster state. If `false` the list of selected nodes are computed
             from the cluster state of the master node. In both cases the coordinating
             node will send requests for further information to each selected node.
-        :param master_timeout: Period to wait for a connection to the master node.
-        :param s: List of columns that determine how the table should be sorted. Sorting
-            defaults to ascending and can be changed by setting `:asc` or `:desc` as
-            a suffix to the column name.
+        :param master_timeout: The period to wait for a connection to the master node.
+        :param s: A comma-separated list of column names or aliases that determines the
+            sort order. Sorting defaults to ascending and can be changed by setting `:asc`
+            or `:desc` as a suffix to the column name.
         :param time: The unit used to display time values.
         :param v: When set to `true` will enable verbose output.
         """
@@ -2926,7 +4072,7 @@ async def transforms(
           application consumption, use the get transform statistics API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-transforms>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-transforms>`_
 
         :param transform_id: A transform identifier or a wildcard expression. If you
             do not specify one of these options, the API returns information for all
diff --git a/elasticsearch/_async/client/ccr.py b/elasticsearch/_async/client/ccr.py
index a98428ffb..6617f2403 100644
--- a/elasticsearch/_async/client/ccr.py
+++ b/elasticsearch/_async/client/ccr.py
@@ -43,7 +43,7 @@ async def delete_auto_follow_pattern(
           <p>Delete a collection of cross-cluster replication auto-follow patterns.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ccr-delete-auto-follow-pattern>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ccr-delete-auto-follow-pattern>`_
 
         :param name: The auto-follow pattern collection to delete.
         :param master_timeout: The period to wait for a connection to the master node.
@@ -130,7 +130,7 @@ async def follow(
           When the API returns, the follower index exists and cross-cluster replication starts replicating operations from the leader index to the follower index.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ccr-follow>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ccr-follow>`_
 
         :param index: The name of the follower index.
         :param leader_index: The name of the index in the leader cluster to follow.
@@ -259,7 +259,7 @@ async def follow_info(
           For example, the results include follower index names, leader index names, replication options, and whether the follower indices are active or paused.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ccr-follow-info>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ccr-follow-info>`_
 
         :param index: A comma-delimited list of follower index patterns.
         :param master_timeout: The period to wait for a connection to the master node.
@@ -311,7 +311,7 @@ async def follow_stats(
           The API returns shard-level stats about the &quot;following tasks&quot; associated with each shard for the specified indices.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ccr-follow-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ccr-follow-stats>`_
 
         :param index: A comma-delimited list of index patterns.
         :param timeout: The period to wait for a response. If no response is received
@@ -380,7 +380,7 @@ async def forget_follower(
           The only purpose of this API is to handle the case of failure to remove the following retention leases after the unfollow API is invoked.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ccr-forget-follower>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ccr-forget-follower>`_
 
         :param index: the name of the leader index for which specified follower retention
             leases should be removed
@@ -445,7 +445,7 @@ async def get_auto_follow_pattern(
           <p>Get cross-cluster replication auto-follow patterns.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ccr-get-auto-follow-pattern-1>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ccr-get-auto-follow-pattern-1>`_
 
         :param name: The auto-follow pattern collection that you want to retrieve. If
             you do not specify a name, the API returns information for all collections.
@@ -505,7 +505,7 @@ async def pause_auto_follow_pattern(
           Remote indices that were created while the pattern was paused will also be followed, unless they have been deleted or closed in the interim.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ccr-pause-auto-follow-pattern>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ccr-pause-auto-follow-pattern>`_
 
         :param name: The name of the auto-follow pattern to pause.
         :param master_timeout: The period to wait for a connection to the master node.
@@ -559,7 +559,7 @@ async def pause_follow(
           You can pause and resume a follower index to change the configuration of the following task.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ccr-pause-follow>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ccr-pause-follow>`_
 
         :param index: The name of the follower index.
         :param master_timeout: The period to wait for a connection to the master node.
@@ -648,7 +648,7 @@ async def put_auto_follow_pattern(
           NOTE: Follower indices that were configured automatically before updating an auto-follow pattern will remain unchanged even if they do not match against the new patterns.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ccr-put-auto-follow-pattern>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ccr-put-auto-follow-pattern>`_
 
         :param name: The name of the collection of auto-follow patterns.
         :param remote_cluster: The remote cluster containing the leader indices to match
@@ -782,7 +782,7 @@ async def resume_auto_follow_pattern(
           Remote indices created while the pattern was paused will also be followed unless they have been deleted or closed in the interim.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ccr-resume-auto-follow-pattern>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ccr-resume-auto-follow-pattern>`_
 
         :param name: The name of the auto-follow pattern to resume.
         :param master_timeout: The period to wait for a connection to the master node.
@@ -860,7 +860,7 @@ async def resume_follow(
           When this API returns, the follower index will resume fetching operations from the leader index.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ccr-resume-follow>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ccr-resume-follow>`_
 
         :param index: The name of the follow index to resume following.
         :param master_timeout: Period to wait for a connection to the master node.
@@ -951,7 +951,7 @@ async def stats(
           <p>This API returns stats about auto-following and the same shard-level stats as the get follower stats API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ccr-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ccr-stats>`_
 
         :param master_timeout: The period to wait for a connection to the master node.
             If the master node is not available before the timeout expires, the request
@@ -1009,7 +1009,7 @@ async def unfollow(
           </blockquote>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ccr-unfollow>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ccr-unfollow>`_
 
         :param index: The name of the follower index.
         :param master_timeout: The period to wait for a connection to the master node.
diff --git a/elasticsearch/_async/client/cluster.py b/elasticsearch/_async/client/cluster.py
index 074bdc0e8..ee8036536 100644
--- a/elasticsearch/_async/client/cluster.py
+++ b/elasticsearch/_async/client/cluster.py
@@ -51,10 +51,11 @@ async def allocation_explain(
           Get explanations for shard allocations in the cluster.
           For unassigned shards, it provides an explanation for why the shard is unassigned.
           For assigned shards, it provides an explanation for why the shard is remaining on its current node and has not moved or rebalanced to another node.
-          This API can be very useful when attempting to diagnose why a shard is unassigned or why a shard continues to remain on its current node when you might expect otherwise.</p>
+          This API can be very useful when attempting to diagnose why a shard is unassigned or why a shard continues to remain on its current node when you might expect otherwise.
+          Refer to the linked documentation for examples of how to troubleshoot allocation issues using this API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-allocation-explain>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-allocation-explain>`_
 
         :param current_node: Specifies the node ID or the name of the node to only explain
             a shard that is currently located on the specified node.
@@ -130,7 +131,7 @@ async def delete_component_template(
           Component templates are building blocks for constructing index templates that specify index mappings, settings, and aliases.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-put-component-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-put-component-template>`_
 
         :param name: Comma-separated list or wildcard expression of component template
             names used to limit the request.
@@ -185,7 +186,7 @@ async def delete_voting_config_exclusions(
           Remove master-eligible nodes from the voting configuration exclusion list.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-post-voting-config-exclusions>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-post-voting-config-exclusions>`_
 
         :param master_timeout: Period to wait for a connection to the master node.
         :param wait_for_removal: Specifies whether to wait for all excluded nodes to
@@ -239,7 +240,7 @@ async def exists_component_template(
           Returns information about whether a particular component template exists.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-put-component-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-put-component-template>`_
 
         :param name: Comma-separated list of component template names used to limit the
             request. Wildcard (*) expressions are supported.
@@ -290,6 +291,7 @@ async def get_component_template(
         local: t.Optional[bool] = None,
         master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
+        settings_filter: t.Optional[t.Union[str, t.Sequence[str]]] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
         .. raw:: html
@@ -298,7 +300,7 @@ async def get_component_template(
           Get information about component templates.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-put-component-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-put-component-template>`_
 
         :param name: Comma-separated list of component template names used to limit the
             request. Wildcard (`*`) expressions are supported.
@@ -310,6 +312,8 @@ async def get_component_template(
         :param master_timeout: Period to wait for a connection to the master node. If
             no response is received before the timeout expires, the request fails and
             returns an error.
+        :param settings_filter: Filter out results, for example to filter out sensitive
+            information. Supports wildcards or full settings keys
         """
         __path_parts: t.Dict[str, str]
         if name not in SKIP_IN_PATH:
@@ -335,6 +339,8 @@ async def get_component_template(
             __query["master_timeout"] = master_timeout
         if pretty is not None:
             __query["pretty"] = pretty
+        if settings_filter is not None:
+            __query["settings_filter"] = settings_filter
         __headers = {"accept": "application/json"}
         return await self.perform_request(  # type: ignore[return-value]
             "GET",
@@ -365,7 +371,7 @@ async def get_settings(
           By default, it returns only settings that have been explicitly defined.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-get-settings>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-get-settings>`_
 
         :param flat_settings: If `true`, returns settings in flat format.
         :param include_defaults: If `true`, returns default cluster settings from the
@@ -441,7 +447,7 @@ async def health(
         wait_for_no_relocating_shards: t.Optional[bool] = None,
         wait_for_nodes: t.Optional[t.Union[int, str]] = None,
         wait_for_status: t.Optional[
-            t.Union[str, t.Literal["green", "red", "yellow"]]
+            t.Union[str, t.Literal["green", "red", "unavailable", "unknown", "yellow"]]
         ] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
@@ -457,7 +463,7 @@ async def health(
           The cluster status is controlled by the worst index status.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-health>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-health>`_
 
         :param index: Comma-separated list of data streams, indices, and index aliases
             used to limit the request. Wildcard expressions (`*`) are supported. To target
@@ -565,7 +571,7 @@ async def info(
           Returns basic information about the cluster.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-info>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-info>`_
 
         :param target: Limits the information returned to the specific target. Supports
             a comma-separated list, such as http,ingest.
@@ -614,7 +620,7 @@ async def pending_tasks(
           However, if a user-initiated task such as a create index command causes a cluster state update, the activity of this task might be reported by both task api and pending cluster tasks API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-pending-tasks>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-pending-tasks>`_
 
         :param local: If `true`, the request retrieves information from the local node
             only. If `false`, information is retrieved from the master node.
@@ -680,7 +686,7 @@ async def post_voting_config_exclusions(
           They are not required when removing master-ineligible nodes or when removing fewer than half of the master-eligible nodes.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-post-voting-config-exclusions>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-post-voting-config-exclusions>`_
 
         :param master_timeout: Period to wait for a connection to the master node.
         :param node_ids: A comma-separated list of the persistent ids of the nodes to
@@ -731,6 +737,7 @@ async def put_component_template(
         *,
         name: str,
         template: t.Optional[t.Mapping[str, t.Any]] = None,
+        cause: t.Optional[str] = None,
         create: t.Optional[bool] = None,
         deprecated: t.Optional[bool] = None,
         error_trace: t.Optional[bool] = None,
@@ -761,7 +768,7 @@ async def put_component_template(
           To be applied, a component template must be included in an index template's <code>composed_of</code> list.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-put-component-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-put-component-template>`_
 
         :param name: Name of the component template to create. Elasticsearch includes
             the following built-in component templates: `logs-mappings`; `logs-settings`;
@@ -774,6 +781,7 @@ async def put_component_template(
             update settings API.
         :param template: The template to be applied which includes mappings, settings,
             or aliases configuration.
+        :param cause: User defined reason for create the component template.
         :param create: If `true`, this request cannot replace or update existing component
             templates.
         :param deprecated: Marks this index template as deprecated. When creating or
@@ -798,6 +806,8 @@ async def put_component_template(
         __path = f'/_component_template/{__path_parts["name"]}'
         __query: t.Dict[str, t.Any] = {}
         __body: t.Dict[str, t.Any] = body if body is not None else {}
+        if cause is not None:
+            __query["cause"] = cause
         if create is not None:
             __query["create"] = create
         if error_trace is not None:
@@ -866,13 +876,13 @@ async def put_settings(
           If a cluster becomes unstable, transient settings can clear unexpectedly, resulting in a potentially undesired cluster configuration.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-put-settings>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-put-settings>`_
 
         :param flat_settings: Return settings in flat format (default: false)
         :param master_timeout: Explicit operation timeout for connection to master node
-        :param persistent:
+        :param persistent: The settings that persist after the cluster restarts.
         :param timeout: Explicit operation timeout
-        :param transient:
+        :param transient: The settings that do not persist after the cluster restarts.
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_cluster/settings"
@@ -932,7 +942,7 @@ async def remote_info(
           </blockquote>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-remote-info>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-remote-info>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_remote/info"
@@ -989,7 +999,7 @@ async def reroute(
           <p>Once the problem has been corrected, allocation can be manually retried by calling the reroute API with the <code>?retry_failed</code> URI query parameter, which will attempt a single retry round for these shards.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-reroute>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-reroute>`_
 
         :param commands: Defines the commands to perform.
         :param dry_run: If true, then the request simulates the operation. It will calculate
@@ -1094,7 +1104,7 @@ async def state(
           Instead, obtain the information you require using other more stable cluster APIs.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-state>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-state>`_
 
         :param metric: Limit the information returned to the specified metrics
         :param index: A comma-separated list of index names; use `_all` or empty string
@@ -1182,7 +1192,7 @@ async def stats(
           Get basic index metrics (shard numbers, store size, memory usage) and information about the current nodes that form the cluster (number, roles, os, jvm versions, memory usage, cpu and installed plugins).</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-stats>`_
 
         :param node_id: Comma-separated list of node filters used to limit returned information.
             Defaults to all nodes in the cluster.
diff --git a/elasticsearch/_async/client/connector.py b/elasticsearch/_async/client/connector.py
index debf9e3ce..31fecb03c 100644
--- a/elasticsearch/_async/client/connector.py
+++ b/elasticsearch/_async/client/connector.py
@@ -49,7 +49,7 @@ async def check_in(
           <p>Update the <code>last_seen</code> field in the connector and set it to the current timestamp.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-check-in>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-check-in>`_
 
         :param connector_id: The unique identifier of the connector to be checked in
         """
@@ -99,7 +99,7 @@ async def delete(
           These need to be removed manually.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-delete>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-delete>`_
 
         :param connector_id: The unique identifier of the connector to be deleted
         :param delete_sync_jobs: A flag indicating if associated sync jobs should be
@@ -152,7 +152,7 @@ async def get(
           <p>Get the details about a connector.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-get>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-get>`_
 
         :param connector_id: The unique identifier of the connector
         :param include_deleted: A flag to indicate if the desired connector should be
@@ -256,7 +256,7 @@ async def last_sync(
           This action is used for analytics and monitoring.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-last-sync>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-last-sync>`_
 
         :param connector_id: The unique identifier of the connector to be updated
         :param last_access_control_sync_error:
@@ -356,7 +356,7 @@ async def list(
           <p>Get information about all connectors.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-list>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-list>`_
 
         :param connector_name: A comma-separated list of connector names to fetch connector
             documents for
@@ -441,7 +441,7 @@ async def post(
           Self-managed connectors (Connector clients) are self-managed on your infrastructure.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-put>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-put>`_
 
         :param description:
         :param index_name:
@@ -523,7 +523,7 @@ async def put(
           <p>Create or update a connector.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-put>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-put>`_
 
         :param connector_id: The unique identifier of the connector to be created or
             updated. ID is auto-generated if not provided.
@@ -598,7 +598,7 @@ async def sync_job_cancel(
           The connector service is then responsible for setting the status of connector sync jobs to cancelled.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-sync-job-cancel>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-sync-job-cancel>`_
 
         :param connector_sync_job_id: The unique identifier of the connector sync job
         """
@@ -649,7 +649,7 @@ async def sync_job_check_in(
           This service runs automatically on Elastic Cloud for Elastic managed connectors.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-sync-job-check-in>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-sync-job-check-in>`_
 
         :param connector_sync_job_id: The unique identifier of the connector sync job
             to be checked in.
@@ -709,7 +709,7 @@ async def sync_job_claim(
           This service runs automatically on Elastic Cloud for Elastic managed connectors.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-sync-job-claim>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-sync-job-claim>`_
 
         :param connector_sync_job_id: The unique identifier of the connector sync job.
         :param worker_hostname: The host name of the current system that will run the
@@ -771,7 +771,7 @@ async def sync_job_delete(
           This is a destructive action that is not recoverable.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-sync-job-delete>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-sync-job-delete>`_
 
         :param connector_sync_job_id: The unique identifier of the connector sync job
             to be deleted
@@ -825,7 +825,7 @@ async def sync_job_error(
           This service runs automatically on Elastic Cloud for Elastic managed connectors.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-sync-job-error>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-sync-job-error>`_
 
         :param connector_sync_job_id: The unique identifier for the connector sync job.
         :param error: The error for the connector sync job error field.
@@ -879,7 +879,7 @@ async def sync_job_get(
           <p>Get a connector sync job.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-sync-job-get>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-sync-job-get>`_
 
         :param connector_sync_job_id: The unique identifier of the connector sync job
         """
@@ -952,7 +952,7 @@ async def sync_job_list(
           <p>Get information about all stored connector sync jobs listed by their creation date in ascending order.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-sync-job-list>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-sync-job-list>`_
 
         :param connector_id: A connector id to fetch connector sync jobs for
         :param from_: Starting offset (default: 0)
@@ -1018,7 +1018,7 @@ async def sync_job_post(
           <p>Create a connector sync job document in the internal index and initialize its counters and timestamps with default values.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-sync-job-post>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-sync-job-post>`_
 
         :param id: The id of the associated connector
         :param job_type:
@@ -1094,7 +1094,7 @@ async def sync_job_update_stats(
           This service runs automatically on Elastic Cloud for Elastic managed connectors.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-sync-job-update-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-sync-job-update-stats>`_
 
         :param connector_sync_job_id: The unique identifier of the connector sync job.
         :param deleted_document_count: The number of documents the sync job deleted.
@@ -1177,7 +1177,7 @@ async def update_active_filtering(
           <p>Activates the valid draft filtering for a connector.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-update-filtering>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-update-filtering>`_
 
         :param connector_id: The unique identifier of the connector to be updated
         """
@@ -1230,7 +1230,7 @@ async def update_api_key_id(
           Self-managed connectors (connector clients) do not use this field.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-update-api-key-id>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-update-api-key-id>`_
 
         :param connector_id: The unique identifier of the connector to be updated
         :param api_key_id:
@@ -1289,7 +1289,7 @@ async def update_configuration(
           <p>Update the configuration field in the connector document.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-update-configuration>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-update-configuration>`_
 
         :param connector_id: The unique identifier of the connector to be updated
         :param configuration:
@@ -1349,7 +1349,7 @@ async def update_error(
           Otherwise, if the error is reset to null, the connector status is updated to connected.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-update-error>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-update-error>`_
 
         :param connector_id: The unique identifier of the connector to be updated
         :param error:
@@ -1417,7 +1417,7 @@ async def update_features(
           This service runs automatically on Elastic Cloud for Elastic managed connectors.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-update-features>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-update-features>`_
 
         :param connector_id: The unique identifier of the connector to be updated.
         :param features:
@@ -1478,7 +1478,7 @@ async def update_filtering(
           The filtering property is used to configure sync rules (both basic and advanced) for a connector.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-update-filtering>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-update-filtering>`_
 
         :param connector_id: The unique identifier of the connector to be updated
         :param advanced_snippet:
@@ -1539,7 +1539,7 @@ async def update_filtering_validation(
           <p>Update the draft filtering validation info for a connector.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/update-connector-filtering-validation-api.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-update-filtering-validation>`_
 
         :param connector_id: The unique identifier of the connector to be updated
         :param validation:
@@ -1596,7 +1596,7 @@ async def update_index_name(
           <p>Update the <code>index_name</code> field of a connector, specifying the index where the data ingested by the connector is stored.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-update-index-name>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-update-index-name>`_
 
         :param connector_id: The unique identifier of the connector to be updated
         :param index_name:
@@ -1653,7 +1653,7 @@ async def update_name(
           <p>Update the connector name and description.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-update-name>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-update-name>`_
 
         :param connector_id: The unique identifier of the connector to be updated
         :param description:
@@ -1710,7 +1710,7 @@ async def update_native(
           <p>Update the connector is_native flag.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/update-connector-native-api.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-update-native>`_
 
         :param connector_id: The unique identifier of the connector to be updated
         :param is_native:
@@ -1767,7 +1767,7 @@ async def update_pipeline(
           <p>When you create a new connector, the configuration of an ingest pipeline is populated with default settings.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-update-pipeline>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-update-pipeline>`_
 
         :param connector_id: The unique identifier of the connector to be updated
         :param pipeline:
@@ -1823,7 +1823,7 @@ async def update_scheduling(
           <p>Update the connector scheduling.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-update-scheduling>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-update-scheduling>`_
 
         :param connector_id: The unique identifier of the connector to be updated
         :param scheduling:
@@ -1879,7 +1879,7 @@ async def update_service_type(
           <p>Update the connector service type.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-update-service-type>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-update-service-type>`_
 
         :param connector_id: The unique identifier of the connector to be updated
         :param service_type:
@@ -1942,7 +1942,7 @@ async def update_status(
           <p>Update the connector status.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-update-status>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-update-status>`_
 
         :param connector_id: The unique identifier of the connector to be updated
         :param status:
diff --git a/elasticsearch/_async/client/dangling_indices.py b/elasticsearch/_async/client/dangling_indices.py
index 57289c91a..b681b95ea 100644
--- a/elasticsearch/_async/client/dangling_indices.py
+++ b/elasticsearch/_async/client/dangling_indices.py
@@ -46,7 +46,7 @@ async def delete_dangling_index(
           For example, this can happen if you delete more than <code>cluster.indices.tombstones.size</code> indices while an Elasticsearch node is offline.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-dangling-indices-delete-dangling-index>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-dangling-indices-delete-dangling-index>`_
 
         :param index_uuid: The UUID of the index to delete. Use the get dangling indices
             API to find the UUID.
@@ -107,7 +107,7 @@ async def import_dangling_index(
           For example, this can happen if you delete more than <code>cluster.indices.tombstones.size</code> indices while an Elasticsearch node is offline.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-dangling-indices-import-dangling-index>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-dangling-indices-import-dangling-index>`_
 
         :param index_uuid: The UUID of the index to import. Use the get dangling indices
             API to locate the UUID.
@@ -168,7 +168,7 @@ async def list_dangling_indices(
           <p>Use this API to list dangling indices, which you can then import or delete.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-dangling-indices-list-dangling-indices>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-dangling-indices-list-dangling-indices>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_dangling"
diff --git a/elasticsearch/_async/client/enrich.py b/elasticsearch/_async/client/enrich.py
index ae37254ca..47a33ed28 100644
--- a/elasticsearch/_async/client/enrich.py
+++ b/elasticsearch/_async/client/enrich.py
@@ -43,7 +43,7 @@ async def delete_policy(
           Deletes an existing enrich policy and its enrich index.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-enrich-delete-policy>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-enrich-delete-policy>`_
 
         :param name: Enrich policy to delete.
         :param master_timeout: Period to wait for a connection to the master node.
@@ -92,7 +92,7 @@ async def execute_policy(
           Create the enrich index for an existing enrich policy.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-enrich-execute-policy>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-enrich-execute-policy>`_
 
         :param name: Enrich policy to execute.
         :param master_timeout: Period to wait for a connection to the master node.
@@ -144,7 +144,7 @@ async def get_policy(
           Returns information about an enrich policy.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-enrich-get-policy>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-enrich-get-policy>`_
 
         :param name: Comma-separated list of enrich policy names used to limit the request.
             To return information for all enrich policies, omit this parameter.
@@ -202,7 +202,7 @@ async def put_policy(
           Creates an enrich policy.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-enrich-put-policy>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-enrich-put-policy>`_
 
         :param name: Name of the enrich policy to create or update.
         :param geo_match: Matches enrich data to incoming documents based on a `geo_shape`
@@ -263,7 +263,7 @@ async def stats(
           Returns enrich coordinator statistics and information about enrich policies that are currently executing.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-enrich-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-enrich-stats>`_
 
         :param master_timeout: Period to wait for a connection to the master node.
         """
diff --git a/elasticsearch/_async/client/eql.py b/elasticsearch/_async/client/eql.py
index 524604f17..2e7a16dfa 100644
--- a/elasticsearch/_async/client/eql.py
+++ b/elasticsearch/_async/client/eql.py
@@ -43,7 +43,7 @@ async def delete(
           The API also deletes results for the search.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-eql-delete>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-eql-delete>`_
 
         :param id: Identifier for the search to delete. A search ID is provided in the
             EQL search API's response for an async search. A search ID is also provided
@@ -93,7 +93,7 @@ async def get(
           Get the current status and available results for an async EQL search or a stored synchronous EQL search.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-eql-get>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-eql-get>`_
 
         :param id: Identifier for the search.
         :param keep_alive: Period for which the search and its results are stored on
@@ -147,7 +147,7 @@ async def get_status(
           Get the current status for an async EQL search or a stored synchronous EQL search without returning results.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-eql-get-status>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-eql-get-status>`_
 
         :param id: Identifier for the search.
         """
@@ -204,6 +204,7 @@ async def search(
         allow_partial_search_results: t.Optional[bool] = None,
         allow_partial_sequence_results: t.Optional[bool] = None,
         case_sensitive: t.Optional[bool] = None,
+        ccs_minimize_roundtrips: t.Optional[bool] = None,
         error_trace: t.Optional[bool] = None,
         event_category_field: t.Optional[str] = None,
         expand_wildcards: t.Optional[
@@ -246,11 +247,13 @@ async def search(
           EQL assumes each document in a data stream or index corresponds to an event.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-eql-search>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-eql-search>`_
 
         :param index: The name of the index to scope the operation
         :param query: EQL query you wish to run.
-        :param allow_no_indices:
+        :param allow_no_indices: Whether to ignore if a wildcard indices expression resolves
+            into no concrete indices. (This includes `_all` string or when no indices
+            have been specified)
         :param allow_partial_search_results: Allow query execution also in case of shard
             failures. If true, the query will keep running and will return results based
             on the available shards. For sequences, the behavior can be further refined
@@ -261,9 +264,12 @@ async def search(
             If false, the sequence query will return successfully, but will always have
             empty results.
         :param case_sensitive:
+        :param ccs_minimize_roundtrips: Indicates whether network round-trips should
+            be minimized as part of cross-cluster search requests execution
         :param event_category_field: Field containing the event classification, such
             as process, file, or network.
-        :param expand_wildcards:
+        :param expand_wildcards: Whether to expand wildcard expression to concrete indices
+            that are open, closed or both.
         :param fetch_size: Maximum number of events to search at a time for sequence
             queries.
         :param fields: Array of wildcard (*) patterns. The response returns values for
@@ -298,6 +304,8 @@ async def search(
         __body: t.Dict[str, t.Any] = body if body is not None else {}
         if allow_no_indices is not None:
             __query["allow_no_indices"] = allow_no_indices
+        if ccs_minimize_roundtrips is not None:
+            __query["ccs_minimize_roundtrips"] = ccs_minimize_roundtrips
         if error_trace is not None:
             __query["error_trace"] = error_trace
         if expand_wildcards is not None:
diff --git a/elasticsearch/_async/client/esql.py b/elasticsearch/_async/client/esql.py
index 0df836730..59bde98c3 100644
--- a/elasticsearch/_async/client/esql.py
+++ b/elasticsearch/_async/client/esql.py
@@ -22,6 +22,9 @@
 from ._base import NamespacedClient
 from .utils import SKIP_IN_PATH, _quote, _rewrite_parameters
 
+if t.TYPE_CHECKING:
+    from elasticsearch.esql import ESQLBase
+
 
 class EsqlClient(NamespacedClient):
 
@@ -31,17 +34,20 @@ class EsqlClient(NamespacedClient):
             "columnar",
             "filter",
             "include_ccs_metadata",
+            "keep_alive",
+            "keep_on_completion",
             "locale",
             "params",
             "profile",
             "tables",
+            "wait_for_completion_timeout",
         ),
         ignore_deprecated_options={"params"},
     )
     async def async_query(
         self,
         *,
-        query: t.Optional[str] = None,
+        query: t.Optional[t.Union[str, "ESQLBase"]] = None,
         columnar: t.Optional[bool] = None,
         delimiter: t.Optional[str] = None,
         drop_null_columns: t.Optional[bool] = None,
@@ -80,7 +86,7 @@ async def async_query(
           <p>The API accepts the same parameters and request body as the synchronous query API, along with additional async related properties.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-esql-async-query>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-esql-async-query>`_
 
         :param query: The ES|QL query API accepts an ES|QL query string in the query
             parameter, runs it, and returns the results.
@@ -96,7 +102,12 @@ async def async_query(
             which has the name of all the columns.
         :param filter: Specify a Query DSL query in the filter parameter to filter the
             set of documents that an ES|QL query runs on.
-        :param format: A short version of the Accept header, for example `json` or `yaml`.
+        :param format: A short version of the Accept header, e.g. json, yaml. `csv`,
+            `tsv`, and `txt` formats will return results in a tabular format, excluding
+            other metadata fields from the response. For async requests, nothing will
+            be returned if the async query doesn't finish within the timeout. The query
+            ID and running status are available in the `X-Elasticsearch-Async-Id` and
+            `X-Elasticsearch-Async-Is-Running` HTTP headers of the response, respectively.
         :param include_ccs_metadata: When set to `true` and performing a cross-cluster
             query, the response will include an extra `_clusters` object with information
             about the clusters that participated in the search along with info such as
@@ -144,23 +155,21 @@ async def async_query(
             __query["format"] = format
         if human is not None:
             __query["human"] = human
-        if keep_alive is not None:
-            __query["keep_alive"] = keep_alive
-        if keep_on_completion is not None:
-            __query["keep_on_completion"] = keep_on_completion
         if pretty is not None:
             __query["pretty"] = pretty
-        if wait_for_completion_timeout is not None:
-            __query["wait_for_completion_timeout"] = wait_for_completion_timeout
         if not __body:
             if query is not None:
-                __body["query"] = query
+                __body["query"] = str(query)
             if columnar is not None:
                 __body["columnar"] = columnar
             if filter is not None:
                 __body["filter"] = filter
             if include_ccs_metadata is not None:
                 __body["include_ccs_metadata"] = include_ccs_metadata
+            if keep_alive is not None:
+                __body["keep_alive"] = keep_alive
+            if keep_on_completion is not None:
+                __body["keep_on_completion"] = keep_on_completion
             if locale is not None:
                 __body["locale"] = locale
             if params is not None:
@@ -169,6 +178,8 @@ async def async_query(
                 __body["profile"] = profile
             if tables is not None:
                 __body["tables"] = tables
+            if wait_for_completion_timeout is not None:
+                __body["wait_for_completion_timeout"] = wait_for_completion_timeout
         __headers = {"accept": "application/json", "content-type": "application/json"}
         return await self.perform_request(  # type: ignore[return-value]
             "POST",
@@ -203,7 +214,7 @@ async def async_query_delete(
           </ul>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-esql-async-query-delete>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-esql-async-query-delete>`_
 
         :param id: The unique identifier of the query. A query ID is provided in the
             ES|QL async query API response for a query that does not complete in the
@@ -241,6 +252,14 @@ async def async_query_get(
         drop_null_columns: t.Optional[bool] = None,
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        format: t.Optional[
+            t.Union[
+                str,
+                t.Literal[
+                    "arrow", "cbor", "csv", "json", "smile", "tsv", "txt", "yaml"
+                ],
+            ]
+        ] = None,
         human: t.Optional[bool] = None,
         keep_alive: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
@@ -256,7 +275,7 @@ async def async_query_get(
           If the Elasticsearch security features are enabled, only the user who first submitted the ES|QL query can retrieve the results using this API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-esql-async-query-get>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-esql-async-query-get>`_
 
         :param id: The unique identifier of the query. A query ID is provided in the
             ES|QL async query API response for a query that does not complete in the
@@ -266,6 +285,7 @@ async def async_query_get(
             will be removed from the `columns` and `values` portion of the results. If
             `true`, the response will include an extra section under the name `all_columns`
             which has the name of all the columns.
+        :param format: A short version of the Accept header, for example `json` or `yaml`.
         :param keep_alive: The period for which the query and its results are stored
             in the cluster. When this period expires, the query and its results are deleted,
             even if the query is still ongoing.
@@ -286,6 +306,8 @@ async def async_query_get(
             __query["error_trace"] = error_trace
         if filter_path is not None:
             __query["filter_path"] = filter_path
+        if format is not None:
+            __query["format"] = format
         if human is not None:
             __query["human"] = human
         if keep_alive is not None:
@@ -323,7 +345,7 @@ async def async_query_stop(
           If the Elasticsearch security features are enabled, only the user who first submitted the ES|QL query can stop it.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/esql-async-query-stop-api.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-esql-async-query-stop>`_
 
         :param id: The unique identifier of the query. A query ID is provided in the
             ES|QL async query API response for a query that does not complete in the
@@ -375,7 +397,7 @@ async def async_query_stop(
     async def query(
         self,
         *,
-        query: t.Optional[str] = None,
+        query: t.Optional[t.Union[str, "ESQLBase"]] = None,
         columnar: t.Optional[bool] = None,
         delimiter: t.Optional[str] = None,
         drop_null_columns: t.Optional[bool] = None,
@@ -408,7 +430,7 @@ async def query(
           Get search results for an ES|QL (Elasticsearch query language) query.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/esql-rest.html>`_
+        `<https://www.elastic.co/docs/explore-analyze/query-filter/languages/esql-rest>`_
 
         :param query: The ES|QL query API accepts an ES|QL query string in the query
             parameter, runs it, and returns the results.
@@ -424,7 +446,9 @@ async def query(
             `all_columns` which has the name of all columns.
         :param filter: Specify a Query DSL query in the filter parameter to filter the
             set of documents that an ES|QL query runs on.
-        :param format: A short version of the Accept header, e.g. json, yaml.
+        :param format: A short version of the Accept header, e.g. json, yaml. `csv`,
+            `tsv`, and `txt` formats will return results in a tabular format, excluding
+            other metadata fields from the response.
         :param include_ccs_metadata: When set to `true` and performing a cross-cluster
             query, the response will include an extra `_clusters` object with information
             about the clusters that participated in the search along with info such as
@@ -462,7 +486,7 @@ async def query(
             __query["pretty"] = pretty
         if not __body:
             if query is not None:
-                __body["query"] = query
+                __body["query"] = str(query)
             if columnar is not None:
                 __body["columnar"] = columnar
             if filter is not None:
diff --git a/elasticsearch/_async/client/features.py b/elasticsearch/_async/client/features.py
index 2fb86fe23..7e139ed48 100644
--- a/elasticsearch/_async/client/features.py
+++ b/elasticsearch/_async/client/features.py
@@ -48,7 +48,7 @@ async def get_features(
           In order for a feature state to be listed in this API and recognized as a valid feature state by the create snapshot API, the plugin that defines that feature must be installed on the master node.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-features-get-features>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-features-get-features>`_
 
         :param master_timeout: Period to wait for a connection to the master node.
         """
@@ -102,7 +102,7 @@ async def reset_features(
           <p>IMPORTANT: The features installed on the node you submit this request to are the features that will be reset. Run on the master node if you have any doubts about which plugins are installed on individual nodes.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-features-reset-features>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-features-reset-features>`_
 
         :param master_timeout: Period to wait for a connection to the master node.
         """
diff --git a/elasticsearch/_async/client/fleet.py b/elasticsearch/_async/client/fleet.py
index 896ba78b6..66a04d0bf 100644
--- a/elasticsearch/_async/client/fleet.py
+++ b/elasticsearch/_async/client/fleet.py
@@ -53,7 +53,7 @@ async def global_checkpoints(
           This API is designed for internal use by the Fleet server project.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/group/endpoint-fleet>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/group/endpoint-fleet>`_
 
         :param index: A single index or index alias that resolves to a single index.
         :param checkpoints: A comma separated list of previous global checkpoints. When
@@ -144,7 +144,7 @@ async def msearch(
           However, similar to the Fleet search API, it supports the <code>wait_for_checkpoints</code> parameter.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-fleet-msearch>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-fleet-msearch>`_
 
         :param searches:
         :param index: A single target to search. If the target is an index alias, it
@@ -155,9 +155,9 @@ async def msearch(
             example, a request targeting foo*,bar* returns an error if an index starts
             with foo but no index starts with bar.
         :param allow_partial_search_results: If true, returns partial results if there
-            are shard request timeouts or [shard failures](https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-replication.html#shard-failures).
-            If false, returns an error with no partial results. Defaults to the configured
-            cluster setting `search.default_allow_partial_results` which is true by default.
+            are shard request timeouts or shard failures. If false, returns an error
+            with no partial results. Defaults to the configured cluster setting `search.default_allow_partial_results`,
+            which is true by default.
         :param ccs_minimize_roundtrips: If true, network roundtrips between the coordinating
             node and remote clusters are minimized for cross-cluster search requests.
         :param expand_wildcards: Type of index that wildcard expressions can match. If
@@ -393,7 +393,7 @@ async def search(
           after the provided checkpoint has been processed and is visible for searches inside of Elasticsearch.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-fleet-search>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-fleet-search>`_
 
         :param index: A single target to search. If the target is an index alias, it
             must resolve to a single index.
@@ -401,9 +401,9 @@ async def search(
         :param aggs:
         :param allow_no_indices:
         :param allow_partial_search_results: If true, returns partial results if there
-            are shard request timeouts or [shard failures](https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-replication.html#shard-failures).
-            If false, returns an error with no partial results. Defaults to the configured
-            cluster setting `search.default_allow_partial_results` which is true by default.
+            are shard request timeouts or shard failures. If false, returns an error
+            with no partial results. Defaults to the configured cluster setting `search.default_allow_partial_results`,
+            which is true by default.
         :param analyze_wildcard:
         :param analyzer:
         :param batched_reduce_size:
@@ -430,7 +430,7 @@ async def search(
         :param lenient:
         :param max_concurrent_shard_requests:
         :param min_score: Minimum _score for matching documents. Documents with a lower
-            _score are not included in the search results.
+            _score are not included in search results and results collected by aggregations.
         :param pit: Limits the search to a point in time (PIT). If you provide a PIT,
             you cannot specify an <index> in the request path.
         :param post_filter:
diff --git a/elasticsearch/_async/client/graph.py b/elasticsearch/_async/client/graph.py
index a8c35dbfe..d8556b539 100644
--- a/elasticsearch/_async/client/graph.py
+++ b/elasticsearch/_async/client/graph.py
@@ -55,7 +55,7 @@ async def explore(
           You can exclude vertices that have already been returned.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/group/endpoint-graph>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/group/endpoint-graph>`_
 
         :param index: Name of the index.
         :param connections: Specifies or more fields from which you want to extract terms
diff --git a/elasticsearch/_async/client/ilm.py b/elasticsearch/_async/client/ilm.py
index c15aaa807..f5ab66c5b 100644
--- a/elasticsearch/_async/client/ilm.py
+++ b/elasticsearch/_async/client/ilm.py
@@ -44,7 +44,7 @@ async def delete_lifecycle(
           You cannot delete policies that are currently in use. If the policy is being used to manage any indices, the request fails and returns an error.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ilm-delete-lifecycle>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ilm-delete-lifecycle>`_
 
         :param name: Identifier for the policy.
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -102,7 +102,7 @@ async def explain_lifecycle(
           <p>The response indicates when the index entered each lifecycle state, provides the definition of the running phase, and information about any failures.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ilm-explain-lifecycle>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ilm-explain-lifecycle>`_
 
         :param index: Comma-separated list of data streams, indices, and aliases to target.
             Supports wildcards (`*`). To target all data streams and indices, use `*`
@@ -163,7 +163,7 @@ async def get_lifecycle(
           <p>Get lifecycle policies.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ilm-get-lifecycle>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ilm-get-lifecycle>`_
 
         :param name: Identifier for the policy.
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -218,7 +218,7 @@ async def get_status(
           <p>Get the current index lifecycle management status.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ilm-get-status>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ilm-get-status>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_ilm/status"
@@ -275,7 +275,7 @@ async def migrate_to_data_tiers(
           Use the stop ILM and get ILM status APIs to wait until the reported operation mode is <code>STOPPED</code>.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ilm-migrate-to-data-tiers>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ilm-migrate-to-data-tiers>`_
 
         :param dry_run: If true, simulates the migration from node attributes based allocation
             filters to data tiers, but does not perform the migration. This provides
@@ -354,7 +354,7 @@ async def move_to_step(
           An index cannot move to a step that is not part of its policy.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ilm-move-to-step>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ilm-move-to-step>`_
 
         :param index: The name of the index whose lifecycle step is to change
         :param current_step: The step that the index is expected to be in.
@@ -422,7 +422,7 @@ async def put_lifecycle(
           <p>NOTE: Only the latest version of the policy is stored, you cannot revert to previous versions.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ilm-put-lifecycle>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ilm-put-lifecycle>`_
 
         :param name: Identifier for the policy.
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -486,7 +486,7 @@ async def remove_policy(
           It also stops managing the indices.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ilm-remove-policy>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ilm-remove-policy>`_
 
         :param index: The name of the index to remove policy on
         """
@@ -532,7 +532,7 @@ async def retry(
           Use the explain lifecycle state API to determine whether an index is in the ERROR step.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ilm-retry>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ilm-retry>`_
 
         :param index: The name of the indices (comma-separated) whose failed lifecycle
             step is to be retry
@@ -580,7 +580,7 @@ async def start(
           Restarting ILM is necessary only when it has been stopped using the stop ILM API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ilm-start>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ilm-start>`_
 
         :param master_timeout: Period to wait for a connection to the master node. If
             no response is received before the timeout expires, the request fails and
@@ -634,7 +634,7 @@ async def stop(
           Use the get ILM status API to check whether ILM is running.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ilm-stop>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ilm-stop>`_
 
         :param master_timeout: Period to wait for a connection to the master node. If
             no response is received before the timeout expires, the request fails and
diff --git a/elasticsearch/_async/client/indices.py b/elasticsearch/_async/client/indices.py
index 31ee76bca..1683a215a 100644
--- a/elasticsearch/_async/client/indices.py
+++ b/elasticsearch/_async/client/indices.py
@@ -62,7 +62,7 @@ async def add_block(
           Index blocks limit the operations allowed on an index by blocking specific operation types.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-add-block>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-add-block>`_
 
         :param index: A comma-separated list or wildcard expression of index names used
             to limit the request. By default, you must explicitly name the indices you
@@ -173,7 +173,7 @@ async def analyze(
           The <code>_analyze</code> endpoint without a specified index will always use <code>10000</code> as its limit.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-analyze>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-analyze>`_
 
         :param index: Index used to derive the analyzer. If specified, the `analyzer`
             or field parameter overrides this value. If no index is specified or the
@@ -265,7 +265,7 @@ async def cancel_migrate_reindex(
           <p>Cancel a migration reindex attempt for a data stream or index.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/migrate-data-stream.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-cancel-migrate-reindex>`_
 
         :param index: The index or data stream name
         """
@@ -327,7 +327,7 @@ async def clear_cache(
           To clear the cache only of specific fields, use the <code>fields</code> parameter.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-clear-cache>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-clear-cache>`_
 
         :param index: Comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (`*`). To target all data streams
@@ -338,7 +338,7 @@ async def clear_cache(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param fielddata: If `true`, clears the fields cache. Use the `fields` parameter
             to clear the cache of specific fields only.
         :param fields: Comma-separated list of field names used to limit the `fielddata`
@@ -449,7 +449,7 @@ async def clone(
           <p>Because the clone operation creates a new index to clone the shards to, the wait for active shards setting on index creation applies to the clone index action as well.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-clone>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-clone>`_
 
         :param index: Name of the source index to clone.
         :param target: Name of the target index to create.
@@ -553,7 +553,7 @@ async def close(
           Closing indices can be turned off with the cluster settings API by setting <code>cluster.indices.close.enable</code> to <code>false</code>.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-close>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-close>`_
 
         :param index: Comma-separated list or wildcard expression of index names used
             to limit the request.
@@ -563,7 +563,7 @@ async def close(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -654,9 +654,17 @@ async def create(
           Note that changing this setting will also affect the <code>wait_for_active_shards</code> value on all subsequent write operations.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-create>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-create>`_
 
-        :param index: Name of the index you wish to create.
+        :param index: Name of the index you wish to create. Index names must meet the
+            following criteria: * Lowercase only * Cannot include `\\`, `/`, `*`, `?`,
+            `"`, `<`, `>`, `|`, ` ` (space character), `,`, or `#` * Indices prior to
+            7.0 could contain a colon (`:`), but that has been deprecated and will not
+            be supported in later versions * Cannot start with `-`, `_`, or `+` * Cannot
+            be `.` or `..` * Cannot be longer than 255 bytes (note thtat it is bytes,
+            so multi-byte characters will reach the limit faster) * Names starting with
+            `.` are deprecated, except for hidden indices and internal indices managed
+            by plugins
         :param aliases: Aliases for the index.
         :param mappings: Mapping for fields in the index. If specified, this mapping
             can include: - Field names - Field data types - Mapping parameters
@@ -731,7 +739,7 @@ async def create_data_stream(
           <p>You must have a matching index template with data stream enabled.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-create-data-stream>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-create-data-stream>`_
 
         :param name: Name of the data stream, which must meet the following criteria:
             Lowercase only; Cannot include `\\`, `/`, `*`, `?`, `"`, `<`, `>`, `|`, `,`,
@@ -794,7 +802,7 @@ async def create_from(
           <p>Copy the mappings and settings from the source index to a destination index while allowing request settings and mappings to override the source values.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/migrate-data-stream.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-create-from>`_
 
         :param source: The source index or data stream name
         :param dest: The destination index or data stream name
@@ -861,7 +869,7 @@ async def data_streams_stats(
           <p>Get statistics for one or more data streams.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-data-streams-stats-1>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-data-streams-stats-1>`_
 
         :param name: Comma-separated list of data streams used to limit the request.
             Wildcard expressions (`*`) are supported. To target all data streams in a
@@ -930,7 +938,7 @@ async def delete(
           You can then use the delete index API to delete the previous write index.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-delete>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-delete>`_
 
         :param index: Comma-separated list of indices to delete. You cannot specify index
             aliases. By default, this parameter does not support wildcards (`*`) or `_all`.
@@ -942,7 +950,7 @@ async def delete(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -1004,7 +1012,7 @@ async def delete_alias(
           Removes a data stream or index from an alias.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-delete-alias>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-delete-alias>`_
 
         :param index: Comma-separated list of data streams or indices used to limit the
             request. Supports wildcards (`*`).
@@ -1072,7 +1080,7 @@ async def delete_data_lifecycle(
           Removes the data stream lifecycle from a data stream, rendering it not managed by the data stream lifecycle.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-delete-data-lifecycle>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-delete-data-lifecycle>`_
 
         :param name: A comma-separated list of data streams of which the data stream
             lifecycle will be deleted; use `*` to get all data streams
@@ -1136,7 +1144,7 @@ async def delete_data_stream(
           Deletes one or more data streams and their backing indices.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-delete-data-stream>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-delete-data-stream>`_
 
         :param name: Comma-separated list of data streams to delete. Wildcard (`*`) expressions
             are supported.
@@ -1194,7 +1202,7 @@ async def delete_index_template(
           existing templates.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-delete-index-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-delete-index-template>`_
 
         :param name: Comma-separated list of index template names used to limit the request.
             Wildcard (*) expressions are supported.
@@ -1246,10 +1254,11 @@ async def delete_template(
         """
         .. raw:: html
 
-          <p>Delete a legacy index template.</p>
+          <p>Delete a legacy index template.
+          IMPORTANT: This documentation is about legacy index templates, which are deprecated and will be replaced by the composable templates introduced in Elasticsearch 7.8.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-delete-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-delete-template>`_
 
         :param name: The name of the legacy index template to delete. Wildcard (`*`)
             expressions are supported.
@@ -1321,7 +1330,7 @@ async def disk_usage(
           The stored size of the <code>_id</code> field is likely underestimated while the <code>_source</code> field is overestimated.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-disk-usage>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-disk-usage>`_
 
         :param index: Comma-separated list of data streams, indices, and aliases used
             to limit the request. It’s recommended to execute this API with a single
@@ -1404,7 +1413,7 @@ async def downsample(
           The source index must be read only (<code>index.blocks.write: true</code>).</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-downsample>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-downsample>`_
 
         :param index: Name of the time series index to downsample.
         :param target_index: Name of the index to create.
@@ -1476,7 +1485,7 @@ async def exists(
           Check if one or more indices, index aliases, or data streams exist.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-exists>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-exists>`_
 
         :param index: Comma-separated list of data streams, indices, and aliases. Supports
             wildcards (`*`).
@@ -1486,7 +1495,7 @@ async def exists(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param flat_settings: If `true`, returns settings in flat format.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
@@ -1558,7 +1567,7 @@ async def exists_alias(
           <p>Check if one or more data stream or index aliases exist.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-exists-alias>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-exists-alias>`_
 
         :param name: Comma-separated list of aliases to check. Supports wildcards (`*`).
         :param index: Comma-separated list of data streams or indices used to limit the
@@ -1570,7 +1579,7 @@ async def exists_alias(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param ignore_unavailable: If `false`, requests that include a missing data stream
             or index in the target indices or data streams return an error.
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -1622,7 +1631,9 @@ async def exists_index_template(
         name: str,
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        flat_settings: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
+        local: t.Optional[bool] = None,
         master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
     ) -> HeadApiResponse:
@@ -1633,10 +1644,14 @@ async def exists_index_template(
           <p>Check whether index templates exist.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-exists-index-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-exists-index-template>`_
 
         :param name: Comma-separated list of index template names used to limit the request.
             Wildcard (*) expressions are supported.
+        :param flat_settings: If true, returns settings in flat format.
+        :param local: If true, the request retrieves information from the local node
+            only. Defaults to false, which means information is retrieved from the master
+            node.
         :param master_timeout: Period to wait for a connection to the master node. If
             no response is received before the timeout expires, the request fails and
             returns an error.
@@ -1650,8 +1665,12 @@ async def exists_index_template(
             __query["error_trace"] = error_trace
         if filter_path is not None:
             __query["filter_path"] = filter_path
+        if flat_settings is not None:
+            __query["flat_settings"] = flat_settings
         if human is not None:
             __query["human"] = human
+        if local is not None:
+            __query["local"] = local
         if master_timeout is not None:
             __query["master_timeout"] = master_timeout
         if pretty is not None:
@@ -1688,7 +1707,7 @@ async def exists_template(
           <p>IMPORTANT: This documentation is about legacy index templates, which are deprecated and will be replaced by the composable templates introduced in Elasticsearch 7.8.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-exists-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-exists-template>`_
 
         :param name: A comma-separated list of index template names used to limit the
             request. Wildcard (`*`) expressions are supported.
@@ -1746,7 +1765,7 @@ async def explain_data_lifecycle(
           Get information about an index or data stream's current data stream lifecycle status, such as time since index creation, time since rollover, the lifecycle configuration managing the index, or any errors encountered during lifecycle execution.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-explain-data-lifecycle>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-explain-data-lifecycle>`_
 
         :param index: The name of the index to explain
         :param include_defaults: indicates if the API should return the default values
@@ -1801,9 +1820,6 @@ async def field_usage_stats(
         human: t.Optional[bool] = None,
         ignore_unavailable: t.Optional[bool] = None,
         pretty: t.Optional[bool] = None,
-        wait_for_active_shards: t.Optional[
-            t.Union[int, t.Union[str, t.Literal["all", "index-setting"]]]
-        ] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
         .. raw:: html
@@ -1816,7 +1832,7 @@ async def field_usage_stats(
           A given request will increment each count by a maximum value of 1, even if the request accesses the same field multiple times.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-field-usage-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-field-usage-stats>`_
 
         :param index: Comma-separated list or wildcard expression of index names used
             to limit the request.
@@ -1833,9 +1849,6 @@ async def field_usage_stats(
             in the statistics.
         :param ignore_unavailable: If `true`, missing or closed indices are not included
             in the response.
-        :param wait_for_active_shards: The number of shard copies that must be active
-            before proceeding with the operation. Set to all or any positive integer
-            up to the total number of shards in the index (`number_of_replicas+1`).
         """
         if index in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'index'")
@@ -1858,8 +1871,6 @@ async def field_usage_stats(
             __query["ignore_unavailable"] = ignore_unavailable
         if pretty is not None:
             __query["pretty"] = pretty
-        if wait_for_active_shards is not None:
-            __query["wait_for_active_shards"] = wait_for_active_shards
         __headers = {"accept": "application/json"}
         return await self.perform_request(  # type: ignore[return-value]
             "GET",
@@ -1906,7 +1917,7 @@ async def flush(
           If you call the flush API after indexing some documents then a successful response indicates that Elasticsearch has flushed all the documents that were indexed before the flush API was called.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-flush>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-flush>`_
 
         :param index: Comma-separated list of data streams, indices, and aliases to flush.
             Supports wildcards (`*`). To flush all data streams and indices, omit this
@@ -1917,7 +1928,7 @@ async def flush(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param force: If `true`, the request forces a flush even if there are no changes
             to commit to the index.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
@@ -2031,7 +2042,7 @@ async def forcemerge(
           </code></pre>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-forcemerge>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-forcemerge>`_
 
         :param index: A comma-separated list of index names; use `_all` or empty string
             to perform the operation on all indices
@@ -2129,7 +2140,7 @@ async def get(
           stream’s backing indices.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-get>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-get>`_
 
         :param index: Comma-separated list of data streams, indices, and index aliases
             used to limit the request. Wildcard expressions (*) are supported.
@@ -2222,7 +2233,7 @@ async def get_alias(
           Retrieves information for one or more data stream or index aliases.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-get-alias>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-get-alias>`_
 
         :param index: Comma-separated list of data streams or indices used to limit the
             request. Supports wildcards (`*`). To target all data streams and indices,
@@ -2235,7 +2246,7 @@ async def get_alias(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -2309,14 +2320,13 @@ async def get_data_lifecycle(
           <p>Get the data stream lifecycle configuration of one or more data streams.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-get-data-lifecycle>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-get-data-lifecycle>`_
 
         :param name: Comma-separated list of data streams to limit the request. Supports
             wildcards (`*`). To target all data streams, omit this parameter or use `*`
             or `_all`.
         :param expand_wildcards: Type of data stream that wildcard patterns can match.
-            Supports comma-separated values, such as `open,hidden`. Valid values are:
-            `all`, `open`, `closed`, `hidden`, `none`.
+            Supports comma-separated values, such as `open,hidden`.
         :param include_defaults: If `true`, return all default settings in the response.
         :param master_timeout: Period to wait for a connection to the master node. If
             no response is received before the timeout expires, the request fails and
@@ -2367,7 +2377,7 @@ async def get_data_lifecycle_stats(
           Get statistics about the data streams that are managed by a data stream lifecycle.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-get-data-lifecycle-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-get-data-lifecycle-stats>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_lifecycle/stats"
@@ -2418,7 +2428,7 @@ async def get_data_stream(
           <p>Get information about one or more data streams.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-get-data-stream>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-get-data-stream>`_
 
         :param name: Comma-separated list of data stream names used to limit the request.
             Wildcard (`*`) expressions are supported. If omitted, all data streams are
@@ -2487,6 +2497,7 @@ async def get_field_mapping(
         human: t.Optional[bool] = None,
         ignore_unavailable: t.Optional[bool] = None,
         include_defaults: t.Optional[bool] = None,
+        local: t.Optional[bool] = None,
         pretty: t.Optional[bool] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
@@ -2498,7 +2509,7 @@ async def get_field_mapping(
           <p>This API is useful if you don't need a complete mapping or if an index mapping contains a large number of fields.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-get-mapping>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-get-mapping>`_
 
         :param fields: Comma-separated list or wildcard expression of fields used to
             limit returned information. Supports wildcards (`*`).
@@ -2511,10 +2522,12 @@ async def get_field_mapping(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
         :param include_defaults: If `true`, return all default settings in the response.
+        :param local: If `true`, the request retrieves information from the local node
+            only.
         """
         if fields in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'fields'")
@@ -2542,6 +2555,8 @@ async def get_field_mapping(
             __query["ignore_unavailable"] = ignore_unavailable
         if include_defaults is not None:
             __query["include_defaults"] = include_defaults
+        if local is not None:
+            __query["local"] = local
         if pretty is not None:
             __query["pretty"] = pretty
         __headers = {"accept": "application/json"}
@@ -2575,7 +2590,7 @@ async def get_index_template(
           Get information about one or more index templates.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-get-index-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-get-index-template>`_
 
         :param name: Comma-separated list of index template names used to limit the request.
             Wildcard (*) expressions are supported.
@@ -2652,7 +2667,7 @@ async def get_mapping(
           For data streams, the API retrieves mappings for the stream’s backing indices.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-get-mapping>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-get-mapping>`_
 
         :param index: Comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (`*`). To target all data streams
@@ -2663,7 +2678,7 @@ async def get_mapping(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
         :param local: If `true`, the request retrieves information from the local node
@@ -2726,7 +2741,7 @@ async def get_migrate_reindex_status(
           <p>Get the status of a migration reindex attempt for a data stream or index.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/migrate-data-stream.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/group/endpoint-migration>`_
 
         :param index: The index or data stream name.
         """
@@ -2786,7 +2801,7 @@ async def get_settings(
           For data streams, it returns setting information for the stream's backing indices.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-get-settings>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-get-settings>`_
 
         :param index: Comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (`*`). To target all data streams
@@ -2873,12 +2888,12 @@ async def get_template(
         """
         .. raw:: html
 
-          <p>Get index templates.
+          <p>Get legacy index templates.
           Get information about one or more index templates.</p>
           <p>IMPORTANT: This documentation is about legacy index templates, which are deprecated and will be replaced by the composable templates introduced in Elasticsearch 7.8.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-get-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-get-template>`_
 
         :param name: Comma-separated list of index template names used to limit the request.
             Wildcard (`*`) expressions are supported. To return all index templates,
@@ -2945,7 +2960,7 @@ async def migrate_reindex(
           The persistent task ID is returned immediately and the reindexing work is completed in that task.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/migrate-data-stream.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-migrate-reindex>`_
 
         :param reindex:
         """
@@ -3006,7 +3021,7 @@ async def migrate_to_data_stream(
           The write index for the alias becomes the write index for the stream.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/data-streams.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-migrate-to-data-stream>`_
 
         :param name: Name of the index alias to convert to a data stream.
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -3062,7 +3077,7 @@ async def modify_data_stream(
           Performs one or more data stream modification actions in a single atomic operation.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/data-streams.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-modify-data-stream>`_
 
         :param actions: Actions to perform.
         """
@@ -3141,7 +3156,7 @@ async def open(
           <p>Because opening or closing an index allocates its shards, the <code>wait_for_active_shards</code> setting on index creation applies to the <code>_open</code> and <code>_close</code> index actions as well.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-open>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-open>`_
 
         :param index: Comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (`*`). By default, you must explicitly
@@ -3155,7 +3170,7 @@ async def open(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -3227,7 +3242,7 @@ async def promote_data_stream(
           This will affect the lifecycle management of the data stream and interfere with the data stream size and retention.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/data-streams.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-promote-data-stream>`_
 
         :param name: The name of the data stream
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -3293,7 +3308,7 @@ async def put_alias(
           Adds a data stream or index to an alias.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-aliases.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-put-alias>`_
 
         :param index: Comma-separated list of data streams or indices to add. Supports
             wildcards (`*`). Wildcard patterns that match both data streams and indices
@@ -3400,7 +3415,7 @@ async def put_data_lifecycle(
           Update the data stream lifecycle of the specified data streams.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/data-streams-put-lifecycle.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-put-data-lifecycle>`_
 
         :param name: Comma-separated list of data streams used to limit the request.
             Supports wildcards (`*`). To target all data streams use `*` or `_all`.
@@ -3414,8 +3429,7 @@ async def put_data_lifecycle(
             for this data stream. A data stream lifecycle that's disabled (enabled: `false`)
             will have no effect on the data stream.
         :param expand_wildcards: Type of data stream that wildcard patterns can match.
-            Supports comma-separated values, such as `open,hidden`. Valid values are:
-            `all`, `hidden`, `open`, `closed`, `none`.
+            Supports comma-separated values, such as `open,hidden`.
         :param master_timeout: Period to wait for a connection to the master node. If
             no response is received before the timeout expires, the request fails and
             returns an error.
@@ -3528,7 +3542,7 @@ async def put_index_template(
           If an entry already exists with the same key, then it is overwritten by the new definition.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-put-template.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-put-index-template>`_
 
         :param name: Index or template name
         :param allow_auto_create: This setting overrides the value of the `action.auto_create_index`
@@ -3691,27 +3705,20 @@ async def put_mapping(
 
           <p>Update field mappings.
           Add new fields to an existing data stream or index.
-          You can also use this API to change the search settings of existing fields and add new properties to existing object fields.
-          For data streams, these changes are applied to all backing indices by default.</p>
-          <p><strong>Add multi-fields to an existing field</strong></p>
-          <p>Multi-fields let you index the same field in different ways.
-          You can use this API to update the fields mapping parameter and enable multi-fields for an existing field.
-          WARNING: If an index (or data stream) contains documents when you add a multi-field, those documents will not have values for the new multi-field.
-          You can populate the new multi-field with the update by query API.</p>
-          <p><strong>Change supported mapping parameters for an existing field</strong></p>
-          <p>The documentation for each mapping parameter indicates whether you can update it for an existing field using this API.
-          For example, you can use the update mapping API to update the <code>ignore_above</code> parameter.</p>
-          <p><strong>Change the mapping of an existing field</strong></p>
-          <p>Except for supported mapping parameters, you can't change the mapping or field type of an existing field.
-          Changing an existing field could invalidate data that's already indexed.</p>
-          <p>If you need to change the mapping of a field in a data stream's backing indices, refer to documentation about modifying data streams.
-          If you need to change the mapping of a field in other indices, create a new index with the correct mapping and reindex your data into that index.</p>
-          <p><strong>Rename a field</strong></p>
-          <p>Renaming a field would invalidate data already indexed under the old field name.
-          Instead, add an alias field to create an alternate field name.</p>
-
-
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-put-mapping>`_
+          You can use the update mapping API to:</p>
+          <ul>
+          <li>Add a new field to an existing index</li>
+          <li>Update mappings for multiple indices in a single request</li>
+          <li>Add new properties to an object field</li>
+          <li>Enable multi-fields for an existing field</li>
+          <li>Update supported mapping parameters</li>
+          <li>Change a field's mapping using reindexing</li>
+          <li>Rename a field using a field alias</li>
+          </ul>
+          <p>Learn how to use the update mapping API with practical examples in the <a href="https://www.elastic.co/docs/manage-data/data-store/mapping/update-mappings-examples">Update mapping API examples</a> guide.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-put-mapping>`_
 
         :param index: A comma-separated list of index names the mapping should be added
             to (supports wildcards); use `_all` or omit to add the mapping on all indices.
@@ -3727,7 +3734,7 @@ async def put_mapping(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param field_names: Control whether field names are enabled for the index.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
@@ -3835,6 +3842,7 @@ async def put_settings(
         master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         preserve_existing: t.Optional[bool] = None,
         pretty: t.Optional[bool] = None,
+        reopen: t.Optional[bool] = None,
         timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
@@ -3844,8 +3852,36 @@ async def put_settings(
           Changes dynamic index settings in real time.
           For data streams, index setting changes are applied to all backing indices by default.</p>
           <p>To revert a setting to the default value, use a null value.
-          The list of per-index settings that can be updated dynamically on live indices can be found in index module documentation.
+          The list of per-index settings that can be updated dynamically on live indices can be found in index settings documentation.
           To preserve existing settings from being updated, set the <code>preserve_existing</code> parameter to <code>true</code>.</p>
+          <p>For performance optimization during bulk indexing, you can disable the refresh interval.
+          Refer to <a href="https://www.elastic.co/docs/deploy-manage/production-guidance/optimize-performance/indexing-speed#disable-refresh-interval">disable refresh interval</a> for an example.
+          There are multiple valid ways to represent index settings in the request body. You can specify only the setting, for example:</p>
+          <pre><code>{
+            &quot;number_of_replicas&quot;: 1
+          }
+          </code></pre>
+          <p>Or you can use an <code>index</code> setting object:</p>
+          <pre><code>{
+            &quot;index&quot;: {
+              &quot;number_of_replicas&quot;: 1
+            }
+          }
+          </code></pre>
+          <p>Or you can use dot annotation:</p>
+          <pre><code>{
+            &quot;index.number_of_replicas&quot;: 1
+          }
+          </code></pre>
+          <p>Or you can embed any of the aforementioned options in a <code>settings</code> object. For example:</p>
+          <pre><code>{
+            &quot;settings&quot;: {
+              &quot;index&quot;: {
+                &quot;number_of_replicas&quot;: 1
+              }
+            }
+          }
+          </code></pre>
           <p>NOTE: You can only define new analyzers on closed indices.
           To add an analyzer, you must close the index, define the analyzer, and reopen the index.
           You cannot close the write index of a data stream.
@@ -3853,10 +3889,11 @@ async def put_settings(
           Then roll over the data stream to apply the new analyzer to the stream's write index and future backing indices.
           This affects searches and any new data added to the stream after the rollover.
           However, it does not affect the data stream's backing indices or their existing data.
-          To change the analyzer for existing backing indices, you must create a new data stream and reindex your data into it.</p>
+          To change the analyzer for existing backing indices, you must create a new data stream and reindex your data into it.
+          Refer to <a href="https://www.elastic.co/docs/manage-data/data-store/text-analysis/specify-an-analyzer#update-analyzers-on-existing-indices">updating analyzers on existing indices</a> for step-by-step examples.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-put-settings>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-put-settings>`_
 
         :param settings:
         :param index: Comma-separated list of data streams, indices, and aliases used
@@ -3877,6 +3914,9 @@ async def put_settings(
             no response is received before the timeout expires, the request fails and
             returns an error.
         :param preserve_existing: If `true`, existing index settings remain unchanged.
+        :param reopen: Whether to close and reopen the index to apply non-dynamic settings.
+            If set to `true` the indices to which the settings are being applied will
+            be closed temporarily and then reopened in order to apply the changes.
         :param timeout: Period to wait for a response. If no response is received before
             the timeout expires, the request fails and returns an error.
         """
@@ -3914,6 +3954,8 @@ async def put_settings(
             __query["preserve_existing"] = preserve_existing
         if pretty is not None:
             __query["pretty"] = pretty
+        if reopen is not None:
+            __query["reopen"] = reopen
         if timeout is not None:
             __query["timeout"] = timeout
         __body = settings if settings is not None else body
@@ -3960,7 +4002,7 @@ async def put_template(
         """
         .. raw:: html
 
-          <p>Create or update an index template.
+          <p>Create or update a legacy index template.
           Index templates define settings, mappings, and aliases that can be applied automatically to new indices.
           Elasticsearch applies templates to new indices based on an index pattern that matches the index name.</p>
           <p>IMPORTANT: This documentation is about legacy index templates, which are deprecated and will be replaced by the composable templates introduced in Elasticsearch 7.8.</p>
@@ -3977,11 +4019,11 @@ async def put_template(
           NOTE: Multiple matching templates with the same order value will result in a non-deterministic merging order.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-put-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-put-template>`_
 
         :param name: The name of the template
         :param aliases: Aliases for the index.
-        :param cause:
+        :param cause: User defined reason for creating/updating the index template
         :param create: If true, this request cannot replace or update existing index
             templates.
         :param index_patterns: Array of wildcard expressions used to match the names
@@ -4049,10 +4091,20 @@ async def recovery(
         *,
         index: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         active_only: t.Optional[bool] = None,
+        allow_no_indices: t.Optional[bool] = None,
         detailed: t.Optional[bool] = None,
         error_trace: t.Optional[bool] = None,
+        expand_wildcards: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[str, t.Literal["all", "closed", "hidden", "none", "open"]]
+                ],
+                t.Union[str, t.Literal["all", "closed", "hidden", "none", "open"]],
+            ]
+        ] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         human: t.Optional[bool] = None,
+        ignore_unavailable: t.Optional[bool] = None,
         pretty: t.Optional[bool] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
@@ -4079,14 +4131,23 @@ async def recovery(
           This means that if a shard copy completes a recovery and then Elasticsearch relocates it onto a different node then the information about the original recovery will not be shown in the recovery API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-recovery>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-recovery>`_
 
         :param index: Comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (`*`). To target all data streams
             and indices, omit this parameter or use `*` or `_all`.
         :param active_only: If `true`, the response only includes ongoing shard recoveries.
+        :param allow_no_indices: If `false`, the request returns an error if any wildcard
+            expression, index alias, or `_all` value targets only missing or closed indices.
+            This behavior applies even if the request targets other open indices.
         :param detailed: If `true`, the response includes detailed information about
             shard recoveries.
+        :param expand_wildcards: Type of index that wildcard patterns can match. If the
+            request can target data streams, this argument determines whether wildcard
+            expressions match hidden data streams. Supports comma-separated values, such
+            as `open,hidden`.
+        :param ignore_unavailable: If `false`, the request returns an error if it targets
+            a missing or closed index.
         """
         __path_parts: t.Dict[str, str]
         if index not in SKIP_IN_PATH:
@@ -4098,14 +4159,20 @@ async def recovery(
         __query: t.Dict[str, t.Any] = {}
         if active_only is not None:
             __query["active_only"] = active_only
+        if allow_no_indices is not None:
+            __query["allow_no_indices"] = allow_no_indices
         if detailed is not None:
             __query["detailed"] = detailed
         if error_trace is not None:
             __query["error_trace"] = error_trace
+        if expand_wildcards is not None:
+            __query["expand_wildcards"] = expand_wildcards
         if filter_path is not None:
             __query["filter_path"] = filter_path
         if human is not None:
             __query["human"] = human
+        if ignore_unavailable is not None:
+            __query["ignore_unavailable"] = ignore_unavailable
         if pretty is not None:
             __query["pretty"] = pretty
         __headers = {"accept": "application/json"}
@@ -4153,7 +4220,7 @@ async def refresh(
           This option ensures the indexing operation waits for a periodic refresh before running the search.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-refresh>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-refresh>`_
 
         :param index: Comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (`*`). To target all data streams
@@ -4164,7 +4231,7 @@ async def refresh(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
         """
@@ -4219,6 +4286,7 @@ async def reload_search_analyzers(
         human: t.Optional[bool] = None,
         ignore_unavailable: t.Optional[bool] = None,
         pretty: t.Optional[bool] = None,
+        resource: t.Optional[str] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
         .. raw:: html
@@ -4236,7 +4304,7 @@ async def reload_search_analyzers(
           This ensures the synonym file is updated everywhere in the cluster in case shards are relocated in the future.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-reload-search-analyzers>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-reload-search-analyzers>`_
 
         :param index: A comma-separated list of index names to reload analyzers for
         :param allow_no_indices: Whether to ignore if a wildcard indices expression resolves
@@ -4246,6 +4314,7 @@ async def reload_search_analyzers(
             that are open, closed or both.
         :param ignore_unavailable: Whether specified concrete indices should be ignored
             when unavailable (missing or closed)
+        :param resource: Changed resource to reload analyzers from if applicable
         """
         if index in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'index'")
@@ -4266,6 +4335,8 @@ async def reload_search_analyzers(
             __query["ignore_unavailable"] = ignore_unavailable
         if pretty is not None:
             __query["pretty"] = pretty
+        if resource is not None:
+            __query["resource"] = resource
         __headers = {"accept": "application/json"}
         return await self.perform_request(  # type: ignore[return-value]
             "POST",
@@ -4340,7 +4411,7 @@ async def resolve_cluster(
           If a connection was (re-)established, this will also cause the <code>remote/info</code> endpoint to now indicate a connected status.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-resolve-cluster>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-resolve-cluster>`_
 
         :param name: A comma-separated list of names or index patterns for the indices,
             aliases, and data streams to resolve. Resources on remote clusters can be
@@ -4359,10 +4430,9 @@ async def resolve_cluster(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
-            NOTE: This option is only supported when specifying an index expression.
-            You will get an error if you specify index options to the `_resolve/cluster`
-            API endpoint that takes no index expression.
+            as `open,hidden`. NOTE: This option is only supported when specifying an
+            index expression. You will get an error if you specify index options to the
+            `_resolve/cluster` API endpoint that takes no index expression.
         :param ignore_throttled: If true, concrete, expanded, or aliased indices are
             ignored when frozen. NOTE: This option is only supported when specifying
             an index expression. You will get an error if you specify index options to
@@ -4442,7 +4512,7 @@ async def resolve_index(
           Multiple patterns and remote clusters are supported.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-resolve-index>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-resolve-index>`_
 
         :param name: Comma-separated name(s) or index pattern(s) of the indices, aliases,
             and data streams to resolve. Resources on remote clusters can be specified
@@ -4455,7 +4525,7 @@ async def resolve_index(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
         """
@@ -4502,6 +4572,7 @@ async def rollover(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         human: t.Optional[bool] = None,
+        lazy: t.Optional[bool] = None,
         mappings: t.Optional[t.Mapping[str, t.Any]] = None,
         master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
@@ -4516,7 +4587,7 @@ async def rollover(
         .. raw:: html
 
           <p>Roll over to a new index.
-          TIP: It is recommended to use the index lifecycle rollover action to automate rollovers.</p>
+          TIP: We recommend using the index lifecycle rollover action to automate rollovers. However, Serverless does not support Index Lifecycle Management (ILM), so don't use this approach in the Serverless context.</p>
           <p>The rollover API creates a new index for a data stream or index alias.
           The API behavior depends on the rollover target.</p>
           <p><strong>Roll over a data stream</strong></p>
@@ -4543,7 +4614,7 @@ async def rollover(
           If you roll over the alias on May 7, 2099, the new index's name is <code>my-index-2099.05.07-000002</code>.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-rollover>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-rollover>`_
 
         :param alias: Name of the data stream or index alias to roll over.
         :param new_index: Name of the index to create. Supports date math. Data streams
@@ -4558,6 +4629,9 @@ async def rollover(
             conditions are satisfied.
         :param dry_run: If `true`, checks whether the current index satisfies the specified
             conditions but does not perform a rollover.
+        :param lazy: If set to true, the rollover action will only mark a data stream
+            to signal that it needs to be rolled over at the next write. Only allowed
+            on data streams.
         :param mappings: Mapping for fields in the index. If specified, this mapping
             can include field names, field data types, and mapping paramaters.
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -4592,6 +4666,8 @@ async def rollover(
             __query["filter_path"] = filter_path
         if human is not None:
             __query["human"] = human
+        if lazy is not None:
+            __query["lazy"] = lazy
         if master_timeout is not None:
             __query["master_timeout"] = master_timeout
         if pretty is not None:
@@ -4652,7 +4728,7 @@ async def segments(
           For data streams, the API returns information about the stream's backing indices.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-segments>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-segments>`_
 
         :param index: Comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (`*`). To target all data streams
@@ -4663,7 +4739,7 @@ async def segments(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
         """
@@ -4741,7 +4817,7 @@ async def shard_stores(
           <p>By default, the API returns store information only for primary shards that are unassigned or have one or more unassigned replica shards.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-shard-stores>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-shard-stores>`_
 
         :param index: List of data streams, indices, and aliases used to limit the request.
         :param allow_no_indices: If false, the request returns an error if any wildcard
@@ -4843,7 +4919,7 @@ async def shrink(
           </ul>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-shrink>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-shrink>`_
 
         :param index: Name of the source index to shrink.
         :param target: Name of the target index to create.
@@ -4908,6 +4984,8 @@ async def simulate_index_template(
         self,
         *,
         name: str,
+        cause: t.Optional[str] = None,
+        create: t.Optional[bool] = None,
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         human: t.Optional[bool] = None,
@@ -4922,9 +5000,13 @@ async def simulate_index_template(
           Get the index configuration that would be applied to the specified index from an existing index template.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-simulate-index-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-simulate-index-template>`_
 
         :param name: Name of the index to simulate
+        :param cause: User defined reason for dry-run creating the new template for simulation
+            purposes
+        :param create: Whether the index template we optionally defined in the body should
+            only be dry-run added if new or can also replace an existing one
         :param include_defaults: If true, returns all relevant default configurations
             for the index template.
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -4936,6 +5018,10 @@ async def simulate_index_template(
         __path_parts: t.Dict[str, str] = {"name": _quote(name)}
         __path = f'/_index_template/_simulate_index/{__path_parts["name"]}'
         __query: t.Dict[str, t.Any] = {}
+        if cause is not None:
+            __query["cause"] = cause
+        if create is not None:
+            __query["create"] = create
         if error_trace is not None:
             __query["error_trace"] = error_trace
         if filter_path is not None:
@@ -4978,6 +5064,7 @@ async def simulate_template(
         *,
         name: t.Optional[str] = None,
         allow_auto_create: t.Optional[bool] = None,
+        cause: t.Optional[str] = None,
         composed_of: t.Optional[t.Sequence[str]] = None,
         create: t.Optional[bool] = None,
         data_stream: t.Optional[t.Mapping[str, t.Any]] = None,
@@ -5003,7 +5090,7 @@ async def simulate_template(
           Get the index configuration that would be applied by a particular index template.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-simulate-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-simulate-template>`_
 
         :param name: Name of the index template to simulate. To test a template configuration
             before you add it to the cluster, omit this parameter and specify the template
@@ -5014,6 +5101,8 @@ async def simulate_template(
             via `actions.auto_create_index`. If set to `false`, then indices or data
             streams matching the template must always be explicitly created, and may
             never be automatically created.
+        :param cause: User defined reason for dry-run creating the new template for simulation
+            purposes
         :param composed_of: An ordered list of component template names. Component templates
             are merged in the order specified, meaning that the last component template
             specified has the highest precedence.
@@ -5058,6 +5147,8 @@ async def simulate_template(
             __path = "/_index_template/_simulate"
         __query: t.Dict[str, t.Any] = {}
         __body: t.Dict[str, t.Any] = body if body is not None else {}
+        if cause is not None:
+            __query["cause"] = cause
         if create is not None:
             __query["create"] = create
         if error_trace is not None:
@@ -5171,7 +5262,7 @@ async def split(
           </ul>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-split>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-split>`_
 
         :param index: Name of the source index to split.
         :param target: Name of the target index to create.
@@ -5273,7 +5364,7 @@ async def stats(
           Although the shard is no longer part of the node, that node retains any node-level statistics to which the shard contributed.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-stats>`_
 
         :param index: A comma-separated list of index names; use `_all` or empty string
             to perform the operation on all indices
@@ -5372,7 +5463,7 @@ async def update_aliases(
           Adds a data stream or index to an alias.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-aliases.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-update-aliases>`_
 
         :param actions: Actions to perform.
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -5451,7 +5542,7 @@ async def validate_query(
           Validates a query without running it.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/search-validate.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-validate-query>`_
 
         :param index: Comma-separated list of data streams, indices, and aliases to search.
             Supports wildcards (`*`). To search all data streams or indices, omit this
@@ -5472,7 +5563,7 @@ async def validate_query(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param explain: If `true`, the response returns detailed information if an error
             has occurred.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
diff --git a/elasticsearch/_async/client/inference.py b/elasticsearch/_async/client/inference.py
index 54dd0d32b..22f51e29e 100644
--- a/elasticsearch/_async/client/inference.py
+++ b/elasticsearch/_async/client/inference.py
@@ -25,6 +25,74 @@
 
 class InferenceClient(NamespacedClient):
 
+    @_rewrite_parameters(
+        body_fields=("input", "task_settings"),
+    )
+    async def completion(
+        self,
+        *,
+        inference_id: str,
+        input: t.Optional[t.Union[str, t.Sequence[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,
+        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 completion inference on the service</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-inference>`_
+
+        :param inference_id: The inference Id
+        :param input: Inference input. Either a string or an array of strings.
+        :param task_settings: Optional task settings
+        :param timeout: Specifies 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] = {"inference_id": _quote(inference_id)}
+        __path = f'/_inference/completion/{__path_parts["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 input is not None:
+                __body["input"] = input
+            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.completion",
+            path_parts=__path_parts,
+        )
+
     @_rewrite_parameters()
     async def delete(
         self,
@@ -33,7 +101,13 @@ async def delete(
         task_type: t.Optional[
             t.Union[
                 str,
-                t.Literal["completion", "rerank", "sparse_embedding", "text_embedding"],
+                t.Literal[
+                    "chat_completion",
+                    "completion",
+                    "rerank",
+                    "sparse_embedding",
+                    "text_embedding",
+                ],
             ]
         ] = None,
         dry_run: t.Optional[bool] = None,
@@ -49,7 +123,7 @@ async def delete(
           <p>Delete an inference endpoint</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-inference-delete>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-delete>`_
 
         :param inference_id: The inference identifier.
         :param task_type: The task type
@@ -102,7 +176,13 @@ async def get(
         task_type: t.Optional[
             t.Union[
                 str,
-                t.Literal["completion", "rerank", "sparse_embedding", "text_embedding"],
+                t.Literal[
+                    "chat_completion",
+                    "completion",
+                    "rerank",
+                    "sparse_embedding",
+                    "text_embedding",
+                ],
             ]
         ] = None,
         inference_id: t.Optional[str] = None,
@@ -117,7 +197,7 @@ async def get(
           <p>Get an inference endpoint</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-inference-get>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-get>`_
 
         :param task_type: The task type
         :param inference_id: The inference Id
@@ -165,7 +245,13 @@ async def inference(
         task_type: t.Optional[
             t.Union[
                 str,
-                t.Literal["completion", "rerank", "sparse_embedding", "text_embedding"],
+                t.Literal[
+                    "chat_completion",
+                    "completion",
+                    "rerank",
+                    "sparse_embedding",
+                    "text_embedding",
+                ],
             ]
         ] = None,
         error_trace: t.Optional[bool] = None,
@@ -184,13 +270,14 @@ async def inference(
           <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/docs/api/doc/elasticsearch/operation/operation-inference-inference>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/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
@@ -266,33 +353,57 @@ async def put(
         task_type: t.Optional[
             t.Union[
                 str,
-                t.Literal["completion", "rerank", "sparse_embedding", "text_embedding"],
+                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,
         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>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>text_embedding</code>)</li>
+          <li>Mistral (<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/docs/api/doc/elasticsearch/operation/operation-inference-put>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put>`_
 
         :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'")
@@ -323,6 +434,8 @@ async def put(
             __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]
@@ -336,62 +449,69 @@ async def put(
         )
 
     @_rewrite_parameters(
-        body_name="inference_config",
+        body_fields=(
+            "service",
+            "service_settings",
+            "chunking_settings",
+            "task_settings",
+        ),
     )
-    async def update(
+    async def put_alibabacloud(
         self,
         *,
-        inference_id: str,
-        inference_config: t.Optional[t.Mapping[str, t.Any]] = None,
-        body: t.Optional[t.Mapping[str, t.Any]] = None,
-        task_type: t.Optional[
-            t.Union[
-                str,
-                t.Literal["completion", "rerank", "sparse_embedding", "text_embedding"],
-            ]
-        ] = None,
+        task_type: t.Union[
+            str, t.Literal["completion", "rerank", "space_embedding", "text_embedding"]
+        ],
+        alibabacloud_inference_id: str,
+        service: t.Optional[t.Union[str, t.Literal["alibabacloud-ai-search"]]] = 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>Update an inference endpoint.</p>
-          <p>Modify <code>task_settings</code>, secrets (within <code>service_settings</code>), or <code>num_allocations</code> for an inference endpoint, depending on the specific endpoint service and <code>task_type</code>.</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>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>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-inference-update>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-alibabacloud>`_
 
-        :param inference_id: The unique identifier of the inference endpoint.
-        :param inference_config:
-        :param task_type: The type of inference task that the model performs.
+        :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.
+        :param service: The type of service supported for the specified task type. In
+            this case, `alibabacloud-ai-search`.
+        :param service_settings: Settings used to install the inference model. These
+            settings are specific to the `alibabacloud-ai-search` 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 inference_id in SKIP_IN_PATH:
-            raise ValueError("Empty value passed for parameter 'inference_id'")
-        if inference_config is None and body is None:
+        if task_type in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'task_type'")
+        if alibabacloud_inference_id in SKIP_IN_PATH:
             raise ValueError(
-                "Empty value passed for parameters 'inference_config' and 'body', one of them should be set."
+                "Empty value passed for parameter 'alibabacloud_inference_id'"
             )
-        elif inference_config is not None and body is not None:
-            raise ValueError("Cannot set both 'inference_config' and 'body'")
-        __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"]}/_update'
-        elif inference_id not in SKIP_IN_PATH:
-            __path_parts = {"inference_id": _quote(inference_id)}
-            __path = f'/_inference/{__path_parts["inference_id"]}/_update'
-        else:
-            raise ValueError("Couldn't find a path for the given parameters")
+        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),
+            "alibabacloud_inference_id": _quote(alibabacloud_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["alibabacloud_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:
@@ -400,10 +520,1759 @@ async def update(
             __query["human"] = human
         if pretty is not None:
             __query["pretty"] = pretty
-        __body = inference_config if inference_config is not None else body
-        __headers = {"accept": "application/json", "content-type": "application/json"}
+        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
+        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",
+            "PUT",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="inference.put_alibabacloud",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=(
+            "service",
+            "service_settings",
+            "chunking_settings",
+            "task_settings",
+        ),
+    )
+    async def put_amazonbedrock(
+        self,
+        *,
+        task_type: t.Union[str, t.Literal["completion", "text_embedding"]],
+        amazonbedrock_inference_id: str,
+        service: t.Optional[t.Union[str, t.Literal["amazonbedrock"]]] = 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 Amazon Bedrock inference endpoint.</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>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-amazonbedrock>`_
+
+        :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.
+        :param service: The type of service supported for the specified task type. In
+            this case, `amazonbedrock`.
+        :param service_settings: Settings used to install the inference model. These
+            settings are specific to the `amazonbedrock` 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'")
+        if amazonbedrock_inference_id in SKIP_IN_PATH:
+            raise ValueError(
+                "Empty value passed for parameter 'amazonbedrock_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),
+            "amazonbedrock_inference_id": _quote(amazonbedrock_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["amazonbedrock_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
+        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_amazonbedrock",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=(
+            "service",
+            "service_settings",
+            "chunking_settings",
+            "task_settings",
+        ),
+    )
+    async def put_anthropic(
+        self,
+        *,
+        task_type: t.Union[str, t.Literal["completion"]],
+        anthropic_inference_id: str,
+        service: t.Optional[t.Union[str, t.Literal["anthropic"]]] = 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 Anthropic inference endpoint.</p>
+          <p>Create an inference endpoint to perform an inference task with the <code>anthropic</code> service.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-anthropic>`_
+
+        :param task_type: The task type. The only valid task type for the model to perform
+            is `completion`.
+        :param anthropic_inference_id: The unique identifier of the inference endpoint.
+        :param service: The type of service supported for the specified task type. In
+            this case, `anthropic`.
+        :param service_settings: Settings used to install the inference model. These
+            settings are specific to the `watsonxai` 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'")
+        if anthropic_inference_id in SKIP_IN_PATH:
+            raise ValueError(
+                "Empty value passed for parameter 'anthropic_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),
+            "anthropic_inference_id": _quote(anthropic_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["anthropic_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
+        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_anthropic",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=(
+            "service",
+            "service_settings",
+            "chunking_settings",
+            "task_settings",
+        ),
+    )
+    async def put_azureaistudio(
+        self,
+        *,
+        task_type: t.Union[str, t.Literal["completion", "text_embedding"]],
+        azureaistudio_inference_id: str,
+        service: t.Optional[t.Union[str, t.Literal["azureaistudio"]]] = 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 Azure AI studio inference endpoint.</p>
+          <p>Create an inference endpoint to perform an inference task with the <code>azureaistudio</code> service.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-azureaistudio>`_
+
+        :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.
+        :param service: The type of service supported for the specified task type. In
+            this case, `azureaistudio`.
+        :param service_settings: Settings used to install the inference model. These
+            settings are specific to the `openai` 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'")
+        if azureaistudio_inference_id in SKIP_IN_PATH:
+            raise ValueError(
+                "Empty value passed for parameter 'azureaistudio_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),
+            "azureaistudio_inference_id": _quote(azureaistudio_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["azureaistudio_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
+        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_azureaistudio",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=(
+            "service",
+            "service_settings",
+            "chunking_settings",
+            "task_settings",
+        ),
+    )
+    async def put_azureopenai(
+        self,
+        *,
+        task_type: t.Union[str, t.Literal["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,
+        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 Azure OpenAI inference endpoint.</p>
+          <p>Create an inference endpoint to perform an inference task with the <code>azureopenai</code> service.</p>
+          <p>The list of chat completion models that you can choose from in your Azure OpenAI deployment include:</p>
+          <ul>
+          <li><a href="https://learn.microsoft.com/en-us/azure/ai-services/openai/concepts/models?tabs=global-standard%2Cstandard-chat-completions#gpt-4-and-gpt-4-turbo-models">GPT-4 and GPT-4 Turbo models</a></li>
+          <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>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-azureopenai>`_
+
+        :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 azureopenai_inference_id: The unique identifier of the inference endpoint.
+        :param service: The type of service supported for the specified task type. In
+            this case, `azureopenai`.
+        :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.
+        :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'")
+        if azureopenai_inference_id in SKIP_IN_PATH:
+            raise ValueError(
+                "Empty value passed for parameter 'azureopenai_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),
+            "azureopenai_inference_id": _quote(azureopenai_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["azureopenai_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
+        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_azureopenai",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=(
+            "service",
+            "service_settings",
+            "chunking_settings",
+            "task_settings",
+        ),
+    )
+    async def put_cohere(
+        self,
+        *,
+        task_type: t.Union[str, t.Literal["completion", "rerank", "text_embedding"]],
+        cohere_inference_id: str,
+        service: t.Optional[t.Union[str, t.Literal["cohere"]]] = 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 a Cohere inference endpoint.</p>
+          <p>Create an inference endpoint to perform an inference task with the <code>cohere</code> service.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-cohere>`_
+
+        :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.
+        :param service: The type of service supported for the specified task type. In
+            this case, `cohere`.
+        :param service_settings: Settings used to install the inference model. These
+            settings are specific to the `cohere` 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'")
+        if cohere_inference_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'cohere_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),
+            "cohere_inference_id": _quote(cohere_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["cohere_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
+        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_cohere",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=(
+            "service",
+            "service_settings",
+            "chunking_settings",
+            "task_settings",
+        ),
+    )
+    async def put_elasticsearch(
+        self,
+        *,
+        task_type: t.Union[
+            str, t.Literal["rerank", "sparse_embedding", "text_embedding"]
+        ],
+        elasticsearch_inference_id: str,
+        service: t.Optional[t.Union[str, t.Literal["elasticsearch"]]] = 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 Elasticsearch inference endpoint.</p>
+          <p>Create an inference endpoint to perform an inference task with the <code>elasticsearch</code> service.</p>
+          <blockquote>
+          <p>info
+          Your Elasticsearch deployment contains preconfigured ELSER and E5 inference endpoints, you only need to create the enpoints using the API if you want to customize the settings.</p>
+          </blockquote>
+          <p>If you use the ELSER or the E5 model through the <code>elasticsearch</code> service, the API request will automatically download and deploy the model if it isn't downloaded yet.</p>
+          <blockquote>
+          <p>info
+          You might see a 502 bad gateway error in the response when using the Kibana Console. This error usually just reflects a timeout, while the model downloads in the background. You can check the download progress in the Machine Learning UI. If using the Python client, you can set the timeout parameter to a higher value.</p>
+          </blockquote>
+          <p>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/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-elasticsearch>`_
+
+        :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.
+            The must not match the `model_id`.
+        :param service: The type of service supported for the specified task type. In
+            this case, `elasticsearch`.
+        :param service_settings: Settings used to install the inference model. These
+            settings are specific to the `elasticsearch` 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'")
+        if elasticsearch_inference_id in SKIP_IN_PATH:
+            raise ValueError(
+                "Empty value passed for parameter 'elasticsearch_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),
+            "elasticsearch_inference_id": _quote(elasticsearch_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["elasticsearch_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
+        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_elasticsearch",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=("service", "service_settings", "chunking_settings"),
+    )
+    async def put_elser(
+        self,
+        *,
+        task_type: t.Union[str, t.Literal["sparse_embedding"]],
+        elser_inference_id: str,
+        service: t.Optional[t.Union[str, t.Literal["elser"]]] = 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 an ELSER inference endpoint.</p>
+          <p>Create an inference endpoint to perform an inference task with the <code>elser</code> service.
+          You can also deploy ELSER by using the Elasticsearch inference integration.</p>
+          <blockquote>
+          <p>info
+          Your Elasticsearch deployment contains a preconfigured ELSER inference endpoint, you only need to create the enpoint using the API if you want to customize the settings.</p>
+          </blockquote>
+          <p>The API request will automatically download and deploy the ELSER model if it isn't already downloaded.</p>
+          <blockquote>
+          <p>info
+          You might see a 502 bad gateway error in the response when using the Kibana Console. This error usually just reflects a timeout, while the model downloads in the background. You can check the download progress in the Machine Learning UI. If using the Python client, you can set the timeout parameter to a higher value.</p>
+          </blockquote>
+          <p>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/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-elser>`_
+
+        :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.
+        :param service: The type of service supported for the specified task type. In
+            this case, `elser`.
+        :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'")
+        if elser_inference_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'elser_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),
+            "elser_inference_id": _quote(elser_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["elser_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_elser",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=("service", "service_settings", "chunking_settings"),
+    )
+    async def put_googleaistudio(
+        self,
+        *,
+        task_type: t.Union[str, t.Literal["completion", "text_embedding"]],
+        googleaistudio_inference_id: str,
+        service: t.Optional[t.Union[str, t.Literal["googleaistudio"]]] = 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 an Google AI Studio inference endpoint.</p>
+          <p>Create an inference endpoint to perform an inference task with the <code>googleaistudio</code> service.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-googleaistudio>`_
+
+        :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.
+        :param service: The type of service supported for the specified task type. In
+            this case, `googleaistudio`.
+        :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'")
+        if googleaistudio_inference_id in SKIP_IN_PATH:
+            raise ValueError(
+                "Empty value passed for parameter 'googleaistudio_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),
+            "googleaistudio_inference_id": _quote(googleaistudio_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["googleaistudio_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_googleaistudio",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=(
+            "service",
+            "service_settings",
+            "chunking_settings",
+            "task_settings",
+        ),
+    )
+    async def put_googlevertexai(
+        self,
+        *,
+        task_type: t.Union[str, t.Literal["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,
+        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 a Google Vertex AI inference endpoint.</p>
+          <p>Create an inference endpoint to perform an inference task with the <code>googlevertexai</code> service.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-googlevertexai>`_
+
+        :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.
+        :param service: The type of service supported for the specified task type. In
+            this case, `googlevertexai`.
+        :param service_settings: Settings used to install the inference model. These
+            settings are specific to the `googlevertexai` 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'")
+        if googlevertexai_inference_id in SKIP_IN_PATH:
+            raise ValueError(
+                "Empty value passed for parameter 'googlevertexai_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),
+            "googlevertexai_inference_id": _quote(googlevertexai_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["googlevertexai_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
+        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_googlevertexai",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=("service", "service_settings", "chunking_settings"),
+    )
+    async def put_hugging_face(
+        self,
+        *,
+        task_type: t.Union[str, t.Literal["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,
+        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 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>
+          <ul>
+          <li><code>all-MiniLM-L6-v2</code></li>
+          <li><code>all-MiniLM-L12-v2</code></li>
+          <li><code>all-mpnet-base-v2</code></li>
+          <li><code>e5-base-v2</code></li>
+          <li><code>e5-small-v2</code></li>
+          <li><code>multilingual-e5-base</code></li>
+          <li><code>multilingual-e5-small</code></li>
+          </ul>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-hugging-face>`_
+
+        :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.
+        :param service: The type of service supported for the specified task type. In
+            this case, `hugging_face`.
+        :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 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 huggingface_inference_id in SKIP_IN_PATH:
+            raise ValueError(
+                "Empty value passed for parameter 'huggingface_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),
+            "huggingface_inference_id": _quote(huggingface_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["huggingface_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_hugging_face",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=(
+            "service",
+            "service_settings",
+            "chunking_settings",
+            "task_settings",
+        ),
+    )
+    async def put_jinaai(
+        self,
+        *,
+        task_type: t.Union[str, t.Literal["rerank", "text_embedding"]],
+        jinaai_inference_id: str,
+        service: t.Optional[t.Union[str, t.Literal["jinaai"]]] = 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 JinaAI inference endpoint.</p>
+          <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>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-jinaai>`_
+
+        :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.
+        :param service: The type of service supported for the specified task type. In
+            this case, `jinaai`.
+        :param service_settings: Settings used to install the inference model. These
+            settings are specific to the `jinaai` 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'")
+        if jinaai_inference_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'jinaai_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),
+            "jinaai_inference_id": _quote(jinaai_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["jinaai_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
+        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_jinaai",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=("service", "service_settings", "chunking_settings"),
+    )
+    async def put_mistral(
+        self,
+        *,
+        task_type: t.Union[str, t.Literal["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,
+        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 Mistral inference endpoint.</p>
+          <p>Creates an inference endpoint to perform an inference task with the <code>mistral</code> service.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-mistral>`_
+
+        :param task_type: The task type. The only valid task type for the model to perform
+            is `text_embedding`.
+        :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'")
+        if mistral_inference_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'mistral_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),
+            "mistral_inference_id": _quote(mistral_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["mistral_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_mistral",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=(
+            "service",
+            "service_settings",
+            "chunking_settings",
+            "task_settings",
+        ),
+    )
+    async def put_openai(
+        self,
+        *,
+        task_type: t.Union[
+            str, t.Literal["chat_completion", "completion", "text_embedding"]
+        ],
+        openai_inference_id: str,
+        service: t.Optional[t.Union[str, t.Literal["openai"]]] = 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 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>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-openai>`_
+
+        :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 openai_inference_id: The unique identifier of the inference endpoint.
+        :param service: The type of service supported for the specified task type. In
+            this case, `openai`.
+        :param service_settings: Settings used to install the inference model. These
+            settings are specific to the `openai` 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'")
+        if openai_inference_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'openai_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),
+            "openai_inference_id": _quote(openai_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["openai_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
+        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_openai",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=(
+            "service",
+            "service_settings",
+            "chunking_settings",
+            "task_settings",
+        ),
+    )
+    async def put_voyageai(
+        self,
+        *,
+        task_type: t.Union[str, t.Literal["rerank", "text_embedding"]],
+        voyageai_inference_id: str,
+        service: t.Optional[t.Union[str, t.Literal["voyageai"]]] = 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 a VoyageAI inference endpoint.</p>
+          <p>Create an inference endpoint to perform an inference task with the <code>voyageai</code> service.</p>
+          <p>Avoid creating multiple endpoints for the same model unless required, as each endpoint consumes significant resources.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-voyageai>`_
+
+        :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.
+        :param service: The type of service supported for the specified task type. In
+            this case, `voyageai`.
+        :param service_settings: Settings used to install the inference model. These
+            settings are specific to the `voyageai` 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'")
+        if voyageai_inference_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'voyageai_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),
+            "voyageai_inference_id": _quote(voyageai_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["voyageai_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
+        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_voyageai",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=("service", "service_settings"),
+    )
+    async def put_watsonx(
+        self,
+        *,
+        task_type: t.Union[str, t.Literal["text_embedding"]],
+        watsonx_inference_id: str,
+        service: t.Optional[t.Union[str, t.Literal["watsonxai"]]] = 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 Watsonx inference endpoint.</p>
+          <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>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-watsonx>`_
+
+        :param task_type: The task type. The only valid task type for the model to perform
+            is `text_embedding`.
+        :param watsonx_inference_id: The unique identifier of the inference endpoint.
+        :param service: The type of service supported for the specified task type. In
+            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'")
+        if watsonx_inference_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'watsonx_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),
+            "watsonx_inference_id": _quote(watsonx_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["watsonx_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 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_watsonx",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=("input", "query", "task_settings"),
+    )
+    async def rerank(
+        self,
+        *,
+        inference_id: str,
+        input: t.Optional[t.Union[str, 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,
+        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 reranking inference on the service</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/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 query: Query input.
+        :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'")
+        if query is None and body is None:
+            raise ValueError("Empty value passed for parameter 'query'")
+        __path_parts: t.Dict[str, str] = {"inference_id": _quote(inference_id)}
+        __path = f'/_inference/rerank/{__path_parts["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 input is not None:
+                __body["input"] = input
+            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.rerank",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=("input", "task_settings"),
+    )
+    async def sparse_embedding(
+        self,
+        *,
+        inference_id: str,
+        input: t.Optional[t.Union[str, t.Sequence[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,
+        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 sparse embedding inference on the service</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-inference>`_
+
+        :param inference_id: The inference Id
+        :param input: Inference input. Either a string or an array of strings.
+        :param task_settings: Optional task settings
+        :param timeout: Specifies 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] = {"inference_id": _quote(inference_id)}
+        __path = f'/_inference/sparse_embedding/{__path_parts["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 input is not None:
+                __body["input"] = input
+            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.sparse_embedding",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=("input", "task_settings"),
+    )
+    async def text_embedding(
+        self,
+        *,
+        inference_id: str,
+        input: t.Optional[t.Union[str, t.Sequence[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,
+        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 text embedding inference on the service</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-inference>`_
+
+        :param inference_id: The inference Id
+        :param input: Inference input. Either a string or an array of strings.
+        :param task_settings: Optional task settings
+        :param timeout: Specifies 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] = {"inference_id": _quote(inference_id)}
+        __path = f'/_inference/text_embedding/{__path_parts["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 input is not None:
+                __body["input"] = input
+            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.text_embedding",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_name="inference_config",
+    )
+    async def update(
+        self,
+        *,
+        inference_id: str,
+        inference_config: t.Optional[t.Mapping[str, t.Any]] = None,
+        body: t.Optional[t.Mapping[str, t.Any]] = 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,
+        pretty: t.Optional[bool] = None,
+    ) -> ObjectApiResponse[t.Any]:
+        """
+        .. raw:: html
+
+          <p>Update an inference endpoint.</p>
+          <p>Modify <code>task_settings</code>, secrets (within <code>service_settings</code>), or <code>num_allocations</code> for an inference endpoint, depending on the specific endpoint service and <code>task_type</code>.</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>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-update>`_
+
+        :param inference_id: The unique identifier of the inference endpoint.
+        :param inference_config:
+        :param task_type: The type of inference task that the model performs.
+        """
+        if inference_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'inference_id'")
+        if inference_config is None and body is None:
+            raise ValueError(
+                "Empty value passed for parameters 'inference_config' and 'body', one of them should be set."
+            )
+        elif inference_config is not None and body is not None:
+            raise ValueError("Cannot set both 'inference_config' and 'body'")
+        __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"]}/_update'
+        elif inference_id not in SKIP_IN_PATH:
+            __path_parts = {"inference_id": _quote(inference_id)}
+            __path = f'/_inference/{__path_parts["inference_id"]}/_update'
+        else:
+            raise ValueError("Couldn't find a path for the given parameters")
+        __query: t.Dict[str, t.Any] = {}
+        if error_trace is not None:
+            __query["error_trace"] = error_trace
+        if filter_path is not None:
+            __query["filter_path"] = filter_path
+        if human is not None:
+            __query["human"] = human
+        if pretty is not None:
+            __query["pretty"] = pretty
+        __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]
+            "PUT",
             __path,
             params=__query,
             headers=__headers,
diff --git a/elasticsearch/_async/client/ingest.py b/elasticsearch/_async/client/ingest.py
index 1cf0cfe1b..d2fa0e4ae 100644
--- a/elasticsearch/_async/client/ingest.py
+++ b/elasticsearch/_async/client/ingest.py
@@ -44,7 +44,7 @@ async def delete_geoip_database(
           <p>Delete one or more IP geolocation database configurations.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ingest-delete-geoip-database>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ingest-delete-geoip-database>`_
 
         :param id: A comma-separated list of geoip database configurations to delete
         :param master_timeout: The period to wait for a connection to the master node.
@@ -98,7 +98,7 @@ async def delete_ip_location_database(
           <p>Delete IP geolocation database configurations.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ingest-delete-ip-location-database>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ingest-delete-ip-location-database>`_
 
         :param id: A comma-separated list of IP location database configurations.
         :param master_timeout: The period to wait for a connection to the master node.
@@ -155,7 +155,7 @@ async def delete_pipeline(
           Delete one or more ingest pipelines.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ingest-delete-pipeline>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ingest-delete-pipeline>`_
 
         :param id: Pipeline ID or wildcard expression of pipeline IDs used to limit the
             request. To delete all ingest pipelines in a cluster, use a value of `*`.
@@ -208,7 +208,7 @@ async def geo_ip_stats(
           Get download statistics for GeoIP2 databases that are used with the GeoIP processor.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/geoip-processor.html>`_
+        `<https://www.elastic.co/docs/reference/enrich-processor/geoip-processor>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_ingest/geoip/stats"
@@ -248,7 +248,7 @@ async def get_geoip_database(
           <p>Get information about one or more IP geolocation database configurations.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ingest-get-geoip-database>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ingest-get-geoip-database>`_
 
         :param id: A comma-separated list of database configuration IDs to retrieve.
             Wildcard (`*`) expressions are supported. To get all database configurations,
@@ -288,7 +288,6 @@ async def get_ip_location_database(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         human: t.Optional[bool] = None,
-        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
@@ -297,15 +296,11 @@ async def get_ip_location_database(
           <p>Get IP geolocation database configurations.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ingest-get-ip-location-database>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ingest-get-ip-location-database>`_
 
         :param id: Comma-separated list of database configuration IDs to retrieve. Wildcard
             (`*`) expressions are supported. To get all database configurations, omit
             this parameter or use `*`.
-        :param master_timeout: The period to wait for a connection to the master node.
-            If no response is received before the timeout expires, the request fails
-            and returns an error. A value of `-1` indicates that the request should never
-            time out.
         """
         __path_parts: t.Dict[str, str]
         if id not in SKIP_IN_PATH:
@@ -321,8 +316,6 @@ async def get_ip_location_database(
             __query["filter_path"] = filter_path
         if human is not None:
             __query["human"] = human
-        if master_timeout is not None:
-            __query["master_timeout"] = master_timeout
         if pretty is not None:
             __query["pretty"] = pretty
         __headers = {"accept": "application/json"}
@@ -355,7 +348,7 @@ async def get_pipeline(
           This API returns a local reference of the pipeline.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ingest-get-pipeline>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ingest-get-pipeline>`_
 
         :param id: Comma-separated list of pipeline IDs to retrieve. Wildcard (`*`) expressions
             are supported. To get all ingest pipelines, omit this parameter or use `*`.
@@ -412,7 +405,7 @@ async def processor_grok(
           A grok pattern is like a regular expression that supports aliased expressions that can be reused.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/grok-processor.html>`_
+        `<https://www.elastic.co/docs/reference/enrich-processor/grok-processor>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_ingest/processor/grok"
@@ -459,7 +452,7 @@ async def put_geoip_database(
           <p>Refer to the create or update IP geolocation database configuration API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ingest-put-geoip-database>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ingest-put-geoip-database>`_
 
         :param id: ID of the database configuration to create or update.
         :param maxmind: The configuration necessary to identify which IP geolocation
@@ -534,7 +527,7 @@ async def put_ip_location_database(
           <p>Create or update an IP geolocation database configuration.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ingest-put-ip-location-database>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ingest-put-ip-location-database>`_
 
         :param id: The database configuration identifier.
         :param configuration:
@@ -620,7 +613,7 @@ async def put_pipeline(
           Changes made using this API take effect immediately.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/ingest.html>`_
+        `<https://www.elastic.co/docs/manage-data/ingest/transform-enrich/ingest-pipelines>`_
 
         :param id: ID of the ingest pipeline to create or update.
         :param deprecated: Marks this ingest pipeline as deprecated. When a deprecated
@@ -717,7 +710,7 @@ async def simulate(
           You can either specify an existing pipeline to use with the provided documents or supply a pipeline definition in the body of the request.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ingest-simulate>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ingest-simulate>`_
 
         :param docs: Sample documents to test in the pipeline.
         :param id: The pipeline to test. If you don't specify a `pipeline` in the request
diff --git a/elasticsearch/_async/client/license.py b/elasticsearch/_async/client/license.py
index c6809725f..05ebbd30b 100644
--- a/elasticsearch/_async/client/license.py
+++ b/elasticsearch/_async/client/license.py
@@ -44,7 +44,7 @@ async def delete(
           <p>If the operator privileges feature is enabled, only operator users can use this API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-license-delete>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-license-delete>`_
 
         :param master_timeout: The period to wait for a connection to the master node.
         :param timeout: The period to wait for a response. If no response is received
@@ -98,7 +98,7 @@ async def get(
           </blockquote>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-license-get>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-license-get>`_
 
         :param accept_enterprise: If `true`, this parameter returns enterprise for Enterprise
             license types. If `false`, this parameter returns platinum for both platinum
@@ -147,7 +147,7 @@ async def get_basic_status(
           <p>Get the basic license status.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-license-get-basic-status>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-license-get-basic-status>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_license/basic_status"
@@ -185,7 +185,7 @@ async def get_trial_status(
           <p>Get the trial status.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-license-get-trial-status>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-license-get-trial-status>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_license/trial_status"
@@ -237,7 +237,7 @@ async def post(
           If the operator privileges feature is enabled, only operator users can use this API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-license-post>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-license-post>`_
 
         :param acknowledge: Specifies whether you acknowledge the license changes.
         :param license:
@@ -308,7 +308,7 @@ async def post_start_basic(
           <p>To check the status of your basic license, use the get basic license API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-license-post-start-basic>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-license-post-start-basic>`_
 
         :param acknowledge: whether the user has acknowledged acknowledge messages (default:
             false)
@@ -353,7 +353,7 @@ async def post_start_trial(
         human: t.Optional[bool] = None,
         master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
-        type_query_string: t.Optional[str] = None,
+        type: t.Optional[str] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
         .. raw:: html
@@ -365,12 +365,12 @@ async def post_start_trial(
           <p>To check the status of your trial, use the get trial status API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-license-post-start-trial>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-license-post-start-trial>`_
 
         :param acknowledge: whether the user has acknowledged acknowledge messages (default:
             false)
         :param master_timeout: Period to wait for a connection to the master node.
-        :param type_query_string:
+        :param type: The type of trial license to generate (default: "trial")
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_license/start_trial"
@@ -387,8 +387,8 @@ async def post_start_trial(
             __query["master_timeout"] = master_timeout
         if pretty is not None:
             __query["pretty"] = pretty
-        if type_query_string is not None:
-            __query["type_query_string"] = type_query_string
+        if type is not None:
+            __query["type"] = type
         __headers = {"accept": "application/json"}
         return await self.perform_request(  # type: ignore[return-value]
             "POST",
diff --git a/elasticsearch/_async/client/logstash.py b/elasticsearch/_async/client/logstash.py
index c63983710..d4d6381ff 100644
--- a/elasticsearch/_async/client/logstash.py
+++ b/elasticsearch/_async/client/logstash.py
@@ -43,7 +43,7 @@ async def delete_pipeline(
           If the request succeeds, you receive an empty response with an appropriate status code.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-logstash-delete-pipeline>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-logstash-delete-pipeline>`_
 
         :param id: An identifier for the pipeline.
         """
@@ -87,7 +87,7 @@ async def get_pipeline(
           Get pipelines that are used for Logstash Central Management.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-logstash-get-pipeline>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-logstash-get-pipeline>`_
 
         :param id: A comma-separated list of pipeline identifiers.
         """
@@ -139,9 +139,11 @@ async def put_pipeline(
           If the specified pipeline exists, it is replaced.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-logstash-put-pipeline>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-logstash-put-pipeline>`_
 
-        :param id: An identifier for the pipeline.
+        :param id: An identifier for the pipeline. Pipeline IDs must begin with a letter
+            or underscore and contain only letters, underscores, dashes, hyphens and
+            numbers.
         :param pipeline:
         """
         if id in SKIP_IN_PATH:
diff --git a/elasticsearch/_async/client/migration.py b/elasticsearch/_async/client/migration.py
index 4ff5a18fc..ce74c5aa0 100644
--- a/elasticsearch/_async/client/migration.py
+++ b/elasticsearch/_async/client/migration.py
@@ -44,7 +44,7 @@ async def deprecations(
           You are strongly recommended to use the Upgrade Assistant.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-migration-deprecations>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-migration-deprecations>`_
 
         :param index: Comma-separate list of data streams or indices to check. Wildcard
             (*) expressions are supported.
@@ -94,7 +94,7 @@ async def get_feature_upgrade_status(
           You are strongly recommended to use the Upgrade Assistant.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-migration-get-feature-upgrade-status>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-migration-get-feature-upgrade-status>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_migration/system_features"
@@ -136,7 +136,7 @@ async def post_feature_upgrade(
           <p>TIP: The API is designed for indirect use by the Upgrade Assistant. We strongly recommend you use the Upgrade Assistant.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-migration-get-feature-upgrade-status>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-migration-get-feature-upgrade-status>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_migration/system_features"
diff --git a/elasticsearch/_async/client/ml.py b/elasticsearch/_async/client/ml.py
index 80bc46565..ed1dc3f82 100644
--- a/elasticsearch/_async/client/ml.py
+++ b/elasticsearch/_async/client/ml.py
@@ -45,7 +45,7 @@ async def clear_trained_model_deployment_cache(
           Calling this API clears the caches without restarting the deployment.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-clear-trained-model-deployment-cache>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-clear-trained-model-deployment-cache>`_
 
         :param model_id: The unique identifier of the trained model.
         """
@@ -100,7 +100,7 @@ async def close_job(
           When a datafeed that has a specified end date stops, it automatically closes its associated job.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-close-job>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-close-job>`_
 
         :param job_id: Identifier for the anomaly detection job. It can be a job identifier,
             a group name, or a wildcard expression. You can close multiple anomaly detection
@@ -165,7 +165,7 @@ async def delete_calendar(
           <p>Remove all scheduled events from a calendar, then delete it.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-delete-calendar>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-delete-calendar>`_
 
         :param calendar_id: A string that uniquely identifies a calendar.
         """
@@ -209,7 +209,7 @@ async def delete_calendar_event(
           <p>Delete events from a calendar.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-delete-calendar-event>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-delete-calendar-event>`_
 
         :param calendar_id: A string that uniquely identifies a calendar.
         :param event_id: Identifier for the scheduled event. You can obtain this identifier
@@ -260,7 +260,7 @@ async def delete_calendar_job(
           <p>Delete anomaly jobs from a calendar.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-delete-calendar-job>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-delete-calendar-job>`_
 
         :param calendar_id: A string that uniquely identifies a calendar.
         :param job_id: An identifier for the anomaly detection jobs. It can be a job
@@ -312,7 +312,7 @@ async def delete_data_frame_analytics(
           <p>Delete a data frame analytics job.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-delete-data-frame-analytics>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-delete-data-frame-analytics>`_
 
         :param id: Identifier for the data frame analytics job.
         :param force: If `true`, it deletes a job that is not stopped; this method is
@@ -363,7 +363,7 @@ async def delete_datafeed(
           <p>Delete a datafeed.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-delete-datafeed>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-delete-datafeed>`_
 
         :param datafeed_id: A numerical character string that uniquely identifies the
             datafeed. This identifier can contain lowercase alphanumeric characters (a-z
@@ -426,7 +426,7 @@ async def delete_expired_data(
           <code>&lt;job_id&gt;</code>.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-delete-expired-data>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-delete-expired-data>`_
 
         :param job_id: Identifier for an anomaly detection job. It can be a job identifier,
             a group name, or a wildcard expression.
@@ -490,7 +490,7 @@ async def delete_filter(
           filter. You must update or delete the job before you can delete the filter.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-delete-filter>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-delete-filter>`_
 
         :param filter_id: A string that uniquely identifies a filter.
         """
@@ -540,7 +540,7 @@ async def delete_forecast(
           forecasts before they expire.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-delete-forecast>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-delete-forecast>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param forecast_id: A comma-separated list of forecast identifiers. If you do
@@ -616,7 +616,7 @@ async def delete_job(
           delete job request.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-delete-job>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-delete-job>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param delete_user_annotations: Specifies whether annotations that have been
@@ -676,7 +676,7 @@ async def delete_model_snapshot(
           the <code>model_snapshot_id</code> in the results from the get jobs API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-delete-model-snapshot>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-delete-model-snapshot>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param snapshot_id: Identifier for the model snapshot.
@@ -728,7 +728,7 @@ async def delete_trained_model(
           <p>The request deletes a trained inference model that is not referenced by an ingest pipeline.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-delete-trained-model>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-delete-trained-model>`_
 
         :param model_id: The unique identifier of the trained model.
         :param force: Forcefully deletes a trained model that is referenced by ingest
@@ -783,7 +783,7 @@ async def delete_trained_model_alias(
           by the <code>model_id</code>, this API returns an error.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-delete-trained-model-alias>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-delete-trained-model-alias>`_
 
         :param model_id: The trained model ID to which the model alias refers.
         :param model_alias: The model alias to delete.
@@ -844,7 +844,7 @@ async def estimate_model_memory(
           estimates for the fields it references.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-estimate-model-memory>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-estimate-model-memory>`_
 
         :param analysis_config: For a list of the properties that you can specify in
             the `analysis_config` component of the body of this API.
@@ -916,7 +916,7 @@ async def evaluate_data_frame(
           field and an analytics result field to be present.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-evaluate-data-frame>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-evaluate-data-frame>`_
 
         :param evaluation: Defines the type of evaluation you want to perform.
         :param index: Defines the `index` in which the evaluation will be performed.
@@ -1001,7 +1001,7 @@ async def explain_data_frame_analytics(
           </ul>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-explain-data-frame-analytics>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-explain-data-frame-analytics>`_
 
         :param id: Identifier for the data frame analytics job. This identifier can contain
             lowercase alphanumeric characters (a-z and 0-9), hyphens, and underscores.
@@ -1112,7 +1112,7 @@ async def flush_job(
           analyzing further data.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-flush-job>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-flush-job>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param advance_time: Refer to the description for the `advance_time` query parameter.
@@ -1187,7 +1187,7 @@ async def forecast(
           based on historical data.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-forecast>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-forecast>`_
 
         :param job_id: Identifier for the anomaly detection job. The job must be open
             when you create a forecast; otherwise, an error occurs.
@@ -1273,7 +1273,7 @@ async def get_buckets(
           The API presents a chronological view of the records, grouped by bucket.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-buckets>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-buckets>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param timestamp: The timestamp of a single bucket result. If you do not specify
@@ -1371,7 +1371,7 @@ async def get_calendar_events(
           <p>Get info about events in calendars.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-calendar-events>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-calendar-events>`_
 
         :param calendar_id: A string that uniquely identifies a calendar. You can get
             information for multiple calendars by using a comma-separated list of ids
@@ -1440,7 +1440,7 @@ async def get_calendars(
           <p>Get calendar configuration info.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-calendars>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-calendars>`_
 
         :param calendar_id: A string that uniquely identifies a calendar. You can get
             information for multiple calendars by using a comma-separated list of ids
@@ -1516,7 +1516,7 @@ async def get_categories(
           <p>Get anomaly detection job results for categories.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-categories>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-categories>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param category_id: Identifier for the category, which is unique in the job.
@@ -1604,7 +1604,7 @@ async def get_data_frame_analytics(
           wildcard expression.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-data-frame-analytics>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-data-frame-analytics>`_
 
         :param id: Identifier for the data frame analytics job. If you do not specify
             this option, the API returns information for the first hundred data frame
@@ -1676,10 +1676,10 @@ async def get_data_frame_analytics_stats(
         """
         .. raw:: html
 
-          <p>Get data frame analytics jobs usage info.</p>
+          <p>Get data frame analytics job stats.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-data-frame-analytics-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-data-frame-analytics-stats>`_
 
         :param id: Identifier for the data frame analytics job. If you do not specify
             this option, the API returns information for the first hundred data frame
@@ -1744,7 +1744,7 @@ async def get_datafeed_stats(
         """
         .. raw:: html
 
-          <p>Get datafeeds usage info.
+          <p>Get datafeed stats.
           You can get statistics for multiple datafeeds in a single API request by
           using a comma-separated list of datafeeds or a wildcard expression. You can
           get statistics for all datafeeds by using <code>_all</code>, by specifying <code>*</code> as the
@@ -1753,7 +1753,7 @@ async def get_datafeed_stats(
           This API returns a maximum of 10,000 datafeeds.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-datafeed-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-datafeed-stats>`_
 
         :param datafeed_id: Identifier for the datafeed. It can be a datafeed identifier
             or a wildcard expression. If you do not specify one of these options, the
@@ -1817,7 +1817,7 @@ async def get_datafeeds(
           This API returns a maximum of 10,000 datafeeds.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-datafeeds>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-datafeeds>`_
 
         :param datafeed_id: Identifier for the datafeed. It can be a datafeed identifier
             or a wildcard expression. If you do not specify one of these options, the
@@ -1884,7 +1884,7 @@ async def get_filters(
           You can get a single filter or all filters.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-filters>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-filters>`_
 
         :param filter_id: A string that uniquely identifies a filter.
         :param from_: Skips the specified number of filters.
@@ -1952,7 +1952,7 @@ async def get_influencers(
           <code>influencer_field_name</code> is specified in the job configuration.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-influencers>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-influencers>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param desc: If true, the results are sorted in descending order.
@@ -2033,10 +2033,10 @@ async def get_job_stats(
         """
         .. raw:: html
 
-          <p>Get anomaly detection jobs usage info.</p>
+          <p>Get anomaly detection job stats.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-job-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-job-stats>`_
 
         :param job_id: Identifier for the anomaly detection job. It can be a job identifier,
             a group name, a comma-separated list of jobs, or a wildcard expression. If
@@ -2100,7 +2100,7 @@ async def get_jobs(
           <code>_all</code>, by specifying <code>*</code> as the <code>&lt;job_id&gt;</code>, or by omitting the <code>&lt;job_id&gt;</code>.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-jobs>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-jobs>`_
 
         :param job_id: Identifier for the anomaly detection job. It can be a job identifier,
             a group name, or a wildcard expression. If you do not specify one of these
@@ -2166,7 +2166,7 @@ async def get_memory_stats(
           on each node, both within the JVM heap, and natively, outside of the JVM.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-memory-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-memory-stats>`_
 
         :param node_id: The names of particular nodes in the cluster to target. For example,
             `nodeId1,nodeId2` or `ml:true`
@@ -2224,7 +2224,7 @@ async def get_model_snapshot_upgrade_stats(
           <p>Get anomaly detection job model snapshot upgrade usage info.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-model-snapshot-upgrade-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-model-snapshot-upgrade-stats>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param snapshot_id: A numerical character string that uniquely identifies the
@@ -2298,7 +2298,7 @@ async def get_model_snapshots(
           <p>Get model snapshots info.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-model-snapshots>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-model-snapshots>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param snapshot_id: A numerical character string that uniquely identifies the
@@ -2418,7 +2418,7 @@ async def get_overall_buckets(
           jobs' largest bucket span.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-overall-buckets>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-overall-buckets>`_
 
         :param job_id: Identifier for the anomaly detection job. It can be a job identifier,
             a group name, a comma-separated list of jobs or groups, or a wildcard expression.
@@ -2528,7 +2528,7 @@ async def get_records(
           number of detectors.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-records>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-records>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param desc: Refer to the description for the `desc` query parameter.
@@ -2616,7 +2616,6 @@ async def get_trained_models(
                 ],
             ]
         ] = None,
-        include_model_definition: t.Optional[bool] = None,
         pretty: t.Optional[bool] = None,
         size: t.Optional[int] = None,
         tags: t.Optional[t.Union[str, t.Sequence[str]]] = None,
@@ -2627,7 +2626,7 @@ async def get_trained_models(
           <p>Get trained model configuration info.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-trained-models>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-trained-models>`_
 
         :param model_id: The unique identifier of the trained model or a model alias.
             You can get information for multiple trained models in a single API request
@@ -2646,8 +2645,6 @@ async def get_trained_models(
         :param from_: Skips the specified number of models.
         :param include: A comma delimited string of optional fields to include in the
             response body.
-        :param include_model_definition: parameter is deprecated! Use [include=definition]
-            instead
         :param size: Specifies the maximum number of models to obtain.
         :param tags: A comma delimited string of tags. A trained model can have many
             tags, or none. When supplied, only trained models that contain all the supplied
@@ -2677,8 +2674,6 @@ async def get_trained_models(
             __query["human"] = human
         if include is not None:
             __query["include"] = include
-        if include_model_definition is not None:
-            __query["include_model_definition"] = include_model_definition
         if pretty is not None:
             __query["pretty"] = pretty
         if size is not None:
@@ -2718,7 +2713,7 @@ async def get_trained_models_stats(
           models in a single API request by using a comma-separated list of model IDs or a wildcard expression.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-trained-models-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-trained-models-stats>`_
 
         :param model_id: The unique identifier of the trained model or a model alias.
             It can be a comma-separated list or a wildcard expression.
@@ -2784,7 +2779,7 @@ async def infer_trained_model(
           <p>Evaluate a trained model.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-infer-trained-model>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-infer-trained-model>`_
 
         :param model_id: The unique identifier of the trained model.
         :param docs: An array of objects to pass to the model for inference. The objects
@@ -2851,7 +2846,7 @@ async def info(
           cluster configuration.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-info>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-info>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_ml/info"
@@ -2900,7 +2895,7 @@ async def open_job(
           new data is received.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-open-job>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-open-job>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param timeout: Refer to the description for the `timeout` query parameter.
@@ -2957,7 +2952,7 @@ async def post_calendar_events(
           <p>Add scheduled events to the calendar.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-post-calendar-events>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-post-calendar-events>`_
 
         :param calendar_id: A string that uniquely identifies a calendar.
         :param events: A list of one of more scheduled events. The event’s start and
@@ -3018,7 +3013,7 @@ async def post_data(
           It is not currently possible to post data to multiple jobs using wildcards or a comma-separated list.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-post-data>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-post-data>`_
 
         :param job_id: Identifier for the anomaly detection job. The job must have a
             state of open to receive and process the data.
@@ -3085,7 +3080,7 @@ async def preview_data_frame_analytics(
           Preview the extracted features used by a data frame analytics config.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-preview-data-frame-analytics>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-preview-data-frame-analytics>`_
 
         :param id: Identifier for the data frame analytics job.
         :param config: A data frame analytics config as described in create data frame
@@ -3158,7 +3153,7 @@ async def preview_datafeed(
           You can also use secondary authorization headers to supply the credentials.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-preview-datafeed>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-preview-datafeed>`_
 
         :param datafeed_id: A numerical character string that uniquely identifies the
             datafeed. This identifier can contain lowercase alphanumeric characters (a-z
@@ -3237,7 +3232,7 @@ async def put_calendar(
           <p>Create a calendar.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-put-calendar>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-put-calendar>`_
 
         :param calendar_id: A string that uniquely identifies a calendar.
         :param description: A description of the calendar.
@@ -3294,7 +3289,7 @@ async def put_calendar_job(
           <p>Add anomaly detection job to calendar.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-put-calendar-job>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-put-calendar-job>`_
 
         :param calendar_id: A string that uniquely identifies a calendar.
         :param job_id: An identifier for the anomaly detection jobs. It can be a job
@@ -3377,7 +3372,7 @@ async def put_data_frame_analytics(
           <p>If you supply only a subset of the regression or classification parameters, hyperparameter optimization occurs. It determines a value for each of the undefined parameters.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-put-data-frame-analytics>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-put-data-frame-analytics>`_
 
         :param id: Identifier for the data frame analytics job. This identifier can contain
             lowercase alphanumeric characters (a-z and 0-9), hyphens, and underscores.
@@ -3554,7 +3549,8 @@ async def put_datafeed(
           Datafeeds retrieve data from Elasticsearch for analysis by an anomaly detection job.
           You can associate only one datafeed with each anomaly detection job.
           The datafeed contains a query that runs at a defined interval (<code>frequency</code>).
-          If you are concerned about delayed data, you can add a delay (<code>query_delay') at each interval. By default, the datafeed uses the following query: </code>{&quot;match_all&quot;: {&quot;boost&quot;: 1}}`.</p>
+          If you are concerned about delayed data, you can add a delay (<code>query_delay</code>) at each interval.
+          By default, the datafeed uses the following query: <code>{&quot;match_all&quot;: {&quot;boost&quot;: 1}}</code>.</p>
           <p>When Elasticsearch security features are enabled, your datafeed remembers which roles the user who created it had
           at the time of creation and runs the query using those same roles. If you provide secondary authorization headers,
           those credentials are used instead.
@@ -3562,7 +3558,7 @@ async def put_datafeed(
           directly to the <code>.ml-config</code> index. Do not give users <code>write</code> privileges on the <code>.ml-config</code> index.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-put-datafeed>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-put-datafeed>`_
 
         :param datafeed_id: A numerical character string that uniquely identifies the
             datafeed. This identifier can contain lowercase alphanumeric characters (a-z
@@ -3604,11 +3600,11 @@ async def put_datafeed(
         :param ignore_unavailable: If true, unavailable indices (missing or closed) are
             ignored.
         :param indexes: An array of index names. Wildcards are supported. If any of the
-            indices are in remote clusters, the machine learning nodes must have the
-            `remote_cluster_client` role.
+            indices are in remote clusters, the master nodes and the machine learning
+            nodes must have the `remote_cluster_client` role.
         :param indices: An array of index names. Wildcards are supported. If any of the
-            indices are in remote clusters, the machine learning nodes must have the
-            `remote_cluster_client` role.
+            indices are in remote clusters, the master nodes and the machine learning
+            nodes must have the `remote_cluster_client` role.
         :param indices_options: Specifies index expansion options that are used during
             search
         :param job_id: Identifier for the anomaly detection job.
@@ -3724,7 +3720,7 @@ async def put_filter(
           Specifically, filters are referenced in the <code>custom_rules</code> property of detector configuration objects.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-put-filter>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-put-filter>`_
 
         :param filter_id: A string that uniquely identifies a filter.
         :param description: A description of the filter.
@@ -3826,7 +3822,7 @@ async def put_job(
           If you include a <code>datafeed_config</code> but do not provide a query, the datafeed uses <code>{&quot;match_all&quot;: {&quot;boost&quot;: 1}}</code>.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-put-job>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-put-job>`_
 
         :param job_id: The identifier for the anomaly detection job. This identifier
             can contain lowercase alphanumeric characters (a-z and 0-9), hyphens, and
@@ -3876,13 +3872,7 @@ async def put_job(
         :param description: A description of the job.
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
-            expressions match hidden data streams. Supports comma-separated values. Valid
-            values are: * `all`: Match any data stream or index, including hidden ones.
-            * `closed`: Match closed, non-hidden indices. Also matches any non-hidden
-            data stream. Data streams cannot be closed. * `hidden`: Match hidden data
-            streams and hidden indices. Must be combined with `open`, `closed`, or both.
-            * `none`: Wildcard patterns are not accepted. * `open`: Match open, non-hidden
-            indices. Also matches any non-hidden data stream.
+            expressions match hidden data streams. Supports comma-separated values.
         :param groups: A list of job groups. A job can belong to no groups or many.
         :param ignore_throttled: If `true`, concrete, expanded or aliased indices are
             ignored when frozen.
@@ -4034,7 +4024,7 @@ async def put_trained_model(
           Enable you to supply a trained model that is not created by data frame analytics.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-put-trained-model>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-put-trained-model>`_
 
         :param model_id: The unique identifier of the trained model.
         :param compressed_definition: The compressed (GZipped and Base64 encoded) inference
@@ -4155,7 +4145,7 @@ async def put_trained_model_alias(
           returns a warning.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-put-trained-model-alias>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-put-trained-model-alias>`_
 
         :param model_id: The identifier for the trained model that the alias refers to.
         :param model_alias: The alias to create or update. This value cannot end in numbers.
@@ -4216,7 +4206,7 @@ async def put_trained_model_definition_part(
           <p>Create part of a trained model definition.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-put-trained-model-definition-part>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-put-trained-model-definition-part>`_
 
         :param model_id: The unique identifier of the trained model.
         :param part: The definition part number. When the definition is loaded for inference
@@ -4298,7 +4288,7 @@ async def put_trained_model_vocabulary(
           The vocabulary is stored in the index as described in <code>inference_config.*.vocabulary</code> of the trained model definition.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-put-trained-model-vocabulary>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-put-trained-model-vocabulary>`_
 
         :param model_id: The unique identifier of the trained model.
         :param vocabulary: The model vocabulary, which must not be empty.
@@ -4361,7 +4351,7 @@ async def reset_job(
           comma separated list.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-reset-job>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-reset-job>`_
 
         :param job_id: The ID of the job to reset.
         :param delete_user_annotations: Specifies whether annotations that have been
@@ -4425,7 +4415,7 @@ async def revert_model_snapshot(
           snapshot after Black Friday or a critical system failure.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-revert-model-snapshot>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-revert-model-snapshot>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param snapshot_id: You can specify `empty` as the <snapshot_id>. Reverting to
@@ -4500,7 +4490,7 @@ async def set_upgrade_mode(
           machine learning info API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-set-upgrade-mode>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-set-upgrade-mode>`_
 
         :param enabled: When `true`, it enables `upgrade_mode` which temporarily halts
             all job and datafeed tasks and prohibits new job and datafeed tasks from
@@ -4560,7 +4550,7 @@ async def start_data_frame_analytics(
           the destination index in advance with custom settings and mappings.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-start-data-frame-analytics>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-start-data-frame-analytics>`_
 
         :param id: Identifier for the data frame analytics job. This identifier can contain
             lowercase alphanumeric characters (a-z and 0-9), hyphens, and underscores.
@@ -4623,7 +4613,7 @@ async def start_datafeed(
           authorization headers when you created or updated the datafeed, those credentials are used instead.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-start-datafeed>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-start-datafeed>`_
 
         :param datafeed_id: A numerical character string that uniquely identifies the
             datafeed. This identifier can contain lowercase alphanumeric characters (a-z
@@ -4700,7 +4690,7 @@ async def start_trained_model_deployment(
           It allocates the model to every machine learning node.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-start-trained-model-deployment>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-start-trained-model-deployment>`_
 
         :param model_id: The unique identifier of the trained model. Currently, only
             PyTorch models are supported.
@@ -4801,7 +4791,7 @@ async def stop_data_frame_analytics(
           throughout its lifecycle.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-stop-data-frame-analytics>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-stop-data-frame-analytics>`_
 
         :param id: Identifier for the data frame analytics job. This identifier can contain
             lowercase alphanumeric characters (a-z and 0-9), hyphens, and underscores.
@@ -4871,7 +4861,7 @@ async def stop_datafeed(
           multiple times throughout its lifecycle.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-stop-datafeed>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-stop-datafeed>`_
 
         :param datafeed_id: Identifier for the datafeed. You can stop multiple datafeeds
             in a single API request by using a comma-separated list of datafeeds or a
@@ -4936,7 +4926,7 @@ async def stop_trained_model_deployment(
           <p>Stop a trained model deployment.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-stop-trained-model-deployment>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-stop-trained-model-deployment>`_
 
         :param model_id: The unique identifier of the trained model.
         :param allow_no_match: Specifies what to do when the request: contains wildcard
@@ -5119,7 +5109,7 @@ async def update_datafeed(
           those credentials are used instead.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-update-datafeed>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-update-datafeed>`_
 
         :param datafeed_id: A numerical character string that uniquely identifies the
             datafeed. This identifier can contain lowercase alphanumeric characters (a-z
@@ -5145,13 +5135,7 @@ async def update_datafeed(
             check runs only on real-time datafeeds.
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
-            expressions match hidden data streams. Supports comma-separated values. Valid
-            values are: * `all`: Match any data stream or index, including hidden ones.
-            * `closed`: Match closed, non-hidden indices. Also matches any non-hidden
-            data stream. Data streams cannot be closed. * `hidden`: Match hidden data
-            streams and hidden indices. Must be combined with `open`, `closed`, or both.
-            * `none`: Wildcard patterns are not accepted. * `open`: Match open, non-hidden
-            indices. Also matches any non-hidden data stream.
+            expressions match hidden data streams. Supports comma-separated values.
         :param frequency: The interval at which scheduled queries are made while the
             datafeed runs in real time. The default value is either the bucket span for
             short bucket spans, or, for longer bucket spans, a sensible fraction of the
@@ -5286,7 +5270,7 @@ async def update_filter(
           Updates the description of a filter, adds items, or removes items from the list.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-update-filter>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-update-filter>`_
 
         :param filter_id: A string that uniquely identifies a filter.
         :param add_items: The items to add to the filter.
@@ -5380,7 +5364,7 @@ async def update_job(
           Updates certain properties of an anomaly detection job.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-update-job>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-update-job>`_
 
         :param job_id: Identifier for the job.
         :param allow_lazy_open: Advanced configuration option. Specifies whether this
@@ -5512,7 +5496,7 @@ async def update_model_snapshot(
           Updates certain properties of a snapshot.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-update-model-snapshot>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-update-model-snapshot>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param snapshot_id: Identifier for the model snapshot.
@@ -5577,7 +5561,7 @@ async def update_trained_model_deployment(
           <p>Update a trained model deployment.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-update-trained-model-deployment>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-update-trained-model-deployment>`_
 
         :param model_id: The unique identifier of the trained model. Currently, only
             PyTorch models are supported.
@@ -5654,7 +5638,7 @@ async def upgrade_job_snapshot(
           job.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-upgrade-job-snapshot>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-upgrade-job-snapshot>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param snapshot_id: A numerical character string that uniquely identifies the
@@ -5733,7 +5717,7 @@ async def validate(
           <p>Validate an anomaly detection job.</p>
 
 
-        `<https://www.elastic.co/guide/en/machine-learning/master/ml-jobs.html>`_
+        `<https://www.elastic.co/guide/en/machine-learning/9.0/ml-jobs.html>`_
 
         :param analysis_config:
         :param analysis_limits:
diff --git a/elasticsearch/_async/client/nodes.py b/elasticsearch/_async/client/nodes.py
index be00377a0..cd4e95a7d 100644
--- a/elasticsearch/_async/client/nodes.py
+++ b/elasticsearch/_async/client/nodes.py
@@ -50,7 +50,7 @@ async def clear_repositories_metering_archive(
           Clear the archived repositories metering information in the cluster.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-nodes-clear-repositories-metering-archive>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-nodes-clear-repositories-metering-archive>`_
 
         :param node_id: Comma-separated list of node IDs or names used to limit returned
             information.
@@ -105,10 +105,10 @@ async def get_repositories_metering_info(
           Additionally, the information exposed by this API is volatile, meaning that it will not be present after node restarts.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-nodes-get-repositories-metering-info>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-nodes-get-repositories-metering-info>`_
 
         :param node_id: Comma-separated list of node IDs or names used to limit returned
-            information. All the nodes selective options are explained [here](https://www.elastic.co/guide/en/elasticsearch/reference/current/cluster.html#cluster-nodes).
+            information.
         """
         if node_id in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'node_id'")
@@ -162,7 +162,7 @@ async def hot_threads(
           The output is plain text with a breakdown of the top hot threads for each node.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-nodes-hot-threads>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-nodes-hot-threads>`_
 
         :param node_id: List of node IDs or names used to limit returned information.
         :param ignore_idle_threads: If true, known idle threads (e.g. waiting in a socket
@@ -235,7 +235,7 @@ async def info(
           <p>By default, the API returns all attributes and core settings for cluster nodes.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-nodes-info>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-nodes-info>`_
 
         :param node_id: Comma-separated list of node IDs or names used to limit returned
             information.
@@ -308,7 +308,7 @@ async def reload_secure_settings(
           Alternatively, you can reload the secure settings on each node by locally accessing the API and passing the node-specific Elasticsearch keystore password.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-nodes-reload-secure-settings>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-nodes-reload-secure-settings>`_
 
         :param node_id: The names of particular nodes in the cluster to target.
         :param secure_settings_password: The password for the Elasticsearch keystore.
@@ -383,7 +383,7 @@ async def stats(
           By default, all stats are returned. You can limit the returned information by using metrics.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-nodes-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-nodes-stats>`_
 
         :param node_id: Comma-separated list of node IDs or names used to limit returned
             information.
@@ -498,7 +498,7 @@ async def usage(
           <p>Get feature usage information.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-nodes-usage>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-nodes-usage>`_
 
         :param node_id: A comma-separated list of node IDs or names to limit the returned
             information; use `_local` to return information from the node you're connecting
diff --git a/elasticsearch/_async/client/query_rules.py b/elasticsearch/_async/client/query_rules.py
index 4e056f817..80d95053b 100644
--- a/elasticsearch/_async/client/query_rules.py
+++ b/elasticsearch/_async/client/query_rules.py
@@ -44,7 +44,7 @@ async def delete_rule(
           This is a destructive action that is only recoverable by re-adding the same rule with the create or update query rule API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-query-rules-delete-rule>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-query-rules-delete-rule>`_
 
         :param ruleset_id: The unique identifier of the query ruleset containing the
             rule to delete
@@ -97,7 +97,7 @@ async def delete_ruleset(
           This is a destructive action that is not recoverable.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-query-rules-delete-ruleset>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-query-rules-delete-ruleset>`_
 
         :param ruleset_id: The unique identifier of the query ruleset to delete
         """
@@ -142,7 +142,7 @@ async def get_rule(
           Get details about a query rule within a query ruleset.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-query-rules-get-rule>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-query-rules-get-rule>`_
 
         :param ruleset_id: The unique identifier of the query ruleset containing the
             rule to retrieve
@@ -194,7 +194,7 @@ async def get_ruleset(
           Get details about a query ruleset.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-query-rules-get-ruleset>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-query-rules-get-ruleset>`_
 
         :param ruleset_id: The unique identifier of the query ruleset
         """
@@ -241,7 +241,7 @@ async def list_rulesets(
           Get summarized information about the query rulesets.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-query-rules-list-rulesets>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-query-rules-list-rulesets>`_
 
         :param from_: The offset from the first result to fetch.
         :param size: The maximum number of results to retrieve.
@@ -302,7 +302,7 @@ async def put_rule(
           If multiple matching rules pin more than 100 documents, only the first 100 documents are pinned in the order they are specified in the ruleset.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-query-rules-put-rule>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-query-rules-put-rule>`_
 
         :param ruleset_id: The unique identifier of the query ruleset containing the
             rule to be created or updated.
@@ -389,7 +389,7 @@ async def put_ruleset(
           If multiple matching rules pin more than 100 documents, only the first 100 documents are pinned in the order they are specified in the ruleset.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-query-rules-put-ruleset>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-query-rules-put-ruleset>`_
 
         :param ruleset_id: The unique identifier of the query ruleset to be created or
             updated.
@@ -446,7 +446,7 @@ async def test(
           Evaluate match criteria against a query ruleset to identify the rules that would match that criteria.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-query-rules-test>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-query-rules-test>`_
 
         :param ruleset_id: The unique identifier of the query ruleset to be created or
             updated
diff --git a/elasticsearch/_async/client/rollup.py b/elasticsearch/_async/client/rollup.py
index e0d581d77..63a3955aa 100644
--- a/elasticsearch/_async/client/rollup.py
+++ b/elasticsearch/_async/client/rollup.py
@@ -67,7 +67,7 @@ async def delete_job(
           </code></pre>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-rollup-delete-job>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-rollup-delete-job>`_
 
         :param id: Identifier for the job.
         """
@@ -115,7 +115,7 @@ async def get_jobs(
           For details about a historical rollup job, the rollup capabilities API may be more useful.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-rollup-get-jobs>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-rollup-get-jobs>`_
 
         :param id: Identifier for the rollup job. If it is `_all` or omitted, the API
             returns all rollup jobs.
@@ -171,7 +171,7 @@ async def get_rollup_caps(
           </ol>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-rollup-get-rollup-caps>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-rollup-get-rollup-caps>`_
 
         :param id: Index, indices or index-pattern to return rollup capabilities for.
             `_all` may be used to fetch rollup capabilities from all jobs.
@@ -225,7 +225,7 @@ async def get_rollup_index_caps(
           </ul>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-rollup-get-rollup-index-caps>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-rollup-get-rollup-index-caps>`_
 
         :param index: Data stream or index to check for rollup capabilities. Wildcard
             (`*`) expressions are supported.
@@ -295,7 +295,7 @@ async def put_job(
           <p>Jobs are created in a <code>STOPPED</code> state. You can start them with the start rollup jobs API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-rollup-put-job>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-rollup-put-job>`_
 
         :param id: Identifier for the rollup job. This can be any alphanumeric string
             and uniquely identifies the data that is associated with the rollup job.
@@ -419,31 +419,10 @@ async def rollup_search(
           The following functionality is not available:</p>
           <p><code>size</code>: Because rollups work on pre-aggregated data, no search hits can be returned and so size must be set to zero or omitted entirely.
           <code>highlighter</code>, <code>suggestors</code>, <code>post_filter</code>, <code>profile</code>, <code>explain</code>: These are similarly disallowed.</p>
-          <p><strong>Searching both historical rollup and non-rollup data</strong></p>
-          <p>The rollup search API has the capability to search across both &quot;live&quot; non-rollup data and the aggregated rollup data.
-          This is done by simply adding the live indices to the URI. For example:</p>
-          <pre><code>GET sensor-1,sensor_rollup/_rollup_search
-          {
-            &quot;size&quot;: 0,
-            &quot;aggregations&quot;: {
-               &quot;max_temperature&quot;: {
-                &quot;max&quot;: {
-                  &quot;field&quot;: &quot;temperature&quot;
-                }
-              }
-            }
-          }
-          </code></pre>
-          <p>The rollup search endpoint does two things when the search runs:</p>
-          <ul>
-          <li>The original request is sent to the non-rollup index unaltered.</li>
-          <li>A rewritten version of the original request is sent to the rollup index.</li>
-          </ul>
-          <p>When the two responses are received, the endpoint rewrites the rollup response and merges the two together.
-          During the merging process, if there is any overlap in buckets between the two responses, the buckets from the non-rollup index are used.</p>
+          <p>For more detailed examples of using the rollup search API, including querying rolled-up data only or combining rolled-up and live data, refer to the External documentation.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-rollup-rollup-search>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-rollup-rollup-search>`_
 
         :param index: A comma-separated list of data streams and indices used to limit
             the request. This parameter has the following rules: * At least one data
@@ -521,7 +500,7 @@ async def start_job(
           If you try to start a job that is already started, nothing happens.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-rollup-start-job>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-rollup-start-job>`_
 
         :param id: Identifier for the rollup job.
         """
@@ -575,7 +554,7 @@ async def stop_job(
           If the specified time elapses without the job moving to STOPPED, a timeout exception occurs.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-rollup-stop-job>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-rollup-stop-job>`_
 
         :param id: Identifier for the rollup job.
         :param timeout: If `wait_for_completion` is `true`, the API blocks for (at maximum)
diff --git a/elasticsearch/_async/client/search_application.py b/elasticsearch/_async/client/search_application.py
index 30352bd67..5e02c132c 100644
--- a/elasticsearch/_async/client/search_application.py
+++ b/elasticsearch/_async/client/search_application.py
@@ -49,7 +49,7 @@ async def delete(
           <p>Remove a search application and its associated alias. Indices attached to the search application are not removed.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-search-application-delete>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-search-application-delete>`_
 
         :param name: The name of the search application to delete.
         """
@@ -94,7 +94,7 @@ async def delete_behavioral_analytics(
           The associated data stream is also deleted.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-search-application-delete-behavioral-analytics>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-search-application-delete-behavioral-analytics>`_
 
         :param name: The name of the analytics collection to be deleted
         """
@@ -138,7 +138,7 @@ async def get(
           <p>Get search application details.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-search-application-get>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-search-application-get>`_
 
         :param name: The name of the search application
         """
@@ -182,7 +182,7 @@ async def get_behavioral_analytics(
           <p>Get behavioral analytics collections.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-search-application-get-behavioral-analytics>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-search-application-get-behavioral-analytics>`_
 
         :param name: A list of analytics collections to limit the returned information
         """
@@ -234,7 +234,7 @@ async def list(
           Get information about search applications.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-search-application-get-behavioral-analytics>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-search-application-get-behavioral-analytics>`_
 
         :param from_: Starting offset.
         :param q: Query in the Lucene query string syntax.
@@ -290,7 +290,7 @@ async def post_behavioral_analytics_event(
           <p>Create a behavioral analytics collection event.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-search-application-post-behavioral-analytics-event>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-search-application-post-behavioral-analytics-event>`_
 
         :param collection_name: The name of the behavioral analytics collection.
         :param event_type: The analytics event type.
@@ -357,7 +357,7 @@ async def put(
           <p>Create or update a search application.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-search-application-put>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-search-application-put>`_
 
         :param name: The name of the search application to be created or updated.
         :param search_application:
@@ -414,7 +414,7 @@ async def put_behavioral_analytics(
           <p>Create a behavioral analytics collection.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-search-application-put-behavioral-analytics>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-search-application-put-behavioral-analytics>`_
 
         :param name: The name of the analytics collection to be created or updated.
         """
@@ -467,7 +467,7 @@ async def render_query(
           <p>You must have <code>read</code> privileges on the backing alias of the search application.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-search-application-render-query>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-search-application-render-query>`_
 
         :param name: The name of the search application to render teh query for.
         :param params:
@@ -531,7 +531,7 @@ async def search(
           Unspecified template parameters are assigned their default values if applicable.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-search-application-search>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-search-application-search>`_
 
         :param name: The name of the search application to be searched.
         :param params: Query parameters specific to this request, which will override
diff --git a/elasticsearch/_async/client/searchable_snapshots.py b/elasticsearch/_async/client/searchable_snapshots.py
index 9b6902fac..dc55f3a6e 100644
--- a/elasticsearch/_async/client/searchable_snapshots.py
+++ b/elasticsearch/_async/client/searchable_snapshots.py
@@ -50,7 +50,7 @@ async def cache_stats(
           Get statistics about the shared cache for partially mounted indices.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-searchable-snapshots-cache-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-searchable-snapshots-cache-stats>`_
 
         :param node_id: The names of the nodes in the cluster to target.
         :param master_timeout:
@@ -111,7 +111,7 @@ async def clear_cache(
           Clear indices and data streams from the shared cache for partially mounted indices.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-searchable-snapshots-clear-cache>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-searchable-snapshots-clear-cache>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases to
             clear from the cache. It supports wildcards (`*`).
@@ -190,7 +190,7 @@ async def mount(
           Manually mounting ILM-managed snapshots can interfere with ILM processes.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-searchable-snapshots-mount>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-searchable-snapshots-mount>`_
 
         :param repository: The name of the repository containing the snapshot of the
             index to mount.
@@ -278,7 +278,7 @@ async def stats(
           <p>Get searchable snapshot statistics.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-searchable-snapshots-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-searchable-snapshots-stats>`_
 
         :param index: A comma-separated list of data streams and indices to retrieve
             statistics for.
diff --git a/elasticsearch/_async/client/security.py b/elasticsearch/_async/client/security.py
index 0bc3084a3..f1b128f3d 100644
--- a/elasticsearch/_async/client/security.py
+++ b/elasticsearch/_async/client/security.py
@@ -58,7 +58,7 @@ async def activate_user_profile(
           Any updates do not change existing content for either the <code>labels</code> or <code>data</code> fields.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-activate-user-profile>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-activate-user-profile>`_
 
         :param grant_type: The type of grant.
         :param access_token: The user's Elasticsearch access token or JWT. Both `access`
@@ -124,7 +124,7 @@ async def authenticate(
           If the user cannot be authenticated, this API returns a 401 status code.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-authenticate>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-authenticate>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_security/_authenticate"
@@ -171,7 +171,7 @@ async def bulk_delete_role(
           The bulk delete roles API cannot delete roles that are defined in roles files.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-bulk-delete-role>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-bulk-delete-role>`_
 
         :param names: An array of role names to delete
         :param refresh: If `true` (the default) then refresh the affected shards to make
@@ -232,7 +232,7 @@ async def bulk_put_role(
           The bulk create or update roles API cannot update roles that are defined in roles files.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-bulk-put-role>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-bulk-put-role>`_
 
         :param roles: A dictionary of role name to RoleDescriptor objects to add or update
         :param refresh: If `true` (the default) then refresh the affected shards to make
@@ -300,7 +300,7 @@ async def bulk_update_api_keys(
           <p>A successful request returns a JSON structure that contains the IDs of all updated API keys, the IDs of API keys that already had the requested changes and did not require an update, and error details for any failed update.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-bulk-update-api-keys>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-bulk-update-api-keys>`_
 
         :param ids: The API key identifiers.
         :param expiration: Expiration time for the API keys. By default, API keys never
@@ -378,7 +378,7 @@ async def change_password(
           <p>Change the passwords of users in the native realm and built-in users.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-change-password>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-change-password>`_
 
         :param username: The user whose password you want to change. If you do not specify
             this parameter, the password is changed for the current user.
@@ -445,7 +445,7 @@ async def clear_api_key_cache(
           The cache is also automatically cleared on state changes of the security index.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-clear-api-key-cache>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-clear-api-key-cache>`_
 
         :param ids: Comma-separated list of API key IDs to evict from the API key cache.
             To evict all API keys, use `*`. Does not support other wildcard patterns.
@@ -491,7 +491,7 @@ async def clear_cached_privileges(
           The cache is also automatically cleared for applications that have their privileges updated.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-clear-cached-privileges>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-clear-cached-privileges>`_
 
         :param application: A comma-separated list of applications. To clear all applications,
             use an asterism (`*`). It does not support other wildcard patterns.
@@ -541,7 +541,7 @@ async def clear_cached_realms(
           For more information, refer to the documentation about controlling the user cache.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-clear-cached-realms>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-clear-cached-realms>`_
 
         :param realms: A comma-separated list of realms. To clear all realms, use an
             asterisk (`*`). It does not support other wildcard patterns.
@@ -591,7 +591,7 @@ async def clear_cached_roles(
           <p>Evict roles from the native role cache.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-clear-cached-roles>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-clear-cached-roles>`_
 
         :param name: A comma-separated list of roles to evict from the role cache. To
             evict all roles, use an asterisk (`*`). It does not support other wildcard
@@ -643,7 +643,7 @@ async def clear_cached_service_tokens(
           The cache for tokens backed by the <code>service_tokens</code> file is cleared automatically on file changes.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-clear-cached-service-tokens>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-clear-cached-service-tokens>`_
 
         :param namespace: The namespace, which is a top-level grouping of service accounts.
         :param service: The name of the service, which must be unique within its namespace.
@@ -715,7 +715,7 @@ async def create_api_key(
           To configure or turn off the API key service, refer to API key service setting documentation.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-create-api-key>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-create-api-key>`_
 
         :param expiration: The expiration time for the API key. By default, API keys
             never expire.
@@ -805,7 +805,7 @@ async def create_cross_cluster_api_key(
           Attempting to update them with the update REST API key API or the bulk update REST API keys API will result in an error.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-create-cross-cluster-api-key>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-create-cross-cluster-api-key>`_
 
         :param access: The access to be granted to this API key. The access is composed
             of permissions for cross-cluster search and cross-cluster replication. At
@@ -880,7 +880,7 @@ async def create_service_token(
           You must actively delete them if they are no longer needed.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-create-service-token>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-create-service-token>`_
 
         :param namespace: The name of the namespace, which is a top-level grouping of
             service accounts.
@@ -966,7 +966,7 @@ async def delegate_pki(
           The proxy is trusted to have performed the TLS authentication and this API translates that authentication into an Elasticsearch access token.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-delegate-pki>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-delegate-pki>`_
 
         :param x509_certificate_chain: The X509Certificate chain, which is represented
             as an ordered string array. Each string in the array is a base64-encoded
@@ -1030,7 +1030,7 @@ async def delete_privileges(
           </ul>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-delete-privileges>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-delete-privileges>`_
 
         :param application: The name of the application. Application privileges are always
             associated with exactly one application.
@@ -1093,7 +1093,7 @@ async def delete_role(
           The delete roles API cannot remove roles that are defined in roles files.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-delete-role>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-delete-role>`_
 
         :param name: The name of the role.
         :param refresh: If `true` (the default) then refresh the affected shards to make
@@ -1147,7 +1147,7 @@ async def delete_role_mapping(
           The delete role mappings API cannot remove role mappings that are defined in role mapping files.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-delete-role-mapping>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-delete-role-mapping>`_
 
         :param name: The distinct name that identifies the role mapping. The name is
             used solely as an identifier to facilitate interaction via the API; it does
@@ -1203,7 +1203,7 @@ async def delete_service_token(
           <p>Delete service account tokens for a service in a specified namespace.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-delete-service-token>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-delete-service-token>`_
 
         :param namespace: The namespace, which is a top-level grouping of service accounts.
         :param service: The service name.
@@ -1265,7 +1265,7 @@ async def delete_user(
           <p>Delete users from the native realm.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-delete-user>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-delete-user>`_
 
         :param username: An identifier for the user.
         :param refresh: If `true` (the default) then refresh the affected shards to make
@@ -1319,7 +1319,7 @@ async def disable_user(
           You can use this API to revoke a user's access to Elasticsearch.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-disable-user>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-disable-user>`_
 
         :param username: An identifier for the user.
         :param refresh: If `true` (the default) then refresh the affected shards to make
@@ -1376,7 +1376,7 @@ async def disable_user_profile(
           To re-enable a disabled user profile, use the enable user profile API .</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-disable-user-profile>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-disable-user-profile>`_
 
         :param uid: Unique identifier for the user profile.
         :param refresh: If 'true', Elasticsearch refreshes the affected shards to make
@@ -1429,7 +1429,7 @@ async def enable_user(
           By default, when you create users, they are enabled.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-enable-user>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-enable-user>`_
 
         :param username: An identifier for the user.
         :param refresh: If `true` (the default) then refresh the affected shards to make
@@ -1486,7 +1486,7 @@ async def enable_user_profile(
           If you later disable the user profile, you can use the enable user profile API to make the profile visible in these searches again.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-enable-user-profile>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-enable-user-profile>`_
 
         :param uid: A unique identifier for the user profile.
         :param refresh: If 'true', Elasticsearch refreshes the affected shards to make
@@ -1536,7 +1536,7 @@ async def enroll_kibana(
           Kibana uses this API internally to configure itself for communications with an Elasticsearch cluster that already has security features enabled.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-enroll-kibana>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-enroll-kibana>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_security/enroll/kibana"
@@ -1577,7 +1577,7 @@ async def enroll_node(
           The response contains key and certificate material that allows the caller to generate valid signed certificates for the HTTP layer of all nodes in the cluster.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-enroll-node>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-enroll-node>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_security/enroll/node"
@@ -1626,7 +1626,7 @@ async def get_api_key(
           If you have <code>read_security</code>, <code>manage_api_key</code> or greater privileges (including <code>manage_security</code>), this API returns all API keys regardless of ownership.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-get-api-key>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-get-api-key>`_
 
         :param active_only: A boolean flag that can be used to query API keys that are
             currently active. An API key is considered active if it is neither invalidated,
@@ -1704,7 +1704,7 @@ async def get_builtin_privileges(
           <p>Get the list of cluster privileges and index privileges that are available in this version of Elasticsearch.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-get-builtin-privileges>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-get-builtin-privileges>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_security/privilege/_builtin"
@@ -1749,7 +1749,7 @@ async def get_privileges(
           </ul>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-get-privileges>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-get-privileges>`_
 
         :param application: The name of the application. Application privileges are always
             associated with exactly one application. If you do not specify this parameter,
@@ -1805,7 +1805,7 @@ async def get_role(
           The get roles API cannot retrieve roles that are defined in roles files.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-get-role>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-get-role>`_
 
         :param name: The name of the role. You can specify multiple roles as a comma-separated
             list. If you do not specify this parameter, the API returns information about
@@ -1856,7 +1856,7 @@ async def get_role_mapping(
           The get role mappings API cannot retrieve role mappings that are defined in role mapping files.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-get-role-mapping>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-get-role-mapping>`_
 
         :param name: The distinct name that identifies the role mapping. The name is
             used solely as an identifier to facilitate interaction via the API; it does
@@ -1909,7 +1909,7 @@ async def get_service_accounts(
           <p>NOTE: Currently, only the <code>elastic/fleet-server</code> service account is available.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-get-service-accounts>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-get-service-accounts>`_
 
         :param namespace: The name of the namespace. Omit this parameter to retrieve
             information about all service accounts. If you omit this parameter, you must
@@ -1967,7 +1967,7 @@ async def get_service_credentials(
           Tokens with the same name from different nodes are assumed to be the same token and are only counted once towards the total number of service tokens.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-get-service-credentials>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-get-service-credentials>`_
 
         :param namespace: The name of the namespace.
         :param service: The service name.
@@ -2023,7 +2023,7 @@ async def get_settings(
           </ul>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-get-settings>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-get-settings>`_
 
         :param master_timeout: Period to wait for a connection to the master node. If
             no response is received before the timeout expires, the request fails and
@@ -2099,7 +2099,7 @@ async def get_token(
           If you want to invalidate a token immediately, you can do so by using the invalidate token API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-get-token>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-get-token>`_
 
         :param grant_type: The type of grant. Supported grant types are: `password`,
             `_kerberos`, `client_credentials`, and `refresh_token`.
@@ -2173,7 +2173,7 @@ async def get_user(
           <p>Get information about users in the native realm and built-in users.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-get-user>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-get-user>`_
 
         :param username: An identifier for the user. You can specify multiple usernames
             as a comma-separated list. If you omit this parameter, the API retrieves
@@ -2213,13 +2213,10 @@ async def get_user(
     async def get_user_privileges(
         self,
         *,
-        application: 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,
-        priviledge: t.Optional[str] = None,
-        username: t.Optional[t.Union[None, str]] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
         .. raw:: html
@@ -2231,20 +2228,11 @@ async def get_user_privileges(
           To check whether a user has a specific list of privileges, use the has privileges API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-get-user-privileges>`_
-
-        :param application: The name of the application. Application privileges are always
-            associated with exactly one application. If you do not specify this parameter,
-            the API returns information about all privileges for all applications.
-        :param priviledge: The name of the privilege. If you do not specify this parameter,
-            the API returns information about all privileges for the requested application.
-        :param username:
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-get-user-privileges>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_security/user/_privileges"
         __query: t.Dict[str, t.Any] = {}
-        if application is not None:
-            __query["application"] = application
         if error_trace is not None:
             __query["error_trace"] = error_trace
         if filter_path is not None:
@@ -2253,10 +2241,6 @@ async def get_user_privileges(
             __query["human"] = human
         if pretty is not None:
             __query["pretty"] = pretty
-        if priviledge is not None:
-            __query["priviledge"] = priviledge
-        if username is not None:
-            __query["username"] = username
         __headers = {"accept": "application/json"}
         return await self.perform_request(  # type: ignore[return-value]
             "GET",
@@ -2288,7 +2272,7 @@ async def get_user_profile(
           Elastic reserves the right to change or remove this feature in future releases without prior notice.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-get-user-profile>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-get-user-profile>`_
 
         :param uid: A unique identifier for the user profile.
         :param data: A comma-separated list of filters for the `data` field of the profile
@@ -2345,6 +2329,9 @@ async def grant_api_key(
         human: t.Optional[bool] = None,
         password: t.Optional[str] = None,
         pretty: t.Optional[bool] = None,
+        refresh: t.Optional[
+            t.Union[bool, str, t.Literal["false", "true", "wait_for"]]
+        ] = None,
         run_as: t.Optional[str] = None,
         username: t.Optional[str] = None,
         body: t.Optional[t.Dict[str, t.Any]] = None,
@@ -2372,7 +2359,7 @@ async def grant_api_key(
           <p>By default, API keys never expire. You can specify expiration information when you create the API keys.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-grant-api-key>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-grant-api-key>`_
 
         :param api_key: The API key.
         :param grant_type: The type of grant. Supported grant types are: `access_token`,
@@ -2382,6 +2369,9 @@ async def grant_api_key(
             types.
         :param password: The user's password. If you specify the `password` grant type,
             this parameter is required. It is not valid with other grant types.
+        :param refresh: If 'true', Elasticsearch refreshes the affected shards to make
+            this operation visible to search. If 'wait_for', it waits for a refresh to
+            make this operation visible to search. If 'false', nothing is done with refreshes.
         :param run_as: The name of the user to be impersonated.
         :param username: The user name that identifies the user. If you specify the `password`
             grant type, this parameter is required. It is not valid with other grant
@@ -2403,6 +2393,8 @@ async def grant_api_key(
             __query["human"] = human
         if pretty is not None:
             __query["pretty"] = pretty
+        if refresh is not None:
+            __query["refresh"] = refresh
         if not __body:
             if api_key is not None:
                 __body["api_key"] = api_key
@@ -2519,7 +2511,7 @@ async def has_privileges(
           To check the privileges of other users, you must use the run as feature.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-has-privileges>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-has-privileges>`_
 
         :param user: Username
         :param application:
@@ -2584,7 +2576,7 @@ async def has_privileges_user_profile(
           Elastic reserves the right to change or remove this feature in future releases without prior notice.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-has-privileges-user-profile>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-has-privileges-user-profile>`_
 
         :param privileges: An object containing all the privileges to be checked.
         :param uids: A list of profile IDs. The privileges are checked for associated
@@ -2658,7 +2650,7 @@ async def invalidate_api_key(
           </ul>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-invalidate-api-key>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-invalidate-api-key>`_
 
         :param id:
         :param ids: A list of API key ids. This parameter cannot be used with any of
@@ -2742,7 +2734,7 @@ async def invalidate_token(
           If none of these two are specified, then <code>realm_name</code> and/or <code>username</code> need to be specified.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-invalidate-token>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-invalidate-token>`_
 
         :param realm_name: The name of an authentication realm. This parameter cannot
             be used with either `refresh_token` or `token`.
@@ -2810,7 +2802,7 @@ async def oidc_authenticate(
           These APIs are used internally by Kibana in order to provide OpenID Connect based authentication, but can also be used by other, custom web applications or other clients.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-oidc-authenticate>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-oidc-authenticate>`_
 
         :param nonce: Associate a client session with an ID token and mitigate replay
             attacks. This value needs to be the same as the one that was provided to
@@ -2867,12 +2859,12 @@ async def oidc_authenticate(
         )
 
     @_rewrite_parameters(
-        body_fields=("access_token", "refresh_token"),
+        body_fields=("token", "refresh_token"),
     )
     async def oidc_logout(
         self,
         *,
-        access_token: t.Optional[str] = None,
+        token: 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,
@@ -2890,13 +2882,13 @@ async def oidc_logout(
           These APIs are used internally by Kibana in order to provide OpenID Connect based authentication, but can also be used by other, custom web applications or other clients.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-oidc-logout>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-oidc-logout>`_
 
-        :param access_token: The access token to be invalidated.
+        :param token: The access token to be invalidated.
         :param refresh_token: The refresh token to be invalidated.
         """
-        if access_token is None and body is None:
-            raise ValueError("Empty value passed for parameter 'access_token'")
+        if token is None and body is None:
+            raise ValueError("Empty value passed for parameter 'token'")
         __path_parts: t.Dict[str, str] = {}
         __path = "/_security/oidc/logout"
         __query: t.Dict[str, t.Any] = {}
@@ -2910,8 +2902,8 @@ async def oidc_logout(
         if pretty is not None:
             __query["pretty"] = pretty
         if not __body:
-            if access_token is not None:
-                __body["access_token"] = access_token
+            if token is not None:
+                __body["token"] = token
             if refresh_token is not None:
                 __body["refresh_token"] = refresh_token
         __headers = {"accept": "application/json", "content-type": "application/json"}
@@ -2952,7 +2944,7 @@ async def oidc_prepare_authentication(
           These APIs are used internally by Kibana in order to provide OpenID Connect based authentication, but can also be used by other, custom web applications or other clients.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-oidc-prepare-authentication>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-oidc-prepare-authentication>`_
 
         :param iss: In the case of a third party initiated single sign on, this is the
             issuer identifier for the OP that the RP is to send the authentication request
@@ -3048,7 +3040,7 @@ async def put_privileges(
           <p>Action names can contain any number of printable ASCII characters and must contain at least one of the following characters: <code>/</code>, <code>*</code>, <code>:</code>.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-put-privileges>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-put-privileges>`_
 
         :param privileges:
         :param refresh: If `true` (the default) then refresh the affected shards to make
@@ -3200,7 +3192,7 @@ async def put_role(
           File-based role management is not available in Elastic Serverless.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-put-role>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-put-role>`_
 
         :param name: The name of the role that is being created or updated. On Elasticsearch
             Serverless, the role name must begin with a letter or digit and can only
@@ -3335,7 +3327,7 @@ async def put_role_mapping(
           If the format of the template is set to &quot;json&quot; then the template is expected to produce a JSON string or an array of JSON strings for the role names.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-put-role-mapping>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-put-role-mapping>`_
 
         :param name: The distinct name that identifies the role mapping. The name is
             used solely as an identifier to facilitate interaction via the API; it does
@@ -3437,7 +3429,7 @@ async def put_user(
           To change a user's password without updating any other fields, use the change password API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-put-user>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-put-user>`_
 
         :param username: An identifier for the user. NOTE: Usernames must be at least
             1 and no more than 507 characters. They can contain alphanumeric characters
@@ -3553,10 +3545,11 @@ async def query_api_keys(
           You can optionally filter the results with a query.</p>
           <p>To use this API, you must have at least the <code>manage_own_api_key</code> or the <code>read_security</code> cluster privileges.
           If you have only the <code>manage_own_api_key</code> privilege, this API returns only the API keys that you own.
-          If you have the <code>read_security</code>, <code>manage_api_key</code>, or greater privileges (including <code>manage_security</code>), this API returns all API keys regardless of ownership.</p>
+          If you have the <code>read_security</code>, <code>manage_api_key</code>, or greater privileges (including <code>manage_security</code>), this API returns all API keys regardless of ownership.
+          Refer to the linked documentation for examples of how to find API keys:</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-query-api-keys>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-query-api-keys>`_
 
         :param aggregations: Any aggregations to run over the corpus of returned API
             keys. Aggregations and queries work together. Aggregations are computed only
@@ -3699,7 +3692,7 @@ async def query_role(
           Also, the results can be paginated and sorted.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-query-role>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-query-role>`_
 
         :param from_: The starting document offset. It must not be negative. By default,
             you cannot page through more than 10,000 hits using the `from` and `size`
@@ -3792,7 +3785,7 @@ async def query_user(
           This API is only for native users.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-query-user>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-query-user>`_
 
         :param from_: The starting document offset. It must not be negative. By default,
             you cannot page through more than 10,000 hits using the `from` and `size`
@@ -3885,7 +3878,7 @@ async def saml_authenticate(
           This API endpoint essentially exchanges SAML responses that indicate successful authentication in the IdP for Elasticsearch access and refresh tokens, which can be used for authentication against Elasticsearch.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-saml-authenticate>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-saml-authenticate>`_
 
         :param content: The SAML response as it was sent by the user's browser, usually
             a Base64 encoded XML document.
@@ -3958,7 +3951,7 @@ async def saml_complete_logout(
           The caller of this API must prepare the request accordingly so that this API can handle either of them.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-saml-complete-logout>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-saml-complete-logout>`_
 
         :param ids: A JSON array with all the valid SAML Request Ids that the caller
             of the API has for the current user.
@@ -4034,7 +4027,7 @@ async def saml_invalidate(
           Thus the user can be redirected back to their IdP.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-saml-invalidate>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-saml-invalidate>`_
 
         :param query_string: The query part of the URL that the user was redirected to
             by the SAML IdP to initiate the Single Logout. This query should include
@@ -4109,7 +4102,7 @@ async def saml_logout(
           If the SAML realm in Elasticsearch is configured accordingly and the SAML IdP supports this, the Elasticsearch response contains a URL to redirect the user to the IdP that contains a SAML logout request (starting an SP-initiated SAML Single Logout).</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-saml-logout>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-saml-logout>`_
 
         :param token: The access token that was returned as a response to calling the
             SAML authenticate API. Alternatively, the most recent token that was received
@@ -4179,7 +4172,7 @@ async def saml_prepare_authentication(
           The caller of this API needs to store this identifier as it needs to be used in a following step of the authentication process.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-saml-prepare-authentication>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-saml-prepare-authentication>`_
 
         :param acs: The Assertion Consumer Service URL that matches the one of the SAML
             realms in Elasticsearch. The realm is used to generate the authentication
@@ -4240,7 +4233,7 @@ async def saml_service_provider_metadata(
           This API generates Service Provider metadata based on the configuration of a SAML realm in Elasticsearch.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-saml-service-provider-metadata>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-saml-service-provider-metadata>`_
 
         :param realm_name: The name of the SAML realm in Elasticsearch.
         """
@@ -4293,7 +4286,7 @@ async def suggest_user_profiles(
           Elastic reserves the right to change or remove this feature in future releases without prior notice.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-suggest-user-profiles>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-suggest-user-profiles>`_
 
         :param data: A comma-separated list of filters for the `data` field of the profile
             document. To return all content use `data=*`. To return a subset of content,
@@ -4380,7 +4373,7 @@ async def update_api_key(
           This change can occur if the owner user's permissions have changed since the API key was created or last modified.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-update-api-key>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-update-api-key>`_
 
         :param id: The ID of the API key to update.
         :param expiration: The expiration time for the API key. By default, API keys
@@ -4466,9 +4459,10 @@ async def update_cross_cluster_api_key(
           <p>This API supports updates to an API key's access scope, metadata, and expiration.
           The owner user's information, such as the <code>username</code> and <code>realm</code>, is also updated automatically on every call.</p>
           <p>NOTE: This API cannot update REST API keys, which should be updated by either the update API key or bulk update API keys API.</p>
+          <p>To learn more about how to use this API, refer to the <a href="https://www.elastic.co/docs/reference/elasticsearch/rest-apis/update-cc-api-key-examples">Update cross cluter API key API examples page</a>.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-update-cross-cluster-api-key>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-update-cross-cluster-api-key>`_
 
         :param id: The ID of the cross-cluster API key to update.
         :param access: The access to be granted to this API key. The access is composed
@@ -4547,7 +4541,7 @@ async def update_settings(
           This API does not yet support configuring the settings for indices before they are in use.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-update-settings>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-update-settings>`_
 
         :param master_timeout: The period to wait for a connection to the master node.
             If no response is received before the timeout expires, the request fails
@@ -4632,7 +4626,7 @@ async def update_user_profile_data(
           The <code>update_profile_data</code> global privilege grants privileges for updating only the allowed namespaces.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-update-user-profile-data>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-update-user-profile-data>`_
 
         :param uid: A unique identifier for the user profile.
         :param data: Non-searchable data that you want to associate with the user profile.
diff --git a/elasticsearch/_async/client/shutdown.py b/elasticsearch/_async/client/shutdown.py
index 5dbc33e92..fce85995d 100644
--- a/elasticsearch/_async/client/shutdown.py
+++ b/elasticsearch/_async/client/shutdown.py
@@ -53,7 +53,7 @@ async def delete_node(
           <p>If the operator privileges feature is enabled, you must be an operator to use this API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-shutdown-delete-node>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-shutdown-delete-node>`_
 
         :param node_id: The node id of node to be removed from the shutdown state
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -112,7 +112,7 @@ async def get_node(
           <p>If the operator privileges feature is enabled, you must be an operator to use this API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-shutdown-get-node>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-shutdown-get-node>`_
 
         :param node_id: Which node for which to retrieve the shutdown status
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -187,7 +187,7 @@ async def put_node(
           Monitor the node shutdown status to determine when it is safe to stop Elasticsearch.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-shutdown-put-node>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-shutdown-put-node>`_
 
         :param node_id: The node identifier. This parameter is not validated against
             the cluster's active nodes. This enables you to register a node for shut
diff --git a/elasticsearch/_async/client/simulate.py b/elasticsearch/_async/client/simulate.py
index 3c3d33288..d3c13f311 100644
--- a/elasticsearch/_async/client/simulate.py
+++ b/elasticsearch/_async/client/simulate.py
@@ -35,7 +35,7 @@ class SimulateClient(NamespacedClient):
         body_fields=(
             "docs",
             "component_template_substitutions",
-            "index_template_subtitutions",
+            "index_template_substitutions",
             "mapping_addition",
             "pipeline_substitutions",
         ),
@@ -52,7 +52,7 @@ async def ingest(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         human: t.Optional[bool] = None,
-        index_template_subtitutions: t.Optional[
+        index_template_substitutions: t.Optional[
             t.Mapping[str, t.Mapping[str, t.Any]]
         ] = None,
         mapping_addition: t.Optional[t.Mapping[str, t.Any]] = None,
@@ -81,7 +81,7 @@ async def ingest(
           These will be used in place of the pipeline definitions that are already in the system. This can be used to replace existing pipeline definitions or to create new ones. The pipeline substitutions are used only within this request.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-simulate-ingest>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-simulate-ingest>`_
 
         :param docs: Sample documents to test in the pipeline.
         :param index: The index to simulate ingesting into. This value can be overridden
@@ -90,7 +90,7 @@ async def ingest(
             an index argument.
         :param component_template_substitutions: A map of component template names to
             substitute component template definition objects.
-        :param index_template_subtitutions: A map of index template names to substitute
+        :param index_template_substitutions: A map of index template names to substitute
             index template definition objects.
         :param mapping_addition:
         :param pipeline: The pipeline to use as the default pipeline. This value can
@@ -127,8 +127,8 @@ async def ingest(
                 __body["component_template_substitutions"] = (
                     component_template_substitutions
                 )
-            if index_template_subtitutions is not None:
-                __body["index_template_subtitutions"] = index_template_subtitutions
+            if index_template_substitutions is not None:
+                __body["index_template_substitutions"] = index_template_substitutions
             if mapping_addition is not None:
                 __body["mapping_addition"] = mapping_addition
             if pipeline_substitutions is not None:
diff --git a/elasticsearch/_async/client/slm.py b/elasticsearch/_async/client/slm.py
index 3eaafd865..aefc3f4fa 100644
--- a/elasticsearch/_async/client/slm.py
+++ b/elasticsearch/_async/client/slm.py
@@ -45,7 +45,7 @@ async def delete_lifecycle(
           This operation prevents any future snapshots from being taken but does not cancel in-progress snapshots or remove previously-taken snapshots.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-slm-delete-lifecycle>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-slm-delete-lifecycle>`_
 
         :param policy_id: The id of the snapshot lifecycle policy to remove
         :param master_timeout: The period to wait for a connection to the master node.
@@ -101,7 +101,7 @@ async def execute_lifecycle(
           The snapshot policy is normally applied according to its schedule, but you might want to manually run a policy before performing an upgrade or other maintenance.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-slm-execute-lifecycle>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-slm-execute-lifecycle>`_
 
         :param policy_id: The id of the snapshot lifecycle policy to be executed
         :param master_timeout: The period to wait for a connection to the master node.
@@ -156,7 +156,7 @@ async def execute_retention(
           The retention policy is normally applied according to its schedule.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-slm-execute-retention>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-slm-execute-retention>`_
 
         :param master_timeout: The period to wait for a connection to the master node.
             If no response is received before the timeout expires, the request fails
@@ -208,7 +208,7 @@ async def get_lifecycle(
           Get snapshot lifecycle policy definitions and information about the latest snapshot attempts.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-slm-get-lifecycle>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-slm-get-lifecycle>`_
 
         :param policy_id: Comma-separated list of snapshot lifecycle policies to retrieve
         :param master_timeout: The period to wait for a connection to the master node.
@@ -265,7 +265,7 @@ async def get_stats(
           Get global and policy-level statistics about actions taken by snapshot lifecycle management.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-slm-get-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-slm-get-stats>`_
 
         :param master_timeout: Period to wait for a connection to the master node. If
             no response is received before the timeout expires, the request fails and
@@ -315,7 +315,7 @@ async def get_status(
           <p>Get the snapshot lifecycle management status.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-slm-get-status>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-slm-get-status>`_
 
         :param master_timeout: The period to wait for a connection to the master node.
             If no response is received before the timeout expires, the request fails
@@ -379,7 +379,7 @@ async def put_lifecycle(
           Only the latest version of a policy is stored.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-slm-put-lifecycle>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-slm-put-lifecycle>`_
 
         :param policy_id: The identifier for the snapshot lifecycle policy you want to
             create or update.
@@ -465,7 +465,7 @@ async def start(
           Manually starting SLM is necessary only if it has been stopped using the stop SLM API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-slm-start>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-slm-start>`_
 
         :param master_timeout: The period to wait for a connection to the master node.
             If no response is received before the timeout expires, the request fails
@@ -523,7 +523,7 @@ async def stop(
           Use the get snapshot lifecycle management status API to see if SLM is running.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-slm-stop>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-slm-stop>`_
 
         :param master_timeout: The period to wait for a connection to the master node.
             If no response is received before the timeout expires, the request fails
diff --git a/elasticsearch/_async/client/snapshot.py b/elasticsearch/_async/client/snapshot.py
index 9c1f993c4..02abc5ad6 100644
--- a/elasticsearch/_async/client/snapshot.py
+++ b/elasticsearch/_async/client/snapshot.py
@@ -50,7 +50,7 @@ async def cleanup_repository(
           Trigger the review of the contents of a snapshot repository and delete any stale data not referenced by existing snapshots.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-snapshot-cleanup-repository>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-snapshot-cleanup-repository>`_
 
         :param name: The name of the snapshot repository to clean up.
         :param master_timeout: The period to wait for a connection to the master node.
@@ -105,7 +105,6 @@ async def clone(
         human: t.Optional[bool] = None,
         master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
-        timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         body: t.Optional[t.Dict[str, t.Any]] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
@@ -115,7 +114,7 @@ async def clone(
           Clone part of all of a snapshot into another snapshot in the same repository.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-snapshot-clone>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-snapshot-clone>`_
 
         :param repository: The name of the snapshot repository that both source and target
             snapshot belong to.
@@ -126,8 +125,6 @@ async def clone(
         :param master_timeout: The period to wait for the master node. If the master
             node is not available before the timeout expires, the request fails and returns
             an error. To indicate that the request should never timeout, set it to `-1`.
-        :param timeout: The period of time to wait for a response. If no response is
-            received before the timeout expires, the request fails and returns an error.
         """
         if repository in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'repository'")
@@ -155,8 +152,6 @@ async def clone(
             __query["master_timeout"] = master_timeout
         if pretty is not None:
             __query["pretty"] = pretty
-        if timeout is not None:
-            __query["timeout"] = timeout
         if not __body:
             if indices is not None:
                 __body["indices"] = indices
@@ -216,7 +211,7 @@ async def create(
           Take a snapshot of a cluster or of data streams and indices.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-snapshot-create>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-snapshot-create>`_
 
         :param repository: The name of the repository for the snapshot.
         :param snapshot: The name of the snapshot. It supportes date math. It must be
@@ -343,7 +338,7 @@ async def create_repository(
           If both parameters are specified, only the query parameter is used.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-snapshot-create-repository>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-snapshot-create-repository>`_
 
         :param name: The name of the snapshot repository to register or update.
         :param repository:
@@ -408,6 +403,7 @@ async def delete(
         human: t.Optional[bool] = None,
         master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
+        wait_for_completion: t.Optional[bool] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
         .. raw:: html
@@ -415,7 +411,7 @@ async def delete(
           <p>Delete snapshots.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-snapshot-delete>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-snapshot-delete>`_
 
         :param repository: The name of the repository to delete a snapshot from.
         :param snapshot: A comma-separated list of snapshot names to delete. It also
@@ -423,6 +419,9 @@ async def delete(
         :param master_timeout: The period to wait for the master node. If the master
             node is not available before the timeout expires, the request fails and returns
             an error. To indicate that the request should never timeout, set it to `-1`.
+        :param wait_for_completion: If `true`, the request returns a response when the
+            matching snapshots are all deleted. If `false`, the request returns a response
+            as soon as the deletes are scheduled.
         """
         if repository in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'repository'")
@@ -444,6 +443,8 @@ async def delete(
             __query["master_timeout"] = master_timeout
         if pretty is not None:
             __query["pretty"] = pretty
+        if wait_for_completion is not None:
+            __query["wait_for_completion"] = wait_for_completion
         __headers = {"accept": "application/json"}
         return await self.perform_request(  # type: ignore[return-value]
             "DELETE",
@@ -474,7 +475,7 @@ async def delete_repository(
           The snapshots themselves are left untouched and in place.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-snapshot-delete-repository>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-snapshot-delete-repository>`_
 
         :param name: The ame of the snapshot repositories to unregister. Wildcard (`*`)
             patterns are supported.
@@ -560,7 +561,7 @@ async def get(
           Snapshots concurrently created may be seen during an iteration.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-snapshot-get>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-snapshot-get>`_
 
         :param repository: A comma-separated list of snapshot repository names used to
             limit the request. Wildcard (`*`) expressions are supported.
@@ -686,7 +687,7 @@ async def get_repository(
           <p>Get snapshot repository information.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-snapshot-get-repository>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-snapshot-get-repository>`_
 
         :param name: A comma-separated list of snapshot repository names used to limit
             the request. Wildcard (`*`) expressions are supported including combining
@@ -830,7 +831,7 @@ async def repository_analyze(
           Some operations also verify the behavior on small blobs with sizes other than 8 bytes.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-snapshot-repository-analyze>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-snapshot-repository-analyze>`_
 
         :param name: The name of the repository.
         :param blob_count: The total number of blobs to write to the repository during
@@ -963,7 +964,7 @@ async def repository_verify_integrity(
           The response body format is therefore not considered stable and may be different in newer versions.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-snapshot-repository-verify-integrity>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-snapshot-repository-verify-integrity>`_
 
         :param name: The name of the snapshot repository.
         :param blob_thread_pool_concurrency: If `verify_blob_contents` is `true`, this
@@ -1085,7 +1086,7 @@ async def restore(
           <p>If your snapshot contains data from App Search or Workplace Search, you must restore the Enterprise Search encryption key before you restore the snapshot.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-snapshot-restore>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-snapshot-restore>`_
 
         :param repository: The name of the repository to restore a snapshot from.
         :param snapshot: The name of the snapshot to restore.
@@ -1235,7 +1236,7 @@ async def status(
           These requests can also tax machine resources and, when using cloud storage, incur high processing costs.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-snapshot-status>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-snapshot-status>`_
 
         :param repository: The snapshot repository name used to limit the request. It
             supports wildcards (`*`) if `<snapshot>` isn't specified.
@@ -1303,7 +1304,7 @@ async def verify_repository(
           Check for common misconfigurations in a snapshot repository.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-snapshot-verify-repository>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-snapshot-verify-repository>`_
 
         :param name: The name of the snapshot repository to verify.
         :param master_timeout: The period to wait for the master node. If the master
diff --git a/elasticsearch/_async/client/sql.py b/elasticsearch/_async/client/sql.py
index 3eb37a6cc..5cc1b552f 100644
--- a/elasticsearch/_async/client/sql.py
+++ b/elasticsearch/_async/client/sql.py
@@ -44,7 +44,7 @@ async def clear_cursor(
           <p>Clear an SQL search cursor.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-sql-clear-cursor>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-sql-clear-cursor>`_
 
         :param cursor: Cursor to clear.
         """
@@ -99,7 +99,7 @@ async def delete_async(
           </ul>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-sql-delete-async>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-sql-delete-async>`_
 
         :param id: The identifier for the search.
         """
@@ -150,7 +150,7 @@ async def get_async(
           <p>If the Elasticsearch security features are enabled, only the user who first submitted the SQL search can retrieve the search using this API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-sql-get-async>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-sql-get-async>`_
 
         :param id: The identifier for the search.
         :param delimiter: The separator for CSV results. The API supports this parameter
@@ -212,7 +212,7 @@ async def get_async_status(
           Get the current status of an async SQL search or a stored synchronous SQL search.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-sql-get-async-status>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-sql-get-async-status>`_
 
         :param id: The identifier for the search.
         """
@@ -283,7 +283,7 @@ async def query(
         keep_alive: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         keep_on_completion: t.Optional[bool] = None,
         page_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
-        params: t.Optional[t.Mapping[str, t.Any]] = None,
+        params: t.Optional[t.Sequence[t.Any]] = None,
         pretty: t.Optional[bool] = None,
         query: t.Optional[str] = None,
         request_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
@@ -301,7 +301,7 @@ async def query(
           Run an SQL request.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-sql-query>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-sql-query>`_
 
         :param allow_partial_search_results: If `true`, the response has partial results
             when there are shard request timeouts or shard failures. If `false`, the
@@ -427,7 +427,7 @@ async def translate(
           It accepts the same request body parameters as the SQL search API, excluding <code>cursor</code>.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-sql-translate>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-sql-translate>`_
 
         :param query: The SQL query to run.
         :param fetch_size: The maximum number of rows (or entries) to return in one response.
diff --git a/elasticsearch/_async/client/ssl.py b/elasticsearch/_async/client/ssl.py
index 468c7b93c..8d5e68258 100644
--- a/elasticsearch/_async/client/ssl.py
+++ b/elasticsearch/_async/client/ssl.py
@@ -52,7 +52,7 @@ async def certificates(
           <p>If Elasticsearch is configured to use a keystore or truststore, the API output includes all certificates in that store, even though some of the certificates might not be in active use within the cluster.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ssl-certificates>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ssl-certificates>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_ssl/certificates"
diff --git a/elasticsearch/_async/client/synonyms.py b/elasticsearch/_async/client/synonyms.py
index 26b248a35..b1dbdb719 100644
--- a/elasticsearch/_async/client/synonyms.py
+++ b/elasticsearch/_async/client/synonyms.py
@@ -53,7 +53,7 @@ async def delete_synonym(
           When the synonyms set is not used in analyzers, you will be able to delete it.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-synonyms-delete-synonym>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-synonyms-delete-synonym>`_
 
         :param id: The synonyms set identifier to delete.
         """
@@ -98,7 +98,7 @@ async def delete_synonym_rule(
           Delete a synonym rule from a synonym set.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-synonyms-delete-synonym-rule>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-synonyms-delete-synonym-rule>`_
 
         :param set_id: The ID of the synonym set to update.
         :param rule_id: The ID of the synonym rule to delete.
@@ -151,7 +151,7 @@ async def get_synonym(
           <p>Get a synonym set.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-synonyms-get-synonym>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-synonyms-get-synonym>`_
 
         :param id: The synonyms set identifier to retrieve.
         :param from_: The starting offset for query rules to retrieve.
@@ -202,7 +202,7 @@ async def get_synonym_rule(
           Get a synonym rule from a synonym set.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-synonyms-get-synonym-rule>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-synonyms-get-synonym-rule>`_
 
         :param set_id: The ID of the synonym set to retrieve the synonym rule from.
         :param rule_id: The ID of the synonym rule to retrieve.
@@ -255,7 +255,7 @@ async def get_synonyms_sets(
           Get a summary of all defined synonym sets.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-synonyms-get-synonym>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-synonyms-get-synonym>`_
 
         :param from_: The starting offset for synonyms sets to retrieve.
         :param size: The maximum number of synonyms sets to retrieve.
@@ -309,9 +309,10 @@ async def put_synonym(
           If you need to manage more synonym rules, you can create multiple synonym sets.</p>
           <p>When an existing synonyms set is updated, the search analyzers that use the synonyms set are reloaded automatically for all indices.
           This is equivalent to invoking the reload search analyzers API for all indices that use the synonyms set.</p>
+          <p>For practical examples of how to create or update a synonyms set, refer to the External documentation.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-synonyms-put-synonym>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-synonyms-put-synonym>`_
 
         :param id: The ID of the synonyms set to be created or updated.
         :param synonyms_set: The synonym rules definitions for the synonyms set.
@@ -370,7 +371,7 @@ async def put_synonym_rule(
           <p>When you update a synonym rule, all analyzers using the synonyms set will be reloaded automatically to reflect the new rule.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-synonyms-put-synonym-rule>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-synonyms-put-synonym-rule>`_
 
         :param set_id: The ID of the synonym set.
         :param rule_id: The ID of the synonym rule to be updated or created.
diff --git a/elasticsearch/_async/client/tasks.py b/elasticsearch/_async/client/tasks.py
index e03f0d363..629d68129 100644
--- a/elasticsearch/_async/client/tasks.py
+++ b/elasticsearch/_async/client/tasks.py
@@ -60,7 +60,7 @@ async def cancel(
           You can also use the node hot threads API to obtain detailed information about the work the system is doing instead of completing the cancelled task.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/group/endpoint-tasks>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/group/endpoint-tasks>`_
 
         :param task_id: The task identifier.
         :param actions: A comma-separated list or wildcard expression of actions that
@@ -128,7 +128,7 @@ async def get(
           <p>If the task identifier is not found, a 404 response code indicates that there are no resources that match the request.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/group/endpoint-tasks>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/group/endpoint-tasks>`_
 
         :param task_id: The task identifier.
         :param timeout: The period to wait for a response. If no response is received
@@ -238,7 +238,7 @@ async def list(
           The <code>X-Opaque-Id</code> in the children <code>headers</code> is the child task of the task that was initiated by the REST request.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/group/endpoint-tasks>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/group/endpoint-tasks>`_
 
         :param actions: A comma-separated list or wildcard expression of actions used
             to limit the request. For example, you can use `cluser:*` to retrieve all
diff --git a/elasticsearch/_async/client/text_structure.py b/elasticsearch/_async/client/text_structure.py
index 6307f20bb..08b29d2b8 100644
--- a/elasticsearch/_async/client/text_structure.py
+++ b/elasticsearch/_async/client/text_structure.py
@@ -72,7 +72,7 @@ async def find_field_structure(
           It helps determine why the returned structure was chosen.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/group/endpoint-text_structure>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/group/endpoint-text_structure>`_
 
         :param field: The field that should be analyzed.
         :param index: The name of the index that contains the analyzed field.
@@ -259,7 +259,7 @@ async def find_message_structure(
           It helps determine why the returned structure was chosen.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-text-structure-find-message-structure>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-text-structure-find-message-structure>`_
 
         :param messages: The list of messages you want to analyze.
         :param column_names: If the format is `delimited`, you can specify the column
@@ -433,7 +433,7 @@ async def find_structure(
           However, you can optionally override some of the decisions about the text structure by specifying one or more query parameters.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-text-structure-find-structure>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-text-structure-find-structure>`_
 
         :param text_files:
         :param charset: The text's character set. It must be a character set that is
@@ -620,7 +620,7 @@ async def test_grok_pattern(
           The API indicates whether the lines match the pattern together with the offsets and lengths of the matched substrings.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-text-structure-test-grok-pattern>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-text-structure-test-grok-pattern>`_
 
         :param grok_pattern: The Grok pattern to run on the text.
         :param text: The lines of text to run the Grok pattern on.
diff --git a/elasticsearch/_async/client/transform.py b/elasticsearch/_async/client/transform.py
index 191c959d3..0f0fc8938 100644
--- a/elasticsearch/_async/client/transform.py
+++ b/elasticsearch/_async/client/transform.py
@@ -44,7 +44,7 @@ async def delete_transform(
           <p>Delete a transform.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-transform-delete-transform>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-transform-delete-transform>`_
 
         :param transform_id: Identifier for the transform.
         :param delete_dest_index: If this value is true, the destination index is deleted
@@ -108,7 +108,7 @@ async def get_transform(
           Get configuration information for transforms.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-transform-get-transform>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-transform-get-transform>`_
 
         :param transform_id: Identifier for the transform. It can be a transform identifier
             or a wildcard expression. You can get information for all transforms by using
@@ -181,7 +181,7 @@ async def get_transform_stats(
           <p>Get usage information for transforms.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-transform-get-transform-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-transform-get-transform-stats>`_
 
         :param transform_id: Identifier for the transform. It can be a transform identifier
             or a wildcard expression. You can get information for all transforms by using
@@ -269,7 +269,7 @@ async def preview_transform(
           types of the source index and the transform aggregations.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-transform-preview-transform>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-transform-preview-transform>`_
 
         :param transform_id: Identifier for the transform to preview. If you specify
             this path parameter, you cannot provide transform configuration details in
@@ -406,7 +406,7 @@ async def put_transform(
           give users any privileges on <code>.data-frame-internal*</code> indices.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-transform-put-transform>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-transform-put-transform>`_
 
         :param transform_id: Identifier for the transform. This identifier can contain
             lowercase alphanumeric characters (a-z and 0-9), hyphens, and underscores.
@@ -512,7 +512,7 @@ async def reset_transform(
           If the destination index was created by the transform, it is deleted.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-transform-reset-transform>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-transform-reset-transform>`_
 
         :param transform_id: Identifier for the transform. This identifier can contain
             lowercase alphanumeric characters (a-z and 0-9), hyphens, and underscores.
@@ -572,7 +572,7 @@ async def schedule_now_transform(
           is called again in the meantime.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-transform-schedule-now-transform>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-transform-schedule-now-transform>`_
 
         :param transform_id: Identifier for the transform.
         :param timeout: Controls the time to wait for the scheduling to take place
@@ -602,6 +602,66 @@ async def schedule_now_transform(
             path_parts=__path_parts,
         )
 
+    @_rewrite_parameters()
+    async def set_upgrade_mode(
+        self,
+        *,
+        enabled: t.Optional[bool] = None,
+        error_trace: t.Optional[bool] = None,
+        filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        human: t.Optional[bool] = None,
+        pretty: t.Optional[bool] = None,
+        timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
+    ) -> ObjectApiResponse[t.Any]:
+        """
+        .. raw:: html
+
+          <p>Set upgrade_mode for transform indices.
+          Sets a cluster wide upgrade_mode setting that prepares transform
+          indices for an upgrade.
+          When upgrading your cluster, in some circumstances you must restart your
+          nodes and reindex your transform indices. In those circumstances,
+          there must be no transforms running. You can close the transforms,
+          do the upgrade, then open all the transforms again. Alternatively,
+          you can use this API to temporarily halt tasks associated with the transforms
+          and prevent new transforms from opening. You can also use this API
+          during upgrades that do not require you to reindex your transform
+          indices, though stopping transforms is not a requirement in that case.
+          You can see the current value for the upgrade_mode setting by using the get
+          transform info API.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-transform-set-upgrade-mode>`_
+
+        :param enabled: When `true`, it enables `upgrade_mode` which temporarily halts
+            all transform tasks and prohibits new transform tasks from starting.
+        :param timeout: The time to wait for the request to be completed.
+        """
+        __path_parts: t.Dict[str, str] = {}
+        __path = "/_transform/set_upgrade_mode"
+        __query: t.Dict[str, t.Any] = {}
+        if enabled is not None:
+            __query["enabled"] = enabled
+        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
+        __headers = {"accept": "application/json"}
+        return await self.perform_request(  # type: ignore[return-value]
+            "POST",
+            __path,
+            params=__query,
+            headers=__headers,
+            endpoint_id="transform.set_upgrade_mode",
+            path_parts=__path_parts,
+        )
+
     @_rewrite_parameters(
         parameter_aliases={"from": "from_"},
     )
@@ -635,7 +695,7 @@ async def start_transform(
           destination indices, the transform fails when it attempts unauthorized operations.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-transform-start-transform>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-transform-start-transform>`_
 
         :param transform_id: Identifier for the transform.
         :param from_: Restricts the set of transformed entities to those changed after
@@ -693,7 +753,7 @@ async def stop_transform(
           Stops one or more transforms.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-transform-stop-transform>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-transform-stop-transform>`_
 
         :param transform_id: Identifier for the transform. To stop multiple transforms,
             use a comma-separated list or a wildcard expression. To stop all transforms,
@@ -795,7 +855,7 @@ async def update_transform(
           time of update and runs with those privileges.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-transform-update-transform>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-transform-update-transform>`_
 
         :param transform_id: Identifier for the transform.
         :param defer_validation: When true, deferrable validations are not run. This
@@ -890,7 +950,7 @@ async def upgrade_transforms(
           You may want to perform a recent cluster backup prior to the upgrade.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-transform-upgrade-transforms>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-transform-upgrade-transforms>`_
 
         :param dry_run: When true, the request checks for updates but does not run them.
         :param timeout: Period to wait for a response. If no response is received before
diff --git a/elasticsearch/_async/client/watcher.py b/elasticsearch/_async/client/watcher.py
index d51776c45..92c1aedc6 100644
--- a/elasticsearch/_async/client/watcher.py
+++ b/elasticsearch/_async/client/watcher.py
@@ -45,10 +45,11 @@ async def ack_watch(
           <p>IMPORTANT: If the specified watch is currently being executed, this API will return an error
           The reason for this behavior is to prevent overwriting the watch status from a watch execution.</p>
           <p>Acknowledging an action throttles further executions of that action until its <code>ack.state</code> is reset to <code>awaits_successful_execution</code>.
-          This happens when the condition of the watch is not met (the condition evaluates to false).</p>
+          This happens when the condition of the watch is not met (the condition evaluates to false).
+          To demonstrate how throttling works in practice and how it can be configured for individual actions within a watch, refer to External documentation.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-ack-watch>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-watcher-ack-watch>`_
 
         :param watch_id: The watch identifier.
         :param action_id: A comma-separated list of the action identifiers to acknowledge.
@@ -104,7 +105,7 @@ async def activate_watch(
           A watch can be either active or inactive.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-activate-watch>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-watcher-activate-watch>`_
 
         :param watch_id: The watch identifier.
         """
@@ -148,7 +149,7 @@ async def deactivate_watch(
           A watch can be either active or inactive.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-deactivate-watch>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-watcher-deactivate-watch>`_
 
         :param watch_id: The watch identifier.
         """
@@ -196,7 +197,7 @@ async def delete_watch(
           When Elasticsearch security features are enabled, make sure no write privileges are granted to anyone for the <code>.watches</code> index.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-delete-watch>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-watcher-delete-watch>`_
 
         :param id: The watch identifier.
         """
@@ -274,10 +275,11 @@ async def execute_watch(
           This serves as great tool for testing and debugging your watches prior to adding them to Watcher.</p>
           <p>When Elasticsearch security features are enabled on your cluster, watches are run with the privileges of the user that stored the watches.
           If your user is allowed to read index <code>a</code>, but not index <code>b</code>, then the exact same set of rules will apply during execution of a watch.</p>
-          <p>When using the run watch API, the authorization data of the user that called the API will be used as a base, instead of the information who stored the watch.</p>
+          <p>When using the run watch API, the authorization data of the user that called the API will be used as a base, instead of the information who stored the watch.
+          Refer to the external documentation for examples of watch execution requests, including existing, customized, and inline watches.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-execute-watch>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-watcher-execute-watch>`_
 
         :param id: The watch identifier.
         :param action_modes: Determines how to handle the watch actions as part of the
@@ -365,7 +367,7 @@ async def get_settings(
           Only a subset of settings are shown, for example <code>index.auto_expand_replicas</code> and <code>index.number_of_replicas</code>.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-get-settings>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-watcher-get-settings>`_
 
         :param master_timeout: The period to wait for a connection to the master node.
             If no response is received before the timeout expires, the request fails
@@ -410,7 +412,7 @@ async def get_watch(
           <p>Get a watch.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-get-watch>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-watcher-get-watch>`_
 
         :param id: The watch identifier.
         """
@@ -485,7 +487,7 @@ async def put_watch(
           If the user is able to read index <code>a</code>, but not index <code>b</code>, the same will apply when the watch runs.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-put-watch>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-watcher-put-watch>`_
 
         :param id: The identifier for the watch.
         :param actions: The list of actions that will be run if the condition matches.
@@ -598,7 +600,7 @@ async def query_watches(
           <p>Note that only the <code>_id</code> and <code>metadata.*</code> fields are queryable or sortable.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-query-watches>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-watcher-query-watches>`_
 
         :param from_: The offset from the first result to fetch. It must be non-negative.
         :param query: A query that filters the watches to be returned.
@@ -673,7 +675,7 @@ async def start(
           Start the Watcher service if it is not already running.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-start>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-watcher-start>`_
 
         :param master_timeout: Period to wait for a connection to the master node.
         """
@@ -739,7 +741,7 @@ async def stats(
           You retrieve more metrics by using the metric parameter.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-watcher-stats>`_
 
         :param metric: Defines which additional metrics are included in the response.
         :param emit_stacktraces: Defines whether stack traces are generated for each
@@ -790,7 +792,7 @@ async def stop(
           Stop the Watcher service if it is running.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-stop>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-watcher-stop>`_
 
         :param master_timeout: The period to wait for the master node. If the master
             node is not available before the timeout expires, the request fails and returns
@@ -845,10 +847,13 @@ async def update_settings(
           <p>Update Watcher index settings.
           Update settings for the Watcher internal index (<code>.watches</code>).
           Only a subset of settings can be modified.
-          This includes <code>index.auto_expand_replicas</code> and <code>index.number_of_replicas</code>.</p>
+          This includes <code>index.auto_expand_replicas</code>, <code>index.number_of_replicas</code>, <code>index.routing.allocation.exclude.*</code>,
+          <code>index.routing.allocation.include.*</code> and <code>index.routing.allocation.require.*</code>.
+          Modification of <code>index.routing.allocation.include._tier_preference</code> is an exception and is not allowed as the
+          Watcher shards must always be in the <code>data_content</code> tier.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-update-settings>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-watcher-update-settings>`_
 
         :param index_auto_expand_replicas:
         :param index_number_of_replicas:
diff --git a/elasticsearch/_async/client/xpack.py b/elasticsearch/_async/client/xpack.py
index 710d36cb1..543e651ba 100644
--- a/elasticsearch/_async/client/xpack.py
+++ b/elasticsearch/_async/client/xpack.py
@@ -54,7 +54,7 @@ async def info(
           </ul>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-info>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-info>`_
 
         :param accept_enterprise: If this param is used it must be set to true
         :param categories: A comma-separated list of the information categories to include
@@ -103,7 +103,7 @@ async def usage(
           The API also provides some usage statistics.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/group/endpoint-xpack>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/group/endpoint-xpack>`_
 
         :param master_timeout: The period to wait for a connection to the master node.
             If no response is received before the timeout expires, the request fails
diff --git a/elasticsearch/_async/helpers.py b/elasticsearch/_async/helpers.py
index 4c53f0bbe..e4d5e6bc5 100644
--- a/elasticsearch/_async/helpers.py
+++ b/elasticsearch/_async/helpers.py
@@ -136,7 +136,6 @@ def aiter(x: Union[Iterable[T], AsyncIterable[T]]) -> AsyncIterator[T]:
         return x.__aiter__()
 
     async def f() -> AsyncIterable[T]:
-        nonlocal x
         ix: Iterable[T] = x
         for item in ix:
             yield item
diff --git a/elasticsearch/_sync/client/__init__.py b/elasticsearch/_sync/client/__init__.py
index 6d9131995..1b50c265a 100644
--- a/elasticsearch/_sync/client/__init__.py
+++ b/elasticsearch/_sync/client/__init__.py
@@ -18,7 +18,6 @@
 
 import logging
 import typing as t
-import warnings
 
 from elastic_transport import (
     BaseNode,
@@ -181,37 +180,13 @@ def __init__(
             t.Callable[[t.Dict[str, t.Any], NodeConfig], t.Optional[NodeConfig]]
         ] = None,
         meta_header: t.Union[DefaultType, bool] = DEFAULT,
-        timeout: t.Union[DefaultType, None, float] = DEFAULT,
-        randomize_hosts: t.Union[DefaultType, bool] = DEFAULT,
-        host_info_callback: t.Optional[
-            t.Callable[
-                [t.Dict[str, t.Any], t.Dict[str, t.Union[str, int]]],
-                t.Optional[t.Dict[str, t.Union[str, int]]],
-            ]
-        ] = None,
-        sniffer_timeout: t.Union[DefaultType, None, float] = DEFAULT,
-        sniff_on_connection_fail: t.Union[DefaultType, bool] = DEFAULT,
         http_auth: t.Union[DefaultType, t.Any] = DEFAULT,
-        maxsize: t.Union[DefaultType, int] = DEFAULT,
         # Internal use only
         _transport: t.Optional[Transport] = None,
     ) -> None:
         if hosts is None and cloud_id is None and _transport is None:
             raise ValueError("Either 'hosts' or 'cloud_id' must be specified")
 
-        if timeout is not DEFAULT:
-            if request_timeout is not DEFAULT:
-                raise ValueError(
-                    "Can't specify both 'timeout' and 'request_timeout', "
-                    "instead only specify 'request_timeout'"
-                )
-            warnings.warn(
-                "The 'timeout' parameter is deprecated in favor of 'request_timeout'",
-                category=DeprecationWarning,
-                stacklevel=2,
-            )
-            request_timeout = timeout
-
         if serializer is not None:
             if serializers is not DEFAULT:
                 raise ValueError(
@@ -220,58 +195,6 @@ def __init__(
                 )
             serializers = {default_mimetype: serializer}
 
-        if randomize_hosts is not DEFAULT:
-            if randomize_nodes_in_pool is not DEFAULT:
-                raise ValueError(
-                    "Can't specify both 'randomize_hosts' and 'randomize_nodes_in_pool', "
-                    "instead only specify 'randomize_nodes_in_pool'"
-                )
-            warnings.warn(
-                "The 'randomize_hosts' parameter is deprecated in favor of 'randomize_nodes_in_pool'",
-                category=DeprecationWarning,
-                stacklevel=2,
-            )
-            randomize_nodes_in_pool = randomize_hosts
-
-        if sniffer_timeout is not DEFAULT:
-            if min_delay_between_sniffing is not DEFAULT:
-                raise ValueError(
-                    "Can't specify both 'sniffer_timeout' and 'min_delay_between_sniffing', "
-                    "instead only specify 'min_delay_between_sniffing'"
-                )
-            warnings.warn(
-                "The 'sniffer_timeout' parameter is deprecated in favor of 'min_delay_between_sniffing'",
-                category=DeprecationWarning,
-                stacklevel=2,
-            )
-            min_delay_between_sniffing = sniffer_timeout
-
-        if sniff_on_connection_fail is not DEFAULT:
-            if sniff_on_node_failure is not DEFAULT:
-                raise ValueError(
-                    "Can't specify both 'sniff_on_connection_fail' and 'sniff_on_node_failure', "
-                    "instead only specify 'sniff_on_node_failure'"
-                )
-            warnings.warn(
-                "The 'sniff_on_connection_fail' parameter is deprecated in favor of 'sniff_on_node_failure'",
-                category=DeprecationWarning,
-                stacklevel=2,
-            )
-            sniff_on_node_failure = sniff_on_connection_fail
-
-        if maxsize is not DEFAULT:
-            if connections_per_node is not DEFAULT:
-                raise ValueError(
-                    "Can't specify both 'maxsize' and 'connections_per_node', "
-                    "instead only specify 'connections_per_node'"
-                )
-            warnings.warn(
-                "The 'maxsize' parameter is deprecated in favor of 'connections_per_node'",
-                category=DeprecationWarning,
-                stacklevel=2,
-            )
-            connections_per_node = maxsize
-
         # Setting min_delay_between_sniffing=True implies sniff_before_requests=True
         if min_delay_between_sniffing is not DEFAULT:
             sniff_before_requests = True
@@ -293,22 +216,7 @@ def __init__(
             )
 
         sniff_callback = None
-        if host_info_callback is not None:
-            if sniffed_node_callback is not None:
-                raise ValueError(
-                    "Can't specify both 'host_info_callback' and 'sniffed_node_callback', "
-                    "instead only specify 'sniffed_node_callback'"
-                )
-            warnings.warn(
-                "The 'host_info_callback' parameter is deprecated in favor of 'sniffed_node_callback'",
-                category=DeprecationWarning,
-                stacklevel=2,
-            )
-
-            sniff_callback = create_sniff_callback(
-                host_info_callback=host_info_callback
-            )
-        elif sniffed_node_callback is not None:
+        if sniffed_node_callback is not None:
             sniff_callback = create_sniff_callback(
                 sniffed_node_callback=sniffed_node_callback
             )
@@ -698,6 +606,7 @@ def bulk(
           <li>JavaScript: Check out <code>client.helpers.*</code></li>
           <li>.NET: Check out <code>BulkAllObservable</code></li>
           <li>PHP: Check out bulk indexing.</li>
+          <li>Ruby: Check out <code>Elasticsearch::Helpers::BulkHelper</code></li>
           </ul>
           <p><strong>Submitting bulk requests with cURL</strong></p>
           <p>If you're providing text file input to <code>curl</code>, you must use the <code>--data-binary</code> flag instead of plain <code>-d</code>.
@@ -727,9 +636,11 @@ def bulk(
           Imagine a <code>_bulk?refresh=wait_for</code> request with three documents in it that happen to be routed to different shards in an index with five shards.
           The request will only wait for those three shards to refresh.
           The other two shards that make up the index do not participate in the <code>_bulk</code> request at all.</p>
+          <p>You might want to disable the refresh interval temporarily to improve indexing throughput for large bulk requests.
+          Refer to the linked documentation for step-by-step instructions using the index settings API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-bulk>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-bulk>`_
 
         :param operations:
         :param index: The name of the data stream, index, or index alias to perform bulk
@@ -854,7 +765,7 @@ def clear_scroll(
           Clear the search context and results for a scrolling search.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-clear-scroll>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-clear-scroll>`_
 
         :param scroll_id: The scroll IDs to clear. To clear all scroll IDs, use `_all`.
         """
@@ -911,7 +822,7 @@ def close_point_in_time(
           However, keeping points in time has a cost; close them as soon as they are no longer required for search requests.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-open-point-in-time>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-open-point-in-time>`_
 
         :param id: The ID of the point-in-time.
         """
@@ -995,7 +906,7 @@ def count(
           This means that replicas increase the scalability of the count.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-count>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-count>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases to
             search. It supports wildcards (`*`). To search all data streams and indices,
@@ -1125,6 +1036,8 @@ def create(
         refresh: t.Optional[
             t.Union[bool, str, t.Literal["false", "true", "wait_for"]]
         ] = None,
+        require_alias: t.Optional[bool] = None,
+        require_data_stream: t.Optional[bool] = None,
         routing: t.Optional[str] = None,
         timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         version: t.Optional[int] = None,
@@ -1192,7 +1105,7 @@ def create(
           The <code>_shards</code> section of the API response reveals the number of shard copies on which replication succeeded and failed.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-create>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-create>`_
 
         :param index: The name of the data stream or index to target. If the target doesn't
             exist and matches the name or wildcard (`*`) pattern of an index template
@@ -1212,6 +1125,9 @@ def create(
         :param refresh: If `true`, Elasticsearch refreshes the affected shards to make
             this operation visible to search. If `wait_for`, it waits for a refresh to
             make this operation visible to search. If `false`, it does nothing with refreshes.
+        :param require_alias: If `true`, the destination must be an index alias.
+        :param require_data_stream: If `true`, the request's actions must target a data
+            stream (existing or to be created).
         :param routing: A custom value that is used to route operations to a specific
             shard.
         :param timeout: The period the request waits for the following operations: automatic
@@ -1260,6 +1176,10 @@ def create(
             __query["pretty"] = pretty
         if refresh is not None:
             __query["refresh"] = refresh
+        if require_alias is not None:
+            __query["require_alias"] = require_alias
+        if require_data_stream is not None:
+            __query["require_data_stream"] = require_data_stream
         if routing is not None:
             __query["routing"] = routing
         if timeout is not None:
@@ -1336,7 +1256,7 @@ def delete(
           It then gets redirected into the primary shard within that ID group and replicated (if needed) to shard replicas within that ID group.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-delete>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-delete>`_
 
         :param index: The name of the target index.
         :param id: A unique identifier for the document.
@@ -1405,7 +1325,7 @@ def delete(
         )
 
     @_rewrite_parameters(
-        body_fields=("max_docs", "query", "slice"),
+        body_fields=("max_docs", "query", "slice", "sort"),
         parameter_aliases={"from": "from_"},
     )
     def delete_by_query(
@@ -1449,7 +1369,12 @@ def delete_by_query(
         ] = None,
         slice: t.Optional[t.Mapping[str, t.Any]] = None,
         slices: t.Optional[t.Union[int, t.Union[str, t.Literal["auto"]]]] = None,
-        sort: t.Optional[t.Sequence[str]] = None,
+        sort: t.Optional[
+            t.Union[
+                t.Sequence[t.Union[str, t.Mapping[str, t.Any]]],
+                t.Union[str, t.Mapping[str, t.Any]],
+            ]
+        ] = None,
         stats: t.Optional[t.Sequence[str]] = None,
         terminate_after: t.Optional[int] = None,
         timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
@@ -1525,7 +1450,7 @@ def delete_by_query(
           The get task status API will continue to list the delete by query task until this task checks that it has been cancelled and terminates itself.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-delete-by-query>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-delete-by-query>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases to
             search. It supports wildcards (`*`). To search all data streams or indices,
@@ -1551,7 +1476,7 @@ def delete_by_query(
             If the request can target data streams, this argument determines whether
             wildcard expressions match hidden data streams. It supports comma-separated
             values, such as `open,hidden`.
-        :param from_: Starting offset (default: 0)
+        :param from_: Skips the specified number of documents.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
         :param lenient: If `true`, format-based query failures (such as providing text
@@ -1581,7 +1506,7 @@ def delete_by_query(
         :param slice: Slice the request manually using the provided slice ID and total
             number of slices.
         :param slices: The number of slices this task should be divided into.
-        :param sort: A comma-separated list of `<field>:<direction>` pairs.
+        :param sort: A sort object that specifies the order of deleted documents.
         :param stats: The specific `tag` of the request for logging and statistical purposes.
         :param terminate_after: The maximum number of documents to collect for each shard.
             If a query reaches this limit, Elasticsearch terminates the query early.
@@ -1671,8 +1596,6 @@ def delete_by_query(
             __query["search_type"] = search_type
         if slices is not None:
             __query["slices"] = slices
-        if sort is not None:
-            __query["sort"] = sort
         if stats is not None:
             __query["stats"] = stats
         if terminate_after is not None:
@@ -1692,6 +1615,8 @@ def delete_by_query(
                 __body["query"] = query
             if slice is not None:
                 __body["slice"] = slice
+            if sort is not None:
+                __body["sort"] = sort
         __headers = {"accept": "application/json", "content-type": "application/json"}
         return self.perform_request(  # type: ignore[return-value]
             "POST",
@@ -1722,7 +1647,7 @@ def delete_by_query_rethrottle(
           Rethrottling that speeds up the query takes effect immediately but rethrotting that slows down the query takes effect after completing the current batch to prevent scroll timeouts.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-delete-by-query-rethrottle>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-delete-by-query-rethrottle>`_
 
         :param task_id: The ID for the task.
         :param requests_per_second: The throttle for this request in sub-requests per
@@ -1772,7 +1697,7 @@ def delete_script(
           Deletes a stored script or search template.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-delete-script>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-delete-script>`_
 
         :param id: The identifier for the stored script or search template.
         :param master_timeout: The period to wait for a connection to the master node.
@@ -1856,7 +1781,7 @@ def exists(
           Elasticsearch cleans up deleted documents in the background as you continue to index more data.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-get>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-get>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases. It
             supports wildcards (`*`).
@@ -1979,7 +1904,7 @@ def exists_source(
           <p>A document's source is not available if it is disabled in the mapping.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-get>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-get>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases. It
             supports wildcards (`*`).
@@ -2085,7 +2010,7 @@ def explain(
           It computes a score explanation for a query and a specific document.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-explain>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-explain>`_
 
         :param index: Index names that are used to limit the request. Only a single index
             name can be provided to this parameter.
@@ -2220,7 +2145,7 @@ def field_caps(
           For example, a runtime field with a type of keyword is returned the same as any other field that belongs to the <code>keyword</code> family.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-field-caps>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-field-caps>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (*). To target all data streams
@@ -2381,12 +2306,12 @@ def get(
           Elasticsearch cleans up deleted documents in the background as you continue to index more data.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-get>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-get>`_
 
         :param index: The name of the index that contains the document.
         :param id: A unique document identifier.
         :param force_synthetic_source: Indicates whether the request forces synthetic
-            `_source`. Use this paramater to test if the mapping supports synthetic `_source`
+            `_source`. Use this parameter to test if the mapping supports synthetic `_source`
             and to get a sense of the worst case performance. Fetches with this parameter
             enabled will be slower than enabling synthetic source natively in the index.
         :param preference: The node or shard the operation should be performed on. By
@@ -2417,8 +2342,8 @@ def get(
         :param stored_fields: A comma-separated list of stored fields to return as part
             of a hit. If no fields are specified, no stored fields are included in the
             response. If this field is specified, the `_source` parameter defaults to
-            `false`. Only leaf fields can be retrieved with the `stored_field` option.
-            Object fields can't be returned;​if specified, the request fails.
+            `false`. Only leaf fields can be retrieved with the `stored_fields` option.
+            Object fields can't be returned; if specified, the request fails.
         :param version: The version number for concurrency control. It must match the
             current version of the document for the request to succeed.
         :param version_type: The version type.
@@ -2488,7 +2413,7 @@ def get_script(
           Retrieves a stored script or search template.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-get-script>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-get-script>`_
 
         :param id: The identifier for the stored script or search template.
         :param master_timeout: The period to wait for the master node. If the master
@@ -2537,7 +2462,7 @@ def get_script_context(
           <p>Get a list of supported script contexts and their methods.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-get-script-context>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-get-script-context>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_script_context"
@@ -2576,7 +2501,7 @@ def get_script_languages(
           <p>Get a list of available script types, languages, and contexts.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-get-script-languages>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-get-script-languages>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_script_language"
@@ -2622,7 +2547,6 @@ def get_source(
         source: t.Optional[t.Union[bool, t.Union[str, t.Sequence[str]]]] = None,
         source_excludes: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         source_includes: t.Optional[t.Union[str, t.Sequence[str]]] = None,
-        stored_fields: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         version: t.Optional[int] = None,
         version_type: t.Optional[
             t.Union[str, t.Literal["external", "external_gte", "force", "internal"]]
@@ -2641,7 +2565,7 @@ def get_source(
           </code></pre>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-get>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-get>`_
 
         :param index: The name of the index that contains the document.
         :param id: A unique document identifier.
@@ -2659,8 +2583,6 @@ def get_source(
             the response.
         :param source_includes: A comma-separated list of source fields to include in
             the response.
-        :param stored_fields: A comma-separated list of stored fields to return as part
-            of a hit.
         :param version: The version number for concurrency control. It must match the
             current version of the document for the request to succeed.
         :param version_type: The version type.
@@ -2694,8 +2616,6 @@ def get_source(
             __query["_source_excludes"] = source_excludes
         if source_includes is not None:
             __query["_source_includes"] = source_includes
-        if stored_fields is not None:
-            __query["stored_fields"] = stored_fields
         if version is not None:
             __query["version"] = version
         if version_type is not None:
@@ -2741,7 +2661,7 @@ def health_report(
           When setting up automated polling of the API for health status, set verbose to false to disable the more expensive analysis logic.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-health-report>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-health-report>`_
 
         :param feature: A feature of the cluster, as returned by the top-level health
             report API.
@@ -2804,6 +2724,7 @@ def index(
             t.Union[bool, str, t.Literal["false", "true", "wait_for"]]
         ] = None,
         require_alias: t.Optional[bool] = None,
+        require_data_stream: t.Optional[bool] = None,
         routing: t.Optional[str] = None,
         timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         version: t.Optional[int] = None,
@@ -2906,7 +2827,7 @@ def index(
           </code></pre>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-create>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-create>`_
 
         :param index: The name of the data stream or index to target. If the target doesn't
             exist and matches the name or wildcard (`*`) pattern of an index template
@@ -2939,6 +2860,8 @@ def index(
             this operation visible to search. If `wait_for`, it waits for a refresh to
             make this operation visible to search. If `false`, it does nothing with refreshes.
         :param require_alias: If `true`, the destination must be an index alias.
+        :param require_data_stream: If `true`, the request's actions must target a data
+            stream (existing or to be created).
         :param routing: A custom value that is used to route operations to a specific
             shard.
         :param timeout: The period the request waits for the following operations: automatic
@@ -3000,6 +2923,8 @@ def index(
             __query["refresh"] = refresh
         if require_alias is not None:
             __query["require_alias"] = require_alias
+        if require_data_stream is not None:
+            __query["require_data_stream"] = require_data_stream
         if routing is not None:
             __query["routing"] = routing
         if timeout is not None:
@@ -3035,10 +2960,11 @@ def info(
         .. raw:: html
 
           <p>Get cluster info.
-          Get basic build, version, and cluster information.</p>
+          Get basic build, version, and cluster information.
+          ::: In Serverless, this API is retained for backward compatibility only. Some response fields, such as the version number, should be ignored.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/group/endpoint-info>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/group/endpoint-info>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/"
@@ -3061,127 +2987,6 @@ def info(
             path_parts=__path_parts,
         )
 
-    @_rewrite_parameters(
-        body_fields=(
-            "knn",
-            "docvalue_fields",
-            "fields",
-            "filter",
-            "source",
-            "stored_fields",
-        ),
-        parameter_aliases={"_source": "source"},
-    )
-    @_stability_warning(Stability.EXPERIMENTAL)
-    def knn_search(
-        self,
-        *,
-        index: t.Union[str, t.Sequence[str]],
-        knn: t.Optional[t.Mapping[str, t.Any]] = None,
-        docvalue_fields: t.Optional[t.Sequence[t.Mapping[str, t.Any]]] = None,
-        error_trace: t.Optional[bool] = None,
-        fields: t.Optional[t.Union[str, t.Sequence[str]]] = None,
-        filter: t.Optional[
-            t.Union[t.Mapping[str, t.Any], t.Sequence[t.Mapping[str, t.Any]]]
-        ] = None,
-        filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
-        human: t.Optional[bool] = None,
-        pretty: t.Optional[bool] = None,
-        routing: t.Optional[str] = None,
-        source: t.Optional[t.Union[bool, t.Mapping[str, t.Any]]] = None,
-        stored_fields: t.Optional[t.Union[str, t.Sequence[str]]] = None,
-        body: t.Optional[t.Dict[str, t.Any]] = None,
-    ) -> ObjectApiResponse[t.Any]:
-        """
-        .. raw:: html
-
-          <p>Run a knn search.</p>
-          <p>NOTE: The kNN search API has been replaced by the <code>knn</code> option in the search API.</p>
-          <p>Perform a k-nearest neighbor (kNN) search on a dense_vector field and return the matching documents.
-          Given a query vector, the API finds the k closest vectors and returns those documents as search hits.</p>
-          <p>Elasticsearch uses the HNSW algorithm to support efficient kNN search.
-          Like most kNN algorithms, HNSW is an approximate method that sacrifices result accuracy for improved search speed.
-          This means the results returned are not always the true k closest neighbors.</p>
-          <p>The kNN search API supports restricting the search using a filter.
-          The search will return the top k documents that also match the filter query.</p>
-          <p>A kNN search response has the exact same structure as a search API response.
-          However, certain sections have a meaning specific to kNN search:</p>
-          <ul>
-          <li>The document <code>_score</code> is determined by the similarity between the query and document vector.</li>
-          <li>The <code>hits.total</code> object contains the total number of nearest neighbor candidates considered, which is <code>num_candidates * num_shards</code>. The <code>hits.total.relation</code> will always be <code>eq</code>, indicating an exact value.</li>
-          </ul>
-
-
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/knn-search-api.html>`_
-
-        :param index: A comma-separated list of index names to search; use `_all` or
-            to perform the operation on all indices.
-        :param knn: The kNN query to run.
-        :param docvalue_fields: The request returns doc values for field names matching
-            these patterns in the `hits.fields` property of the response. It accepts
-            wildcard (`*`) patterns.
-        :param fields: The request returns values for field names matching these patterns
-            in the `hits.fields` property of the response. It accepts wildcard (`*`)
-            patterns.
-        :param filter: A query to filter the documents that can match. The kNN search
-            will return the top `k` documents that also match this filter. The value
-            can be a single query or a list of queries. If `filter` isn't provided, all
-            documents are allowed to match.
-        :param routing: A comma-separated list of specific routing values.
-        :param source: Indicates which source fields are returned for matching documents.
-            These fields are returned in the `hits._source` property of the search response.
-        :param stored_fields: A list of stored fields to return as part of a hit. If
-            no fields are specified, no stored fields are included in the response. If
-            this field is specified, the `_source` parameter defaults to `false`. You
-            can pass `_source: true` to return both source fields and stored fields in
-            the search response.
-        """
-        if index in SKIP_IN_PATH:
-            raise ValueError("Empty value passed for parameter 'index'")
-        if knn is None and body is None:
-            raise ValueError("Empty value passed for parameter 'knn'")
-        __path_parts: t.Dict[str, str] = {"index": _quote(index)}
-        __path = f'/{__path_parts["index"]}/_knn_search'
-        __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 routing is not None:
-            __query["routing"] = routing
-        if not __body:
-            if knn is not None:
-                __body["knn"] = knn
-            if docvalue_fields is not None:
-                __body["docvalue_fields"] = docvalue_fields
-            if fields is not None:
-                __body["fields"] = fields
-            if filter is not None:
-                __body["filter"] = filter
-            if source is not None:
-                __body["_source"] = source
-            if stored_fields is not None:
-                __body["stored_fields"] = stored_fields
-        if not __body:
-            __body = None  # type: ignore[assignment]
-        __headers = {"accept": "application/json"}
-        if __body is not None:
-            __headers["content-type"] = "application/json"
-        return self.perform_request(  # type: ignore[return-value]
-            "POST",
-            __path,
-            params=__query,
-            headers=__headers,
-            body=__body,
-            endpoint_id="knn_search",
-            path_parts=__path_parts,
-        )
-
     @_rewrite_parameters(
         body_fields=("docs", "ids"),
         parameter_aliases={
@@ -3228,7 +3033,7 @@ def mget(
           You can include the <code>stored_fields</code> query parameter in the request URI to specify the defaults to use when there are no per-document instructions.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-mget>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-mget>`_
 
         :param index: Name of the index to retrieve documents from when `ids` are specified,
             or when a document in the `docs` array does not specify an index.
@@ -3363,7 +3168,7 @@ def msearch(
           When sending requests to this endpoint the <code>Content-Type</code> header should be set to <code>application/x-ndjson</code>.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-msearch>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-msearch>`_
 
         :param searches:
         :param index: Comma-separated list of data streams, indices, and index aliases
@@ -3390,7 +3195,8 @@ def msearch(
             computationally expensive named queries on a large number of hits may add
             significant overhead.
         :param max_concurrent_searches: Maximum number of concurrent searches the multi
-            search API can execute.
+            search API can execute. Defaults to `max(1, (# of data nodes * min(search
+            thread pool size, 10)))`.
         :param max_concurrent_shard_requests: Maximum number of concurrent shard requests
             that each sub-search request executes per node.
         :param pre_filter_shard_size: Defines a threshold that enforces a pre-filter
@@ -3509,7 +3315,7 @@ def msearch_template(
           </code></pre>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-msearch-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-msearch-template>`_
 
         :param search_templates:
         :param index: A comma-separated list of data streams, indices, and aliases to
@@ -3614,7 +3420,7 @@ def mtermvectors(
           The mapping used is determined by the specified <code>_index</code>.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-mtermvectors>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-mtermvectors>`_
 
         :param index: The name of the index that contains the documents.
         :param docs: An array of existing or artificial documents.
@@ -3718,6 +3524,7 @@ def open_point_in_time(
         human: t.Optional[bool] = None,
         ignore_unavailable: t.Optional[bool] = None,
         index_filter: t.Optional[t.Mapping[str, t.Any]] = None,
+        max_concurrent_shard_requests: t.Optional[int] = None,
         preference: t.Optional[str] = None,
         pretty: t.Optional[bool] = None,
         routing: t.Optional[str] = None,
@@ -3754,7 +3561,7 @@ def open_point_in_time(
           You can check how many point-in-times (that is, search contexts) are open with the nodes stats API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-open-point-in-time>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-open-point-in-time>`_
 
         :param index: A comma-separated list of index names to open point in time; use
             `_all` or empty string to perform the operation on all indices
@@ -3767,12 +3574,13 @@ def open_point_in_time(
         :param expand_wildcards: The type of index that wildcard patterns can match.
             If the request can target data streams, this argument determines whether
             wildcard expressions match hidden data streams. It supports comma-separated
-            values, such as `open,hidden`. Valid values are: `all`, `open`, `closed`,
-            `hidden`, `none`.
+            values, such as `open,hidden`.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
         :param index_filter: Filter indices if the provided query rewrites to `match_none`
             on every shard.
+        :param max_concurrent_shard_requests: Maximum number of concurrent shard requests
+            that each sub-search request executes per node.
         :param preference: The node or shard the operation should be performed on. By
             default, it is random.
         :param routing: A custom value that is used to route operations to a specific
@@ -3800,6 +3608,8 @@ def open_point_in_time(
             __query["human"] = human
         if ignore_unavailable is not None:
             __query["ignore_unavailable"] = ignore_unavailable
+        if max_concurrent_shard_requests is not None:
+            __query["max_concurrent_shard_requests"] = max_concurrent_shard_requests
         if preference is not None:
             __query["preference"] = preference
         if pretty is not None:
@@ -3848,7 +3658,7 @@ def put_script(
           Creates or updates a stored script or search template.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-put-script>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-put-script>`_
 
         :param id: The identifier for the stored script or search template. It must be
             unique within the cluster.
@@ -3938,7 +3748,7 @@ def rank_eval(
           <p>Evaluate the quality of ranked search results over a set of typical search queries.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-rank-eval>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-rank-eval>`_
 
         :param requests: A set of typical search requests, together with their provided
             ratings.
@@ -4064,113 +3874,17 @@ def reindex(
           In this case, the response includes a count of the version conflicts that were encountered.
           Note that the handling of other error types is unaffected by the <code>conflicts</code> property.
           Additionally, if you opt to count version conflicts, the operation could attempt to reindex more documents from the source than <code>max_docs</code> until it has successfully indexed <code>max_docs</code> documents into the target or it has gone through every document in the source query.</p>
-          <p>NOTE: The reindex API makes no effort to handle ID collisions.
-          The last document written will &quot;win&quot; but the order isn't usually predictable so it is not a good idea to rely on this behavior.
-          Instead, make sure that IDs are unique by using a script.</p>
-          <p><strong>Running reindex asynchronously</strong></p>
-          <p>If the request contains <code>wait_for_completion=false</code>, Elasticsearch performs some preflight checks, launches the request, and returns a task you can use to cancel or get the status of the task.
-          Elasticsearch creates a record of this task as a document at <code>_tasks/&lt;task_id&gt;</code>.</p>
-          <p><strong>Reindex from multiple sources</strong></p>
-          <p>If you have many sources to reindex it is generally better to reindex them one at a time rather than using a glob pattern to pick up multiple sources.
-          That way you can resume the process if there are any errors by removing the partially completed source and starting over.
-          It also makes parallelizing the process fairly simple: split the list of sources to reindex and run each list in parallel.</p>
-          <p>For example, you can use a bash script like this:</p>
-          <pre><code>for index in i1 i2 i3 i4 i5; do
-            curl -HContent-Type:application/json -XPOST localhost:9200/_reindex?pretty -d'{
-              &quot;source&quot;: {
-                &quot;index&quot;: &quot;'$index'&quot;
-              },
-              &quot;dest&quot;: {
-                &quot;index&quot;: &quot;'$index'-reindexed&quot;
-              }
-            }'
-          done
-          </code></pre>
-          <p><strong>Throttling</strong></p>
-          <p>Set <code>requests_per_second</code> to any positive decimal number (<code>1.4</code>, <code>6</code>, <code>1000</code>, for example) to throttle the rate at which reindex issues batches of index operations.
-          Requests are throttled by padding each batch with a wait time.
-          To turn off throttling, set <code>requests_per_second</code> to <code>-1</code>.</p>
-          <p>The throttling is done by waiting between batches so that the scroll that reindex uses internally can be given a timeout that takes into account the padding.
-          The padding time is the difference between the batch size divided by the <code>requests_per_second</code> and the time spent writing.
-          By default the batch size is <code>1000</code>, so if <code>requests_per_second</code> is set to <code>500</code>:</p>
-          <pre><code>target_time = 1000 / 500 per second = 2 seconds
-          wait_time = target_time - write_time = 2 seconds - .5 seconds = 1.5 seconds
-          </code></pre>
-          <p>Since the batch is issued as a single bulk request, large batch sizes cause Elasticsearch to create many requests and then wait for a while before starting the next set.
-          This is &quot;bursty&quot; instead of &quot;smooth&quot;.</p>
-          <p><strong>Slicing</strong></p>
-          <p>Reindex supports sliced scroll to parallelize the reindexing process.
-          This parallelization can improve efficiency and provide a convenient way to break the request down into smaller parts.</p>
-          <p>NOTE: Reindexing from remote clusters does not support manual or automatic slicing.</p>
-          <p>You can slice a reindex request manually by providing a slice ID and total number of slices to each request.
-          You can also let reindex automatically parallelize by using sliced scroll to slice on <code>_id</code>.
-          The <code>slices</code> parameter specifies the number of slices to use.</p>
-          <p>Adding <code>slices</code> to the reindex request just automates the manual process, creating sub-requests which means it has some quirks:</p>
+          <p>It's recommended to reindex on indices with a green status. Reindexing can fail when a node shuts down or crashes.</p>
           <ul>
-          <li>You can see these requests in the tasks API. These sub-requests are &quot;child&quot; tasks of the task for the request with slices.</li>
-          <li>Fetching the status of the task for the request with <code>slices</code> only contains the status of completed slices.</li>
-          <li>These sub-requests are individually addressable for things like cancellation and rethrottling.</li>
-          <li>Rethrottling the request with <code>slices</code> will rethrottle the unfinished sub-request proportionally.</li>
-          <li>Canceling the request with <code>slices</code> will cancel each sub-request.</li>
-          <li>Due to the nature of <code>slices</code>, each sub-request won't get a perfectly even portion of the documents. All documents will be addressed, but some slices may be larger than others. Expect larger slices to have a more even distribution.</li>
-          <li>Parameters like <code>requests_per_second</code> and <code>max_docs</code> on a request with <code>slices</code> are distributed proportionally to each sub-request. Combine that with the previous point about distribution being uneven and you should conclude that using <code>max_docs</code> with <code>slices</code> might not result in exactly <code>max_docs</code> documents being reindexed.</li>
-          <li>Each sub-request gets a slightly different snapshot of the source, though these are all taken at approximately the same time.</li>
+          <li>When requested with <code>wait_for_completion=true</code> (default), the request fails if the node shuts down.</li>
+          <li>When requested with <code>wait_for_completion=false</code>, a task id is returned, for use with the task management APIs. The task may disappear or fail if the node shuts down.
+          When retrying a failed reindex operation, it might be necessary to set <code>conflicts=proceed</code> or to first delete the partial destination index.
+          Additionally, dry runs, checking disk space, and fetching index recovery information can help address the root cause.</li>
           </ul>
-          <p>If slicing automatically, setting <code>slices</code> to <code>auto</code> will choose a reasonable number for most indices.
-          If slicing manually or otherwise tuning automatic slicing, use the following guidelines.</p>
-          <p>Query performance is most efficient when the number of slices is equal to the number of shards in the index.
-          If that number is large (for example, <code>500</code>), choose a lower number as too many slices will hurt performance.
-          Setting slices higher than the number of shards generally does not improve efficiency and adds overhead.</p>
-          <p>Indexing performance scales linearly across available resources with the number of slices.</p>
-          <p>Whether query or indexing performance dominates the runtime depends on the documents being reindexed and cluster resources.</p>
-          <p><strong>Modify documents during reindexing</strong></p>
-          <p>Like <code>_update_by_query</code>, reindex operations support a script that modifies the document.
-          Unlike <code>_update_by_query</code>, the script is allowed to modify the document's metadata.</p>
-          <p>Just as in <code>_update_by_query</code>, you can set <code>ctx.op</code> to change the operation that is run on the destination.
-          For example, set <code>ctx.op</code> to <code>noop</code> if your script decides that the document doesn’t have to be indexed in the destination. This &quot;no operation&quot; will be reported in the <code>noop</code> counter in the response body.
-          Set <code>ctx.op</code> to <code>delete</code> if your script decides that the document must be deleted from the destination.
-          The deletion will be reported in the <code>deleted</code> counter in the response body.
-          Setting <code>ctx.op</code> to anything else will return an error, as will setting any other field in <code>ctx</code>.</p>
-          <p>Think of the possibilities! Just be careful; you are able to change:</p>
-          <ul>
-          <li><code>_id</code></li>
-          <li><code>_index</code></li>
-          <li><code>_version</code></li>
-          <li><code>_routing</code></li>
-          </ul>
-          <p>Setting <code>_version</code> to <code>null</code> or clearing it from the <code>ctx</code> map is just like not sending the version in an indexing request.
-          It will cause the document to be overwritten in the destination regardless of the version on the target or the version type you use in the reindex API.</p>
-          <p><strong>Reindex from remote</strong></p>
-          <p>Reindex supports reindexing from a remote Elasticsearch cluster.
-          The <code>host</code> parameter must contain a scheme, host, port, and optional path.
-          The <code>username</code> and <code>password</code> parameters are optional and when they are present the reindex operation will connect to the remote Elasticsearch node using basic authentication.
-          Be sure to use HTTPS when using basic authentication or the password will be sent in plain text.
-          There are a range of settings available to configure the behavior of the HTTPS connection.</p>
-          <p>When using Elastic Cloud, it is also possible to authenticate against the remote cluster through the use of a valid API key.
-          Remote hosts must be explicitly allowed with the <code>reindex.remote.whitelist</code> setting.
-          It can be set to a comma delimited list of allowed remote host and port combinations.
-          Scheme is ignored; only the host and port are used.
-          For example:</p>
-          <pre><code>reindex.remote.whitelist: [otherhost:9200, another:9200, 127.0.10.*:9200, localhost:*&quot;]
-          </code></pre>
-          <p>The list of allowed hosts must be configured on any nodes that will coordinate the reindex.
-          This feature should work with remote clusters of any version of Elasticsearch.
-          This should enable you to upgrade from any version of Elasticsearch to the current version by reindexing from a cluster of the old version.</p>
-          <p>WARNING: Elasticsearch does not support forward compatibility across major versions.
-          For example, you cannot reindex from a 7.x cluster into a 6.x cluster.</p>
-          <p>To enable queries sent to older versions of Elasticsearch, the <code>query</code> parameter is sent directly to the remote host without validation or modification.</p>
-          <p>NOTE: Reindexing from remote clusters does not support manual or automatic slicing.</p>
-          <p>Reindexing from a remote server uses an on-heap buffer that defaults to a maximum size of 100mb.
-          If the remote index includes very large documents you'll need to use a smaller batch size.
-          It is also possible to set the socket read timeout on the remote connection with the <code>socket_timeout</code> field and the connection timeout with the <code>connect_timeout</code> field.
-          Both default to 30 seconds.</p>
-          <p><strong>Configuring SSL parameters</strong></p>
-          <p>Reindex from remote supports configurable SSL settings.
-          These must be specified in the <code>elasticsearch.yml</code> file, with the exception of the secure settings, which you add in the Elasticsearch keystore.
-          It is not possible to configure SSL in the body of the reindex request.</p>
-
-
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-reindex>`_
+          <p>Refer to the linked documentation for examples of how to reindex documents.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-reindex>`_
 
         :param dest: The destination you are copying to.
         :param source: The source you are copying from.
@@ -4294,7 +4008,7 @@ def reindex_rethrottle(
           This behavior prevents scroll timeouts.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-reindex>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-reindex>`_
 
         :param task_id: The task identifier, which can be found by using the tasks API.
         :param requests_per_second: The throttle for this request in sub-requests per
@@ -4340,7 +4054,7 @@ def render_search_template(
         human: t.Optional[bool] = None,
         params: t.Optional[t.Mapping[str, t.Any]] = None,
         pretty: t.Optional[bool] = None,
-        source: t.Optional[str] = None,
+        source: t.Optional[t.Union[str, t.Mapping[str, t.Any]]] = None,
         body: t.Optional[t.Dict[str, t.Any]] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
@@ -4350,7 +4064,7 @@ def render_search_template(
           <p>Render a search template as a search request body.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-render-search-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-render-search-template>`_
 
         :param id: The ID of the search template to render. If no `source` is specified,
             this or the `id` request body parameter is required.
@@ -4444,7 +4158,7 @@ def scripts_painless_execute(
           <p>Each context requires a script, but additional parameters depend on the context you're using for that script.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/painless/master/painless-execute-api.html>`_
+        `<https://www.elastic.co/docs/reference/scripting-languages/painless/painless-api-examples>`_
 
         :param context: The context that the script should run in. NOTE: Result ordering
             in the field contexts is not guaranteed.
@@ -4517,7 +4231,7 @@ def scroll(
           <p>IMPORTANT: Results from a scrolling search reflect the state of the index at the time of the initial search request. Subsequent indexing or document changes only affect later search and scroll requests.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-scroll>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-scroll>`_
 
         :param scroll_id: The scroll ID of the search.
         :param rest_total_hits_as_int: If true, the API response’s hit.total property
@@ -4722,7 +4436,7 @@ def search(
           This situation can occur because the splitting criterion is based on Lucene document IDs, which are not stable across changes to the index.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-search>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-search>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases to
             search. It supports wildcards (`*`). To search all data streams and indices,
@@ -4801,7 +4515,8 @@ def search(
             limit the impact of the search on the cluster in order to limit the number
             of concurrent shard requests.
         :param min_score: The minimum `_score` for matching documents. Documents with
-            a lower `_score` are not included in the search results.
+            a lower `_score` are not included in search results and results collected
+            by aggregations.
         :param pit: Limit the search to a point in time (PIT). If you provide a PIT,
             you cannot specify an `<index>` in the request path.
         :param post_filter: Use the `post_filter` parameter to filter search results.
@@ -4828,11 +4543,11 @@ def search(
             of the specified nodes are available, select shards from any available node
             using the default method. * `_prefer_nodes:<node-id>,<node-id>` to if possible,
             run the search on the specified nodes IDs. If not, select shards using the
-            default method. `_shards:<shard>,<shard>` to run the search only on the specified
-            shards. You can combine this value with other `preference` values. However,
-            the `_shards` value must come first. For example: `_shards:2,3|_local`. `<custom-string>`
-            (any string that does not start with `_`) to route searches with the same
-            `<custom-string>` to the same shards in the same order.
+            default method. * `_shards:<shard>,<shard>` to run the search only on the
+            specified shards. You can combine this value with other `preference` values.
+            However, the `_shards` value must come first. For example: `_shards:2,3|_local`.
+            * `<custom-string>` (any string that does not start with `_`) to route searches
+            with the same `<custom-string>` to the same shards in the same order.
         :param profile: Set to `true` to return detailed timing information about the
             execution of individual components in a search request. NOTE: This is a debugging
             tool and adds significant overhead to search execution.
@@ -5168,51 +4883,6 @@ def search_mvt(
           <li>Optionally, a <code>geo_bounds</code> aggregation on the <code>&lt;field&gt;</code>. The search only includes this aggregation if the <code>exact_bounds</code> parameter is <code>true</code>.</li>
           <li>If the optional parameter <code>with_labels</code> is <code>true</code>, the internal search will include a dynamic runtime field that calls the <code>getLabelPosition</code> function of the geometry doc value. This enables the generation of new point features containing suggested geometry labels, so that, for example, multi-polygons will have only one label.</li>
           </ul>
-          <p>For example, Elasticsearch may translate a vector tile search API request with a <code>grid_agg</code> argument of <code>geotile</code> and an <code>exact_bounds</code> argument of <code>true</code> into the following search</p>
-          <pre><code>GET my-index/_search
-          {
-            &quot;size&quot;: 10000,
-            &quot;query&quot;: {
-              &quot;geo_bounding_box&quot;: {
-                &quot;my-geo-field&quot;: {
-                  &quot;top_left&quot;: {
-                    &quot;lat&quot;: -40.979898069620134,
-                    &quot;lon&quot;: -45
-                  },
-                  &quot;bottom_right&quot;: {
-                    &quot;lat&quot;: -66.51326044311186,
-                    &quot;lon&quot;: 0
-                  }
-                }
-              }
-            },
-            &quot;aggregations&quot;: {
-              &quot;grid&quot;: {
-                &quot;geotile_grid&quot;: {
-                  &quot;field&quot;: &quot;my-geo-field&quot;,
-                  &quot;precision&quot;: 11,
-                  &quot;size&quot;: 65536,
-                  &quot;bounds&quot;: {
-                    &quot;top_left&quot;: {
-                      &quot;lat&quot;: -40.979898069620134,
-                      &quot;lon&quot;: -45
-                    },
-                    &quot;bottom_right&quot;: {
-                      &quot;lat&quot;: -66.51326044311186,
-                      &quot;lon&quot;: 0
-                    }
-                  }
-                }
-              },
-              &quot;bounds&quot;: {
-                &quot;geo_bounds&quot;: {
-                  &quot;field&quot;: &quot;my-geo-field&quot;,
-                  &quot;wrap_longitude&quot;: false
-                }
-              }
-            }
-          }
-          </code></pre>
           <p>The API returns results as a binary Mapbox vector tile.
           Mapbox vector tiles are encoded as Google Protobufs (PBF). By default, the tile contains three layers:</p>
           <ul>
@@ -5467,9 +5137,10 @@ def search_mvt(
           Some cells may intersect more than one vector tile.
           To compute the H3 resolution for each precision, Elasticsearch compares the average density of hexagonal bins at each resolution with the average density of tile bins at each zoom level.
           Elasticsearch uses the H3 resolution that is closest to the corresponding geotile density.</p>
+          <p>Learn how to use the vector tile search API with practical examples in the <a href="https://www.elastic.co/docs/reference/elasticsearch/rest-apis/vector-tile-search">Vector tile search examples</a> guide.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-search-mvt>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-search-mvt>`_
 
         :param index: Comma-separated list of data streams, indices, or aliases to search
         :param field: Field containing geospatial data to return
@@ -5643,7 +5314,7 @@ def search_shards(
           <p>If the Elasticsearch security features are enabled, you must have the <code>view_index_metadata</code> or <code>manage</code> index privilege for the target data stream, index, or alias.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-search-shards>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-search-shards>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases to
             search. It supports wildcards (`*`). To search all data streams and indices,
@@ -5656,7 +5327,7 @@ def search_shards(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
         :param local: If `true`, the request retrieves information from the local node
@@ -5744,7 +5415,7 @@ def search_template(
         search_type: t.Optional[
             t.Union[str, t.Literal["dfs_query_then_fetch", "query_then_fetch"]]
         ] = None,
-        source: t.Optional[str] = None,
+        source: t.Optional[t.Union[str, t.Mapping[str, t.Any]]] = None,
         typed_keys: t.Optional[bool] = None,
         body: t.Optional[t.Dict[str, t.Any]] = None,
     ) -> ObjectApiResponse[t.Any]:
@@ -5754,7 +5425,7 @@ def search_template(
           <p>Run a search with a search template.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-search-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-search-template>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases to
             search. It supports wildcards (`*`).
@@ -5768,8 +5439,7 @@ def search_template(
         :param expand_wildcards: The type of index that wildcard patterns can match.
             If the request can target data streams, this argument determines whether
             wildcard expressions match hidden data streams. Supports comma-separated
-            values, such as `open,hidden`. Valid values are: `all`, `open`, `closed`,
-            `hidden`, `none`.
+            values, such as `open,hidden`.
         :param explain: If `true`, returns detailed information about score calculation
             as part of each hit. If you specify both this and the `explain` query parameter,
             the API uses only the query parameter.
@@ -5897,7 +5567,7 @@ def terms_enum(
           </blockquote>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-terms-enum>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-terms-enum>`_
 
         :param index: A comma-separated list of data streams, indices, and index aliases
             to search. Wildcard (`*`) expressions are supported. To search all data streams
@@ -5967,7 +5637,20 @@ def terms_enum(
         )
 
     @_rewrite_parameters(
-        body_fields=("doc", "filter", "per_field_analyzer"),
+        body_fields=(
+            "doc",
+            "field_statistics",
+            "fields",
+            "filter",
+            "offsets",
+            "payloads",
+            "per_field_analyzer",
+            "positions",
+            "routing",
+            "term_statistics",
+            "version",
+            "version_type",
+        ),
     )
     def termvectors(
         self,
@@ -5977,7 +5660,7 @@ def termvectors(
         doc: t.Optional[t.Mapping[str, t.Any]] = None,
         error_trace: t.Optional[bool] = None,
         field_statistics: t.Optional[bool] = None,
-        fields: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        fields: t.Optional[t.Sequence[str]] = None,
         filter: t.Optional[t.Mapping[str, t.Any]] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         human: t.Optional[bool] = None,
@@ -6030,10 +5713,11 @@ def termvectors(
           The information is only retrieved for the shard the requested document resides in.
           The term and field statistics are therefore only useful as relative measures whereas the absolute numbers have no meaning in this context.
           By default, when requesting term vectors of artificial documents, a shard to get the statistics from is randomly selected.
-          Use <code>routing</code> only to hit a particular shard.</p>
+          Use <code>routing</code> only to hit a particular shard.
+          Refer to the linked documentation for detailed examples of how to use this API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-termvectors>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-termvectors>`_
 
         :param index: The name of the index that contains the document.
         :param id: A unique identifier for the document.
@@ -6044,9 +5728,9 @@ def termvectors(
             (the sum of document frequencies for all terms in this field). * The sum
             of total term frequencies (the sum of total term frequencies of each term
             in this field).
-        :param fields: A comma-separated list or wildcard expressions of fields to include
-            in the statistics. It is used as the default list unless a specific field
-            list is provided in the `completion_fields` or `fielddata_fields` parameters.
+        :param fields: A list of fields to include in the statistics. It is used as the
+            default list unless a specific field list is provided in the `completion_fields`
+            or `fielddata_fields` parameters.
         :param filter: Filter terms based on their tf-idf scores. This could be useful
             in order find out a good characteristic vector of a document. This feature
             works in a similar manner to the second phase of the More Like This Query.
@@ -6084,41 +5768,41 @@ def termvectors(
         __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 field_statistics is not None:
-            __query["field_statistics"] = field_statistics
-        if fields is not None:
-            __query["fields"] = fields
         if filter_path is not None:
             __query["filter_path"] = filter_path
         if human is not None:
             __query["human"] = human
-        if offsets is not None:
-            __query["offsets"] = offsets
-        if payloads is not None:
-            __query["payloads"] = payloads
-        if positions is not None:
-            __query["positions"] = positions
         if preference is not None:
             __query["preference"] = preference
         if pretty is not None:
             __query["pretty"] = pretty
         if realtime is not None:
             __query["realtime"] = realtime
-        if routing is not None:
-            __query["routing"] = routing
-        if term_statistics is not None:
-            __query["term_statistics"] = term_statistics
-        if version is not None:
-            __query["version"] = version
-        if version_type is not None:
-            __query["version_type"] = version_type
         if not __body:
             if doc is not None:
                 __body["doc"] = doc
+            if field_statistics is not None:
+                __body["field_statistics"] = field_statistics
+            if fields is not None:
+                __body["fields"] = fields
             if filter is not None:
                 __body["filter"] = filter
+            if offsets is not None:
+                __body["offsets"] = offsets
+            if payloads is not None:
+                __body["payloads"] = payloads
             if per_field_analyzer is not None:
                 __body["per_field_analyzer"] = per_field_analyzer
+            if positions is not None:
+                __body["positions"] = positions
+            if routing is not None:
+                __body["routing"] = routing
+            if term_statistics is not None:
+                __body["term_statistics"] = term_statistics
+            if version is not None:
+                __body["version"] = version
+            if version_type is not None:
+                __body["version_type"] = version_type
         if not __body:
             __body = None  # type: ignore[assignment]
         __headers = {"accept": "application/json"}
@@ -6201,10 +5885,11 @@ def update(
           </ul>
           <p>The document must still be reindexed, but using this API removes some network roundtrips and reduces chances of version conflicts between the GET and the index operation.</p>
           <p>The <code>_source</code> field must be enabled to use this API.
-          In addition to <code>_source</code>, you can access the following variables through the <code>ctx</code> map: <code>_index</code>, <code>_type</code>, <code>_id</code>, <code>_version</code>, <code>_routing</code>, and <code>_now</code> (the current timestamp).</p>
+          In addition to <code>_source</code>, you can access the following variables through the <code>ctx</code> map: <code>_index</code>, <code>_type</code>, <code>_id</code>, <code>_version</code>, <code>_routing</code>, and <code>_now</code> (the current timestamp).
+          For usage examples such as partial updates, upserts, and scripted updates, see the External documentation.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-update>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-update>`_
 
         :param index: The name of the target index. By default, the index is created
             automatically if it doesn't exist.
@@ -6394,6 +6079,24 @@ def update_by_query(
           A bulk update request is performed for each batch of matching documents.
           Any query or update failures cause the update by query request to fail and the failures are shown in the response.
           Any update requests that completed successfully still stick, they are not rolled back.</p>
+          <p><strong>Refreshing shards</strong></p>
+          <p>Specifying the <code>refresh</code> parameter refreshes all shards once the request completes.
+          This is different to the update API's <code>refresh</code> parameter, which causes only the shard
+          that received the request to be refreshed. Unlike the update API, it does not support
+          <code>wait_for</code>.</p>
+          <p><strong>Running update by query asynchronously</strong></p>
+          <p>If the request contains <code>wait_for_completion=false</code>, Elasticsearch
+          performs some preflight checks, launches the request, and returns a
+          <a href="https://www.elastic.co/docs/api/doc/elasticsearch/group/endpoint-tasks">task</a> you can use to cancel or get the status of the task.
+          Elasticsearch creates a record of this task as a document at <code>.tasks/task/${taskId}</code>.</p>
+          <p><strong>Waiting for active shards</strong></p>
+          <p><code>wait_for_active_shards</code> controls how many copies of a shard must be active
+          before proceeding with the request. See <a href="https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-create#operation-create-wait_for_active_shards"><code>wait_for_active_shards</code></a>
+          for details. <code>timeout</code> controls how long each write request waits for unavailable
+          shards to become available. Both work exactly the way they work in the
+          <a href="https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-bulk">Bulk API</a>. Update by query uses scrolled searches, so you can also
+          specify the <code>scroll</code> parameter to control how long it keeps the search context
+          alive, for example <code>?scroll=10m</code>. The default is 5 minutes.</p>
           <p><strong>Throttling update requests</strong></p>
           <p>To control the rate at which update by query issues batches of update operations, you can set <code>requests_per_second</code> to any positive decimal number.
           This pads each batch with a wait time to throttle the rate.
@@ -6428,21 +6131,11 @@ def update_by_query(
           <li>Query performance is most efficient when the number of slices is equal to the number of shards in the index or backing index. If that number is large (for example, 500), choose a lower number as too many slices hurts performance. Setting slices higher than the number of shards generally does not improve efficiency and adds overhead.</li>
           <li>Update performance scales linearly across available resources with the number of slices.</li>
           </ul>
-          <p>Whether query or update performance dominates the runtime depends on the documents being reindexed and cluster resources.</p>
-          <p><strong>Update the document source</strong></p>
-          <p>Update by query supports scripts to update the document source.
-          As with the update API, you can set <code>ctx.op</code> to change the operation that is performed.</p>
-          <p>Set <code>ctx.op = &quot;noop&quot;</code> if your script decides that it doesn't have to make any changes.
-          The update by query operation skips updating the document and increments the <code>noop</code> counter.</p>
-          <p>Set <code>ctx.op = &quot;delete&quot;</code> if your script decides that the document should be deleted.
-          The update by query operation deletes the document and increments the <code>deleted</code> counter.</p>
-          <p>Update by query supports only <code>index</code>, <code>noop</code>, and <code>delete</code>.
-          Setting <code>ctx.op</code> to anything else is an error.
-          Setting any other field in <code>ctx</code> is an error.
-          This API enables you to only modify the source of matching documents; you cannot move them.</p>
-
-
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-update-by-query>`_
+          <p>Whether query or update performance dominates the runtime depends on the documents being reindexed and cluster resources.
+          Refer to the linked documentation for examples of how to update documents using the <code>_update_by_query</code> API:</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-update-by-query>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases to
             search. It supports wildcards (`*`). To search all data streams or indices,
@@ -6467,9 +6160,8 @@ def update_by_query(
         :param expand_wildcards: The type of index that wildcard patterns can match.
             If the request can target data streams, this argument determines whether
             wildcard expressions match hidden data streams. It supports comma-separated
-            values, such as `open,hidden`. Valid values are: `all`, `open`, `closed`,
-            `hidden`, `none`.
-        :param from_: Starting offset (default: 0)
+            values, such as `open,hidden`.
+        :param from_: Skips the specified number of documents.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
         :param lenient: If `true`, format-based query failures (such as providing text
@@ -6662,7 +6354,7 @@ def update_by_query_rethrottle(
           Rethrottling that speeds up the query takes effect immediately but rethrotting that slows down the query takes effect after completing the current batch to prevent scroll timeouts.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-update-by-query-rethrottle>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-update-by-query-rethrottle>`_
 
         :param task_id: The ID for the task.
         :param requests_per_second: The throttle for this request in sub-requests per
diff --git a/elasticsearch/_sync/client/_base.py b/elasticsearch/_sync/client/_base.py
index 8929b1db7..9ee9c3d1b 100644
--- a/elasticsearch/_sync/client/_base.py
+++ b/elasticsearch/_sync/client/_base.py
@@ -174,7 +174,7 @@ def sniff_callback(
                     "GET",
                     "/_nodes/_all/http",
                     headers={
-                        "accept": "application/vnd.elasticsearch+json; compatible-with=8"
+                        "accept": "application/vnd.elasticsearch+json; compatible-with=9"
                     },
                     request_timeout=(
                         sniff_options.sniff_timeout
@@ -298,7 +298,6 @@ def _perform_request(
         def mimetype_header_to_compat(header: str) -> None:
             # Converts all parts of a Accept/Content-Type headers
             # from application/X -> application/vnd.elasticsearch+X
-            nonlocal request_headers
             mimetype = request_headers.get(header, None)
             if mimetype:
                 request_headers[header] = _COMPAT_MIMETYPE_RE.sub(
diff --git a/elasticsearch/_sync/client/async_search.py b/elasticsearch/_sync/client/async_search.py
index 7ee7f4404..fae94879a 100644
--- a/elasticsearch/_sync/client/async_search.py
+++ b/elasticsearch/_sync/client/async_search.py
@@ -44,7 +44,7 @@ def delete(
           If the Elasticsearch security features are enabled, the deletion of a specific async search is restricted to: the authenticated user that submitted the original search request; users that have the <code>cancel_task</code> cluster privilege.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-async-search-submit>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-async-search-submit>`_
 
         :param id: A unique identifier for the async search.
         """
@@ -94,7 +94,7 @@ def get(
           If the Elasticsearch security features are enabled, access to the results of a specific async search is restricted to the user or API key that submitted it.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-async-search-submit>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-async-search-submit>`_
 
         :param id: A unique identifier for the async search.
         :param keep_alive: The length of time that the async search should be available
@@ -164,7 +164,7 @@ def status(
           </ul>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-async-search-submit>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-async-search-submit>`_
 
         :param id: A unique identifier for the async search.
         :param keep_alive: The length of time that the async search needs to be available.
@@ -345,7 +345,7 @@ def submit(
           The maximum allowed size for a stored async search response can be set by changing the <code>search.max_async_search_response_size</code> cluster level setting.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-async-search-submit>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-async-search-submit>`_
 
         :param index: A comma-separated list of index names to search; use `_all` or
             empty string to perform the operation on all indices
@@ -401,7 +401,7 @@ def submit(
             limit the impact of the search on the cluster in order to limit the number
             of concurrent shard requests
         :param min_score: Minimum _score for matching documents. Documents with a lower
-            _score are not included in the search results.
+            _score are not included in search results and results collected by aggregations.
         :param pit: Limits the search to a point in time (PIT). If you provide a PIT,
             you cannot specify an <index> in the request path.
         :param post_filter:
diff --git a/elasticsearch/_sync/client/autoscaling.py b/elasticsearch/_sync/client/autoscaling.py
index 98fe5d109..82dcdcc93 100644
--- a/elasticsearch/_sync/client/autoscaling.py
+++ b/elasticsearch/_sync/client/autoscaling.py
@@ -44,7 +44,7 @@ def delete_autoscaling_policy(
           <p>NOTE: This feature is designed for indirect use by Elasticsearch Service, Elastic Cloud Enterprise, and Elastic Cloud on Kubernetes. Direct use is not supported.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-autoscaling-delete-autoscaling-policy>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-autoscaling-delete-autoscaling-policy>`_
 
         :param name: the name of the autoscaling policy
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -104,7 +104,7 @@ def get_autoscaling_capacity(
           Do not use this information to make autoscaling decisions.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-autoscaling-get-autoscaling-capacity>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-autoscaling-get-autoscaling-capacity>`_
 
         :param master_timeout: Period to wait for a connection to the master node. If
             no response is received before the timeout expires, the request fails and
@@ -151,7 +151,7 @@ def get_autoscaling_policy(
           <p>NOTE: This feature is designed for indirect use by Elasticsearch Service, Elastic Cloud Enterprise, and Elastic Cloud on Kubernetes. Direct use is not supported.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-autoscaling-get-autoscaling-capacity>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-autoscaling-get-autoscaling-capacity>`_
 
         :param name: the name of the autoscaling policy
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -206,7 +206,7 @@ def put_autoscaling_policy(
           <p>NOTE: This feature is designed for indirect use by Elasticsearch Service, Elastic Cloud Enterprise, and Elastic Cloud on Kubernetes. Direct use is not supported.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-autoscaling-put-autoscaling-policy>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-autoscaling-put-autoscaling-policy>`_
 
         :param name: the name of the autoscaling policy
         :param policy:
diff --git a/elasticsearch/_sync/client/cat.py b/elasticsearch/_sync/client/cat.py
index af14bf7f8..c2e38c2cf 100644
--- a/elasticsearch/_sync/client/cat.py
+++ b/elasticsearch/_sync/client/cat.py
@@ -47,7 +47,34 @@ def aliases(
         ] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "alias",
+                            "filter",
+                            "index",
+                            "is_write_index",
+                            "routing.index",
+                            "routing.search",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "alias",
+                        "filter",
+                        "index",
+                        "is_write_index",
+                        "routing.index",
+                        "routing.search",
+                    ],
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
@@ -64,7 +91,7 @@ def aliases(
           <p>IMPORTANT: CAT APIs are only intended for human consumption using the command line or the Kibana console. They are not intended for use by applications. For application consumption, use the aliases API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-aliases>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-aliases>`_
 
         :param name: A comma-separated list of aliases to retrieve. Supports wildcards
             (`*`). To retrieve all aliases, omit this parameter or use `*` or `_all`.
@@ -74,7 +101,8 @@ def aliases(
             values, such as `open,hidden`.
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param master_timeout: The period to wait for a connection to the master node.
@@ -137,7 +165,48 @@ def allocation(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "disk.avail",
+                            "disk.indices",
+                            "disk.indices.forecast",
+                            "disk.percent",
+                            "disk.total",
+                            "disk.used",
+                            "host",
+                            "ip",
+                            "node",
+                            "node.role",
+                            "shards",
+                            "shards.undesired",
+                            "write_load.forecast",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "disk.avail",
+                        "disk.indices",
+                        "disk.indices.forecast",
+                        "disk.percent",
+                        "disk.total",
+                        "disk.used",
+                        "host",
+                        "ip",
+                        "node",
+                        "node.role",
+                        "shards",
+                        "shards.undesired",
+                        "write_load.forecast",
+                    ],
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
@@ -154,14 +223,15 @@ def allocation(
           <p>IMPORTANT: CAT APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-allocation>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-allocation>`_
 
         :param node_id: A comma-separated list of node identifiers or names used to limit
             the returned information.
         :param bytes: The unit used to display byte values.
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param local: If `true`, the request computes the list of selected nodes from
@@ -224,7 +294,36 @@ def component_templates(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "alias_count",
+                            "included_in",
+                            "mapping_count",
+                            "metadata_count",
+                            "name",
+                            "settings_count",
+                            "version",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "alias_count",
+                        "included_in",
+                        "mapping_count",
+                        "metadata_count",
+                        "name",
+                        "settings_count",
+                        "version",
+                    ],
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
@@ -243,13 +342,14 @@ def component_templates(
           They are not intended for use by applications. For application consumption, use the get component template API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-component-templates>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-component-templates>`_
 
         :param name: The name of the component template. It accepts wildcard expressions.
             If it is omitted, all component templates are returned.
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param local: If `true`, the request computes the list of selected nodes from
@@ -310,7 +410,12 @@ def count(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[t.Union[str, t.Literal["count", "epoch", "timestamp"]]],
+                t.Union[str, t.Literal["count", "epoch", "timestamp"]],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         pretty: t.Optional[bool] = None,
@@ -327,14 +432,15 @@ def count(
           They are not intended for use by applications. For application consumption, use the count API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-count>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-count>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases used
             to limit the request. It supports wildcards (`*`). To target all data streams
             and indices, omit this parameter or use `*` or `_all`.
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param s: List of columns that determine how the table should be sorted. Sorting
@@ -389,7 +495,14 @@ def fielddata(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[str, t.Literal["field", "host", "id", "ip", "node", "size"]]
+                ],
+                t.Union[str, t.Literal["field", "host", "id", "ip", "node", "size"]],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         pretty: t.Optional[bool] = None,
@@ -405,14 +518,15 @@ def fielddata(
           They are not intended for use by applications. For application consumption, use the nodes stats API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-fielddata>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-fielddata>`_
 
         :param fields: Comma-separated list of fields used to limit returned information.
             To retrieve all fields, omit this parameter.
         :param bytes: The unit used to display byte values.
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param s: List of columns that determine how the table should be sorted. Sorting
@@ -465,7 +579,52 @@ def health(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "active_shards_percent",
+                            "cluster",
+                            "epoch",
+                            "init",
+                            "max_task_wait_time",
+                            "node.data",
+                            "node.total",
+                            "pending_tasks",
+                            "pri",
+                            "relo",
+                            "shards",
+                            "status",
+                            "timestamp",
+                            "unassign",
+                            "unassign.pri",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "active_shards_percent",
+                        "cluster",
+                        "epoch",
+                        "init",
+                        "max_task_wait_time",
+                        "node.data",
+                        "node.total",
+                        "pending_tasks",
+                        "pri",
+                        "relo",
+                        "shards",
+                        "status",
+                        "timestamp",
+                        "unassign",
+                        "unassign.pri",
+                    ],
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         pretty: t.Optional[bool] = None,
@@ -491,11 +650,12 @@ def health(
           You also can use the API to track the recovery of a large cluster over a longer period of time.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-health>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-health>`_
 
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param s: List of columns that determine how the table should be sorted. Sorting
@@ -549,7 +709,7 @@ def help(self) -> TextApiResponse:
           <p>Get help for the CAT APIs.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/group/endpoint-cat>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/group/endpoint-cat>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_cat"
@@ -583,8 +743,319 @@ def indices(
         ] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
-        health: t.Optional[t.Union[str, t.Literal["green", "red", "yellow"]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "bulk.avg_size_in_bytes",
+                            "bulk.avg_time",
+                            "bulk.total_operations",
+                            "bulk.total_size_in_bytes",
+                            "bulk.total_time",
+                            "completion.size",
+                            "creation.date",
+                            "creation.date.string",
+                            "dataset.size",
+                            "dense_vector.value_count",
+                            "docs.count",
+                            "docs.deleted",
+                            "fielddata.evictions",
+                            "fielddata.memory_size",
+                            "flush.total",
+                            "flush.total_time",
+                            "get.current",
+                            "get.exists_time",
+                            "get.exists_total",
+                            "get.missing_time",
+                            "get.missing_total",
+                            "get.time",
+                            "get.total",
+                            "health",
+                            "index",
+                            "indexing.delete_current",
+                            "indexing.delete_time",
+                            "indexing.delete_total",
+                            "indexing.index_current",
+                            "indexing.index_failed",
+                            "indexing.index_failed_due_to_version_conflict",
+                            "indexing.index_time",
+                            "indexing.index_total",
+                            "memory.total",
+                            "merges.current",
+                            "merges.current_docs",
+                            "merges.current_size",
+                            "merges.total",
+                            "merges.total_docs",
+                            "merges.total_size",
+                            "merges.total_time",
+                            "pri",
+                            "pri.bulk.avg_size_in_bytes",
+                            "pri.bulk.avg_time",
+                            "pri.bulk.total_operations",
+                            "pri.bulk.total_size_in_bytes",
+                            "pri.bulk.total_time",
+                            "pri.completion.size",
+                            "pri.dense_vector.value_count",
+                            "pri.fielddata.evictions",
+                            "pri.fielddata.memory_size",
+                            "pri.flush.total",
+                            "pri.flush.total_time",
+                            "pri.get.current",
+                            "pri.get.exists_time",
+                            "pri.get.exists_total",
+                            "pri.get.missing_time",
+                            "pri.get.missing_total",
+                            "pri.get.time",
+                            "pri.get.total",
+                            "pri.indexing.delete_current",
+                            "pri.indexing.delete_time",
+                            "pri.indexing.delete_total",
+                            "pri.indexing.index_current",
+                            "pri.indexing.index_failed",
+                            "pri.indexing.index_failed_due_to_version_conflict",
+                            "pri.indexing.index_time",
+                            "pri.indexing.index_total",
+                            "pri.memory.total",
+                            "pri.merges.current",
+                            "pri.merges.current_docs",
+                            "pri.merges.current_size",
+                            "pri.merges.total",
+                            "pri.merges.total_docs",
+                            "pri.merges.total_size",
+                            "pri.merges.total_time",
+                            "pri.query_cache.evictions",
+                            "pri.query_cache.memory_size",
+                            "pri.refresh.external_time",
+                            "pri.refresh.external_total",
+                            "pri.refresh.listeners",
+                            "pri.refresh.time",
+                            "pri.refresh.total",
+                            "pri.request_cache.evictions",
+                            "pri.request_cache.hit_count",
+                            "pri.request_cache.memory_size",
+                            "pri.request_cache.miss_count",
+                            "pri.search.fetch_current",
+                            "pri.search.fetch_time",
+                            "pri.search.fetch_total",
+                            "pri.search.open_contexts",
+                            "pri.search.query_current",
+                            "pri.search.query_time",
+                            "pri.search.query_total",
+                            "pri.search.scroll_current",
+                            "pri.search.scroll_time",
+                            "pri.search.scroll_total",
+                            "pri.segments.count",
+                            "pri.segments.fixed_bitset_memory",
+                            "pri.segments.index_writer_memory",
+                            "pri.segments.memory",
+                            "pri.segments.version_map_memory",
+                            "pri.sparse_vector.value_count",
+                            "pri.store.size",
+                            "pri.suggest.current",
+                            "pri.suggest.time",
+                            "pri.suggest.total",
+                            "pri.warmer.current",
+                            "pri.warmer.total",
+                            "pri.warmer.total_time",
+                            "query_cache.evictions",
+                            "query_cache.memory_size",
+                            "refresh.external_time",
+                            "refresh.external_total",
+                            "refresh.listeners",
+                            "refresh.time",
+                            "refresh.total",
+                            "rep",
+                            "request_cache.evictions",
+                            "request_cache.hit_count",
+                            "request_cache.memory_size",
+                            "request_cache.miss_count",
+                            "search.fetch_current",
+                            "search.fetch_time",
+                            "search.fetch_total",
+                            "search.open_contexts",
+                            "search.query_current",
+                            "search.query_time",
+                            "search.query_total",
+                            "search.scroll_current",
+                            "search.scroll_time",
+                            "search.scroll_total",
+                            "segments.count",
+                            "segments.fixed_bitset_memory",
+                            "segments.index_writer_memory",
+                            "segments.memory",
+                            "segments.version_map_memory",
+                            "sparse_vector.value_count",
+                            "status",
+                            "store.size",
+                            "suggest.current",
+                            "suggest.time",
+                            "suggest.total",
+                            "uuid",
+                            "warmer.current",
+                            "warmer.total",
+                            "warmer.total_time",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "bulk.avg_size_in_bytes",
+                        "bulk.avg_time",
+                        "bulk.total_operations",
+                        "bulk.total_size_in_bytes",
+                        "bulk.total_time",
+                        "completion.size",
+                        "creation.date",
+                        "creation.date.string",
+                        "dataset.size",
+                        "dense_vector.value_count",
+                        "docs.count",
+                        "docs.deleted",
+                        "fielddata.evictions",
+                        "fielddata.memory_size",
+                        "flush.total",
+                        "flush.total_time",
+                        "get.current",
+                        "get.exists_time",
+                        "get.exists_total",
+                        "get.missing_time",
+                        "get.missing_total",
+                        "get.time",
+                        "get.total",
+                        "health",
+                        "index",
+                        "indexing.delete_current",
+                        "indexing.delete_time",
+                        "indexing.delete_total",
+                        "indexing.index_current",
+                        "indexing.index_failed",
+                        "indexing.index_failed_due_to_version_conflict",
+                        "indexing.index_time",
+                        "indexing.index_total",
+                        "memory.total",
+                        "merges.current",
+                        "merges.current_docs",
+                        "merges.current_size",
+                        "merges.total",
+                        "merges.total_docs",
+                        "merges.total_size",
+                        "merges.total_time",
+                        "pri",
+                        "pri.bulk.avg_size_in_bytes",
+                        "pri.bulk.avg_time",
+                        "pri.bulk.total_operations",
+                        "pri.bulk.total_size_in_bytes",
+                        "pri.bulk.total_time",
+                        "pri.completion.size",
+                        "pri.dense_vector.value_count",
+                        "pri.fielddata.evictions",
+                        "pri.fielddata.memory_size",
+                        "pri.flush.total",
+                        "pri.flush.total_time",
+                        "pri.get.current",
+                        "pri.get.exists_time",
+                        "pri.get.exists_total",
+                        "pri.get.missing_time",
+                        "pri.get.missing_total",
+                        "pri.get.time",
+                        "pri.get.total",
+                        "pri.indexing.delete_current",
+                        "pri.indexing.delete_time",
+                        "pri.indexing.delete_total",
+                        "pri.indexing.index_current",
+                        "pri.indexing.index_failed",
+                        "pri.indexing.index_failed_due_to_version_conflict",
+                        "pri.indexing.index_time",
+                        "pri.indexing.index_total",
+                        "pri.memory.total",
+                        "pri.merges.current",
+                        "pri.merges.current_docs",
+                        "pri.merges.current_size",
+                        "pri.merges.total",
+                        "pri.merges.total_docs",
+                        "pri.merges.total_size",
+                        "pri.merges.total_time",
+                        "pri.query_cache.evictions",
+                        "pri.query_cache.memory_size",
+                        "pri.refresh.external_time",
+                        "pri.refresh.external_total",
+                        "pri.refresh.listeners",
+                        "pri.refresh.time",
+                        "pri.refresh.total",
+                        "pri.request_cache.evictions",
+                        "pri.request_cache.hit_count",
+                        "pri.request_cache.memory_size",
+                        "pri.request_cache.miss_count",
+                        "pri.search.fetch_current",
+                        "pri.search.fetch_time",
+                        "pri.search.fetch_total",
+                        "pri.search.open_contexts",
+                        "pri.search.query_current",
+                        "pri.search.query_time",
+                        "pri.search.query_total",
+                        "pri.search.scroll_current",
+                        "pri.search.scroll_time",
+                        "pri.search.scroll_total",
+                        "pri.segments.count",
+                        "pri.segments.fixed_bitset_memory",
+                        "pri.segments.index_writer_memory",
+                        "pri.segments.memory",
+                        "pri.segments.version_map_memory",
+                        "pri.sparse_vector.value_count",
+                        "pri.store.size",
+                        "pri.suggest.current",
+                        "pri.suggest.time",
+                        "pri.suggest.total",
+                        "pri.warmer.current",
+                        "pri.warmer.total",
+                        "pri.warmer.total_time",
+                        "query_cache.evictions",
+                        "query_cache.memory_size",
+                        "refresh.external_time",
+                        "refresh.external_total",
+                        "refresh.listeners",
+                        "refresh.time",
+                        "refresh.total",
+                        "rep",
+                        "request_cache.evictions",
+                        "request_cache.hit_count",
+                        "request_cache.memory_size",
+                        "request_cache.miss_count",
+                        "search.fetch_current",
+                        "search.fetch_time",
+                        "search.fetch_total",
+                        "search.open_contexts",
+                        "search.query_current",
+                        "search.query_time",
+                        "search.query_total",
+                        "search.scroll_current",
+                        "search.scroll_time",
+                        "search.scroll_total",
+                        "segments.count",
+                        "segments.fixed_bitset_memory",
+                        "segments.index_writer_memory",
+                        "segments.memory",
+                        "segments.version_map_memory",
+                        "sparse_vector.value_count",
+                        "status",
+                        "store.size",
+                        "suggest.current",
+                        "suggest.time",
+                        "suggest.total",
+                        "uuid",
+                        "warmer.current",
+                        "warmer.total",
+                        "warmer.total_time",
+                    ],
+                ],
+            ]
+        ] = None,
+        health: t.Optional[
+            t.Union[str, t.Literal["green", "red", "unavailable", "unknown", "yellow"]]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         include_unloaded_segments: t.Optional[bool] = None,
@@ -616,7 +1087,7 @@ def indices(
           They are not intended for use by applications. For application consumption, use an index endpoint.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-indices>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-indices>`_
 
         :param index: Comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (`*`). To target all data streams
@@ -625,7 +1096,8 @@ def indices(
         :param expand_wildcards: The type of index that wildcard patterns can match.
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param health: The health status used to limit returned indices. By default,
             the response includes indices of any health status.
         :param help: When set to `true` will output available columns. This option can't
@@ -697,7 +1169,12 @@ def master(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[t.Union[str, t.Literal["host", "id", "ip", "node"]]],
+                t.Union[str, t.Literal["host", "id", "ip", "node"]],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
@@ -714,11 +1191,12 @@ def master(
           <p>IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the nodes info API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-master>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-master>`_
 
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param local: If `true`, the request computes the list of selected nodes from
@@ -892,7 +1370,7 @@ def ml_data_frame_analytics(
           application consumption, use the get data frame analytics jobs statistics API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-ml-data-frame-analytics>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-ml-data-frame-analytics>`_
 
         :param id: The ID of the data frame analytics to fetch
         :param allow_no_match: Whether to ignore if a wildcard expression matches no
@@ -1060,7 +1538,7 @@ def ml_datafeeds(
           application consumption, use the get datafeed statistics API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-ml-datafeeds>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-ml-datafeeds>`_
 
         :param datafeed_id: A numerical character string that uniquely identifies the
             datafeed.
@@ -1426,7 +1904,7 @@ def ml_jobs(
           application consumption, use the get anomaly detection job statistics API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-ml-jobs>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-ml-jobs>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param allow_no_match: Specifies what to do when the request: * Contains wildcard
@@ -1611,7 +2089,7 @@ def ml_trained_models(
           application consumption, use the get trained models statistics API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-ml-trained-models>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-ml-trained-models>`_
 
         :param model_id: A unique identifier for the trained model.
         :param allow_no_match: Specifies what to do when the request: contains wildcard
@@ -1687,7 +2165,24 @@ def nodeattrs(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "attr", "host", "id", "ip", "node", "pid", "port", "value"
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "attr", "host", "id", "ip", "node", "pid", "port", "value"
+                    ],
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
@@ -1704,11 +2199,12 @@ def nodeattrs(
           IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the nodes info API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-nodeattrs>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-nodeattrs>`_
 
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param local: If `true`, the request computes the list of selected nodes from
@@ -1767,7 +2263,200 @@ def nodes(
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
         full_id: t.Optional[t.Union[bool, str]] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "build",
+                            "completion.size",
+                            "cpu",
+                            "disk.avail",
+                            "disk.total",
+                            "disk.used",
+                            "disk.used_percent",
+                            "fielddata.evictions",
+                            "fielddata.memory_size",
+                            "file_desc.current",
+                            "file_desc.max",
+                            "file_desc.percent",
+                            "flush.total",
+                            "flush.total_time",
+                            "get.current",
+                            "get.exists_time",
+                            "get.exists_total",
+                            "get.missing_time",
+                            "get.missing_total",
+                            "get.time",
+                            "get.total",
+                            "heap.current",
+                            "heap.max",
+                            "heap.percent",
+                            "http_address",
+                            "id",
+                            "indexing.delete_current",
+                            "indexing.delete_time",
+                            "indexing.delete_total",
+                            "indexing.index_current",
+                            "indexing.index_failed",
+                            "indexing.index_failed_due_to_version_conflict",
+                            "indexing.index_time",
+                            "indexing.index_total",
+                            "ip",
+                            "jdk",
+                            "load_15m",
+                            "load_1m",
+                            "load_5m",
+                            "mappings.total_count",
+                            "mappings.total_estimated_overhead_in_bytes",
+                            "master",
+                            "merges.current",
+                            "merges.current_docs",
+                            "merges.current_size",
+                            "merges.total",
+                            "merges.total_docs",
+                            "merges.total_size",
+                            "merges.total_time",
+                            "name",
+                            "node.role",
+                            "pid",
+                            "port",
+                            "query_cache.evictions",
+                            "query_cache.hit_count",
+                            "query_cache.memory_size",
+                            "query_cache.miss_count",
+                            "ram.current",
+                            "ram.max",
+                            "ram.percent",
+                            "refresh.time",
+                            "refresh.total",
+                            "request_cache.evictions",
+                            "request_cache.hit_count",
+                            "request_cache.memory_size",
+                            "request_cache.miss_count",
+                            "script.cache_evictions",
+                            "script.compilations",
+                            "search.fetch_current",
+                            "search.fetch_time",
+                            "search.fetch_total",
+                            "search.open_contexts",
+                            "search.query_current",
+                            "search.query_time",
+                            "search.query_total",
+                            "search.scroll_current",
+                            "search.scroll_time",
+                            "search.scroll_total",
+                            "segments.count",
+                            "segments.fixed_bitset_memory",
+                            "segments.index_writer_memory",
+                            "segments.memory",
+                            "segments.version_map_memory",
+                            "shard_stats.total_count",
+                            "suggest.current",
+                            "suggest.time",
+                            "suggest.total",
+                            "uptime",
+                            "version",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "build",
+                        "completion.size",
+                        "cpu",
+                        "disk.avail",
+                        "disk.total",
+                        "disk.used",
+                        "disk.used_percent",
+                        "fielddata.evictions",
+                        "fielddata.memory_size",
+                        "file_desc.current",
+                        "file_desc.max",
+                        "file_desc.percent",
+                        "flush.total",
+                        "flush.total_time",
+                        "get.current",
+                        "get.exists_time",
+                        "get.exists_total",
+                        "get.missing_time",
+                        "get.missing_total",
+                        "get.time",
+                        "get.total",
+                        "heap.current",
+                        "heap.max",
+                        "heap.percent",
+                        "http_address",
+                        "id",
+                        "indexing.delete_current",
+                        "indexing.delete_time",
+                        "indexing.delete_total",
+                        "indexing.index_current",
+                        "indexing.index_failed",
+                        "indexing.index_failed_due_to_version_conflict",
+                        "indexing.index_time",
+                        "indexing.index_total",
+                        "ip",
+                        "jdk",
+                        "load_15m",
+                        "load_1m",
+                        "load_5m",
+                        "mappings.total_count",
+                        "mappings.total_estimated_overhead_in_bytes",
+                        "master",
+                        "merges.current",
+                        "merges.current_docs",
+                        "merges.current_size",
+                        "merges.total",
+                        "merges.total_docs",
+                        "merges.total_size",
+                        "merges.total_time",
+                        "name",
+                        "node.role",
+                        "pid",
+                        "port",
+                        "query_cache.evictions",
+                        "query_cache.hit_count",
+                        "query_cache.memory_size",
+                        "query_cache.miss_count",
+                        "ram.current",
+                        "ram.max",
+                        "ram.percent",
+                        "refresh.time",
+                        "refresh.total",
+                        "request_cache.evictions",
+                        "request_cache.hit_count",
+                        "request_cache.memory_size",
+                        "request_cache.miss_count",
+                        "script.cache_evictions",
+                        "script.compilations",
+                        "search.fetch_current",
+                        "search.fetch_time",
+                        "search.fetch_total",
+                        "search.open_contexts",
+                        "search.query_current",
+                        "search.query_time",
+                        "search.query_total",
+                        "search.scroll_current",
+                        "search.scroll_time",
+                        "search.scroll_total",
+                        "segments.count",
+                        "segments.fixed_bitset_memory",
+                        "segments.index_writer_memory",
+                        "segments.memory",
+                        "segments.version_map_memory",
+                        "shard_stats.total_count",
+                        "suggest.current",
+                        "suggest.time",
+                        "suggest.total",
+                        "uptime",
+                        "version",
+                    ],
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         include_unloaded_segments: t.Optional[bool] = None,
@@ -1787,23 +2476,24 @@ def nodes(
           IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the nodes info API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-nodes>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-nodes>`_
 
         :param bytes: The unit used to display byte values.
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
         :param full_id: If `true`, return the full node ID. If `false`, return the shortened
             node ID.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param include_unloaded_segments: If true, the response includes information
             from segments that are not loaded into memory.
-        :param master_timeout: Period to wait for a connection to the master node.
-        :param s: List of columns that determine how the table should be sorted. Sorting
-            defaults to ascending and can be changed by setting `:asc` or `:desc` as
-            a suffix to the column name.
-        :param time: Unit used to display time values.
+        :param master_timeout: The period to wait for a connection to the master node.
+        :param s: A comma-separated list of column names or aliases that determines the
+            sort order. Sorting defaults to ascending and can be changed by setting `:asc`
+            or `:desc` as a suffix to the column name.
+        :param time: The unit used to display time values.
         :param v: When set to `true` will enable verbose output.
         """
         __path_parts: t.Dict[str, str] = {}
@@ -1854,7 +2544,19 @@ def pending_tasks(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal["insertOrder", "priority", "source", "timeInQueue"],
+                    ]
+                ],
+                t.Union[
+                    str, t.Literal["insertOrder", "priority", "source", "timeInQueue"]
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
@@ -1874,11 +2576,12 @@ def pending_tasks(
           IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the pending cluster tasks API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-pending-tasks>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-pending-tasks>`_
 
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param local: If `true`, the request computes the list of selected nodes from
@@ -1936,7 +2639,19 @@ def plugins(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal["component", "description", "id", "name", "version"],
+                    ]
+                ],
+                t.Union[
+                    str, t.Literal["component", "description", "id", "name", "version"]
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         include_bootstrap: t.Optional[bool] = None,
@@ -1954,11 +2669,12 @@ def plugins(
           IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the nodes info API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-plugins>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-plugins>`_
 
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param include_bootstrap: Include bootstrap plugins in the response
@@ -2022,7 +2738,74 @@ def recovery(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "bytes",
+                            "bytes_percent",
+                            "bytes_recovered",
+                            "bytes_total",
+                            "files",
+                            "files_percent",
+                            "files_recovered",
+                            "files_total",
+                            "index",
+                            "repository",
+                            "shard",
+                            "snapshot",
+                            "source_host",
+                            "source_node",
+                            "stage",
+                            "start_time",
+                            "start_time_millis",
+                            "stop_time",
+                            "stop_time_millis",
+                            "target_host",
+                            "target_node",
+                            "time",
+                            "translog_ops",
+                            "translog_ops_percent",
+                            "translog_ops_recovered",
+                            "type",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "bytes",
+                        "bytes_percent",
+                        "bytes_recovered",
+                        "bytes_total",
+                        "files",
+                        "files_percent",
+                        "files_recovered",
+                        "files_total",
+                        "index",
+                        "repository",
+                        "shard",
+                        "snapshot",
+                        "source_host",
+                        "source_node",
+                        "stage",
+                        "start_time",
+                        "start_time_millis",
+                        "stop_time",
+                        "stop_time_millis",
+                        "target_host",
+                        "target_node",
+                        "time",
+                        "translog_ops",
+                        "translog_ops_percent",
+                        "translog_ops_recovered",
+                        "type",
+                    ],
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         pretty: t.Optional[bool] = None,
@@ -2042,7 +2825,7 @@ def recovery(
           IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the index recovery API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-recovery>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-recovery>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (`*`). To target all data streams
@@ -2053,13 +2836,14 @@ def recovery(
             shard recoveries.
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
-        :param s: List of columns that determine how the table should be sorted. Sorting
-            defaults to ascending and can be changed by setting `:asc` or `:desc` as
-            a suffix to the column name.
-        :param time: Unit used to display time values.
+        :param s: A comma-separated list of column names or aliases that determines the
+            sort order. Sorting defaults to ascending and can be changed by setting `:asc`
+            or `:desc` as a suffix to the column name.
+        :param time: The unit used to display time values.
         :param v: When set to `true` will enable verbose output.
         """
         __path_parts: t.Dict[str, str]
@@ -2130,7 +2914,7 @@ def repositories(
           IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the get snapshot repository API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-repositories>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-repositories>`_
 
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
@@ -2193,7 +2977,52 @@ def segments(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "committed",
+                            "compound",
+                            "docs.count",
+                            "docs.deleted",
+                            "generation",
+                            "id",
+                            "index",
+                            "ip",
+                            "prirep",
+                            "searchable",
+                            "segment",
+                            "shard",
+                            "size",
+                            "size.memory",
+                            "version",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "committed",
+                        "compound",
+                        "docs.count",
+                        "docs.deleted",
+                        "generation",
+                        "id",
+                        "index",
+                        "ip",
+                        "prirep",
+                        "searchable",
+                        "segment",
+                        "shard",
+                        "size",
+                        "size.memory",
+                        "version",
+                    ],
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
@@ -2211,7 +3040,7 @@ def segments(
           IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the index segments API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-segments>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-segments>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (`*`). To target all data streams
@@ -2219,7 +3048,8 @@ def segments(
         :param bytes: The unit used to display byte values.
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param local: If `true`, the request computes the list of selected nodes from
@@ -2227,9 +3057,9 @@ def segments(
             from the cluster state of the master node. In both cases the coordinating
             node will send requests for further information to each selected node.
         :param master_timeout: Period to wait for a connection to the master node.
-        :param s: List of columns that determine how the table should be sorted. Sorting
-            defaults to ascending and can be changed by setting `:asc` or `:desc` as
-            a suffix to the column name.
+        :param s: A comma-separated list of column names or aliases that determines the
+            sort order. Sorting defaults to ascending and can be changed by setting `:asc`
+            or `:desc` as a suffix to the column name.
         :param v: When set to `true` will enable verbose output.
         """
         __path_parts: t.Dict[str, str]
@@ -2285,7 +3115,162 @@ def shards(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "completion.size",
+                            "dataset.size",
+                            "dense_vector.value_count",
+                            "docs",
+                            "dsparse_vector.value_count",
+                            "fielddata.evictions",
+                            "fielddata.memory_size",
+                            "flush.total",
+                            "flush.total_time",
+                            "get.current",
+                            "get.exists_time",
+                            "get.exists_total",
+                            "get.missing_time",
+                            "get.missing_total",
+                            "get.time",
+                            "get.total",
+                            "id",
+                            "index",
+                            "indexing.delete_current",
+                            "indexing.delete_time",
+                            "indexing.delete_total",
+                            "indexing.index_current",
+                            "indexing.index_failed",
+                            "indexing.index_failed_due_to_version_conflict",
+                            "indexing.index_time",
+                            "indexing.index_total",
+                            "ip",
+                            "merges.current",
+                            "merges.current_docs",
+                            "merges.current_size",
+                            "merges.total",
+                            "merges.total_docs",
+                            "merges.total_size",
+                            "merges.total_time",
+                            "node",
+                            "prirep",
+                            "query_cache.evictions",
+                            "query_cache.memory_size",
+                            "recoverysource.type",
+                            "refresh.time",
+                            "refresh.total",
+                            "search.fetch_current",
+                            "search.fetch_time",
+                            "search.fetch_total",
+                            "search.open_contexts",
+                            "search.query_current",
+                            "search.query_time",
+                            "search.query_total",
+                            "search.scroll_current",
+                            "search.scroll_time",
+                            "search.scroll_total",
+                            "segments.count",
+                            "segments.fixed_bitset_memory",
+                            "segments.index_writer_memory",
+                            "segments.memory",
+                            "segments.version_map_memory",
+                            "seq_no.global_checkpoint",
+                            "seq_no.local_checkpoint",
+                            "seq_no.max",
+                            "shard",
+                            "state",
+                            "store",
+                            "suggest.current",
+                            "suggest.time",
+                            "suggest.total",
+                            "sync_id",
+                            "unassigned.at",
+                            "unassigned.details",
+                            "unassigned.for",
+                            "unassigned.reason",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "completion.size",
+                        "dataset.size",
+                        "dense_vector.value_count",
+                        "docs",
+                        "dsparse_vector.value_count",
+                        "fielddata.evictions",
+                        "fielddata.memory_size",
+                        "flush.total",
+                        "flush.total_time",
+                        "get.current",
+                        "get.exists_time",
+                        "get.exists_total",
+                        "get.missing_time",
+                        "get.missing_total",
+                        "get.time",
+                        "get.total",
+                        "id",
+                        "index",
+                        "indexing.delete_current",
+                        "indexing.delete_time",
+                        "indexing.delete_total",
+                        "indexing.index_current",
+                        "indexing.index_failed",
+                        "indexing.index_failed_due_to_version_conflict",
+                        "indexing.index_time",
+                        "indexing.index_total",
+                        "ip",
+                        "merges.current",
+                        "merges.current_docs",
+                        "merges.current_size",
+                        "merges.total",
+                        "merges.total_docs",
+                        "merges.total_size",
+                        "merges.total_time",
+                        "node",
+                        "prirep",
+                        "query_cache.evictions",
+                        "query_cache.memory_size",
+                        "recoverysource.type",
+                        "refresh.time",
+                        "refresh.total",
+                        "search.fetch_current",
+                        "search.fetch_time",
+                        "search.fetch_total",
+                        "search.open_contexts",
+                        "search.query_current",
+                        "search.query_time",
+                        "search.query_total",
+                        "search.scroll_current",
+                        "search.scroll_time",
+                        "search.scroll_total",
+                        "segments.count",
+                        "segments.fixed_bitset_memory",
+                        "segments.index_writer_memory",
+                        "segments.memory",
+                        "segments.version_map_memory",
+                        "seq_no.global_checkpoint",
+                        "seq_no.local_checkpoint",
+                        "seq_no.max",
+                        "shard",
+                        "state",
+                        "store",
+                        "suggest.current",
+                        "suggest.time",
+                        "suggest.total",
+                        "sync_id",
+                        "unassigned.at",
+                        "unassigned.details",
+                        "unassigned.for",
+                        "unassigned.reason",
+                    ],
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
@@ -2305,7 +3290,7 @@ def shards(
           IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-shards>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-shards>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (`*`). To target all data streams
@@ -2316,11 +3301,11 @@ def shards(
         :param h: List of columns to appear in the response. Supports simple wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
-        :param master_timeout: Period to wait for a connection to the master node.
-        :param s: List of columns that determine how the table should be sorted. Sorting
-            defaults to ascending and can be changed by setting `:asc` or `:desc` as
-            a suffix to the column name.
-        :param time: Unit used to display time values.
+        :param master_timeout: The period to wait for a connection to the master node.
+        :param s: A comma-separated list of column names or aliases that determines the
+            sort order. Sorting defaults to ascending and can be changed by setting `:asc`
+            or `:desc` as a suffix to the column name.
+        :param time: The unit used to display time values.
         :param v: When set to `true` will enable verbose output.
         """
         __path_parts: t.Dict[str, str]
@@ -2373,7 +3358,48 @@ def snapshots(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "duration",
+                            "end_epoch",
+                            "end_time",
+                            "failed_shards",
+                            "id",
+                            "indices",
+                            "reason",
+                            "repository",
+                            "start_epoch",
+                            "start_time",
+                            "status",
+                            "successful_shards",
+                            "total_shards",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "duration",
+                        "end_epoch",
+                        "end_time",
+                        "failed_shards",
+                        "id",
+                        "indices",
+                        "reason",
+                        "repository",
+                        "start_epoch",
+                        "start_time",
+                        "status",
+                        "successful_shards",
+                        "total_shards",
+                    ],
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         ignore_unavailable: t.Optional[bool] = None,
@@ -2394,14 +3420,15 @@ def snapshots(
           IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the get snapshot API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-snapshots>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-snapshots>`_
 
         :param repository: A comma-separated list of snapshot repositories used to limit
             the request. Accepts wildcard expressions. `_all` returns all repositories.
             If any repository fails during the request, Elasticsearch returns an error.
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param ignore_unavailable: If `true`, the response does not include information
@@ -2465,7 +3492,52 @@ def tasks(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "action",
+                            "id",
+                            "ip",
+                            "node",
+                            "node_id",
+                            "parent_task_id",
+                            "port",
+                            "running_time",
+                            "running_time_ns",
+                            "start_time",
+                            "task_id",
+                            "timestamp",
+                            "type",
+                            "version",
+                            "x_opaque_id",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "action",
+                        "id",
+                        "ip",
+                        "node",
+                        "node_id",
+                        "parent_task_id",
+                        "port",
+                        "running_time",
+                        "running_time_ns",
+                        "start_time",
+                        "task_id",
+                        "timestamp",
+                        "type",
+                        "version",
+                        "x_opaque_id",
+                    ],
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         nodes: t.Optional[t.Sequence[str]] = None,
@@ -2487,14 +3559,15 @@ def tasks(
           IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the task management API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-tasks>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-tasks>`_
 
         :param actions: The task action names, which are used to limit the response.
         :param detailed: If `true`, the response includes detailed information about
             shard recoveries.
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param nodes: Unique node identifiers, which are used to limit the response.
@@ -2563,7 +3636,24 @@ def templates(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "composed_of", "index_patterns", "name", "order", "version"
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "composed_of", "index_patterns", "name", "order", "version"
+                    ],
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
@@ -2581,13 +3671,14 @@ def templates(
           IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the get index template API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-templates>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-templates>`_
 
         :param name: The name of the template to return. Accepts wildcard expressions.
             If omitted, all templates are returned.
         :param format: Specifies the format to return the columnar data in, can be set
             to `text`, `json`, `cbor`, `yaml`, or `smile`.
-        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param h: A comma-separated list of columns names to display. It supports simple
+            wildcards.
         :param help: When set to `true` will output available columns. This option can't
             be combined with any other query string option.
         :param local: If `true`, the request computes the list of selected nodes from
@@ -2648,7 +3739,62 @@ def thread_pool(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         format: t.Optional[str] = None,
-        h: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        h: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "active",
+                            "completed",
+                            "core",
+                            "ephemeral_id",
+                            "host",
+                            "ip",
+                            "keep_alive",
+                            "largest",
+                            "max",
+                            "name",
+                            "node_id",
+                            "node_name",
+                            "pid",
+                            "pool_size",
+                            "port",
+                            "queue",
+                            "queue_size",
+                            "rejected",
+                            "size",
+                            "type",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "active",
+                        "completed",
+                        "core",
+                        "ephemeral_id",
+                        "host",
+                        "ip",
+                        "keep_alive",
+                        "largest",
+                        "max",
+                        "name",
+                        "node_id",
+                        "node_name",
+                        "pid",
+                        "pool_size",
+                        "port",
+                        "queue",
+                        "queue_size",
+                        "rejected",
+                        "size",
+                        "type",
+                    ],
+                ],
+            ]
+        ] = None,
         help: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
         local: t.Optional[bool] = None,
@@ -2669,7 +3815,7 @@ def thread_pool(
           IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the nodes info API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-thread-pool>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-thread-pool>`_
 
         :param thread_pool_patterns: A comma-separated list of thread pool names used
             to limit the request. Accepts wildcard expressions.
@@ -2682,10 +3828,10 @@ def thread_pool(
             the local cluster state. If `false` the list of selected nodes are computed
             from the cluster state of the master node. In both cases the coordinating
             node will send requests for further information to each selected node.
-        :param master_timeout: Period to wait for a connection to the master node.
-        :param s: List of columns that determine how the table should be sorted. Sorting
-            defaults to ascending and can be changed by setting `:asc` or `:desc` as
-            a suffix to the column name.
+        :param master_timeout: The period to wait for a connection to the master node.
+        :param s: A comma-separated list of column names or aliases that determines the
+            sort order. Sorting defaults to ascending and can be changed by setting `:asc`
+            or `:desc` as a suffix to the column name.
         :param time: The unit used to display time values.
         :param v: When set to `true` will enable verbose output.
         """
@@ -2926,7 +4072,7 @@ def transforms(
           application consumption, use the get transform statistics API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cat-transforms>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cat-transforms>`_
 
         :param transform_id: A transform identifier or a wildcard expression. If you
             do not specify one of these options, the API returns information for all
diff --git a/elasticsearch/_sync/client/ccr.py b/elasticsearch/_sync/client/ccr.py
index 0eec10516..adc108f8b 100644
--- a/elasticsearch/_sync/client/ccr.py
+++ b/elasticsearch/_sync/client/ccr.py
@@ -43,7 +43,7 @@ def delete_auto_follow_pattern(
           <p>Delete a collection of cross-cluster replication auto-follow patterns.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ccr-delete-auto-follow-pattern>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ccr-delete-auto-follow-pattern>`_
 
         :param name: The auto-follow pattern collection to delete.
         :param master_timeout: The period to wait for a connection to the master node.
@@ -130,7 +130,7 @@ def follow(
           When the API returns, the follower index exists and cross-cluster replication starts replicating operations from the leader index to the follower index.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ccr-follow>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ccr-follow>`_
 
         :param index: The name of the follower index.
         :param leader_index: The name of the index in the leader cluster to follow.
@@ -259,7 +259,7 @@ def follow_info(
           For example, the results include follower index names, leader index names, replication options, and whether the follower indices are active or paused.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ccr-follow-info>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ccr-follow-info>`_
 
         :param index: A comma-delimited list of follower index patterns.
         :param master_timeout: The period to wait for a connection to the master node.
@@ -311,7 +311,7 @@ def follow_stats(
           The API returns shard-level stats about the &quot;following tasks&quot; associated with each shard for the specified indices.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ccr-follow-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ccr-follow-stats>`_
 
         :param index: A comma-delimited list of index patterns.
         :param timeout: The period to wait for a response. If no response is received
@@ -380,7 +380,7 @@ def forget_follower(
           The only purpose of this API is to handle the case of failure to remove the following retention leases after the unfollow API is invoked.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ccr-forget-follower>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ccr-forget-follower>`_
 
         :param index: the name of the leader index for which specified follower retention
             leases should be removed
@@ -445,7 +445,7 @@ def get_auto_follow_pattern(
           <p>Get cross-cluster replication auto-follow patterns.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ccr-get-auto-follow-pattern-1>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ccr-get-auto-follow-pattern-1>`_
 
         :param name: The auto-follow pattern collection that you want to retrieve. If
             you do not specify a name, the API returns information for all collections.
@@ -505,7 +505,7 @@ def pause_auto_follow_pattern(
           Remote indices that were created while the pattern was paused will also be followed, unless they have been deleted or closed in the interim.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ccr-pause-auto-follow-pattern>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ccr-pause-auto-follow-pattern>`_
 
         :param name: The name of the auto-follow pattern to pause.
         :param master_timeout: The period to wait for a connection to the master node.
@@ -559,7 +559,7 @@ def pause_follow(
           You can pause and resume a follower index to change the configuration of the following task.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ccr-pause-follow>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ccr-pause-follow>`_
 
         :param index: The name of the follower index.
         :param master_timeout: The period to wait for a connection to the master node.
@@ -648,7 +648,7 @@ def put_auto_follow_pattern(
           NOTE: Follower indices that were configured automatically before updating an auto-follow pattern will remain unchanged even if they do not match against the new patterns.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ccr-put-auto-follow-pattern>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ccr-put-auto-follow-pattern>`_
 
         :param name: The name of the collection of auto-follow patterns.
         :param remote_cluster: The remote cluster containing the leader indices to match
@@ -782,7 +782,7 @@ def resume_auto_follow_pattern(
           Remote indices created while the pattern was paused will also be followed unless they have been deleted or closed in the interim.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ccr-resume-auto-follow-pattern>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ccr-resume-auto-follow-pattern>`_
 
         :param name: The name of the auto-follow pattern to resume.
         :param master_timeout: The period to wait for a connection to the master node.
@@ -860,7 +860,7 @@ def resume_follow(
           When this API returns, the follower index will resume fetching operations from the leader index.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ccr-resume-follow>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ccr-resume-follow>`_
 
         :param index: The name of the follow index to resume following.
         :param master_timeout: Period to wait for a connection to the master node.
@@ -951,7 +951,7 @@ def stats(
           <p>This API returns stats about auto-following and the same shard-level stats as the get follower stats API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ccr-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ccr-stats>`_
 
         :param master_timeout: The period to wait for a connection to the master node.
             If the master node is not available before the timeout expires, the request
@@ -1009,7 +1009,7 @@ def unfollow(
           </blockquote>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ccr-unfollow>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ccr-unfollow>`_
 
         :param index: The name of the follower index.
         :param master_timeout: The period to wait for a connection to the master node.
diff --git a/elasticsearch/_sync/client/cluster.py b/elasticsearch/_sync/client/cluster.py
index f7b1269cb..a3829f224 100644
--- a/elasticsearch/_sync/client/cluster.py
+++ b/elasticsearch/_sync/client/cluster.py
@@ -51,10 +51,11 @@ def allocation_explain(
           Get explanations for shard allocations in the cluster.
           For unassigned shards, it provides an explanation for why the shard is unassigned.
           For assigned shards, it provides an explanation for why the shard is remaining on its current node and has not moved or rebalanced to another node.
-          This API can be very useful when attempting to diagnose why a shard is unassigned or why a shard continues to remain on its current node when you might expect otherwise.</p>
+          This API can be very useful when attempting to diagnose why a shard is unassigned or why a shard continues to remain on its current node when you might expect otherwise.
+          Refer to the linked documentation for examples of how to troubleshoot allocation issues using this API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-allocation-explain>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-allocation-explain>`_
 
         :param current_node: Specifies the node ID or the name of the node to only explain
             a shard that is currently located on the specified node.
@@ -130,7 +131,7 @@ def delete_component_template(
           Component templates are building blocks for constructing index templates that specify index mappings, settings, and aliases.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-put-component-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-put-component-template>`_
 
         :param name: Comma-separated list or wildcard expression of component template
             names used to limit the request.
@@ -185,7 +186,7 @@ def delete_voting_config_exclusions(
           Remove master-eligible nodes from the voting configuration exclusion list.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-post-voting-config-exclusions>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-post-voting-config-exclusions>`_
 
         :param master_timeout: Period to wait for a connection to the master node.
         :param wait_for_removal: Specifies whether to wait for all excluded nodes to
@@ -239,7 +240,7 @@ def exists_component_template(
           Returns information about whether a particular component template exists.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-put-component-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-put-component-template>`_
 
         :param name: Comma-separated list of component template names used to limit the
             request. Wildcard (*) expressions are supported.
@@ -290,6 +291,7 @@ def get_component_template(
         local: t.Optional[bool] = None,
         master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
+        settings_filter: t.Optional[t.Union[str, t.Sequence[str]]] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
         .. raw:: html
@@ -298,7 +300,7 @@ def get_component_template(
           Get information about component templates.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-put-component-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-put-component-template>`_
 
         :param name: Comma-separated list of component template names used to limit the
             request. Wildcard (`*`) expressions are supported.
@@ -310,6 +312,8 @@ def get_component_template(
         :param master_timeout: Period to wait for a connection to the master node. If
             no response is received before the timeout expires, the request fails and
             returns an error.
+        :param settings_filter: Filter out results, for example to filter out sensitive
+            information. Supports wildcards or full settings keys
         """
         __path_parts: t.Dict[str, str]
         if name not in SKIP_IN_PATH:
@@ -335,6 +339,8 @@ def get_component_template(
             __query["master_timeout"] = master_timeout
         if pretty is not None:
             __query["pretty"] = pretty
+        if settings_filter is not None:
+            __query["settings_filter"] = settings_filter
         __headers = {"accept": "application/json"}
         return self.perform_request(  # type: ignore[return-value]
             "GET",
@@ -365,7 +371,7 @@ def get_settings(
           By default, it returns only settings that have been explicitly defined.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-get-settings>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-get-settings>`_
 
         :param flat_settings: If `true`, returns settings in flat format.
         :param include_defaults: If `true`, returns default cluster settings from the
@@ -441,7 +447,7 @@ def health(
         wait_for_no_relocating_shards: t.Optional[bool] = None,
         wait_for_nodes: t.Optional[t.Union[int, str]] = None,
         wait_for_status: t.Optional[
-            t.Union[str, t.Literal["green", "red", "yellow"]]
+            t.Union[str, t.Literal["green", "red", "unavailable", "unknown", "yellow"]]
         ] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
@@ -457,7 +463,7 @@ def health(
           The cluster status is controlled by the worst index status.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-health>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-health>`_
 
         :param index: Comma-separated list of data streams, indices, and index aliases
             used to limit the request. Wildcard expressions (`*`) are supported. To target
@@ -565,7 +571,7 @@ def info(
           Returns basic information about the cluster.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-info>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-info>`_
 
         :param target: Limits the information returned to the specific target. Supports
             a comma-separated list, such as http,ingest.
@@ -614,7 +620,7 @@ def pending_tasks(
           However, if a user-initiated task such as a create index command causes a cluster state update, the activity of this task might be reported by both task api and pending cluster tasks API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-pending-tasks>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-pending-tasks>`_
 
         :param local: If `true`, the request retrieves information from the local node
             only. If `false`, information is retrieved from the master node.
@@ -680,7 +686,7 @@ def post_voting_config_exclusions(
           They are not required when removing master-ineligible nodes or when removing fewer than half of the master-eligible nodes.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-post-voting-config-exclusions>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-post-voting-config-exclusions>`_
 
         :param master_timeout: Period to wait for a connection to the master node.
         :param node_ids: A comma-separated list of the persistent ids of the nodes to
@@ -731,6 +737,7 @@ def put_component_template(
         *,
         name: str,
         template: t.Optional[t.Mapping[str, t.Any]] = None,
+        cause: t.Optional[str] = None,
         create: t.Optional[bool] = None,
         deprecated: t.Optional[bool] = None,
         error_trace: t.Optional[bool] = None,
@@ -761,7 +768,7 @@ def put_component_template(
           To be applied, a component template must be included in an index template's <code>composed_of</code> list.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-put-component-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-put-component-template>`_
 
         :param name: Name of the component template to create. Elasticsearch includes
             the following built-in component templates: `logs-mappings`; `logs-settings`;
@@ -774,6 +781,7 @@ def put_component_template(
             update settings API.
         :param template: The template to be applied which includes mappings, settings,
             or aliases configuration.
+        :param cause: User defined reason for create the component template.
         :param create: If `true`, this request cannot replace or update existing component
             templates.
         :param deprecated: Marks this index template as deprecated. When creating or
@@ -798,6 +806,8 @@ def put_component_template(
         __path = f'/_component_template/{__path_parts["name"]}'
         __query: t.Dict[str, t.Any] = {}
         __body: t.Dict[str, t.Any] = body if body is not None else {}
+        if cause is not None:
+            __query["cause"] = cause
         if create is not None:
             __query["create"] = create
         if error_trace is not None:
@@ -866,13 +876,13 @@ def put_settings(
           If a cluster becomes unstable, transient settings can clear unexpectedly, resulting in a potentially undesired cluster configuration.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-put-settings>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-put-settings>`_
 
         :param flat_settings: Return settings in flat format (default: false)
         :param master_timeout: Explicit operation timeout for connection to master node
-        :param persistent:
+        :param persistent: The settings that persist after the cluster restarts.
         :param timeout: Explicit operation timeout
-        :param transient:
+        :param transient: The settings that do not persist after the cluster restarts.
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_cluster/settings"
@@ -932,7 +942,7 @@ def remote_info(
           </blockquote>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-remote-info>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-remote-info>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_remote/info"
@@ -989,7 +999,7 @@ def reroute(
           <p>Once the problem has been corrected, allocation can be manually retried by calling the reroute API with the <code>?retry_failed</code> URI query parameter, which will attempt a single retry round for these shards.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-reroute>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-reroute>`_
 
         :param commands: Defines the commands to perform.
         :param dry_run: If true, then the request simulates the operation. It will calculate
@@ -1094,7 +1104,7 @@ def state(
           Instead, obtain the information you require using other more stable cluster APIs.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-state>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-state>`_
 
         :param metric: Limit the information returned to the specified metrics
         :param index: A comma-separated list of index names; use `_all` or empty string
@@ -1182,7 +1192,7 @@ def stats(
           Get basic index metrics (shard numbers, store size, memory usage) and information about the current nodes that form the cluster (number, roles, os, jvm versions, memory usage, cpu and installed plugins).</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-cluster-stats>`_
 
         :param node_id: Comma-separated list of node filters used to limit returned information.
             Defaults to all nodes in the cluster.
diff --git a/elasticsearch/_sync/client/connector.py b/elasticsearch/_sync/client/connector.py
index fc9b193a1..9e6272faf 100644
--- a/elasticsearch/_sync/client/connector.py
+++ b/elasticsearch/_sync/client/connector.py
@@ -49,7 +49,7 @@ def check_in(
           <p>Update the <code>last_seen</code> field in the connector and set it to the current timestamp.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-check-in>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-check-in>`_
 
         :param connector_id: The unique identifier of the connector to be checked in
         """
@@ -99,7 +99,7 @@ def delete(
           These need to be removed manually.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-delete>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-delete>`_
 
         :param connector_id: The unique identifier of the connector to be deleted
         :param delete_sync_jobs: A flag indicating if associated sync jobs should be
@@ -152,7 +152,7 @@ def get(
           <p>Get the details about a connector.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-get>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-get>`_
 
         :param connector_id: The unique identifier of the connector
         :param include_deleted: A flag to indicate if the desired connector should be
@@ -256,7 +256,7 @@ def last_sync(
           This action is used for analytics and monitoring.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-last-sync>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-last-sync>`_
 
         :param connector_id: The unique identifier of the connector to be updated
         :param last_access_control_sync_error:
@@ -356,7 +356,7 @@ def list(
           <p>Get information about all connectors.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-list>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-list>`_
 
         :param connector_name: A comma-separated list of connector names to fetch connector
             documents for
@@ -441,7 +441,7 @@ def post(
           Self-managed connectors (Connector clients) are self-managed on your infrastructure.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-put>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-put>`_
 
         :param description:
         :param index_name:
@@ -523,7 +523,7 @@ def put(
           <p>Create or update a connector.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-put>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-put>`_
 
         :param connector_id: The unique identifier of the connector to be created or
             updated. ID is auto-generated if not provided.
@@ -598,7 +598,7 @@ def sync_job_cancel(
           The connector service is then responsible for setting the status of connector sync jobs to cancelled.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-sync-job-cancel>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-sync-job-cancel>`_
 
         :param connector_sync_job_id: The unique identifier of the connector sync job
         """
@@ -649,7 +649,7 @@ def sync_job_check_in(
           This service runs automatically on Elastic Cloud for Elastic managed connectors.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-sync-job-check-in>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-sync-job-check-in>`_
 
         :param connector_sync_job_id: The unique identifier of the connector sync job
             to be checked in.
@@ -709,7 +709,7 @@ def sync_job_claim(
           This service runs automatically on Elastic Cloud for Elastic managed connectors.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-sync-job-claim>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-sync-job-claim>`_
 
         :param connector_sync_job_id: The unique identifier of the connector sync job.
         :param worker_hostname: The host name of the current system that will run the
@@ -771,7 +771,7 @@ def sync_job_delete(
           This is a destructive action that is not recoverable.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-sync-job-delete>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-sync-job-delete>`_
 
         :param connector_sync_job_id: The unique identifier of the connector sync job
             to be deleted
@@ -825,7 +825,7 @@ def sync_job_error(
           This service runs automatically on Elastic Cloud for Elastic managed connectors.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-sync-job-error>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-sync-job-error>`_
 
         :param connector_sync_job_id: The unique identifier for the connector sync job.
         :param error: The error for the connector sync job error field.
@@ -879,7 +879,7 @@ def sync_job_get(
           <p>Get a connector sync job.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-sync-job-get>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-sync-job-get>`_
 
         :param connector_sync_job_id: The unique identifier of the connector sync job
         """
@@ -952,7 +952,7 @@ def sync_job_list(
           <p>Get information about all stored connector sync jobs listed by their creation date in ascending order.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-sync-job-list>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-sync-job-list>`_
 
         :param connector_id: A connector id to fetch connector sync jobs for
         :param from_: Starting offset (default: 0)
@@ -1018,7 +1018,7 @@ def sync_job_post(
           <p>Create a connector sync job document in the internal index and initialize its counters and timestamps with default values.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-sync-job-post>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-sync-job-post>`_
 
         :param id: The id of the associated connector
         :param job_type:
@@ -1094,7 +1094,7 @@ def sync_job_update_stats(
           This service runs automatically on Elastic Cloud for Elastic managed connectors.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-sync-job-update-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-sync-job-update-stats>`_
 
         :param connector_sync_job_id: The unique identifier of the connector sync job.
         :param deleted_document_count: The number of documents the sync job deleted.
@@ -1177,7 +1177,7 @@ def update_active_filtering(
           <p>Activates the valid draft filtering for a connector.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-update-filtering>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-update-filtering>`_
 
         :param connector_id: The unique identifier of the connector to be updated
         """
@@ -1230,7 +1230,7 @@ def update_api_key_id(
           Self-managed connectors (connector clients) do not use this field.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-update-api-key-id>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-update-api-key-id>`_
 
         :param connector_id: The unique identifier of the connector to be updated
         :param api_key_id:
@@ -1289,7 +1289,7 @@ def update_configuration(
           <p>Update the configuration field in the connector document.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-update-configuration>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-update-configuration>`_
 
         :param connector_id: The unique identifier of the connector to be updated
         :param configuration:
@@ -1349,7 +1349,7 @@ def update_error(
           Otherwise, if the error is reset to null, the connector status is updated to connected.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-update-error>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-update-error>`_
 
         :param connector_id: The unique identifier of the connector to be updated
         :param error:
@@ -1417,7 +1417,7 @@ def update_features(
           This service runs automatically on Elastic Cloud for Elastic managed connectors.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-update-features>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-update-features>`_
 
         :param connector_id: The unique identifier of the connector to be updated.
         :param features:
@@ -1478,7 +1478,7 @@ def update_filtering(
           The filtering property is used to configure sync rules (both basic and advanced) for a connector.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-update-filtering>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-update-filtering>`_
 
         :param connector_id: The unique identifier of the connector to be updated
         :param advanced_snippet:
@@ -1539,7 +1539,7 @@ def update_filtering_validation(
           <p>Update the draft filtering validation info for a connector.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/update-connector-filtering-validation-api.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-update-filtering-validation>`_
 
         :param connector_id: The unique identifier of the connector to be updated
         :param validation:
@@ -1596,7 +1596,7 @@ def update_index_name(
           <p>Update the <code>index_name</code> field of a connector, specifying the index where the data ingested by the connector is stored.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-update-index-name>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-update-index-name>`_
 
         :param connector_id: The unique identifier of the connector to be updated
         :param index_name:
@@ -1653,7 +1653,7 @@ def update_name(
           <p>Update the connector name and description.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-update-name>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-update-name>`_
 
         :param connector_id: The unique identifier of the connector to be updated
         :param description:
@@ -1710,7 +1710,7 @@ def update_native(
           <p>Update the connector is_native flag.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/update-connector-native-api.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-update-native>`_
 
         :param connector_id: The unique identifier of the connector to be updated
         :param is_native:
@@ -1767,7 +1767,7 @@ def update_pipeline(
           <p>When you create a new connector, the configuration of an ingest pipeline is populated with default settings.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-update-pipeline>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-update-pipeline>`_
 
         :param connector_id: The unique identifier of the connector to be updated
         :param pipeline:
@@ -1823,7 +1823,7 @@ def update_scheduling(
           <p>Update the connector scheduling.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-update-scheduling>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-update-scheduling>`_
 
         :param connector_id: The unique identifier of the connector to be updated
         :param scheduling:
@@ -1879,7 +1879,7 @@ def update_service_type(
           <p>Update the connector service type.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-update-service-type>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-update-service-type>`_
 
         :param connector_id: The unique identifier of the connector to be updated
         :param service_type:
@@ -1942,7 +1942,7 @@ def update_status(
           <p>Update the connector status.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-connector-update-status>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-connector-update-status>`_
 
         :param connector_id: The unique identifier of the connector to be updated
         :param status:
diff --git a/elasticsearch/_sync/client/dangling_indices.py b/elasticsearch/_sync/client/dangling_indices.py
index b40de169e..61d13df21 100644
--- a/elasticsearch/_sync/client/dangling_indices.py
+++ b/elasticsearch/_sync/client/dangling_indices.py
@@ -46,7 +46,7 @@ def delete_dangling_index(
           For example, this can happen if you delete more than <code>cluster.indices.tombstones.size</code> indices while an Elasticsearch node is offline.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-dangling-indices-delete-dangling-index>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-dangling-indices-delete-dangling-index>`_
 
         :param index_uuid: The UUID of the index to delete. Use the get dangling indices
             API to find the UUID.
@@ -107,7 +107,7 @@ def import_dangling_index(
           For example, this can happen if you delete more than <code>cluster.indices.tombstones.size</code> indices while an Elasticsearch node is offline.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-dangling-indices-import-dangling-index>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-dangling-indices-import-dangling-index>`_
 
         :param index_uuid: The UUID of the index to import. Use the get dangling indices
             API to locate the UUID.
@@ -168,7 +168,7 @@ def list_dangling_indices(
           <p>Use this API to list dangling indices, which you can then import or delete.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-dangling-indices-list-dangling-indices>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-dangling-indices-list-dangling-indices>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_dangling"
diff --git a/elasticsearch/_sync/client/enrich.py b/elasticsearch/_sync/client/enrich.py
index a12372552..f2e3a179e 100644
--- a/elasticsearch/_sync/client/enrich.py
+++ b/elasticsearch/_sync/client/enrich.py
@@ -43,7 +43,7 @@ def delete_policy(
           Deletes an existing enrich policy and its enrich index.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-enrich-delete-policy>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-enrich-delete-policy>`_
 
         :param name: Enrich policy to delete.
         :param master_timeout: Period to wait for a connection to the master node.
@@ -92,7 +92,7 @@ def execute_policy(
           Create the enrich index for an existing enrich policy.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-enrich-execute-policy>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-enrich-execute-policy>`_
 
         :param name: Enrich policy to execute.
         :param master_timeout: Period to wait for a connection to the master node.
@@ -144,7 +144,7 @@ def get_policy(
           Returns information about an enrich policy.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-enrich-get-policy>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-enrich-get-policy>`_
 
         :param name: Comma-separated list of enrich policy names used to limit the request.
             To return information for all enrich policies, omit this parameter.
@@ -202,7 +202,7 @@ def put_policy(
           Creates an enrich policy.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-enrich-put-policy>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-enrich-put-policy>`_
 
         :param name: Name of the enrich policy to create or update.
         :param geo_match: Matches enrich data to incoming documents based on a `geo_shape`
@@ -263,7 +263,7 @@ def stats(
           Returns enrich coordinator statistics and information about enrich policies that are currently executing.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-enrich-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-enrich-stats>`_
 
         :param master_timeout: Period to wait for a connection to the master node.
         """
diff --git a/elasticsearch/_sync/client/eql.py b/elasticsearch/_sync/client/eql.py
index 274cdffeb..57cba8bf0 100644
--- a/elasticsearch/_sync/client/eql.py
+++ b/elasticsearch/_sync/client/eql.py
@@ -43,7 +43,7 @@ def delete(
           The API also deletes results for the search.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-eql-delete>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-eql-delete>`_
 
         :param id: Identifier for the search to delete. A search ID is provided in the
             EQL search API's response for an async search. A search ID is also provided
@@ -93,7 +93,7 @@ def get(
           Get the current status and available results for an async EQL search or a stored synchronous EQL search.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-eql-get>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-eql-get>`_
 
         :param id: Identifier for the search.
         :param keep_alive: Period for which the search and its results are stored on
@@ -147,7 +147,7 @@ def get_status(
           Get the current status for an async EQL search or a stored synchronous EQL search without returning results.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-eql-get-status>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-eql-get-status>`_
 
         :param id: Identifier for the search.
         """
@@ -204,6 +204,7 @@ def search(
         allow_partial_search_results: t.Optional[bool] = None,
         allow_partial_sequence_results: t.Optional[bool] = None,
         case_sensitive: t.Optional[bool] = None,
+        ccs_minimize_roundtrips: t.Optional[bool] = None,
         error_trace: t.Optional[bool] = None,
         event_category_field: t.Optional[str] = None,
         expand_wildcards: t.Optional[
@@ -246,11 +247,13 @@ def search(
           EQL assumes each document in a data stream or index corresponds to an event.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-eql-search>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-eql-search>`_
 
         :param index: The name of the index to scope the operation
         :param query: EQL query you wish to run.
-        :param allow_no_indices:
+        :param allow_no_indices: Whether to ignore if a wildcard indices expression resolves
+            into no concrete indices. (This includes `_all` string or when no indices
+            have been specified)
         :param allow_partial_search_results: Allow query execution also in case of shard
             failures. If true, the query will keep running and will return results based
             on the available shards. For sequences, the behavior can be further refined
@@ -261,9 +264,12 @@ def search(
             If false, the sequence query will return successfully, but will always have
             empty results.
         :param case_sensitive:
+        :param ccs_minimize_roundtrips: Indicates whether network round-trips should
+            be minimized as part of cross-cluster search requests execution
         :param event_category_field: Field containing the event classification, such
             as process, file, or network.
-        :param expand_wildcards:
+        :param expand_wildcards: Whether to expand wildcard expression to concrete indices
+            that are open, closed or both.
         :param fetch_size: Maximum number of events to search at a time for sequence
             queries.
         :param fields: Array of wildcard (*) patterns. The response returns values for
@@ -298,6 +304,8 @@ def search(
         __body: t.Dict[str, t.Any] = body if body is not None else {}
         if allow_no_indices is not None:
             __query["allow_no_indices"] = allow_no_indices
+        if ccs_minimize_roundtrips is not None:
+            __query["ccs_minimize_roundtrips"] = ccs_minimize_roundtrips
         if error_trace is not None:
             __query["error_trace"] = error_trace
         if expand_wildcards is not None:
diff --git a/elasticsearch/_sync/client/esql.py b/elasticsearch/_sync/client/esql.py
index ce9a3a838..66703ce6d 100644
--- a/elasticsearch/_sync/client/esql.py
+++ b/elasticsearch/_sync/client/esql.py
@@ -22,6 +22,9 @@
 from ._base import NamespacedClient
 from .utils import SKIP_IN_PATH, _quote, _rewrite_parameters
 
+if t.TYPE_CHECKING:
+    from elasticsearch.esql import ESQLBase
+
 
 class EsqlClient(NamespacedClient):
 
@@ -31,17 +34,20 @@ class EsqlClient(NamespacedClient):
             "columnar",
             "filter",
             "include_ccs_metadata",
+            "keep_alive",
+            "keep_on_completion",
             "locale",
             "params",
             "profile",
             "tables",
+            "wait_for_completion_timeout",
         ),
         ignore_deprecated_options={"params"},
     )
     def async_query(
         self,
         *,
-        query: t.Optional[str] = None,
+        query: t.Optional[t.Union[str, "ESQLBase"]] = None,
         columnar: t.Optional[bool] = None,
         delimiter: t.Optional[str] = None,
         drop_null_columns: t.Optional[bool] = None,
@@ -80,7 +86,7 @@ def async_query(
           <p>The API accepts the same parameters and request body as the synchronous query API, along with additional async related properties.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-esql-async-query>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-esql-async-query>`_
 
         :param query: The ES|QL query API accepts an ES|QL query string in the query
             parameter, runs it, and returns the results.
@@ -96,7 +102,12 @@ def async_query(
             which has the name of all the columns.
         :param filter: Specify a Query DSL query in the filter parameter to filter the
             set of documents that an ES|QL query runs on.
-        :param format: A short version of the Accept header, for example `json` or `yaml`.
+        :param format: A short version of the Accept header, e.g. json, yaml. `csv`,
+            `tsv`, and `txt` formats will return results in a tabular format, excluding
+            other metadata fields from the response. For async requests, nothing will
+            be returned if the async query doesn't finish within the timeout. The query
+            ID and running status are available in the `X-Elasticsearch-Async-Id` and
+            `X-Elasticsearch-Async-Is-Running` HTTP headers of the response, respectively.
         :param include_ccs_metadata: When set to `true` and performing a cross-cluster
             query, the response will include an extra `_clusters` object with information
             about the clusters that participated in the search along with info such as
@@ -144,23 +155,21 @@ def async_query(
             __query["format"] = format
         if human is not None:
             __query["human"] = human
-        if keep_alive is not None:
-            __query["keep_alive"] = keep_alive
-        if keep_on_completion is not None:
-            __query["keep_on_completion"] = keep_on_completion
         if pretty is not None:
             __query["pretty"] = pretty
-        if wait_for_completion_timeout is not None:
-            __query["wait_for_completion_timeout"] = wait_for_completion_timeout
         if not __body:
             if query is not None:
-                __body["query"] = query
+                __body["query"] = str(query)
             if columnar is not None:
                 __body["columnar"] = columnar
             if filter is not None:
                 __body["filter"] = filter
             if include_ccs_metadata is not None:
                 __body["include_ccs_metadata"] = include_ccs_metadata
+            if keep_alive is not None:
+                __body["keep_alive"] = keep_alive
+            if keep_on_completion is not None:
+                __body["keep_on_completion"] = keep_on_completion
             if locale is not None:
                 __body["locale"] = locale
             if params is not None:
@@ -169,6 +178,8 @@ def async_query(
                 __body["profile"] = profile
             if tables is not None:
                 __body["tables"] = tables
+            if wait_for_completion_timeout is not None:
+                __body["wait_for_completion_timeout"] = wait_for_completion_timeout
         __headers = {"accept": "application/json", "content-type": "application/json"}
         return self.perform_request(  # type: ignore[return-value]
             "POST",
@@ -203,7 +214,7 @@ def async_query_delete(
           </ul>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-esql-async-query-delete>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-esql-async-query-delete>`_
 
         :param id: The unique identifier of the query. A query ID is provided in the
             ES|QL async query API response for a query that does not complete in the
@@ -241,6 +252,14 @@ def async_query_get(
         drop_null_columns: t.Optional[bool] = None,
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        format: t.Optional[
+            t.Union[
+                str,
+                t.Literal[
+                    "arrow", "cbor", "csv", "json", "smile", "tsv", "txt", "yaml"
+                ],
+            ]
+        ] = None,
         human: t.Optional[bool] = None,
         keep_alive: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
@@ -256,7 +275,7 @@ def async_query_get(
           If the Elasticsearch security features are enabled, only the user who first submitted the ES|QL query can retrieve the results using this API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-esql-async-query-get>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-esql-async-query-get>`_
 
         :param id: The unique identifier of the query. A query ID is provided in the
             ES|QL async query API response for a query that does not complete in the
@@ -266,6 +285,7 @@ def async_query_get(
             will be removed from the `columns` and `values` portion of the results. If
             `true`, the response will include an extra section under the name `all_columns`
             which has the name of all the columns.
+        :param format: A short version of the Accept header, for example `json` or `yaml`.
         :param keep_alive: The period for which the query and its results are stored
             in the cluster. When this period expires, the query and its results are deleted,
             even if the query is still ongoing.
@@ -286,6 +306,8 @@ def async_query_get(
             __query["error_trace"] = error_trace
         if filter_path is not None:
             __query["filter_path"] = filter_path
+        if format is not None:
+            __query["format"] = format
         if human is not None:
             __query["human"] = human
         if keep_alive is not None:
@@ -323,7 +345,7 @@ def async_query_stop(
           If the Elasticsearch security features are enabled, only the user who first submitted the ES|QL query can stop it.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/esql-async-query-stop-api.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-esql-async-query-stop>`_
 
         :param id: The unique identifier of the query. A query ID is provided in the
             ES|QL async query API response for a query that does not complete in the
@@ -375,7 +397,7 @@ def async_query_stop(
     def query(
         self,
         *,
-        query: t.Optional[str] = None,
+        query: t.Optional[t.Union[str, "ESQLBase"]] = None,
         columnar: t.Optional[bool] = None,
         delimiter: t.Optional[str] = None,
         drop_null_columns: t.Optional[bool] = None,
@@ -408,7 +430,7 @@ def query(
           Get search results for an ES|QL (Elasticsearch query language) query.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/esql-rest.html>`_
+        `<https://www.elastic.co/docs/explore-analyze/query-filter/languages/esql-rest>`_
 
         :param query: The ES|QL query API accepts an ES|QL query string in the query
             parameter, runs it, and returns the results.
@@ -424,7 +446,9 @@ def query(
             `all_columns` which has the name of all columns.
         :param filter: Specify a Query DSL query in the filter parameter to filter the
             set of documents that an ES|QL query runs on.
-        :param format: A short version of the Accept header, e.g. json, yaml.
+        :param format: A short version of the Accept header, e.g. json, yaml. `csv`,
+            `tsv`, and `txt` formats will return results in a tabular format, excluding
+            other metadata fields from the response.
         :param include_ccs_metadata: When set to `true` and performing a cross-cluster
             query, the response will include an extra `_clusters` object with information
             about the clusters that participated in the search along with info such as
@@ -462,7 +486,7 @@ def query(
             __query["pretty"] = pretty
         if not __body:
             if query is not None:
-                __body["query"] = query
+                __body["query"] = str(query)
             if columnar is not None:
                 __body["columnar"] = columnar
             if filter is not None:
diff --git a/elasticsearch/_sync/client/features.py b/elasticsearch/_sync/client/features.py
index 85432324e..7f1e143b7 100644
--- a/elasticsearch/_sync/client/features.py
+++ b/elasticsearch/_sync/client/features.py
@@ -48,7 +48,7 @@ def get_features(
           In order for a feature state to be listed in this API and recognized as a valid feature state by the create snapshot API, the plugin that defines that feature must be installed on the master node.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-features-get-features>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-features-get-features>`_
 
         :param master_timeout: Period to wait for a connection to the master node.
         """
@@ -102,7 +102,7 @@ def reset_features(
           <p>IMPORTANT: The features installed on the node you submit this request to are the features that will be reset. Run on the master node if you have any doubts about which plugins are installed on individual nodes.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-features-reset-features>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-features-reset-features>`_
 
         :param master_timeout: Period to wait for a connection to the master node.
         """
diff --git a/elasticsearch/_sync/client/fleet.py b/elasticsearch/_sync/client/fleet.py
index adb4665d9..a4230440d 100644
--- a/elasticsearch/_sync/client/fleet.py
+++ b/elasticsearch/_sync/client/fleet.py
@@ -53,7 +53,7 @@ def global_checkpoints(
           This API is designed for internal use by the Fleet server project.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/group/endpoint-fleet>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/group/endpoint-fleet>`_
 
         :param index: A single index or index alias that resolves to a single index.
         :param checkpoints: A comma separated list of previous global checkpoints. When
@@ -144,7 +144,7 @@ def msearch(
           However, similar to the Fleet search API, it supports the <code>wait_for_checkpoints</code> parameter.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-fleet-msearch>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-fleet-msearch>`_
 
         :param searches:
         :param index: A single target to search. If the target is an index alias, it
@@ -155,9 +155,9 @@ def msearch(
             example, a request targeting foo*,bar* returns an error if an index starts
             with foo but no index starts with bar.
         :param allow_partial_search_results: If true, returns partial results if there
-            are shard request timeouts or [shard failures](https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-replication.html#shard-failures).
-            If false, returns an error with no partial results. Defaults to the configured
-            cluster setting `search.default_allow_partial_results` which is true by default.
+            are shard request timeouts or shard failures. If false, returns an error
+            with no partial results. Defaults to the configured cluster setting `search.default_allow_partial_results`,
+            which is true by default.
         :param ccs_minimize_roundtrips: If true, network roundtrips between the coordinating
             node and remote clusters are minimized for cross-cluster search requests.
         :param expand_wildcards: Type of index that wildcard expressions can match. If
@@ -393,7 +393,7 @@ def search(
           after the provided checkpoint has been processed and is visible for searches inside of Elasticsearch.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-fleet-search>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-fleet-search>`_
 
         :param index: A single target to search. If the target is an index alias, it
             must resolve to a single index.
@@ -401,9 +401,9 @@ def search(
         :param aggs:
         :param allow_no_indices:
         :param allow_partial_search_results: If true, returns partial results if there
-            are shard request timeouts or [shard failures](https://www.elastic.co/guide/en/elasticsearch/reference/current/docs-replication.html#shard-failures).
-            If false, returns an error with no partial results. Defaults to the configured
-            cluster setting `search.default_allow_partial_results` which is true by default.
+            are shard request timeouts or shard failures. If false, returns an error
+            with no partial results. Defaults to the configured cluster setting `search.default_allow_partial_results`,
+            which is true by default.
         :param analyze_wildcard:
         :param analyzer:
         :param batched_reduce_size:
@@ -430,7 +430,7 @@ def search(
         :param lenient:
         :param max_concurrent_shard_requests:
         :param min_score: Minimum _score for matching documents. Documents with a lower
-            _score are not included in the search results.
+            _score are not included in search results and results collected by aggregations.
         :param pit: Limits the search to a point in time (PIT). If you provide a PIT,
             you cannot specify an <index> in the request path.
         :param post_filter:
diff --git a/elasticsearch/_sync/client/graph.py b/elasticsearch/_sync/client/graph.py
index 735917b80..8a6b8653a 100644
--- a/elasticsearch/_sync/client/graph.py
+++ b/elasticsearch/_sync/client/graph.py
@@ -55,7 +55,7 @@ def explore(
           You can exclude vertices that have already been returned.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/group/endpoint-graph>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/group/endpoint-graph>`_
 
         :param index: Name of the index.
         :param connections: Specifies or more fields from which you want to extract terms
diff --git a/elasticsearch/_sync/client/ilm.py b/elasticsearch/_sync/client/ilm.py
index 26424284a..79ce0fed7 100644
--- a/elasticsearch/_sync/client/ilm.py
+++ b/elasticsearch/_sync/client/ilm.py
@@ -44,7 +44,7 @@ def delete_lifecycle(
           You cannot delete policies that are currently in use. If the policy is being used to manage any indices, the request fails and returns an error.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ilm-delete-lifecycle>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ilm-delete-lifecycle>`_
 
         :param name: Identifier for the policy.
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -102,7 +102,7 @@ def explain_lifecycle(
           <p>The response indicates when the index entered each lifecycle state, provides the definition of the running phase, and information about any failures.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ilm-explain-lifecycle>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ilm-explain-lifecycle>`_
 
         :param index: Comma-separated list of data streams, indices, and aliases to target.
             Supports wildcards (`*`). To target all data streams and indices, use `*`
@@ -163,7 +163,7 @@ def get_lifecycle(
           <p>Get lifecycle policies.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ilm-get-lifecycle>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ilm-get-lifecycle>`_
 
         :param name: Identifier for the policy.
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -218,7 +218,7 @@ def get_status(
           <p>Get the current index lifecycle management status.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ilm-get-status>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ilm-get-status>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_ilm/status"
@@ -275,7 +275,7 @@ def migrate_to_data_tiers(
           Use the stop ILM and get ILM status APIs to wait until the reported operation mode is <code>STOPPED</code>.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ilm-migrate-to-data-tiers>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ilm-migrate-to-data-tiers>`_
 
         :param dry_run: If true, simulates the migration from node attributes based allocation
             filters to data tiers, but does not perform the migration. This provides
@@ -354,7 +354,7 @@ def move_to_step(
           An index cannot move to a step that is not part of its policy.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ilm-move-to-step>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ilm-move-to-step>`_
 
         :param index: The name of the index whose lifecycle step is to change
         :param current_step: The step that the index is expected to be in.
@@ -422,7 +422,7 @@ def put_lifecycle(
           <p>NOTE: Only the latest version of the policy is stored, you cannot revert to previous versions.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ilm-put-lifecycle>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ilm-put-lifecycle>`_
 
         :param name: Identifier for the policy.
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -486,7 +486,7 @@ def remove_policy(
           It also stops managing the indices.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ilm-remove-policy>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ilm-remove-policy>`_
 
         :param index: The name of the index to remove policy on
         """
@@ -532,7 +532,7 @@ def retry(
           Use the explain lifecycle state API to determine whether an index is in the ERROR step.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ilm-retry>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ilm-retry>`_
 
         :param index: The name of the indices (comma-separated) whose failed lifecycle
             step is to be retry
@@ -580,7 +580,7 @@ def start(
           Restarting ILM is necessary only when it has been stopped using the stop ILM API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ilm-start>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ilm-start>`_
 
         :param master_timeout: Period to wait for a connection to the master node. If
             no response is received before the timeout expires, the request fails and
@@ -634,7 +634,7 @@ def stop(
           Use the get ILM status API to check whether ILM is running.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ilm-stop>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ilm-stop>`_
 
         :param master_timeout: Period to wait for a connection to the master node. If
             no response is received before the timeout expires, the request fails and
diff --git a/elasticsearch/_sync/client/indices.py b/elasticsearch/_sync/client/indices.py
index 4d502f1af..ed5e6459a 100644
--- a/elasticsearch/_sync/client/indices.py
+++ b/elasticsearch/_sync/client/indices.py
@@ -62,7 +62,7 @@ def add_block(
           Index blocks limit the operations allowed on an index by blocking specific operation types.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-add-block>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-add-block>`_
 
         :param index: A comma-separated list or wildcard expression of index names used
             to limit the request. By default, you must explicitly name the indices you
@@ -173,7 +173,7 @@ def analyze(
           The <code>_analyze</code> endpoint without a specified index will always use <code>10000</code> as its limit.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-analyze>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-analyze>`_
 
         :param index: Index used to derive the analyzer. If specified, the `analyzer`
             or field parameter overrides this value. If no index is specified or the
@@ -265,7 +265,7 @@ def cancel_migrate_reindex(
           <p>Cancel a migration reindex attempt for a data stream or index.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/migrate-data-stream.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-cancel-migrate-reindex>`_
 
         :param index: The index or data stream name
         """
@@ -327,7 +327,7 @@ def clear_cache(
           To clear the cache only of specific fields, use the <code>fields</code> parameter.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-clear-cache>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-clear-cache>`_
 
         :param index: Comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (`*`). To target all data streams
@@ -338,7 +338,7 @@ def clear_cache(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param fielddata: If `true`, clears the fields cache. Use the `fields` parameter
             to clear the cache of specific fields only.
         :param fields: Comma-separated list of field names used to limit the `fielddata`
@@ -449,7 +449,7 @@ def clone(
           <p>Because the clone operation creates a new index to clone the shards to, the wait for active shards setting on index creation applies to the clone index action as well.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-clone>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-clone>`_
 
         :param index: Name of the source index to clone.
         :param target: Name of the target index to create.
@@ -553,7 +553,7 @@ def close(
           Closing indices can be turned off with the cluster settings API by setting <code>cluster.indices.close.enable</code> to <code>false</code>.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-close>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-close>`_
 
         :param index: Comma-separated list or wildcard expression of index names used
             to limit the request.
@@ -563,7 +563,7 @@ def close(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -654,9 +654,17 @@ def create(
           Note that changing this setting will also affect the <code>wait_for_active_shards</code> value on all subsequent write operations.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-create>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-create>`_
 
-        :param index: Name of the index you wish to create.
+        :param index: Name of the index you wish to create. Index names must meet the
+            following criteria: * Lowercase only * Cannot include `\\`, `/`, `*`, `?`,
+            `"`, `<`, `>`, `|`, ` ` (space character), `,`, or `#` * Indices prior to
+            7.0 could contain a colon (`:`), but that has been deprecated and will not
+            be supported in later versions * Cannot start with `-`, `_`, or `+` * Cannot
+            be `.` or `..` * Cannot be longer than 255 bytes (note thtat it is bytes,
+            so multi-byte characters will reach the limit faster) * Names starting with
+            `.` are deprecated, except for hidden indices and internal indices managed
+            by plugins
         :param aliases: Aliases for the index.
         :param mappings: Mapping for fields in the index. If specified, this mapping
             can include: - Field names - Field data types - Mapping parameters
@@ -731,7 +739,7 @@ def create_data_stream(
           <p>You must have a matching index template with data stream enabled.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-create-data-stream>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-create-data-stream>`_
 
         :param name: Name of the data stream, which must meet the following criteria:
             Lowercase only; Cannot include `\\`, `/`, `*`, `?`, `"`, `<`, `>`, `|`, `,`,
@@ -794,7 +802,7 @@ def create_from(
           <p>Copy the mappings and settings from the source index to a destination index while allowing request settings and mappings to override the source values.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/migrate-data-stream.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-create-from>`_
 
         :param source: The source index or data stream name
         :param dest: The destination index or data stream name
@@ -861,7 +869,7 @@ def data_streams_stats(
           <p>Get statistics for one or more data streams.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-data-streams-stats-1>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-data-streams-stats-1>`_
 
         :param name: Comma-separated list of data streams used to limit the request.
             Wildcard expressions (`*`) are supported. To target all data streams in a
@@ -930,7 +938,7 @@ def delete(
           You can then use the delete index API to delete the previous write index.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-delete>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-delete>`_
 
         :param index: Comma-separated list of indices to delete. You cannot specify index
             aliases. By default, this parameter does not support wildcards (`*`) or `_all`.
@@ -942,7 +950,7 @@ def delete(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -1004,7 +1012,7 @@ def delete_alias(
           Removes a data stream or index from an alias.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-delete-alias>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-delete-alias>`_
 
         :param index: Comma-separated list of data streams or indices used to limit the
             request. Supports wildcards (`*`).
@@ -1072,7 +1080,7 @@ def delete_data_lifecycle(
           Removes the data stream lifecycle from a data stream, rendering it not managed by the data stream lifecycle.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-delete-data-lifecycle>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-delete-data-lifecycle>`_
 
         :param name: A comma-separated list of data streams of which the data stream
             lifecycle will be deleted; use `*` to get all data streams
@@ -1136,7 +1144,7 @@ def delete_data_stream(
           Deletes one or more data streams and their backing indices.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-delete-data-stream>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-delete-data-stream>`_
 
         :param name: Comma-separated list of data streams to delete. Wildcard (`*`) expressions
             are supported.
@@ -1194,7 +1202,7 @@ def delete_index_template(
           existing templates.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-delete-index-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-delete-index-template>`_
 
         :param name: Comma-separated list of index template names used to limit the request.
             Wildcard (*) expressions are supported.
@@ -1246,10 +1254,11 @@ def delete_template(
         """
         .. raw:: html
 
-          <p>Delete a legacy index template.</p>
+          <p>Delete a legacy index template.
+          IMPORTANT: This documentation is about legacy index templates, which are deprecated and will be replaced by the composable templates introduced in Elasticsearch 7.8.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-delete-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-delete-template>`_
 
         :param name: The name of the legacy index template to delete. Wildcard (`*`)
             expressions are supported.
@@ -1321,7 +1330,7 @@ def disk_usage(
           The stored size of the <code>_id</code> field is likely underestimated while the <code>_source</code> field is overestimated.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-disk-usage>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-disk-usage>`_
 
         :param index: Comma-separated list of data streams, indices, and aliases used
             to limit the request. It’s recommended to execute this API with a single
@@ -1404,7 +1413,7 @@ def downsample(
           The source index must be read only (<code>index.blocks.write: true</code>).</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-downsample>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-downsample>`_
 
         :param index: Name of the time series index to downsample.
         :param target_index: Name of the index to create.
@@ -1476,7 +1485,7 @@ def exists(
           Check if one or more indices, index aliases, or data streams exist.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-exists>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-exists>`_
 
         :param index: Comma-separated list of data streams, indices, and aliases. Supports
             wildcards (`*`).
@@ -1486,7 +1495,7 @@ def exists(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param flat_settings: If `true`, returns settings in flat format.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
@@ -1558,7 +1567,7 @@ def exists_alias(
           <p>Check if one or more data stream or index aliases exist.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-exists-alias>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-exists-alias>`_
 
         :param name: Comma-separated list of aliases to check. Supports wildcards (`*`).
         :param index: Comma-separated list of data streams or indices used to limit the
@@ -1570,7 +1579,7 @@ def exists_alias(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param ignore_unavailable: If `false`, requests that include a missing data stream
             or index in the target indices or data streams return an error.
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -1622,7 +1631,9 @@ def exists_index_template(
         name: str,
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        flat_settings: t.Optional[bool] = None,
         human: t.Optional[bool] = None,
+        local: t.Optional[bool] = None,
         master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
     ) -> HeadApiResponse:
@@ -1633,10 +1644,14 @@ def exists_index_template(
           <p>Check whether index templates exist.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-exists-index-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-exists-index-template>`_
 
         :param name: Comma-separated list of index template names used to limit the request.
             Wildcard (*) expressions are supported.
+        :param flat_settings: If true, returns settings in flat format.
+        :param local: If true, the request retrieves information from the local node
+            only. Defaults to false, which means information is retrieved from the master
+            node.
         :param master_timeout: Period to wait for a connection to the master node. If
             no response is received before the timeout expires, the request fails and
             returns an error.
@@ -1650,8 +1665,12 @@ def exists_index_template(
             __query["error_trace"] = error_trace
         if filter_path is not None:
             __query["filter_path"] = filter_path
+        if flat_settings is not None:
+            __query["flat_settings"] = flat_settings
         if human is not None:
             __query["human"] = human
+        if local is not None:
+            __query["local"] = local
         if master_timeout is not None:
             __query["master_timeout"] = master_timeout
         if pretty is not None:
@@ -1688,7 +1707,7 @@ def exists_template(
           <p>IMPORTANT: This documentation is about legacy index templates, which are deprecated and will be replaced by the composable templates introduced in Elasticsearch 7.8.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-exists-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-exists-template>`_
 
         :param name: A comma-separated list of index template names used to limit the
             request. Wildcard (`*`) expressions are supported.
@@ -1746,7 +1765,7 @@ def explain_data_lifecycle(
           Get information about an index or data stream's current data stream lifecycle status, such as time since index creation, time since rollover, the lifecycle configuration managing the index, or any errors encountered during lifecycle execution.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-explain-data-lifecycle>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-explain-data-lifecycle>`_
 
         :param index: The name of the index to explain
         :param include_defaults: indicates if the API should return the default values
@@ -1801,9 +1820,6 @@ def field_usage_stats(
         human: t.Optional[bool] = None,
         ignore_unavailable: t.Optional[bool] = None,
         pretty: t.Optional[bool] = None,
-        wait_for_active_shards: t.Optional[
-            t.Union[int, t.Union[str, t.Literal["all", "index-setting"]]]
-        ] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
         .. raw:: html
@@ -1816,7 +1832,7 @@ def field_usage_stats(
           A given request will increment each count by a maximum value of 1, even if the request accesses the same field multiple times.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-field-usage-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-field-usage-stats>`_
 
         :param index: Comma-separated list or wildcard expression of index names used
             to limit the request.
@@ -1833,9 +1849,6 @@ def field_usage_stats(
             in the statistics.
         :param ignore_unavailable: If `true`, missing or closed indices are not included
             in the response.
-        :param wait_for_active_shards: The number of shard copies that must be active
-            before proceeding with the operation. Set to all or any positive integer
-            up to the total number of shards in the index (`number_of_replicas+1`).
         """
         if index in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'index'")
@@ -1858,8 +1871,6 @@ def field_usage_stats(
             __query["ignore_unavailable"] = ignore_unavailable
         if pretty is not None:
             __query["pretty"] = pretty
-        if wait_for_active_shards is not None:
-            __query["wait_for_active_shards"] = wait_for_active_shards
         __headers = {"accept": "application/json"}
         return self.perform_request(  # type: ignore[return-value]
             "GET",
@@ -1906,7 +1917,7 @@ def flush(
           If you call the flush API after indexing some documents then a successful response indicates that Elasticsearch has flushed all the documents that were indexed before the flush API was called.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-flush>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-flush>`_
 
         :param index: Comma-separated list of data streams, indices, and aliases to flush.
             Supports wildcards (`*`). To flush all data streams and indices, omit this
@@ -1917,7 +1928,7 @@ def flush(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param force: If `true`, the request forces a flush even if there are no changes
             to commit to the index.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
@@ -2031,7 +2042,7 @@ def forcemerge(
           </code></pre>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-forcemerge>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-forcemerge>`_
 
         :param index: A comma-separated list of index names; use `_all` or empty string
             to perform the operation on all indices
@@ -2129,7 +2140,7 @@ def get(
           stream’s backing indices.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-get>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-get>`_
 
         :param index: Comma-separated list of data streams, indices, and index aliases
             used to limit the request. Wildcard expressions (*) are supported.
@@ -2222,7 +2233,7 @@ def get_alias(
           Retrieves information for one or more data stream or index aliases.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-get-alias>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-get-alias>`_
 
         :param index: Comma-separated list of data streams or indices used to limit the
             request. Supports wildcards (`*`). To target all data streams and indices,
@@ -2235,7 +2246,7 @@ def get_alias(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -2309,14 +2320,13 @@ def get_data_lifecycle(
           <p>Get the data stream lifecycle configuration of one or more data streams.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-get-data-lifecycle>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-get-data-lifecycle>`_
 
         :param name: Comma-separated list of data streams to limit the request. Supports
             wildcards (`*`). To target all data streams, omit this parameter or use `*`
             or `_all`.
         :param expand_wildcards: Type of data stream that wildcard patterns can match.
-            Supports comma-separated values, such as `open,hidden`. Valid values are:
-            `all`, `open`, `closed`, `hidden`, `none`.
+            Supports comma-separated values, such as `open,hidden`.
         :param include_defaults: If `true`, return all default settings in the response.
         :param master_timeout: Period to wait for a connection to the master node. If
             no response is received before the timeout expires, the request fails and
@@ -2367,7 +2377,7 @@ def get_data_lifecycle_stats(
           Get statistics about the data streams that are managed by a data stream lifecycle.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-get-data-lifecycle-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-get-data-lifecycle-stats>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_lifecycle/stats"
@@ -2418,7 +2428,7 @@ def get_data_stream(
           <p>Get information about one or more data streams.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-get-data-stream>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-get-data-stream>`_
 
         :param name: Comma-separated list of data stream names used to limit the request.
             Wildcard (`*`) expressions are supported. If omitted, all data streams are
@@ -2487,6 +2497,7 @@ def get_field_mapping(
         human: t.Optional[bool] = None,
         ignore_unavailable: t.Optional[bool] = None,
         include_defaults: t.Optional[bool] = None,
+        local: t.Optional[bool] = None,
         pretty: t.Optional[bool] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
@@ -2498,7 +2509,7 @@ def get_field_mapping(
           <p>This API is useful if you don't need a complete mapping or if an index mapping contains a large number of fields.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-get-mapping>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-get-mapping>`_
 
         :param fields: Comma-separated list or wildcard expression of fields used to
             limit returned information. Supports wildcards (`*`).
@@ -2511,10 +2522,12 @@ def get_field_mapping(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
         :param include_defaults: If `true`, return all default settings in the response.
+        :param local: If `true`, the request retrieves information from the local node
+            only.
         """
         if fields in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'fields'")
@@ -2542,6 +2555,8 @@ def get_field_mapping(
             __query["ignore_unavailable"] = ignore_unavailable
         if include_defaults is not None:
             __query["include_defaults"] = include_defaults
+        if local is not None:
+            __query["local"] = local
         if pretty is not None:
             __query["pretty"] = pretty
         __headers = {"accept": "application/json"}
@@ -2575,7 +2590,7 @@ def get_index_template(
           Get information about one or more index templates.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-get-index-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-get-index-template>`_
 
         :param name: Comma-separated list of index template names used to limit the request.
             Wildcard (*) expressions are supported.
@@ -2652,7 +2667,7 @@ def get_mapping(
           For data streams, the API retrieves mappings for the stream’s backing indices.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-get-mapping>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-get-mapping>`_
 
         :param index: Comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (`*`). To target all data streams
@@ -2663,7 +2678,7 @@ def get_mapping(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
         :param local: If `true`, the request retrieves information from the local node
@@ -2726,7 +2741,7 @@ def get_migrate_reindex_status(
           <p>Get the status of a migration reindex attempt for a data stream or index.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/migrate-data-stream.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/group/endpoint-migration>`_
 
         :param index: The index or data stream name.
         """
@@ -2786,7 +2801,7 @@ def get_settings(
           For data streams, it returns setting information for the stream's backing indices.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-get-settings>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-get-settings>`_
 
         :param index: Comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (`*`). To target all data streams
@@ -2873,12 +2888,12 @@ def get_template(
         """
         .. raw:: html
 
-          <p>Get index templates.
+          <p>Get legacy index templates.
           Get information about one or more index templates.</p>
           <p>IMPORTANT: This documentation is about legacy index templates, which are deprecated and will be replaced by the composable templates introduced in Elasticsearch 7.8.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-get-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-get-template>`_
 
         :param name: Comma-separated list of index template names used to limit the request.
             Wildcard (`*`) expressions are supported. To return all index templates,
@@ -2945,7 +2960,7 @@ def migrate_reindex(
           The persistent task ID is returned immediately and the reindexing work is completed in that task.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/migrate-data-stream.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-migrate-reindex>`_
 
         :param reindex:
         """
@@ -3006,7 +3021,7 @@ def migrate_to_data_stream(
           The write index for the alias becomes the write index for the stream.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/data-streams.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-migrate-to-data-stream>`_
 
         :param name: Name of the index alias to convert to a data stream.
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -3062,7 +3077,7 @@ def modify_data_stream(
           Performs one or more data stream modification actions in a single atomic operation.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/data-streams.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-modify-data-stream>`_
 
         :param actions: Actions to perform.
         """
@@ -3141,7 +3156,7 @@ def open(
           <p>Because opening or closing an index allocates its shards, the <code>wait_for_active_shards</code> setting on index creation applies to the <code>_open</code> and <code>_close</code> index actions as well.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-open>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-open>`_
 
         :param index: Comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (`*`). By default, you must explicitly
@@ -3155,7 +3170,7 @@ def open(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -3227,7 +3242,7 @@ def promote_data_stream(
           This will affect the lifecycle management of the data stream and interfere with the data stream size and retention.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/data-streams.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-promote-data-stream>`_
 
         :param name: The name of the data stream
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -3293,7 +3308,7 @@ def put_alias(
           Adds a data stream or index to an alias.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-aliases.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-put-alias>`_
 
         :param index: Comma-separated list of data streams or indices to add. Supports
             wildcards (`*`). Wildcard patterns that match both data streams and indices
@@ -3400,7 +3415,7 @@ def put_data_lifecycle(
           Update the data stream lifecycle of the specified data streams.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/data-streams-put-lifecycle.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-put-data-lifecycle>`_
 
         :param name: Comma-separated list of data streams used to limit the request.
             Supports wildcards (`*`). To target all data streams use `*` or `_all`.
@@ -3414,8 +3429,7 @@ def put_data_lifecycle(
             for this data stream. A data stream lifecycle that's disabled (enabled: `false`)
             will have no effect on the data stream.
         :param expand_wildcards: Type of data stream that wildcard patterns can match.
-            Supports comma-separated values, such as `open,hidden`. Valid values are:
-            `all`, `hidden`, `open`, `closed`, `none`.
+            Supports comma-separated values, such as `open,hidden`.
         :param master_timeout: Period to wait for a connection to the master node. If
             no response is received before the timeout expires, the request fails and
             returns an error.
@@ -3528,7 +3542,7 @@ def put_index_template(
           If an entry already exists with the same key, then it is overwritten by the new definition.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-put-template.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-put-index-template>`_
 
         :param name: Index or template name
         :param allow_auto_create: This setting overrides the value of the `action.auto_create_index`
@@ -3691,27 +3705,20 @@ def put_mapping(
 
           <p>Update field mappings.
           Add new fields to an existing data stream or index.
-          You can also use this API to change the search settings of existing fields and add new properties to existing object fields.
-          For data streams, these changes are applied to all backing indices by default.</p>
-          <p><strong>Add multi-fields to an existing field</strong></p>
-          <p>Multi-fields let you index the same field in different ways.
-          You can use this API to update the fields mapping parameter and enable multi-fields for an existing field.
-          WARNING: If an index (or data stream) contains documents when you add a multi-field, those documents will not have values for the new multi-field.
-          You can populate the new multi-field with the update by query API.</p>
-          <p><strong>Change supported mapping parameters for an existing field</strong></p>
-          <p>The documentation for each mapping parameter indicates whether you can update it for an existing field using this API.
-          For example, you can use the update mapping API to update the <code>ignore_above</code> parameter.</p>
-          <p><strong>Change the mapping of an existing field</strong></p>
-          <p>Except for supported mapping parameters, you can't change the mapping or field type of an existing field.
-          Changing an existing field could invalidate data that's already indexed.</p>
-          <p>If you need to change the mapping of a field in a data stream's backing indices, refer to documentation about modifying data streams.
-          If you need to change the mapping of a field in other indices, create a new index with the correct mapping and reindex your data into that index.</p>
-          <p><strong>Rename a field</strong></p>
-          <p>Renaming a field would invalidate data already indexed under the old field name.
-          Instead, add an alias field to create an alternate field name.</p>
-
-
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-put-mapping>`_
+          You can use the update mapping API to:</p>
+          <ul>
+          <li>Add a new field to an existing index</li>
+          <li>Update mappings for multiple indices in a single request</li>
+          <li>Add new properties to an object field</li>
+          <li>Enable multi-fields for an existing field</li>
+          <li>Update supported mapping parameters</li>
+          <li>Change a field's mapping using reindexing</li>
+          <li>Rename a field using a field alias</li>
+          </ul>
+          <p>Learn how to use the update mapping API with practical examples in the <a href="https://www.elastic.co/docs/manage-data/data-store/mapping/update-mappings-examples">Update mapping API examples</a> guide.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-put-mapping>`_
 
         :param index: A comma-separated list of index names the mapping should be added
             to (supports wildcards); use `_all` or omit to add the mapping on all indices.
@@ -3727,7 +3734,7 @@ def put_mapping(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param field_names: Control whether field names are enabled for the index.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
@@ -3835,6 +3842,7 @@ def put_settings(
         master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         preserve_existing: t.Optional[bool] = None,
         pretty: t.Optional[bool] = None,
+        reopen: t.Optional[bool] = None,
         timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
@@ -3844,8 +3852,36 @@ def put_settings(
           Changes dynamic index settings in real time.
           For data streams, index setting changes are applied to all backing indices by default.</p>
           <p>To revert a setting to the default value, use a null value.
-          The list of per-index settings that can be updated dynamically on live indices can be found in index module documentation.
+          The list of per-index settings that can be updated dynamically on live indices can be found in index settings documentation.
           To preserve existing settings from being updated, set the <code>preserve_existing</code> parameter to <code>true</code>.</p>
+          <p>For performance optimization during bulk indexing, you can disable the refresh interval.
+          Refer to <a href="https://www.elastic.co/docs/deploy-manage/production-guidance/optimize-performance/indexing-speed#disable-refresh-interval">disable refresh interval</a> for an example.
+          There are multiple valid ways to represent index settings in the request body. You can specify only the setting, for example:</p>
+          <pre><code>{
+            &quot;number_of_replicas&quot;: 1
+          }
+          </code></pre>
+          <p>Or you can use an <code>index</code> setting object:</p>
+          <pre><code>{
+            &quot;index&quot;: {
+              &quot;number_of_replicas&quot;: 1
+            }
+          }
+          </code></pre>
+          <p>Or you can use dot annotation:</p>
+          <pre><code>{
+            &quot;index.number_of_replicas&quot;: 1
+          }
+          </code></pre>
+          <p>Or you can embed any of the aforementioned options in a <code>settings</code> object. For example:</p>
+          <pre><code>{
+            &quot;settings&quot;: {
+              &quot;index&quot;: {
+                &quot;number_of_replicas&quot;: 1
+              }
+            }
+          }
+          </code></pre>
           <p>NOTE: You can only define new analyzers on closed indices.
           To add an analyzer, you must close the index, define the analyzer, and reopen the index.
           You cannot close the write index of a data stream.
@@ -3853,10 +3889,11 @@ def put_settings(
           Then roll over the data stream to apply the new analyzer to the stream's write index and future backing indices.
           This affects searches and any new data added to the stream after the rollover.
           However, it does not affect the data stream's backing indices or their existing data.
-          To change the analyzer for existing backing indices, you must create a new data stream and reindex your data into it.</p>
+          To change the analyzer for existing backing indices, you must create a new data stream and reindex your data into it.
+          Refer to <a href="https://www.elastic.co/docs/manage-data/data-store/text-analysis/specify-an-analyzer#update-analyzers-on-existing-indices">updating analyzers on existing indices</a> for step-by-step examples.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-put-settings>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-put-settings>`_
 
         :param settings:
         :param index: Comma-separated list of data streams, indices, and aliases used
@@ -3877,6 +3914,9 @@ def put_settings(
             no response is received before the timeout expires, the request fails and
             returns an error.
         :param preserve_existing: If `true`, existing index settings remain unchanged.
+        :param reopen: Whether to close and reopen the index to apply non-dynamic settings.
+            If set to `true` the indices to which the settings are being applied will
+            be closed temporarily and then reopened in order to apply the changes.
         :param timeout: Period to wait for a response. If no response is received before
             the timeout expires, the request fails and returns an error.
         """
@@ -3914,6 +3954,8 @@ def put_settings(
             __query["preserve_existing"] = preserve_existing
         if pretty is not None:
             __query["pretty"] = pretty
+        if reopen is not None:
+            __query["reopen"] = reopen
         if timeout is not None:
             __query["timeout"] = timeout
         __body = settings if settings is not None else body
@@ -3960,7 +4002,7 @@ def put_template(
         """
         .. raw:: html
 
-          <p>Create or update an index template.
+          <p>Create or update a legacy index template.
           Index templates define settings, mappings, and aliases that can be applied automatically to new indices.
           Elasticsearch applies templates to new indices based on an index pattern that matches the index name.</p>
           <p>IMPORTANT: This documentation is about legacy index templates, which are deprecated and will be replaced by the composable templates introduced in Elasticsearch 7.8.</p>
@@ -3977,11 +4019,11 @@ def put_template(
           NOTE: Multiple matching templates with the same order value will result in a non-deterministic merging order.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-put-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-put-template>`_
 
         :param name: The name of the template
         :param aliases: Aliases for the index.
-        :param cause:
+        :param cause: User defined reason for creating/updating the index template
         :param create: If true, this request cannot replace or update existing index
             templates.
         :param index_patterns: Array of wildcard expressions used to match the names
@@ -4049,10 +4091,20 @@ def recovery(
         *,
         index: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         active_only: t.Optional[bool] = None,
+        allow_no_indices: t.Optional[bool] = None,
         detailed: t.Optional[bool] = None,
         error_trace: t.Optional[bool] = None,
+        expand_wildcards: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[str, t.Literal["all", "closed", "hidden", "none", "open"]]
+                ],
+                t.Union[str, t.Literal["all", "closed", "hidden", "none", "open"]],
+            ]
+        ] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         human: t.Optional[bool] = None,
+        ignore_unavailable: t.Optional[bool] = None,
         pretty: t.Optional[bool] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
@@ -4079,14 +4131,23 @@ def recovery(
           This means that if a shard copy completes a recovery and then Elasticsearch relocates it onto a different node then the information about the original recovery will not be shown in the recovery API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-recovery>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-recovery>`_
 
         :param index: Comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (`*`). To target all data streams
             and indices, omit this parameter or use `*` or `_all`.
         :param active_only: If `true`, the response only includes ongoing shard recoveries.
+        :param allow_no_indices: If `false`, the request returns an error if any wildcard
+            expression, index alias, or `_all` value targets only missing or closed indices.
+            This behavior applies even if the request targets other open indices.
         :param detailed: If `true`, the response includes detailed information about
             shard recoveries.
+        :param expand_wildcards: Type of index that wildcard patterns can match. If the
+            request can target data streams, this argument determines whether wildcard
+            expressions match hidden data streams. Supports comma-separated values, such
+            as `open,hidden`.
+        :param ignore_unavailable: If `false`, the request returns an error if it targets
+            a missing or closed index.
         """
         __path_parts: t.Dict[str, str]
         if index not in SKIP_IN_PATH:
@@ -4098,14 +4159,20 @@ def recovery(
         __query: t.Dict[str, t.Any] = {}
         if active_only is not None:
             __query["active_only"] = active_only
+        if allow_no_indices is not None:
+            __query["allow_no_indices"] = allow_no_indices
         if detailed is not None:
             __query["detailed"] = detailed
         if error_trace is not None:
             __query["error_trace"] = error_trace
+        if expand_wildcards is not None:
+            __query["expand_wildcards"] = expand_wildcards
         if filter_path is not None:
             __query["filter_path"] = filter_path
         if human is not None:
             __query["human"] = human
+        if ignore_unavailable is not None:
+            __query["ignore_unavailable"] = ignore_unavailable
         if pretty is not None:
             __query["pretty"] = pretty
         __headers = {"accept": "application/json"}
@@ -4153,7 +4220,7 @@ def refresh(
           This option ensures the indexing operation waits for a periodic refresh before running the search.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-refresh>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-refresh>`_
 
         :param index: Comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (`*`). To target all data streams
@@ -4164,7 +4231,7 @@ def refresh(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
         """
@@ -4219,6 +4286,7 @@ def reload_search_analyzers(
         human: t.Optional[bool] = None,
         ignore_unavailable: t.Optional[bool] = None,
         pretty: t.Optional[bool] = None,
+        resource: t.Optional[str] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
         .. raw:: html
@@ -4236,7 +4304,7 @@ def reload_search_analyzers(
           This ensures the synonym file is updated everywhere in the cluster in case shards are relocated in the future.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-reload-search-analyzers>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-reload-search-analyzers>`_
 
         :param index: A comma-separated list of index names to reload analyzers for
         :param allow_no_indices: Whether to ignore if a wildcard indices expression resolves
@@ -4246,6 +4314,7 @@ def reload_search_analyzers(
             that are open, closed or both.
         :param ignore_unavailable: Whether specified concrete indices should be ignored
             when unavailable (missing or closed)
+        :param resource: Changed resource to reload analyzers from if applicable
         """
         if index in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'index'")
@@ -4266,6 +4335,8 @@ def reload_search_analyzers(
             __query["ignore_unavailable"] = ignore_unavailable
         if pretty is not None:
             __query["pretty"] = pretty
+        if resource is not None:
+            __query["resource"] = resource
         __headers = {"accept": "application/json"}
         return self.perform_request(  # type: ignore[return-value]
             "POST",
@@ -4340,7 +4411,7 @@ def resolve_cluster(
           If a connection was (re-)established, this will also cause the <code>remote/info</code> endpoint to now indicate a connected status.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-resolve-cluster>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-resolve-cluster>`_
 
         :param name: A comma-separated list of names or index patterns for the indices,
             aliases, and data streams to resolve. Resources on remote clusters can be
@@ -4359,10 +4430,9 @@ def resolve_cluster(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
-            NOTE: This option is only supported when specifying an index expression.
-            You will get an error if you specify index options to the `_resolve/cluster`
-            API endpoint that takes no index expression.
+            as `open,hidden`. NOTE: This option is only supported when specifying an
+            index expression. You will get an error if you specify index options to the
+            `_resolve/cluster` API endpoint that takes no index expression.
         :param ignore_throttled: If true, concrete, expanded, or aliased indices are
             ignored when frozen. NOTE: This option is only supported when specifying
             an index expression. You will get an error if you specify index options to
@@ -4442,7 +4512,7 @@ def resolve_index(
           Multiple patterns and remote clusters are supported.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-resolve-index>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-resolve-index>`_
 
         :param name: Comma-separated name(s) or index pattern(s) of the indices, aliases,
             and data streams to resolve. Resources on remote clusters can be specified
@@ -4455,7 +4525,7 @@ def resolve_index(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
         """
@@ -4502,6 +4572,7 @@ def rollover(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         human: t.Optional[bool] = None,
+        lazy: t.Optional[bool] = None,
         mappings: t.Optional[t.Mapping[str, t.Any]] = None,
         master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
@@ -4516,7 +4587,7 @@ def rollover(
         .. raw:: html
 
           <p>Roll over to a new index.
-          TIP: It is recommended to use the index lifecycle rollover action to automate rollovers.</p>
+          TIP: We recommend using the index lifecycle rollover action to automate rollovers. However, Serverless does not support Index Lifecycle Management (ILM), so don't use this approach in the Serverless context.</p>
           <p>The rollover API creates a new index for a data stream or index alias.
           The API behavior depends on the rollover target.</p>
           <p><strong>Roll over a data stream</strong></p>
@@ -4543,7 +4614,7 @@ def rollover(
           If you roll over the alias on May 7, 2099, the new index's name is <code>my-index-2099.05.07-000002</code>.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-rollover>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-rollover>`_
 
         :param alias: Name of the data stream or index alias to roll over.
         :param new_index: Name of the index to create. Supports date math. Data streams
@@ -4558,6 +4629,9 @@ def rollover(
             conditions are satisfied.
         :param dry_run: If `true`, checks whether the current index satisfies the specified
             conditions but does not perform a rollover.
+        :param lazy: If set to true, the rollover action will only mark a data stream
+            to signal that it needs to be rolled over at the next write. Only allowed
+            on data streams.
         :param mappings: Mapping for fields in the index. If specified, this mapping
             can include field names, field data types, and mapping paramaters.
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -4592,6 +4666,8 @@ def rollover(
             __query["filter_path"] = filter_path
         if human is not None:
             __query["human"] = human
+        if lazy is not None:
+            __query["lazy"] = lazy
         if master_timeout is not None:
             __query["master_timeout"] = master_timeout
         if pretty is not None:
@@ -4652,7 +4728,7 @@ def segments(
           For data streams, the API returns information about the stream's backing indices.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-segments>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-segments>`_
 
         :param index: Comma-separated list of data streams, indices, and aliases used
             to limit the request. Supports wildcards (`*`). To target all data streams
@@ -4663,7 +4739,7 @@ def segments(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
             a missing or closed index.
         """
@@ -4741,7 +4817,7 @@ def shard_stores(
           <p>By default, the API returns store information only for primary shards that are unassigned or have one or more unassigned replica shards.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-shard-stores>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-shard-stores>`_
 
         :param index: List of data streams, indices, and aliases used to limit the request.
         :param allow_no_indices: If false, the request returns an error if any wildcard
@@ -4843,7 +4919,7 @@ def shrink(
           </ul>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-shrink>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-shrink>`_
 
         :param index: Name of the source index to shrink.
         :param target: Name of the target index to create.
@@ -4908,6 +4984,8 @@ def simulate_index_template(
         self,
         *,
         name: str,
+        cause: t.Optional[str] = None,
+        create: t.Optional[bool] = None,
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         human: t.Optional[bool] = None,
@@ -4922,9 +5000,13 @@ def simulate_index_template(
           Get the index configuration that would be applied to the specified index from an existing index template.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-simulate-index-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-simulate-index-template>`_
 
         :param name: Name of the index to simulate
+        :param cause: User defined reason for dry-run creating the new template for simulation
+            purposes
+        :param create: Whether the index template we optionally defined in the body should
+            only be dry-run added if new or can also replace an existing one
         :param include_defaults: If true, returns all relevant default configurations
             for the index template.
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -4936,6 +5018,10 @@ def simulate_index_template(
         __path_parts: t.Dict[str, str] = {"name": _quote(name)}
         __path = f'/_index_template/_simulate_index/{__path_parts["name"]}'
         __query: t.Dict[str, t.Any] = {}
+        if cause is not None:
+            __query["cause"] = cause
+        if create is not None:
+            __query["create"] = create
         if error_trace is not None:
             __query["error_trace"] = error_trace
         if filter_path is not None:
@@ -4978,6 +5064,7 @@ def simulate_template(
         *,
         name: t.Optional[str] = None,
         allow_auto_create: t.Optional[bool] = None,
+        cause: t.Optional[str] = None,
         composed_of: t.Optional[t.Sequence[str]] = None,
         create: t.Optional[bool] = None,
         data_stream: t.Optional[t.Mapping[str, t.Any]] = None,
@@ -5003,7 +5090,7 @@ def simulate_template(
           Get the index configuration that would be applied by a particular index template.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-simulate-template>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-simulate-template>`_
 
         :param name: Name of the index template to simulate. To test a template configuration
             before you add it to the cluster, omit this parameter and specify the template
@@ -5014,6 +5101,8 @@ def simulate_template(
             via `actions.auto_create_index`. If set to `false`, then indices or data
             streams matching the template must always be explicitly created, and may
             never be automatically created.
+        :param cause: User defined reason for dry-run creating the new template for simulation
+            purposes
         :param composed_of: An ordered list of component template names. Component templates
             are merged in the order specified, meaning that the last component template
             specified has the highest precedence.
@@ -5058,6 +5147,8 @@ def simulate_template(
             __path = "/_index_template/_simulate"
         __query: t.Dict[str, t.Any] = {}
         __body: t.Dict[str, t.Any] = body if body is not None else {}
+        if cause is not None:
+            __query["cause"] = cause
         if create is not None:
             __query["create"] = create
         if error_trace is not None:
@@ -5171,7 +5262,7 @@ def split(
           </ul>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-split>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-split>`_
 
         :param index: Name of the source index to split.
         :param target: Name of the target index to create.
@@ -5273,7 +5364,7 @@ def stats(
           Although the shard is no longer part of the node, that node retains any node-level statistics to which the shard contributed.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-stats>`_
 
         :param index: A comma-separated list of index names; use `_all` or empty string
             to perform the operation on all indices
@@ -5372,7 +5463,7 @@ def update_aliases(
           Adds a data stream or index to an alias.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-aliases.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-update-aliases>`_
 
         :param actions: Actions to perform.
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -5451,7 +5542,7 @@ def validate_query(
           Validates a query without running it.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/search-validate.html>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-validate-query>`_
 
         :param index: Comma-separated list of data streams, indices, and aliases to search.
             Supports wildcards (`*`). To search all data streams or indices, omit this
@@ -5472,7 +5563,7 @@ def validate_query(
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
             expressions match hidden data streams. Supports comma-separated values, such
-            as `open,hidden`. Valid values are: `all`, `open`, `closed`, `hidden`, `none`.
+            as `open,hidden`.
         :param explain: If `true`, the response returns detailed information if an error
             has occurred.
         :param ignore_unavailable: If `false`, the request returns an error if it targets
diff --git a/elasticsearch/_sync/client/inference.py b/elasticsearch/_sync/client/inference.py
index 911a8a530..2cd3dc0d9 100644
--- a/elasticsearch/_sync/client/inference.py
+++ b/elasticsearch/_sync/client/inference.py
@@ -25,6 +25,74 @@
 
 class InferenceClient(NamespacedClient):
 
+    @_rewrite_parameters(
+        body_fields=("input", "task_settings"),
+    )
+    def completion(
+        self,
+        *,
+        inference_id: str,
+        input: t.Optional[t.Union[str, t.Sequence[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,
+        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 completion inference on the service</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-inference>`_
+
+        :param inference_id: The inference Id
+        :param input: Inference input. Either a string or an array of strings.
+        :param task_settings: Optional task settings
+        :param timeout: Specifies 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] = {"inference_id": _quote(inference_id)}
+        __path = f'/_inference/completion/{__path_parts["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 input is not None:
+                __body["input"] = input
+            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 self.perform_request(  # type: ignore[return-value]
+            "POST",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="inference.completion",
+            path_parts=__path_parts,
+        )
+
     @_rewrite_parameters()
     def delete(
         self,
@@ -33,7 +101,13 @@ def delete(
         task_type: t.Optional[
             t.Union[
                 str,
-                t.Literal["completion", "rerank", "sparse_embedding", "text_embedding"],
+                t.Literal[
+                    "chat_completion",
+                    "completion",
+                    "rerank",
+                    "sparse_embedding",
+                    "text_embedding",
+                ],
             ]
         ] = None,
         dry_run: t.Optional[bool] = None,
@@ -49,7 +123,7 @@ def delete(
           <p>Delete an inference endpoint</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-inference-delete>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-delete>`_
 
         :param inference_id: The inference identifier.
         :param task_type: The task type
@@ -102,7 +176,13 @@ def get(
         task_type: t.Optional[
             t.Union[
                 str,
-                t.Literal["completion", "rerank", "sparse_embedding", "text_embedding"],
+                t.Literal[
+                    "chat_completion",
+                    "completion",
+                    "rerank",
+                    "sparse_embedding",
+                    "text_embedding",
+                ],
             ]
         ] = None,
         inference_id: t.Optional[str] = None,
@@ -117,7 +197,7 @@ def get(
           <p>Get an inference endpoint</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-inference-get>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-get>`_
 
         :param task_type: The task type
         :param inference_id: The inference Id
@@ -165,7 +245,13 @@ def inference(
         task_type: t.Optional[
             t.Union[
                 str,
-                t.Literal["completion", "rerank", "sparse_embedding", "text_embedding"],
+                t.Literal[
+                    "chat_completion",
+                    "completion",
+                    "rerank",
+                    "sparse_embedding",
+                    "text_embedding",
+                ],
             ]
         ] = None,
         error_trace: t.Optional[bool] = None,
@@ -184,13 +270,14 @@ def inference(
           <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/docs/api/doc/elasticsearch/operation/operation-inference-inference>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/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
@@ -266,33 +353,57 @@ def put(
         task_type: t.Optional[
             t.Union[
                 str,
-                t.Literal["completion", "rerank", "sparse_embedding", "text_embedding"],
+                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,
         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>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>text_embedding</code>)</li>
+          <li>Mistral (<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/docs/api/doc/elasticsearch/operation/operation-inference-put>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put>`_
 
         :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'")
@@ -323,6 +434,8 @@ def put(
             __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 self.perform_request(  # type: ignore[return-value]
@@ -336,62 +449,69 @@ def put(
         )
 
     @_rewrite_parameters(
-        body_name="inference_config",
+        body_fields=(
+            "service",
+            "service_settings",
+            "chunking_settings",
+            "task_settings",
+        ),
     )
-    def update(
+    def put_alibabacloud(
         self,
         *,
-        inference_id: str,
-        inference_config: t.Optional[t.Mapping[str, t.Any]] = None,
-        body: t.Optional[t.Mapping[str, t.Any]] = None,
-        task_type: t.Optional[
-            t.Union[
-                str,
-                t.Literal["completion", "rerank", "sparse_embedding", "text_embedding"],
-            ]
-        ] = None,
+        task_type: t.Union[
+            str, t.Literal["completion", "rerank", "space_embedding", "text_embedding"]
+        ],
+        alibabacloud_inference_id: str,
+        service: t.Optional[t.Union[str, t.Literal["alibabacloud-ai-search"]]] = 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>Update an inference endpoint.</p>
-          <p>Modify <code>task_settings</code>, secrets (within <code>service_settings</code>), or <code>num_allocations</code> for an inference endpoint, depending on the specific endpoint service and <code>task_type</code>.</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>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>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-inference-update>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-alibabacloud>`_
 
-        :param inference_id: The unique identifier of the inference endpoint.
-        :param inference_config:
-        :param task_type: The type of inference task that the model performs.
+        :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.
+        :param service: The type of service supported for the specified task type. In
+            this case, `alibabacloud-ai-search`.
+        :param service_settings: Settings used to install the inference model. These
+            settings are specific to the `alibabacloud-ai-search` 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 inference_id in SKIP_IN_PATH:
-            raise ValueError("Empty value passed for parameter 'inference_id'")
-        if inference_config is None and body is None:
+        if task_type in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'task_type'")
+        if alibabacloud_inference_id in SKIP_IN_PATH:
             raise ValueError(
-                "Empty value passed for parameters 'inference_config' and 'body', one of them should be set."
+                "Empty value passed for parameter 'alibabacloud_inference_id'"
             )
-        elif inference_config is not None and body is not None:
-            raise ValueError("Cannot set both 'inference_config' and 'body'")
-        __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"]}/_update'
-        elif inference_id not in SKIP_IN_PATH:
-            __path_parts = {"inference_id": _quote(inference_id)}
-            __path = f'/_inference/{__path_parts["inference_id"]}/_update'
-        else:
-            raise ValueError("Couldn't find a path for the given parameters")
+        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),
+            "alibabacloud_inference_id": _quote(alibabacloud_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["alibabacloud_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:
@@ -400,10 +520,1759 @@ def update(
             __query["human"] = human
         if pretty is not None:
             __query["pretty"] = pretty
-        __body = inference_config if inference_config is not None else body
-        __headers = {"accept": "application/json", "content-type": "application/json"}
+        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
+        if not __body:
+            __body = None  # type: ignore[assignment]
+        __headers = {"accept": "application/json"}
+        if __body is not None:
+            __headers["content-type"] = "application/json"
         return self.perform_request(  # type: ignore[return-value]
-            "POST",
+            "PUT",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="inference.put_alibabacloud",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=(
+            "service",
+            "service_settings",
+            "chunking_settings",
+            "task_settings",
+        ),
+    )
+    def put_amazonbedrock(
+        self,
+        *,
+        task_type: t.Union[str, t.Literal["completion", "text_embedding"]],
+        amazonbedrock_inference_id: str,
+        service: t.Optional[t.Union[str, t.Literal["amazonbedrock"]]] = 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 Amazon Bedrock inference endpoint.</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>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-amazonbedrock>`_
+
+        :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.
+        :param service: The type of service supported for the specified task type. In
+            this case, `amazonbedrock`.
+        :param service_settings: Settings used to install the inference model. These
+            settings are specific to the `amazonbedrock` 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'")
+        if amazonbedrock_inference_id in SKIP_IN_PATH:
+            raise ValueError(
+                "Empty value passed for parameter 'amazonbedrock_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),
+            "amazonbedrock_inference_id": _quote(amazonbedrock_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["amazonbedrock_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
+        if not __body:
+            __body = None  # type: ignore[assignment]
+        __headers = {"accept": "application/json"}
+        if __body is not None:
+            __headers["content-type"] = "application/json"
+        return self.perform_request(  # type: ignore[return-value]
+            "PUT",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="inference.put_amazonbedrock",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=(
+            "service",
+            "service_settings",
+            "chunking_settings",
+            "task_settings",
+        ),
+    )
+    def put_anthropic(
+        self,
+        *,
+        task_type: t.Union[str, t.Literal["completion"]],
+        anthropic_inference_id: str,
+        service: t.Optional[t.Union[str, t.Literal["anthropic"]]] = 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 Anthropic inference endpoint.</p>
+          <p>Create an inference endpoint to perform an inference task with the <code>anthropic</code> service.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-anthropic>`_
+
+        :param task_type: The task type. The only valid task type for the model to perform
+            is `completion`.
+        :param anthropic_inference_id: The unique identifier of the inference endpoint.
+        :param service: The type of service supported for the specified task type. In
+            this case, `anthropic`.
+        :param service_settings: Settings used to install the inference model. These
+            settings are specific to the `watsonxai` 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'")
+        if anthropic_inference_id in SKIP_IN_PATH:
+            raise ValueError(
+                "Empty value passed for parameter 'anthropic_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),
+            "anthropic_inference_id": _quote(anthropic_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["anthropic_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
+        if not __body:
+            __body = None  # type: ignore[assignment]
+        __headers = {"accept": "application/json"}
+        if __body is not None:
+            __headers["content-type"] = "application/json"
+        return self.perform_request(  # type: ignore[return-value]
+            "PUT",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="inference.put_anthropic",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=(
+            "service",
+            "service_settings",
+            "chunking_settings",
+            "task_settings",
+        ),
+    )
+    def put_azureaistudio(
+        self,
+        *,
+        task_type: t.Union[str, t.Literal["completion", "text_embedding"]],
+        azureaistudio_inference_id: str,
+        service: t.Optional[t.Union[str, t.Literal["azureaistudio"]]] = 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 Azure AI studio inference endpoint.</p>
+          <p>Create an inference endpoint to perform an inference task with the <code>azureaistudio</code> service.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-azureaistudio>`_
+
+        :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.
+        :param service: The type of service supported for the specified task type. In
+            this case, `azureaistudio`.
+        :param service_settings: Settings used to install the inference model. These
+            settings are specific to the `openai` 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'")
+        if azureaistudio_inference_id in SKIP_IN_PATH:
+            raise ValueError(
+                "Empty value passed for parameter 'azureaistudio_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),
+            "azureaistudio_inference_id": _quote(azureaistudio_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["azureaistudio_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
+        if not __body:
+            __body = None  # type: ignore[assignment]
+        __headers = {"accept": "application/json"}
+        if __body is not None:
+            __headers["content-type"] = "application/json"
+        return self.perform_request(  # type: ignore[return-value]
+            "PUT",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="inference.put_azureaistudio",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=(
+            "service",
+            "service_settings",
+            "chunking_settings",
+            "task_settings",
+        ),
+    )
+    def put_azureopenai(
+        self,
+        *,
+        task_type: t.Union[str, t.Literal["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,
+        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 Azure OpenAI inference endpoint.</p>
+          <p>Create an inference endpoint to perform an inference task with the <code>azureopenai</code> service.</p>
+          <p>The list of chat completion models that you can choose from in your Azure OpenAI deployment include:</p>
+          <ul>
+          <li><a href="https://learn.microsoft.com/en-us/azure/ai-services/openai/concepts/models?tabs=global-standard%2Cstandard-chat-completions#gpt-4-and-gpt-4-turbo-models">GPT-4 and GPT-4 Turbo models</a></li>
+          <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>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-azureopenai>`_
+
+        :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 azureopenai_inference_id: The unique identifier of the inference endpoint.
+        :param service: The type of service supported for the specified task type. In
+            this case, `azureopenai`.
+        :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.
+        :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'")
+        if azureopenai_inference_id in SKIP_IN_PATH:
+            raise ValueError(
+                "Empty value passed for parameter 'azureopenai_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),
+            "azureopenai_inference_id": _quote(azureopenai_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["azureopenai_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
+        if not __body:
+            __body = None  # type: ignore[assignment]
+        __headers = {"accept": "application/json"}
+        if __body is not None:
+            __headers["content-type"] = "application/json"
+        return self.perform_request(  # type: ignore[return-value]
+            "PUT",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="inference.put_azureopenai",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=(
+            "service",
+            "service_settings",
+            "chunking_settings",
+            "task_settings",
+        ),
+    )
+    def put_cohere(
+        self,
+        *,
+        task_type: t.Union[str, t.Literal["completion", "rerank", "text_embedding"]],
+        cohere_inference_id: str,
+        service: t.Optional[t.Union[str, t.Literal["cohere"]]] = 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 a Cohere inference endpoint.</p>
+          <p>Create an inference endpoint to perform an inference task with the <code>cohere</code> service.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-cohere>`_
+
+        :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.
+        :param service: The type of service supported for the specified task type. In
+            this case, `cohere`.
+        :param service_settings: Settings used to install the inference model. These
+            settings are specific to the `cohere` 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'")
+        if cohere_inference_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'cohere_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),
+            "cohere_inference_id": _quote(cohere_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["cohere_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
+        if not __body:
+            __body = None  # type: ignore[assignment]
+        __headers = {"accept": "application/json"}
+        if __body is not None:
+            __headers["content-type"] = "application/json"
+        return self.perform_request(  # type: ignore[return-value]
+            "PUT",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="inference.put_cohere",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=(
+            "service",
+            "service_settings",
+            "chunking_settings",
+            "task_settings",
+        ),
+    )
+    def put_elasticsearch(
+        self,
+        *,
+        task_type: t.Union[
+            str, t.Literal["rerank", "sparse_embedding", "text_embedding"]
+        ],
+        elasticsearch_inference_id: str,
+        service: t.Optional[t.Union[str, t.Literal["elasticsearch"]]] = 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 Elasticsearch inference endpoint.</p>
+          <p>Create an inference endpoint to perform an inference task with the <code>elasticsearch</code> service.</p>
+          <blockquote>
+          <p>info
+          Your Elasticsearch deployment contains preconfigured ELSER and E5 inference endpoints, you only need to create the enpoints using the API if you want to customize the settings.</p>
+          </blockquote>
+          <p>If you use the ELSER or the E5 model through the <code>elasticsearch</code> service, the API request will automatically download and deploy the model if it isn't downloaded yet.</p>
+          <blockquote>
+          <p>info
+          You might see a 502 bad gateway error in the response when using the Kibana Console. This error usually just reflects a timeout, while the model downloads in the background. You can check the download progress in the Machine Learning UI. If using the Python client, you can set the timeout parameter to a higher value.</p>
+          </blockquote>
+          <p>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/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-elasticsearch>`_
+
+        :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.
+            The must not match the `model_id`.
+        :param service: The type of service supported for the specified task type. In
+            this case, `elasticsearch`.
+        :param service_settings: Settings used to install the inference model. These
+            settings are specific to the `elasticsearch` 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'")
+        if elasticsearch_inference_id in SKIP_IN_PATH:
+            raise ValueError(
+                "Empty value passed for parameter 'elasticsearch_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),
+            "elasticsearch_inference_id": _quote(elasticsearch_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["elasticsearch_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
+        if not __body:
+            __body = None  # type: ignore[assignment]
+        __headers = {"accept": "application/json"}
+        if __body is not None:
+            __headers["content-type"] = "application/json"
+        return self.perform_request(  # type: ignore[return-value]
+            "PUT",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="inference.put_elasticsearch",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=("service", "service_settings", "chunking_settings"),
+    )
+    def put_elser(
+        self,
+        *,
+        task_type: t.Union[str, t.Literal["sparse_embedding"]],
+        elser_inference_id: str,
+        service: t.Optional[t.Union[str, t.Literal["elser"]]] = 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 an ELSER inference endpoint.</p>
+          <p>Create an inference endpoint to perform an inference task with the <code>elser</code> service.
+          You can also deploy ELSER by using the Elasticsearch inference integration.</p>
+          <blockquote>
+          <p>info
+          Your Elasticsearch deployment contains a preconfigured ELSER inference endpoint, you only need to create the enpoint using the API if you want to customize the settings.</p>
+          </blockquote>
+          <p>The API request will automatically download and deploy the ELSER model if it isn't already downloaded.</p>
+          <blockquote>
+          <p>info
+          You might see a 502 bad gateway error in the response when using the Kibana Console. This error usually just reflects a timeout, while the model downloads in the background. You can check the download progress in the Machine Learning UI. If using the Python client, you can set the timeout parameter to a higher value.</p>
+          </blockquote>
+          <p>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/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-elser>`_
+
+        :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.
+        :param service: The type of service supported for the specified task type. In
+            this case, `elser`.
+        :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'")
+        if elser_inference_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'elser_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),
+            "elser_inference_id": _quote(elser_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["elser_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 self.perform_request(  # type: ignore[return-value]
+            "PUT",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="inference.put_elser",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=("service", "service_settings", "chunking_settings"),
+    )
+    def put_googleaistudio(
+        self,
+        *,
+        task_type: t.Union[str, t.Literal["completion", "text_embedding"]],
+        googleaistudio_inference_id: str,
+        service: t.Optional[t.Union[str, t.Literal["googleaistudio"]]] = 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 an Google AI Studio inference endpoint.</p>
+          <p>Create an inference endpoint to perform an inference task with the <code>googleaistudio</code> service.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-googleaistudio>`_
+
+        :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.
+        :param service: The type of service supported for the specified task type. In
+            this case, `googleaistudio`.
+        :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'")
+        if googleaistudio_inference_id in SKIP_IN_PATH:
+            raise ValueError(
+                "Empty value passed for parameter 'googleaistudio_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),
+            "googleaistudio_inference_id": _quote(googleaistudio_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["googleaistudio_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 self.perform_request(  # type: ignore[return-value]
+            "PUT",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="inference.put_googleaistudio",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=(
+            "service",
+            "service_settings",
+            "chunking_settings",
+            "task_settings",
+        ),
+    )
+    def put_googlevertexai(
+        self,
+        *,
+        task_type: t.Union[str, t.Literal["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,
+        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 a Google Vertex AI inference endpoint.</p>
+          <p>Create an inference endpoint to perform an inference task with the <code>googlevertexai</code> service.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-googlevertexai>`_
+
+        :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.
+        :param service: The type of service supported for the specified task type. In
+            this case, `googlevertexai`.
+        :param service_settings: Settings used to install the inference model. These
+            settings are specific to the `googlevertexai` 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'")
+        if googlevertexai_inference_id in SKIP_IN_PATH:
+            raise ValueError(
+                "Empty value passed for parameter 'googlevertexai_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),
+            "googlevertexai_inference_id": _quote(googlevertexai_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["googlevertexai_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
+        if not __body:
+            __body = None  # type: ignore[assignment]
+        __headers = {"accept": "application/json"}
+        if __body is not None:
+            __headers["content-type"] = "application/json"
+        return self.perform_request(  # type: ignore[return-value]
+            "PUT",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="inference.put_googlevertexai",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=("service", "service_settings", "chunking_settings"),
+    )
+    def put_hugging_face(
+        self,
+        *,
+        task_type: t.Union[str, t.Literal["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,
+        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 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>
+          <ul>
+          <li><code>all-MiniLM-L6-v2</code></li>
+          <li><code>all-MiniLM-L12-v2</code></li>
+          <li><code>all-mpnet-base-v2</code></li>
+          <li><code>e5-base-v2</code></li>
+          <li><code>e5-small-v2</code></li>
+          <li><code>multilingual-e5-base</code></li>
+          <li><code>multilingual-e5-small</code></li>
+          </ul>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-hugging-face>`_
+
+        :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.
+        :param service: The type of service supported for the specified task type. In
+            this case, `hugging_face`.
+        :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 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 huggingface_inference_id in SKIP_IN_PATH:
+            raise ValueError(
+                "Empty value passed for parameter 'huggingface_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),
+            "huggingface_inference_id": _quote(huggingface_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["huggingface_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 self.perform_request(  # type: ignore[return-value]
+            "PUT",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="inference.put_hugging_face",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=(
+            "service",
+            "service_settings",
+            "chunking_settings",
+            "task_settings",
+        ),
+    )
+    def put_jinaai(
+        self,
+        *,
+        task_type: t.Union[str, t.Literal["rerank", "text_embedding"]],
+        jinaai_inference_id: str,
+        service: t.Optional[t.Union[str, t.Literal["jinaai"]]] = 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 JinaAI inference endpoint.</p>
+          <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>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-jinaai>`_
+
+        :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.
+        :param service: The type of service supported for the specified task type. In
+            this case, `jinaai`.
+        :param service_settings: Settings used to install the inference model. These
+            settings are specific to the `jinaai` 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'")
+        if jinaai_inference_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'jinaai_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),
+            "jinaai_inference_id": _quote(jinaai_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["jinaai_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
+        if not __body:
+            __body = None  # type: ignore[assignment]
+        __headers = {"accept": "application/json"}
+        if __body is not None:
+            __headers["content-type"] = "application/json"
+        return self.perform_request(  # type: ignore[return-value]
+            "PUT",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="inference.put_jinaai",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=("service", "service_settings", "chunking_settings"),
+    )
+    def put_mistral(
+        self,
+        *,
+        task_type: t.Union[str, t.Literal["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,
+        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 Mistral inference endpoint.</p>
+          <p>Creates an inference endpoint to perform an inference task with the <code>mistral</code> service.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-mistral>`_
+
+        :param task_type: The task type. The only valid task type for the model to perform
+            is `text_embedding`.
+        :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'")
+        if mistral_inference_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'mistral_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),
+            "mistral_inference_id": _quote(mistral_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["mistral_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 self.perform_request(  # type: ignore[return-value]
+            "PUT",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="inference.put_mistral",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=(
+            "service",
+            "service_settings",
+            "chunking_settings",
+            "task_settings",
+        ),
+    )
+    def put_openai(
+        self,
+        *,
+        task_type: t.Union[
+            str, t.Literal["chat_completion", "completion", "text_embedding"]
+        ],
+        openai_inference_id: str,
+        service: t.Optional[t.Union[str, t.Literal["openai"]]] = 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 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>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-openai>`_
+
+        :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 openai_inference_id: The unique identifier of the inference endpoint.
+        :param service: The type of service supported for the specified task type. In
+            this case, `openai`.
+        :param service_settings: Settings used to install the inference model. These
+            settings are specific to the `openai` 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'")
+        if openai_inference_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'openai_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),
+            "openai_inference_id": _quote(openai_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["openai_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
+        if not __body:
+            __body = None  # type: ignore[assignment]
+        __headers = {"accept": "application/json"}
+        if __body is not None:
+            __headers["content-type"] = "application/json"
+        return self.perform_request(  # type: ignore[return-value]
+            "PUT",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="inference.put_openai",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=(
+            "service",
+            "service_settings",
+            "chunking_settings",
+            "task_settings",
+        ),
+    )
+    def put_voyageai(
+        self,
+        *,
+        task_type: t.Union[str, t.Literal["rerank", "text_embedding"]],
+        voyageai_inference_id: str,
+        service: t.Optional[t.Union[str, t.Literal["voyageai"]]] = 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 a VoyageAI inference endpoint.</p>
+          <p>Create an inference endpoint to perform an inference task with the <code>voyageai</code> service.</p>
+          <p>Avoid creating multiple endpoints for the same model unless required, as each endpoint consumes significant resources.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-voyageai>`_
+
+        :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.
+        :param service: The type of service supported for the specified task type. In
+            this case, `voyageai`.
+        :param service_settings: Settings used to install the inference model. These
+            settings are specific to the `voyageai` 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'")
+        if voyageai_inference_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'voyageai_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),
+            "voyageai_inference_id": _quote(voyageai_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["voyageai_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
+        if not __body:
+            __body = None  # type: ignore[assignment]
+        __headers = {"accept": "application/json"}
+        if __body is not None:
+            __headers["content-type"] = "application/json"
+        return self.perform_request(  # type: ignore[return-value]
+            "PUT",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="inference.put_voyageai",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=("service", "service_settings"),
+    )
+    def put_watsonx(
+        self,
+        *,
+        task_type: t.Union[str, t.Literal["text_embedding"]],
+        watsonx_inference_id: str,
+        service: t.Optional[t.Union[str, t.Literal["watsonxai"]]] = 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 Watsonx inference endpoint.</p>
+          <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>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-put-watsonx>`_
+
+        :param task_type: The task type. The only valid task type for the model to perform
+            is `text_embedding`.
+        :param watsonx_inference_id: The unique identifier of the inference endpoint.
+        :param service: The type of service supported for the specified task type. In
+            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'")
+        if watsonx_inference_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'watsonx_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),
+            "watsonx_inference_id": _quote(watsonx_inference_id),
+        }
+        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["watsonx_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 not __body:
+            __body = None  # type: ignore[assignment]
+        __headers = {"accept": "application/json"}
+        if __body is not None:
+            __headers["content-type"] = "application/json"
+        return self.perform_request(  # type: ignore[return-value]
+            "PUT",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="inference.put_watsonx",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=("input", "query", "task_settings"),
+    )
+    def rerank(
+        self,
+        *,
+        inference_id: str,
+        input: t.Optional[t.Union[str, 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,
+        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 reranking inference on the service</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/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 query: Query input.
+        :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'")
+        if query is None and body is None:
+            raise ValueError("Empty value passed for parameter 'query'")
+        __path_parts: t.Dict[str, str] = {"inference_id": _quote(inference_id)}
+        __path = f'/_inference/rerank/{__path_parts["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 input is not None:
+                __body["input"] = input
+            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 self.perform_request(  # type: ignore[return-value]
+            "POST",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="inference.rerank",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=("input", "task_settings"),
+    )
+    def sparse_embedding(
+        self,
+        *,
+        inference_id: str,
+        input: t.Optional[t.Union[str, t.Sequence[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,
+        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 sparse embedding inference on the service</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-inference>`_
+
+        :param inference_id: The inference Id
+        :param input: Inference input. Either a string or an array of strings.
+        :param task_settings: Optional task settings
+        :param timeout: Specifies 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] = {"inference_id": _quote(inference_id)}
+        __path = f'/_inference/sparse_embedding/{__path_parts["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 input is not None:
+                __body["input"] = input
+            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 self.perform_request(  # type: ignore[return-value]
+            "POST",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="inference.sparse_embedding",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=("input", "task_settings"),
+    )
+    def text_embedding(
+        self,
+        *,
+        inference_id: str,
+        input: t.Optional[t.Union[str, t.Sequence[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,
+        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 text embedding inference on the service</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-inference>`_
+
+        :param inference_id: The inference Id
+        :param input: Inference input. Either a string or an array of strings.
+        :param task_settings: Optional task settings
+        :param timeout: Specifies 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] = {"inference_id": _quote(inference_id)}
+        __path = f'/_inference/text_embedding/{__path_parts["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 input is not None:
+                __body["input"] = input
+            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 self.perform_request(  # type: ignore[return-value]
+            "POST",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="inference.text_embedding",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_name="inference_config",
+    )
+    def update(
+        self,
+        *,
+        inference_id: str,
+        inference_config: t.Optional[t.Mapping[str, t.Any]] = None,
+        body: t.Optional[t.Mapping[str, t.Any]] = 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,
+        pretty: t.Optional[bool] = None,
+    ) -> ObjectApiResponse[t.Any]:
+        """
+        .. raw:: html
+
+          <p>Update an inference endpoint.</p>
+          <p>Modify <code>task_settings</code>, secrets (within <code>service_settings</code>), or <code>num_allocations</code> for an inference endpoint, depending on the specific endpoint service and <code>task_type</code>.</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>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-inference-update>`_
+
+        :param inference_id: The unique identifier of the inference endpoint.
+        :param inference_config:
+        :param task_type: The type of inference task that the model performs.
+        """
+        if inference_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'inference_id'")
+        if inference_config is None and body is None:
+            raise ValueError(
+                "Empty value passed for parameters 'inference_config' and 'body', one of them should be set."
+            )
+        elif inference_config is not None and body is not None:
+            raise ValueError("Cannot set both 'inference_config' and 'body'")
+        __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"]}/_update'
+        elif inference_id not in SKIP_IN_PATH:
+            __path_parts = {"inference_id": _quote(inference_id)}
+            __path = f'/_inference/{__path_parts["inference_id"]}/_update'
+        else:
+            raise ValueError("Couldn't find a path for the given parameters")
+        __query: t.Dict[str, t.Any] = {}
+        if error_trace is not None:
+            __query["error_trace"] = error_trace
+        if filter_path is not None:
+            __query["filter_path"] = filter_path
+        if human is not None:
+            __query["human"] = human
+        if pretty is not None:
+            __query["pretty"] = pretty
+        __body = inference_config if inference_config is not None else body
+        __headers = {"accept": "application/json", "content-type": "application/json"}
+        return self.perform_request(  # type: ignore[return-value]
+            "PUT",
             __path,
             params=__query,
             headers=__headers,
diff --git a/elasticsearch/_sync/client/ingest.py b/elasticsearch/_sync/client/ingest.py
index 2a1b0463d..14b8912dc 100644
--- a/elasticsearch/_sync/client/ingest.py
+++ b/elasticsearch/_sync/client/ingest.py
@@ -44,7 +44,7 @@ def delete_geoip_database(
           <p>Delete one or more IP geolocation database configurations.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ingest-delete-geoip-database>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ingest-delete-geoip-database>`_
 
         :param id: A comma-separated list of geoip database configurations to delete
         :param master_timeout: The period to wait for a connection to the master node.
@@ -98,7 +98,7 @@ def delete_ip_location_database(
           <p>Delete IP geolocation database configurations.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ingest-delete-ip-location-database>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ingest-delete-ip-location-database>`_
 
         :param id: A comma-separated list of IP location database configurations.
         :param master_timeout: The period to wait for a connection to the master node.
@@ -155,7 +155,7 @@ def delete_pipeline(
           Delete one or more ingest pipelines.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ingest-delete-pipeline>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ingest-delete-pipeline>`_
 
         :param id: Pipeline ID or wildcard expression of pipeline IDs used to limit the
             request. To delete all ingest pipelines in a cluster, use a value of `*`.
@@ -208,7 +208,7 @@ def geo_ip_stats(
           Get download statistics for GeoIP2 databases that are used with the GeoIP processor.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/geoip-processor.html>`_
+        `<https://www.elastic.co/docs/reference/enrich-processor/geoip-processor>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_ingest/geoip/stats"
@@ -248,7 +248,7 @@ def get_geoip_database(
           <p>Get information about one or more IP geolocation database configurations.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ingest-get-geoip-database>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ingest-get-geoip-database>`_
 
         :param id: A comma-separated list of database configuration IDs to retrieve.
             Wildcard (`*`) expressions are supported. To get all database configurations,
@@ -288,7 +288,6 @@ def get_ip_location_database(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         human: t.Optional[bool] = None,
-        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
@@ -297,15 +296,11 @@ def get_ip_location_database(
           <p>Get IP geolocation database configurations.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ingest-get-ip-location-database>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ingest-get-ip-location-database>`_
 
         :param id: Comma-separated list of database configuration IDs to retrieve. Wildcard
             (`*`) expressions are supported. To get all database configurations, omit
             this parameter or use `*`.
-        :param master_timeout: The period to wait for a connection to the master node.
-            If no response is received before the timeout expires, the request fails
-            and returns an error. A value of `-1` indicates that the request should never
-            time out.
         """
         __path_parts: t.Dict[str, str]
         if id not in SKIP_IN_PATH:
@@ -321,8 +316,6 @@ def get_ip_location_database(
             __query["filter_path"] = filter_path
         if human is not None:
             __query["human"] = human
-        if master_timeout is not None:
-            __query["master_timeout"] = master_timeout
         if pretty is not None:
             __query["pretty"] = pretty
         __headers = {"accept": "application/json"}
@@ -355,7 +348,7 @@ def get_pipeline(
           This API returns a local reference of the pipeline.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ingest-get-pipeline>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ingest-get-pipeline>`_
 
         :param id: Comma-separated list of pipeline IDs to retrieve. Wildcard (`*`) expressions
             are supported. To get all ingest pipelines, omit this parameter or use `*`.
@@ -412,7 +405,7 @@ def processor_grok(
           A grok pattern is like a regular expression that supports aliased expressions that can be reused.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/grok-processor.html>`_
+        `<https://www.elastic.co/docs/reference/enrich-processor/grok-processor>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_ingest/processor/grok"
@@ -459,7 +452,7 @@ def put_geoip_database(
           <p>Refer to the create or update IP geolocation database configuration API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ingest-put-geoip-database>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ingest-put-geoip-database>`_
 
         :param id: ID of the database configuration to create or update.
         :param maxmind: The configuration necessary to identify which IP geolocation
@@ -534,7 +527,7 @@ def put_ip_location_database(
           <p>Create or update an IP geolocation database configuration.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ingest-put-ip-location-database>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ingest-put-ip-location-database>`_
 
         :param id: The database configuration identifier.
         :param configuration:
@@ -620,7 +613,7 @@ def put_pipeline(
           Changes made using this API take effect immediately.</p>
 
 
-        `<https://www.elastic.co/guide/en/elasticsearch/reference/master/ingest.html>`_
+        `<https://www.elastic.co/docs/manage-data/ingest/transform-enrich/ingest-pipelines>`_
 
         :param id: ID of the ingest pipeline to create or update.
         :param deprecated: Marks this ingest pipeline as deprecated. When a deprecated
@@ -717,7 +710,7 @@ def simulate(
           You can either specify an existing pipeline to use with the provided documents or supply a pipeline definition in the body of the request.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ingest-simulate>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ingest-simulate>`_
 
         :param docs: Sample documents to test in the pipeline.
         :param id: The pipeline to test. If you don't specify a `pipeline` in the request
diff --git a/elasticsearch/_sync/client/license.py b/elasticsearch/_sync/client/license.py
index bd36f430b..adb53fd86 100644
--- a/elasticsearch/_sync/client/license.py
+++ b/elasticsearch/_sync/client/license.py
@@ -44,7 +44,7 @@ def delete(
           <p>If the operator privileges feature is enabled, only operator users can use this API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-license-delete>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-license-delete>`_
 
         :param master_timeout: The period to wait for a connection to the master node.
         :param timeout: The period to wait for a response. If no response is received
@@ -98,7 +98,7 @@ def get(
           </blockquote>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-license-get>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-license-get>`_
 
         :param accept_enterprise: If `true`, this parameter returns enterprise for Enterprise
             license types. If `false`, this parameter returns platinum for both platinum
@@ -147,7 +147,7 @@ def get_basic_status(
           <p>Get the basic license status.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-license-get-basic-status>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-license-get-basic-status>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_license/basic_status"
@@ -185,7 +185,7 @@ def get_trial_status(
           <p>Get the trial status.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-license-get-trial-status>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-license-get-trial-status>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_license/trial_status"
@@ -237,7 +237,7 @@ def post(
           If the operator privileges feature is enabled, only operator users can use this API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-license-post>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-license-post>`_
 
         :param acknowledge: Specifies whether you acknowledge the license changes.
         :param license:
@@ -308,7 +308,7 @@ def post_start_basic(
           <p>To check the status of your basic license, use the get basic license API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-license-post-start-basic>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-license-post-start-basic>`_
 
         :param acknowledge: whether the user has acknowledged acknowledge messages (default:
             false)
@@ -353,7 +353,7 @@ def post_start_trial(
         human: t.Optional[bool] = None,
         master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
-        type_query_string: t.Optional[str] = None,
+        type: t.Optional[str] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
         .. raw:: html
@@ -365,12 +365,12 @@ def post_start_trial(
           <p>To check the status of your trial, use the get trial status API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-license-post-start-trial>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-license-post-start-trial>`_
 
         :param acknowledge: whether the user has acknowledged acknowledge messages (default:
             false)
         :param master_timeout: Period to wait for a connection to the master node.
-        :param type_query_string:
+        :param type: The type of trial license to generate (default: "trial")
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_license/start_trial"
@@ -387,8 +387,8 @@ def post_start_trial(
             __query["master_timeout"] = master_timeout
         if pretty is not None:
             __query["pretty"] = pretty
-        if type_query_string is not None:
-            __query["type_query_string"] = type_query_string
+        if type is not None:
+            __query["type"] = type
         __headers = {"accept": "application/json"}
         return self.perform_request(  # type: ignore[return-value]
             "POST",
diff --git a/elasticsearch/_sync/client/logstash.py b/elasticsearch/_sync/client/logstash.py
index f8abefa14..4be81de9b 100644
--- a/elasticsearch/_sync/client/logstash.py
+++ b/elasticsearch/_sync/client/logstash.py
@@ -43,7 +43,7 @@ def delete_pipeline(
           If the request succeeds, you receive an empty response with an appropriate status code.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-logstash-delete-pipeline>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-logstash-delete-pipeline>`_
 
         :param id: An identifier for the pipeline.
         """
@@ -87,7 +87,7 @@ def get_pipeline(
           Get pipelines that are used for Logstash Central Management.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-logstash-get-pipeline>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-logstash-get-pipeline>`_
 
         :param id: A comma-separated list of pipeline identifiers.
         """
@@ -139,9 +139,11 @@ def put_pipeline(
           If the specified pipeline exists, it is replaced.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-logstash-put-pipeline>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-logstash-put-pipeline>`_
 
-        :param id: An identifier for the pipeline.
+        :param id: An identifier for the pipeline. Pipeline IDs must begin with a letter
+            or underscore and contain only letters, underscores, dashes, hyphens and
+            numbers.
         :param pipeline:
         """
         if id in SKIP_IN_PATH:
diff --git a/elasticsearch/_sync/client/migration.py b/elasticsearch/_sync/client/migration.py
index 20ebb44fd..9ec38edef 100644
--- a/elasticsearch/_sync/client/migration.py
+++ b/elasticsearch/_sync/client/migration.py
@@ -44,7 +44,7 @@ def deprecations(
           You are strongly recommended to use the Upgrade Assistant.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-migration-deprecations>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-migration-deprecations>`_
 
         :param index: Comma-separate list of data streams or indices to check. Wildcard
             (*) expressions are supported.
@@ -94,7 +94,7 @@ def get_feature_upgrade_status(
           You are strongly recommended to use the Upgrade Assistant.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-migration-get-feature-upgrade-status>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-migration-get-feature-upgrade-status>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_migration/system_features"
@@ -136,7 +136,7 @@ def post_feature_upgrade(
           <p>TIP: The API is designed for indirect use by the Upgrade Assistant. We strongly recommend you use the Upgrade Assistant.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-migration-get-feature-upgrade-status>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-migration-get-feature-upgrade-status>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_migration/system_features"
diff --git a/elasticsearch/_sync/client/ml.py b/elasticsearch/_sync/client/ml.py
index 32c00028f..9c12dae5e 100644
--- a/elasticsearch/_sync/client/ml.py
+++ b/elasticsearch/_sync/client/ml.py
@@ -45,7 +45,7 @@ def clear_trained_model_deployment_cache(
           Calling this API clears the caches without restarting the deployment.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-clear-trained-model-deployment-cache>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-clear-trained-model-deployment-cache>`_
 
         :param model_id: The unique identifier of the trained model.
         """
@@ -100,7 +100,7 @@ def close_job(
           When a datafeed that has a specified end date stops, it automatically closes its associated job.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-close-job>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-close-job>`_
 
         :param job_id: Identifier for the anomaly detection job. It can be a job identifier,
             a group name, or a wildcard expression. You can close multiple anomaly detection
@@ -165,7 +165,7 @@ def delete_calendar(
           <p>Remove all scheduled events from a calendar, then delete it.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-delete-calendar>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-delete-calendar>`_
 
         :param calendar_id: A string that uniquely identifies a calendar.
         """
@@ -209,7 +209,7 @@ def delete_calendar_event(
           <p>Delete events from a calendar.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-delete-calendar-event>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-delete-calendar-event>`_
 
         :param calendar_id: A string that uniquely identifies a calendar.
         :param event_id: Identifier for the scheduled event. You can obtain this identifier
@@ -260,7 +260,7 @@ def delete_calendar_job(
           <p>Delete anomaly jobs from a calendar.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-delete-calendar-job>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-delete-calendar-job>`_
 
         :param calendar_id: A string that uniquely identifies a calendar.
         :param job_id: An identifier for the anomaly detection jobs. It can be a job
@@ -312,7 +312,7 @@ def delete_data_frame_analytics(
           <p>Delete a data frame analytics job.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-delete-data-frame-analytics>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-delete-data-frame-analytics>`_
 
         :param id: Identifier for the data frame analytics job.
         :param force: If `true`, it deletes a job that is not stopped; this method is
@@ -363,7 +363,7 @@ def delete_datafeed(
           <p>Delete a datafeed.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-delete-datafeed>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-delete-datafeed>`_
 
         :param datafeed_id: A numerical character string that uniquely identifies the
             datafeed. This identifier can contain lowercase alphanumeric characters (a-z
@@ -426,7 +426,7 @@ def delete_expired_data(
           <code>&lt;job_id&gt;</code>.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-delete-expired-data>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-delete-expired-data>`_
 
         :param job_id: Identifier for an anomaly detection job. It can be a job identifier,
             a group name, or a wildcard expression.
@@ -490,7 +490,7 @@ def delete_filter(
           filter. You must update or delete the job before you can delete the filter.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-delete-filter>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-delete-filter>`_
 
         :param filter_id: A string that uniquely identifies a filter.
         """
@@ -540,7 +540,7 @@ def delete_forecast(
           forecasts before they expire.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-delete-forecast>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-delete-forecast>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param forecast_id: A comma-separated list of forecast identifiers. If you do
@@ -616,7 +616,7 @@ def delete_job(
           delete job request.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-delete-job>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-delete-job>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param delete_user_annotations: Specifies whether annotations that have been
@@ -676,7 +676,7 @@ def delete_model_snapshot(
           the <code>model_snapshot_id</code> in the results from the get jobs API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-delete-model-snapshot>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-delete-model-snapshot>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param snapshot_id: Identifier for the model snapshot.
@@ -728,7 +728,7 @@ def delete_trained_model(
           <p>The request deletes a trained inference model that is not referenced by an ingest pipeline.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-delete-trained-model>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-delete-trained-model>`_
 
         :param model_id: The unique identifier of the trained model.
         :param force: Forcefully deletes a trained model that is referenced by ingest
@@ -783,7 +783,7 @@ def delete_trained_model_alias(
           by the <code>model_id</code>, this API returns an error.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-delete-trained-model-alias>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-delete-trained-model-alias>`_
 
         :param model_id: The trained model ID to which the model alias refers.
         :param model_alias: The model alias to delete.
@@ -844,7 +844,7 @@ def estimate_model_memory(
           estimates for the fields it references.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-estimate-model-memory>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-estimate-model-memory>`_
 
         :param analysis_config: For a list of the properties that you can specify in
             the `analysis_config` component of the body of this API.
@@ -916,7 +916,7 @@ def evaluate_data_frame(
           field and an analytics result field to be present.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-evaluate-data-frame>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-evaluate-data-frame>`_
 
         :param evaluation: Defines the type of evaluation you want to perform.
         :param index: Defines the `index` in which the evaluation will be performed.
@@ -1001,7 +1001,7 @@ def explain_data_frame_analytics(
           </ul>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-explain-data-frame-analytics>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-explain-data-frame-analytics>`_
 
         :param id: Identifier for the data frame analytics job. This identifier can contain
             lowercase alphanumeric characters (a-z and 0-9), hyphens, and underscores.
@@ -1112,7 +1112,7 @@ def flush_job(
           analyzing further data.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-flush-job>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-flush-job>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param advance_time: Refer to the description for the `advance_time` query parameter.
@@ -1187,7 +1187,7 @@ def forecast(
           based on historical data.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-forecast>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-forecast>`_
 
         :param job_id: Identifier for the anomaly detection job. The job must be open
             when you create a forecast; otherwise, an error occurs.
@@ -1273,7 +1273,7 @@ def get_buckets(
           The API presents a chronological view of the records, grouped by bucket.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-buckets>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-buckets>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param timestamp: The timestamp of a single bucket result. If you do not specify
@@ -1371,7 +1371,7 @@ def get_calendar_events(
           <p>Get info about events in calendars.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-calendar-events>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-calendar-events>`_
 
         :param calendar_id: A string that uniquely identifies a calendar. You can get
             information for multiple calendars by using a comma-separated list of ids
@@ -1440,7 +1440,7 @@ def get_calendars(
           <p>Get calendar configuration info.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-calendars>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-calendars>`_
 
         :param calendar_id: A string that uniquely identifies a calendar. You can get
             information for multiple calendars by using a comma-separated list of ids
@@ -1516,7 +1516,7 @@ def get_categories(
           <p>Get anomaly detection job results for categories.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-categories>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-categories>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param category_id: Identifier for the category, which is unique in the job.
@@ -1604,7 +1604,7 @@ def get_data_frame_analytics(
           wildcard expression.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-data-frame-analytics>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-data-frame-analytics>`_
 
         :param id: Identifier for the data frame analytics job. If you do not specify
             this option, the API returns information for the first hundred data frame
@@ -1676,10 +1676,10 @@ def get_data_frame_analytics_stats(
         """
         .. raw:: html
 
-          <p>Get data frame analytics jobs usage info.</p>
+          <p>Get data frame analytics job stats.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-data-frame-analytics-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-data-frame-analytics-stats>`_
 
         :param id: Identifier for the data frame analytics job. If you do not specify
             this option, the API returns information for the first hundred data frame
@@ -1744,7 +1744,7 @@ def get_datafeed_stats(
         """
         .. raw:: html
 
-          <p>Get datafeeds usage info.
+          <p>Get datafeed stats.
           You can get statistics for multiple datafeeds in a single API request by
           using a comma-separated list of datafeeds or a wildcard expression. You can
           get statistics for all datafeeds by using <code>_all</code>, by specifying <code>*</code> as the
@@ -1753,7 +1753,7 @@ def get_datafeed_stats(
           This API returns a maximum of 10,000 datafeeds.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-datafeed-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-datafeed-stats>`_
 
         :param datafeed_id: Identifier for the datafeed. It can be a datafeed identifier
             or a wildcard expression. If you do not specify one of these options, the
@@ -1817,7 +1817,7 @@ def get_datafeeds(
           This API returns a maximum of 10,000 datafeeds.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-datafeeds>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-datafeeds>`_
 
         :param datafeed_id: Identifier for the datafeed. It can be a datafeed identifier
             or a wildcard expression. If you do not specify one of these options, the
@@ -1884,7 +1884,7 @@ def get_filters(
           You can get a single filter or all filters.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-filters>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-filters>`_
 
         :param filter_id: A string that uniquely identifies a filter.
         :param from_: Skips the specified number of filters.
@@ -1952,7 +1952,7 @@ def get_influencers(
           <code>influencer_field_name</code> is specified in the job configuration.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-influencers>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-influencers>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param desc: If true, the results are sorted in descending order.
@@ -2033,10 +2033,10 @@ def get_job_stats(
         """
         .. raw:: html
 
-          <p>Get anomaly detection jobs usage info.</p>
+          <p>Get anomaly detection job stats.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-job-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-job-stats>`_
 
         :param job_id: Identifier for the anomaly detection job. It can be a job identifier,
             a group name, a comma-separated list of jobs, or a wildcard expression. If
@@ -2100,7 +2100,7 @@ def get_jobs(
           <code>_all</code>, by specifying <code>*</code> as the <code>&lt;job_id&gt;</code>, or by omitting the <code>&lt;job_id&gt;</code>.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-jobs>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-jobs>`_
 
         :param job_id: Identifier for the anomaly detection job. It can be a job identifier,
             a group name, or a wildcard expression. If you do not specify one of these
@@ -2166,7 +2166,7 @@ def get_memory_stats(
           on each node, both within the JVM heap, and natively, outside of the JVM.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-memory-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-memory-stats>`_
 
         :param node_id: The names of particular nodes in the cluster to target. For example,
             `nodeId1,nodeId2` or `ml:true`
@@ -2224,7 +2224,7 @@ def get_model_snapshot_upgrade_stats(
           <p>Get anomaly detection job model snapshot upgrade usage info.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-model-snapshot-upgrade-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-model-snapshot-upgrade-stats>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param snapshot_id: A numerical character string that uniquely identifies the
@@ -2298,7 +2298,7 @@ def get_model_snapshots(
           <p>Get model snapshots info.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-model-snapshots>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-model-snapshots>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param snapshot_id: A numerical character string that uniquely identifies the
@@ -2418,7 +2418,7 @@ def get_overall_buckets(
           jobs' largest bucket span.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-overall-buckets>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-overall-buckets>`_
 
         :param job_id: Identifier for the anomaly detection job. It can be a job identifier,
             a group name, a comma-separated list of jobs or groups, or a wildcard expression.
@@ -2528,7 +2528,7 @@ def get_records(
           number of detectors.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-records>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-records>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param desc: Refer to the description for the `desc` query parameter.
@@ -2616,7 +2616,6 @@ def get_trained_models(
                 ],
             ]
         ] = None,
-        include_model_definition: t.Optional[bool] = None,
         pretty: t.Optional[bool] = None,
         size: t.Optional[int] = None,
         tags: t.Optional[t.Union[str, t.Sequence[str]]] = None,
@@ -2627,7 +2626,7 @@ def get_trained_models(
           <p>Get trained model configuration info.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-trained-models>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-trained-models>`_
 
         :param model_id: The unique identifier of the trained model or a model alias.
             You can get information for multiple trained models in a single API request
@@ -2646,8 +2645,6 @@ def get_trained_models(
         :param from_: Skips the specified number of models.
         :param include: A comma delimited string of optional fields to include in the
             response body.
-        :param include_model_definition: parameter is deprecated! Use [include=definition]
-            instead
         :param size: Specifies the maximum number of models to obtain.
         :param tags: A comma delimited string of tags. A trained model can have many
             tags, or none. When supplied, only trained models that contain all the supplied
@@ -2677,8 +2674,6 @@ def get_trained_models(
             __query["human"] = human
         if include is not None:
             __query["include"] = include
-        if include_model_definition is not None:
-            __query["include_model_definition"] = include_model_definition
         if pretty is not None:
             __query["pretty"] = pretty
         if size is not None:
@@ -2718,7 +2713,7 @@ def get_trained_models_stats(
           models in a single API request by using a comma-separated list of model IDs or a wildcard expression.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-get-trained-models-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-get-trained-models-stats>`_
 
         :param model_id: The unique identifier of the trained model or a model alias.
             It can be a comma-separated list or a wildcard expression.
@@ -2784,7 +2779,7 @@ def infer_trained_model(
           <p>Evaluate a trained model.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-infer-trained-model>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-infer-trained-model>`_
 
         :param model_id: The unique identifier of the trained model.
         :param docs: An array of objects to pass to the model for inference. The objects
@@ -2851,7 +2846,7 @@ def info(
           cluster configuration.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-info>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-info>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_ml/info"
@@ -2900,7 +2895,7 @@ def open_job(
           new data is received.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-open-job>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-open-job>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param timeout: Refer to the description for the `timeout` query parameter.
@@ -2957,7 +2952,7 @@ def post_calendar_events(
           <p>Add scheduled events to the calendar.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-post-calendar-events>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-post-calendar-events>`_
 
         :param calendar_id: A string that uniquely identifies a calendar.
         :param events: A list of one of more scheduled events. The event’s start and
@@ -3018,7 +3013,7 @@ def post_data(
           It is not currently possible to post data to multiple jobs using wildcards or a comma-separated list.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-post-data>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-post-data>`_
 
         :param job_id: Identifier for the anomaly detection job. The job must have a
             state of open to receive and process the data.
@@ -3085,7 +3080,7 @@ def preview_data_frame_analytics(
           Preview the extracted features used by a data frame analytics config.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-preview-data-frame-analytics>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-preview-data-frame-analytics>`_
 
         :param id: Identifier for the data frame analytics job.
         :param config: A data frame analytics config as described in create data frame
@@ -3158,7 +3153,7 @@ def preview_datafeed(
           You can also use secondary authorization headers to supply the credentials.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-preview-datafeed>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-preview-datafeed>`_
 
         :param datafeed_id: A numerical character string that uniquely identifies the
             datafeed. This identifier can contain lowercase alphanumeric characters (a-z
@@ -3237,7 +3232,7 @@ def put_calendar(
           <p>Create a calendar.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-put-calendar>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-put-calendar>`_
 
         :param calendar_id: A string that uniquely identifies a calendar.
         :param description: A description of the calendar.
@@ -3294,7 +3289,7 @@ def put_calendar_job(
           <p>Add anomaly detection job to calendar.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-put-calendar-job>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-put-calendar-job>`_
 
         :param calendar_id: A string that uniquely identifies a calendar.
         :param job_id: An identifier for the anomaly detection jobs. It can be a job
@@ -3377,7 +3372,7 @@ def put_data_frame_analytics(
           <p>If you supply only a subset of the regression or classification parameters, hyperparameter optimization occurs. It determines a value for each of the undefined parameters.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-put-data-frame-analytics>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-put-data-frame-analytics>`_
 
         :param id: Identifier for the data frame analytics job. This identifier can contain
             lowercase alphanumeric characters (a-z and 0-9), hyphens, and underscores.
@@ -3554,7 +3549,8 @@ def put_datafeed(
           Datafeeds retrieve data from Elasticsearch for analysis by an anomaly detection job.
           You can associate only one datafeed with each anomaly detection job.
           The datafeed contains a query that runs at a defined interval (<code>frequency</code>).
-          If you are concerned about delayed data, you can add a delay (<code>query_delay') at each interval. By default, the datafeed uses the following query: </code>{&quot;match_all&quot;: {&quot;boost&quot;: 1}}`.</p>
+          If you are concerned about delayed data, you can add a delay (<code>query_delay</code>) at each interval.
+          By default, the datafeed uses the following query: <code>{&quot;match_all&quot;: {&quot;boost&quot;: 1}}</code>.</p>
           <p>When Elasticsearch security features are enabled, your datafeed remembers which roles the user who created it had
           at the time of creation and runs the query using those same roles. If you provide secondary authorization headers,
           those credentials are used instead.
@@ -3562,7 +3558,7 @@ def put_datafeed(
           directly to the <code>.ml-config</code> index. Do not give users <code>write</code> privileges on the <code>.ml-config</code> index.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-put-datafeed>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-put-datafeed>`_
 
         :param datafeed_id: A numerical character string that uniquely identifies the
             datafeed. This identifier can contain lowercase alphanumeric characters (a-z
@@ -3604,11 +3600,11 @@ def put_datafeed(
         :param ignore_unavailable: If true, unavailable indices (missing or closed) are
             ignored.
         :param indexes: An array of index names. Wildcards are supported. If any of the
-            indices are in remote clusters, the machine learning nodes must have the
-            `remote_cluster_client` role.
+            indices are in remote clusters, the master nodes and the machine learning
+            nodes must have the `remote_cluster_client` role.
         :param indices: An array of index names. Wildcards are supported. If any of the
-            indices are in remote clusters, the machine learning nodes must have the
-            `remote_cluster_client` role.
+            indices are in remote clusters, the master nodes and the machine learning
+            nodes must have the `remote_cluster_client` role.
         :param indices_options: Specifies index expansion options that are used during
             search
         :param job_id: Identifier for the anomaly detection job.
@@ -3724,7 +3720,7 @@ def put_filter(
           Specifically, filters are referenced in the <code>custom_rules</code> property of detector configuration objects.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-put-filter>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-put-filter>`_
 
         :param filter_id: A string that uniquely identifies a filter.
         :param description: A description of the filter.
@@ -3826,7 +3822,7 @@ def put_job(
           If you include a <code>datafeed_config</code> but do not provide a query, the datafeed uses <code>{&quot;match_all&quot;: {&quot;boost&quot;: 1}}</code>.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-put-job>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-put-job>`_
 
         :param job_id: The identifier for the anomaly detection job. This identifier
             can contain lowercase alphanumeric characters (a-z and 0-9), hyphens, and
@@ -3876,13 +3872,7 @@ def put_job(
         :param description: A description of the job.
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
-            expressions match hidden data streams. Supports comma-separated values. Valid
-            values are: * `all`: Match any data stream or index, including hidden ones.
-            * `closed`: Match closed, non-hidden indices. Also matches any non-hidden
-            data stream. Data streams cannot be closed. * `hidden`: Match hidden data
-            streams and hidden indices. Must be combined with `open`, `closed`, or both.
-            * `none`: Wildcard patterns are not accepted. * `open`: Match open, non-hidden
-            indices. Also matches any non-hidden data stream.
+            expressions match hidden data streams. Supports comma-separated values.
         :param groups: A list of job groups. A job can belong to no groups or many.
         :param ignore_throttled: If `true`, concrete, expanded or aliased indices are
             ignored when frozen.
@@ -4034,7 +4024,7 @@ def put_trained_model(
           Enable you to supply a trained model that is not created by data frame analytics.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-put-trained-model>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-put-trained-model>`_
 
         :param model_id: The unique identifier of the trained model.
         :param compressed_definition: The compressed (GZipped and Base64 encoded) inference
@@ -4155,7 +4145,7 @@ def put_trained_model_alias(
           returns a warning.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-put-trained-model-alias>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-put-trained-model-alias>`_
 
         :param model_id: The identifier for the trained model that the alias refers to.
         :param model_alias: The alias to create or update. This value cannot end in numbers.
@@ -4216,7 +4206,7 @@ def put_trained_model_definition_part(
           <p>Create part of a trained model definition.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-put-trained-model-definition-part>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-put-trained-model-definition-part>`_
 
         :param model_id: The unique identifier of the trained model.
         :param part: The definition part number. When the definition is loaded for inference
@@ -4298,7 +4288,7 @@ def put_trained_model_vocabulary(
           The vocabulary is stored in the index as described in <code>inference_config.*.vocabulary</code> of the trained model definition.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-put-trained-model-vocabulary>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-put-trained-model-vocabulary>`_
 
         :param model_id: The unique identifier of the trained model.
         :param vocabulary: The model vocabulary, which must not be empty.
@@ -4361,7 +4351,7 @@ def reset_job(
           comma separated list.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-reset-job>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-reset-job>`_
 
         :param job_id: The ID of the job to reset.
         :param delete_user_annotations: Specifies whether annotations that have been
@@ -4425,7 +4415,7 @@ def revert_model_snapshot(
           snapshot after Black Friday or a critical system failure.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-revert-model-snapshot>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-revert-model-snapshot>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param snapshot_id: You can specify `empty` as the <snapshot_id>. Reverting to
@@ -4500,7 +4490,7 @@ def set_upgrade_mode(
           machine learning info API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-set-upgrade-mode>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-set-upgrade-mode>`_
 
         :param enabled: When `true`, it enables `upgrade_mode` which temporarily halts
             all job and datafeed tasks and prohibits new job and datafeed tasks from
@@ -4560,7 +4550,7 @@ def start_data_frame_analytics(
           the destination index in advance with custom settings and mappings.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-start-data-frame-analytics>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-start-data-frame-analytics>`_
 
         :param id: Identifier for the data frame analytics job. This identifier can contain
             lowercase alphanumeric characters (a-z and 0-9), hyphens, and underscores.
@@ -4623,7 +4613,7 @@ def start_datafeed(
           authorization headers when you created or updated the datafeed, those credentials are used instead.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-start-datafeed>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-start-datafeed>`_
 
         :param datafeed_id: A numerical character string that uniquely identifies the
             datafeed. This identifier can contain lowercase alphanumeric characters (a-z
@@ -4700,7 +4690,7 @@ def start_trained_model_deployment(
           It allocates the model to every machine learning node.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-start-trained-model-deployment>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-start-trained-model-deployment>`_
 
         :param model_id: The unique identifier of the trained model. Currently, only
             PyTorch models are supported.
@@ -4801,7 +4791,7 @@ def stop_data_frame_analytics(
           throughout its lifecycle.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-stop-data-frame-analytics>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-stop-data-frame-analytics>`_
 
         :param id: Identifier for the data frame analytics job. This identifier can contain
             lowercase alphanumeric characters (a-z and 0-9), hyphens, and underscores.
@@ -4871,7 +4861,7 @@ def stop_datafeed(
           multiple times throughout its lifecycle.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-stop-datafeed>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-stop-datafeed>`_
 
         :param datafeed_id: Identifier for the datafeed. You can stop multiple datafeeds
             in a single API request by using a comma-separated list of datafeeds or a
@@ -4936,7 +4926,7 @@ def stop_trained_model_deployment(
           <p>Stop a trained model deployment.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-stop-trained-model-deployment>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-stop-trained-model-deployment>`_
 
         :param model_id: The unique identifier of the trained model.
         :param allow_no_match: Specifies what to do when the request: contains wildcard
@@ -5119,7 +5109,7 @@ def update_datafeed(
           those credentials are used instead.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-update-datafeed>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-update-datafeed>`_
 
         :param datafeed_id: A numerical character string that uniquely identifies the
             datafeed. This identifier can contain lowercase alphanumeric characters (a-z
@@ -5145,13 +5135,7 @@ def update_datafeed(
             check runs only on real-time datafeeds.
         :param expand_wildcards: Type of index that wildcard patterns can match. If the
             request can target data streams, this argument determines whether wildcard
-            expressions match hidden data streams. Supports comma-separated values. Valid
-            values are: * `all`: Match any data stream or index, including hidden ones.
-            * `closed`: Match closed, non-hidden indices. Also matches any non-hidden
-            data stream. Data streams cannot be closed. * `hidden`: Match hidden data
-            streams and hidden indices. Must be combined with `open`, `closed`, or both.
-            * `none`: Wildcard patterns are not accepted. * `open`: Match open, non-hidden
-            indices. Also matches any non-hidden data stream.
+            expressions match hidden data streams. Supports comma-separated values.
         :param frequency: The interval at which scheduled queries are made while the
             datafeed runs in real time. The default value is either the bucket span for
             short bucket spans, or, for longer bucket spans, a sensible fraction of the
@@ -5286,7 +5270,7 @@ def update_filter(
           Updates the description of a filter, adds items, or removes items from the list.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-update-filter>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-update-filter>`_
 
         :param filter_id: A string that uniquely identifies a filter.
         :param add_items: The items to add to the filter.
@@ -5380,7 +5364,7 @@ def update_job(
           Updates certain properties of an anomaly detection job.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-update-job>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-update-job>`_
 
         :param job_id: Identifier for the job.
         :param allow_lazy_open: Advanced configuration option. Specifies whether this
@@ -5512,7 +5496,7 @@ def update_model_snapshot(
           Updates certain properties of a snapshot.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-update-model-snapshot>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-update-model-snapshot>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param snapshot_id: Identifier for the model snapshot.
@@ -5577,7 +5561,7 @@ def update_trained_model_deployment(
           <p>Update a trained model deployment.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-update-trained-model-deployment>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-update-trained-model-deployment>`_
 
         :param model_id: The unique identifier of the trained model. Currently, only
             PyTorch models are supported.
@@ -5654,7 +5638,7 @@ def upgrade_job_snapshot(
           job.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ml-upgrade-job-snapshot>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ml-upgrade-job-snapshot>`_
 
         :param job_id: Identifier for the anomaly detection job.
         :param snapshot_id: A numerical character string that uniquely identifies the
@@ -5733,7 +5717,7 @@ def validate(
           <p>Validate an anomaly detection job.</p>
 
 
-        `<https://www.elastic.co/guide/en/machine-learning/master/ml-jobs.html>`_
+        `<https://www.elastic.co/guide/en/machine-learning/9.0/ml-jobs.html>`_
 
         :param analysis_config:
         :param analysis_limits:
diff --git a/elasticsearch/_sync/client/nodes.py b/elasticsearch/_sync/client/nodes.py
index e300ba3e3..2dedf4b77 100644
--- a/elasticsearch/_sync/client/nodes.py
+++ b/elasticsearch/_sync/client/nodes.py
@@ -50,7 +50,7 @@ def clear_repositories_metering_archive(
           Clear the archived repositories metering information in the cluster.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-nodes-clear-repositories-metering-archive>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-nodes-clear-repositories-metering-archive>`_
 
         :param node_id: Comma-separated list of node IDs or names used to limit returned
             information.
@@ -105,10 +105,10 @@ def get_repositories_metering_info(
           Additionally, the information exposed by this API is volatile, meaning that it will not be present after node restarts.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-nodes-get-repositories-metering-info>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-nodes-get-repositories-metering-info>`_
 
         :param node_id: Comma-separated list of node IDs or names used to limit returned
-            information. All the nodes selective options are explained [here](https://www.elastic.co/guide/en/elasticsearch/reference/current/cluster.html#cluster-nodes).
+            information.
         """
         if node_id in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'node_id'")
@@ -162,7 +162,7 @@ def hot_threads(
           The output is plain text with a breakdown of the top hot threads for each node.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-nodes-hot-threads>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-nodes-hot-threads>`_
 
         :param node_id: List of node IDs or names used to limit returned information.
         :param ignore_idle_threads: If true, known idle threads (e.g. waiting in a socket
@@ -235,7 +235,7 @@ def info(
           <p>By default, the API returns all attributes and core settings for cluster nodes.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-nodes-info>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-nodes-info>`_
 
         :param node_id: Comma-separated list of node IDs or names used to limit returned
             information.
@@ -308,7 +308,7 @@ def reload_secure_settings(
           Alternatively, you can reload the secure settings on each node by locally accessing the API and passing the node-specific Elasticsearch keystore password.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-nodes-reload-secure-settings>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-nodes-reload-secure-settings>`_
 
         :param node_id: The names of particular nodes in the cluster to target.
         :param secure_settings_password: The password for the Elasticsearch keystore.
@@ -383,7 +383,7 @@ def stats(
           By default, all stats are returned. You can limit the returned information by using metrics.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-nodes-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-nodes-stats>`_
 
         :param node_id: Comma-separated list of node IDs or names used to limit returned
             information.
@@ -498,7 +498,7 @@ def usage(
           <p>Get feature usage information.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-nodes-usage>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-nodes-usage>`_
 
         :param node_id: A comma-separated list of node IDs or names to limit the returned
             information; use `_local` to return information from the node you're connecting
diff --git a/elasticsearch/_sync/client/query_rules.py b/elasticsearch/_sync/client/query_rules.py
index 351c4dd80..7620755f2 100644
--- a/elasticsearch/_sync/client/query_rules.py
+++ b/elasticsearch/_sync/client/query_rules.py
@@ -44,7 +44,7 @@ def delete_rule(
           This is a destructive action that is only recoverable by re-adding the same rule with the create or update query rule API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-query-rules-delete-rule>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-query-rules-delete-rule>`_
 
         :param ruleset_id: The unique identifier of the query ruleset containing the
             rule to delete
@@ -97,7 +97,7 @@ def delete_ruleset(
           This is a destructive action that is not recoverable.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-query-rules-delete-ruleset>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-query-rules-delete-ruleset>`_
 
         :param ruleset_id: The unique identifier of the query ruleset to delete
         """
@@ -142,7 +142,7 @@ def get_rule(
           Get details about a query rule within a query ruleset.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-query-rules-get-rule>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-query-rules-get-rule>`_
 
         :param ruleset_id: The unique identifier of the query ruleset containing the
             rule to retrieve
@@ -194,7 +194,7 @@ def get_ruleset(
           Get details about a query ruleset.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-query-rules-get-ruleset>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-query-rules-get-ruleset>`_
 
         :param ruleset_id: The unique identifier of the query ruleset
         """
@@ -241,7 +241,7 @@ def list_rulesets(
           Get summarized information about the query rulesets.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-query-rules-list-rulesets>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-query-rules-list-rulesets>`_
 
         :param from_: The offset from the first result to fetch.
         :param size: The maximum number of results to retrieve.
@@ -302,7 +302,7 @@ def put_rule(
           If multiple matching rules pin more than 100 documents, only the first 100 documents are pinned in the order they are specified in the ruleset.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-query-rules-put-rule>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-query-rules-put-rule>`_
 
         :param ruleset_id: The unique identifier of the query ruleset containing the
             rule to be created or updated.
@@ -389,7 +389,7 @@ def put_ruleset(
           If multiple matching rules pin more than 100 documents, only the first 100 documents are pinned in the order they are specified in the ruleset.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-query-rules-put-ruleset>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-query-rules-put-ruleset>`_
 
         :param ruleset_id: The unique identifier of the query ruleset to be created or
             updated.
@@ -446,7 +446,7 @@ def test(
           Evaluate match criteria against a query ruleset to identify the rules that would match that criteria.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-query-rules-test>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-query-rules-test>`_
 
         :param ruleset_id: The unique identifier of the query ruleset to be created or
             updated
diff --git a/elasticsearch/_sync/client/rollup.py b/elasticsearch/_sync/client/rollup.py
index 5e34d954f..f336554df 100644
--- a/elasticsearch/_sync/client/rollup.py
+++ b/elasticsearch/_sync/client/rollup.py
@@ -67,7 +67,7 @@ def delete_job(
           </code></pre>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-rollup-delete-job>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-rollup-delete-job>`_
 
         :param id: Identifier for the job.
         """
@@ -115,7 +115,7 @@ def get_jobs(
           For details about a historical rollup job, the rollup capabilities API may be more useful.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-rollup-get-jobs>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-rollup-get-jobs>`_
 
         :param id: Identifier for the rollup job. If it is `_all` or omitted, the API
             returns all rollup jobs.
@@ -171,7 +171,7 @@ def get_rollup_caps(
           </ol>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-rollup-get-rollup-caps>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-rollup-get-rollup-caps>`_
 
         :param id: Index, indices or index-pattern to return rollup capabilities for.
             `_all` may be used to fetch rollup capabilities from all jobs.
@@ -225,7 +225,7 @@ def get_rollup_index_caps(
           </ul>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-rollup-get-rollup-index-caps>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-rollup-get-rollup-index-caps>`_
 
         :param index: Data stream or index to check for rollup capabilities. Wildcard
             (`*`) expressions are supported.
@@ -295,7 +295,7 @@ def put_job(
           <p>Jobs are created in a <code>STOPPED</code> state. You can start them with the start rollup jobs API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-rollup-put-job>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-rollup-put-job>`_
 
         :param id: Identifier for the rollup job. This can be any alphanumeric string
             and uniquely identifies the data that is associated with the rollup job.
@@ -419,31 +419,10 @@ def rollup_search(
           The following functionality is not available:</p>
           <p><code>size</code>: Because rollups work on pre-aggregated data, no search hits can be returned and so size must be set to zero or omitted entirely.
           <code>highlighter</code>, <code>suggestors</code>, <code>post_filter</code>, <code>profile</code>, <code>explain</code>: These are similarly disallowed.</p>
-          <p><strong>Searching both historical rollup and non-rollup data</strong></p>
-          <p>The rollup search API has the capability to search across both &quot;live&quot; non-rollup data and the aggregated rollup data.
-          This is done by simply adding the live indices to the URI. For example:</p>
-          <pre><code>GET sensor-1,sensor_rollup/_rollup_search
-          {
-            &quot;size&quot;: 0,
-            &quot;aggregations&quot;: {
-               &quot;max_temperature&quot;: {
-                &quot;max&quot;: {
-                  &quot;field&quot;: &quot;temperature&quot;
-                }
-              }
-            }
-          }
-          </code></pre>
-          <p>The rollup search endpoint does two things when the search runs:</p>
-          <ul>
-          <li>The original request is sent to the non-rollup index unaltered.</li>
-          <li>A rewritten version of the original request is sent to the rollup index.</li>
-          </ul>
-          <p>When the two responses are received, the endpoint rewrites the rollup response and merges the two together.
-          During the merging process, if there is any overlap in buckets between the two responses, the buckets from the non-rollup index are used.</p>
+          <p>For more detailed examples of using the rollup search API, including querying rolled-up data only or combining rolled-up and live data, refer to the External documentation.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-rollup-rollup-search>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-rollup-rollup-search>`_
 
         :param index: A comma-separated list of data streams and indices used to limit
             the request. This parameter has the following rules: * At least one data
@@ -521,7 +500,7 @@ def start_job(
           If you try to start a job that is already started, nothing happens.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-rollup-start-job>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-rollup-start-job>`_
 
         :param id: Identifier for the rollup job.
         """
@@ -575,7 +554,7 @@ def stop_job(
           If the specified time elapses without the job moving to STOPPED, a timeout exception occurs.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-rollup-stop-job>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-rollup-stop-job>`_
 
         :param id: Identifier for the rollup job.
         :param timeout: If `wait_for_completion` is `true`, the API blocks for (at maximum)
diff --git a/elasticsearch/_sync/client/search_application.py b/elasticsearch/_sync/client/search_application.py
index b81980475..3776cc740 100644
--- a/elasticsearch/_sync/client/search_application.py
+++ b/elasticsearch/_sync/client/search_application.py
@@ -49,7 +49,7 @@ def delete(
           <p>Remove a search application and its associated alias. Indices attached to the search application are not removed.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-search-application-delete>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-search-application-delete>`_
 
         :param name: The name of the search application to delete.
         """
@@ -94,7 +94,7 @@ def delete_behavioral_analytics(
           The associated data stream is also deleted.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-search-application-delete-behavioral-analytics>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-search-application-delete-behavioral-analytics>`_
 
         :param name: The name of the analytics collection to be deleted
         """
@@ -138,7 +138,7 @@ def get(
           <p>Get search application details.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-search-application-get>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-search-application-get>`_
 
         :param name: The name of the search application
         """
@@ -182,7 +182,7 @@ def get_behavioral_analytics(
           <p>Get behavioral analytics collections.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-search-application-get-behavioral-analytics>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-search-application-get-behavioral-analytics>`_
 
         :param name: A list of analytics collections to limit the returned information
         """
@@ -234,7 +234,7 @@ def list(
           Get information about search applications.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-search-application-get-behavioral-analytics>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-search-application-get-behavioral-analytics>`_
 
         :param from_: Starting offset.
         :param q: Query in the Lucene query string syntax.
@@ -290,7 +290,7 @@ def post_behavioral_analytics_event(
           <p>Create a behavioral analytics collection event.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-search-application-post-behavioral-analytics-event>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-search-application-post-behavioral-analytics-event>`_
 
         :param collection_name: The name of the behavioral analytics collection.
         :param event_type: The analytics event type.
@@ -357,7 +357,7 @@ def put(
           <p>Create or update a search application.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-search-application-put>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-search-application-put>`_
 
         :param name: The name of the search application to be created or updated.
         :param search_application:
@@ -414,7 +414,7 @@ def put_behavioral_analytics(
           <p>Create a behavioral analytics collection.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-search-application-put-behavioral-analytics>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-search-application-put-behavioral-analytics>`_
 
         :param name: The name of the analytics collection to be created or updated.
         """
@@ -467,7 +467,7 @@ def render_query(
           <p>You must have <code>read</code> privileges on the backing alias of the search application.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-search-application-render-query>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-search-application-render-query>`_
 
         :param name: The name of the search application to render teh query for.
         :param params:
@@ -531,7 +531,7 @@ def search(
           Unspecified template parameters are assigned their default values if applicable.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-search-application-search>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-search-application-search>`_
 
         :param name: The name of the search application to be searched.
         :param params: Query parameters specific to this request, which will override
diff --git a/elasticsearch/_sync/client/searchable_snapshots.py b/elasticsearch/_sync/client/searchable_snapshots.py
index 2160988c0..f44a18797 100644
--- a/elasticsearch/_sync/client/searchable_snapshots.py
+++ b/elasticsearch/_sync/client/searchable_snapshots.py
@@ -50,7 +50,7 @@ def cache_stats(
           Get statistics about the shared cache for partially mounted indices.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-searchable-snapshots-cache-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-searchable-snapshots-cache-stats>`_
 
         :param node_id: The names of the nodes in the cluster to target.
         :param master_timeout:
@@ -111,7 +111,7 @@ def clear_cache(
           Clear indices and data streams from the shared cache for partially mounted indices.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-searchable-snapshots-clear-cache>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-searchable-snapshots-clear-cache>`_
 
         :param index: A comma-separated list of data streams, indices, and aliases to
             clear from the cache. It supports wildcards (`*`).
@@ -190,7 +190,7 @@ def mount(
           Manually mounting ILM-managed snapshots can interfere with ILM processes.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-searchable-snapshots-mount>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-searchable-snapshots-mount>`_
 
         :param repository: The name of the repository containing the snapshot of the
             index to mount.
@@ -278,7 +278,7 @@ def stats(
           <p>Get searchable snapshot statistics.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-searchable-snapshots-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-searchable-snapshots-stats>`_
 
         :param index: A comma-separated list of data streams and indices to retrieve
             statistics for.
diff --git a/elasticsearch/_sync/client/security.py b/elasticsearch/_sync/client/security.py
index 1f7c8bac2..5839ad34b 100644
--- a/elasticsearch/_sync/client/security.py
+++ b/elasticsearch/_sync/client/security.py
@@ -58,7 +58,7 @@ def activate_user_profile(
           Any updates do not change existing content for either the <code>labels</code> or <code>data</code> fields.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-activate-user-profile>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-activate-user-profile>`_
 
         :param grant_type: The type of grant.
         :param access_token: The user's Elasticsearch access token or JWT. Both `access`
@@ -124,7 +124,7 @@ def authenticate(
           If the user cannot be authenticated, this API returns a 401 status code.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-authenticate>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-authenticate>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_security/_authenticate"
@@ -171,7 +171,7 @@ def bulk_delete_role(
           The bulk delete roles API cannot delete roles that are defined in roles files.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-bulk-delete-role>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-bulk-delete-role>`_
 
         :param names: An array of role names to delete
         :param refresh: If `true` (the default) then refresh the affected shards to make
@@ -232,7 +232,7 @@ def bulk_put_role(
           The bulk create or update roles API cannot update roles that are defined in roles files.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-bulk-put-role>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-bulk-put-role>`_
 
         :param roles: A dictionary of role name to RoleDescriptor objects to add or update
         :param refresh: If `true` (the default) then refresh the affected shards to make
@@ -300,7 +300,7 @@ def bulk_update_api_keys(
           <p>A successful request returns a JSON structure that contains the IDs of all updated API keys, the IDs of API keys that already had the requested changes and did not require an update, and error details for any failed update.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-bulk-update-api-keys>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-bulk-update-api-keys>`_
 
         :param ids: The API key identifiers.
         :param expiration: Expiration time for the API keys. By default, API keys never
@@ -378,7 +378,7 @@ def change_password(
           <p>Change the passwords of users in the native realm and built-in users.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-change-password>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-change-password>`_
 
         :param username: The user whose password you want to change. If you do not specify
             this parameter, the password is changed for the current user.
@@ -445,7 +445,7 @@ def clear_api_key_cache(
           The cache is also automatically cleared on state changes of the security index.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-clear-api-key-cache>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-clear-api-key-cache>`_
 
         :param ids: Comma-separated list of API key IDs to evict from the API key cache.
             To evict all API keys, use `*`. Does not support other wildcard patterns.
@@ -491,7 +491,7 @@ def clear_cached_privileges(
           The cache is also automatically cleared for applications that have their privileges updated.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-clear-cached-privileges>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-clear-cached-privileges>`_
 
         :param application: A comma-separated list of applications. To clear all applications,
             use an asterism (`*`). It does not support other wildcard patterns.
@@ -541,7 +541,7 @@ def clear_cached_realms(
           For more information, refer to the documentation about controlling the user cache.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-clear-cached-realms>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-clear-cached-realms>`_
 
         :param realms: A comma-separated list of realms. To clear all realms, use an
             asterisk (`*`). It does not support other wildcard patterns.
@@ -591,7 +591,7 @@ def clear_cached_roles(
           <p>Evict roles from the native role cache.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-clear-cached-roles>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-clear-cached-roles>`_
 
         :param name: A comma-separated list of roles to evict from the role cache. To
             evict all roles, use an asterisk (`*`). It does not support other wildcard
@@ -643,7 +643,7 @@ def clear_cached_service_tokens(
           The cache for tokens backed by the <code>service_tokens</code> file is cleared automatically on file changes.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-clear-cached-service-tokens>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-clear-cached-service-tokens>`_
 
         :param namespace: The namespace, which is a top-level grouping of service accounts.
         :param service: The name of the service, which must be unique within its namespace.
@@ -715,7 +715,7 @@ def create_api_key(
           To configure or turn off the API key service, refer to API key service setting documentation.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-create-api-key>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-create-api-key>`_
 
         :param expiration: The expiration time for the API key. By default, API keys
             never expire.
@@ -805,7 +805,7 @@ def create_cross_cluster_api_key(
           Attempting to update them with the update REST API key API or the bulk update REST API keys API will result in an error.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-create-cross-cluster-api-key>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-create-cross-cluster-api-key>`_
 
         :param access: The access to be granted to this API key. The access is composed
             of permissions for cross-cluster search and cross-cluster replication. At
@@ -880,7 +880,7 @@ def create_service_token(
           You must actively delete them if they are no longer needed.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-create-service-token>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-create-service-token>`_
 
         :param namespace: The name of the namespace, which is a top-level grouping of
             service accounts.
@@ -966,7 +966,7 @@ def delegate_pki(
           The proxy is trusted to have performed the TLS authentication and this API translates that authentication into an Elasticsearch access token.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-delegate-pki>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-delegate-pki>`_
 
         :param x509_certificate_chain: The X509Certificate chain, which is represented
             as an ordered string array. Each string in the array is a base64-encoded
@@ -1030,7 +1030,7 @@ def delete_privileges(
           </ul>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-delete-privileges>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-delete-privileges>`_
 
         :param application: The name of the application. Application privileges are always
             associated with exactly one application.
@@ -1093,7 +1093,7 @@ def delete_role(
           The delete roles API cannot remove roles that are defined in roles files.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-delete-role>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-delete-role>`_
 
         :param name: The name of the role.
         :param refresh: If `true` (the default) then refresh the affected shards to make
@@ -1147,7 +1147,7 @@ def delete_role_mapping(
           The delete role mappings API cannot remove role mappings that are defined in role mapping files.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-delete-role-mapping>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-delete-role-mapping>`_
 
         :param name: The distinct name that identifies the role mapping. The name is
             used solely as an identifier to facilitate interaction via the API; it does
@@ -1203,7 +1203,7 @@ def delete_service_token(
           <p>Delete service account tokens for a service in a specified namespace.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-delete-service-token>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-delete-service-token>`_
 
         :param namespace: The namespace, which is a top-level grouping of service accounts.
         :param service: The service name.
@@ -1265,7 +1265,7 @@ def delete_user(
           <p>Delete users from the native realm.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-delete-user>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-delete-user>`_
 
         :param username: An identifier for the user.
         :param refresh: If `true` (the default) then refresh the affected shards to make
@@ -1319,7 +1319,7 @@ def disable_user(
           You can use this API to revoke a user's access to Elasticsearch.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-disable-user>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-disable-user>`_
 
         :param username: An identifier for the user.
         :param refresh: If `true` (the default) then refresh the affected shards to make
@@ -1376,7 +1376,7 @@ def disable_user_profile(
           To re-enable a disabled user profile, use the enable user profile API .</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-disable-user-profile>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-disable-user-profile>`_
 
         :param uid: Unique identifier for the user profile.
         :param refresh: If 'true', Elasticsearch refreshes the affected shards to make
@@ -1429,7 +1429,7 @@ def enable_user(
           By default, when you create users, they are enabled.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-enable-user>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-enable-user>`_
 
         :param username: An identifier for the user.
         :param refresh: If `true` (the default) then refresh the affected shards to make
@@ -1486,7 +1486,7 @@ def enable_user_profile(
           If you later disable the user profile, you can use the enable user profile API to make the profile visible in these searches again.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-enable-user-profile>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-enable-user-profile>`_
 
         :param uid: A unique identifier for the user profile.
         :param refresh: If 'true', Elasticsearch refreshes the affected shards to make
@@ -1536,7 +1536,7 @@ def enroll_kibana(
           Kibana uses this API internally to configure itself for communications with an Elasticsearch cluster that already has security features enabled.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-enroll-kibana>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-enroll-kibana>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_security/enroll/kibana"
@@ -1577,7 +1577,7 @@ def enroll_node(
           The response contains key and certificate material that allows the caller to generate valid signed certificates for the HTTP layer of all nodes in the cluster.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-enroll-node>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-enroll-node>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_security/enroll/node"
@@ -1626,7 +1626,7 @@ def get_api_key(
           If you have <code>read_security</code>, <code>manage_api_key</code> or greater privileges (including <code>manage_security</code>), this API returns all API keys regardless of ownership.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-get-api-key>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-get-api-key>`_
 
         :param active_only: A boolean flag that can be used to query API keys that are
             currently active. An API key is considered active if it is neither invalidated,
@@ -1704,7 +1704,7 @@ def get_builtin_privileges(
           <p>Get the list of cluster privileges and index privileges that are available in this version of Elasticsearch.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-get-builtin-privileges>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-get-builtin-privileges>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_security/privilege/_builtin"
@@ -1749,7 +1749,7 @@ def get_privileges(
           </ul>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-get-privileges>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-get-privileges>`_
 
         :param application: The name of the application. Application privileges are always
             associated with exactly one application. If you do not specify this parameter,
@@ -1805,7 +1805,7 @@ def get_role(
           The get roles API cannot retrieve roles that are defined in roles files.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-get-role>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-get-role>`_
 
         :param name: The name of the role. You can specify multiple roles as a comma-separated
             list. If you do not specify this parameter, the API returns information about
@@ -1856,7 +1856,7 @@ def get_role_mapping(
           The get role mappings API cannot retrieve role mappings that are defined in role mapping files.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-get-role-mapping>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-get-role-mapping>`_
 
         :param name: The distinct name that identifies the role mapping. The name is
             used solely as an identifier to facilitate interaction via the API; it does
@@ -1909,7 +1909,7 @@ def get_service_accounts(
           <p>NOTE: Currently, only the <code>elastic/fleet-server</code> service account is available.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-get-service-accounts>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-get-service-accounts>`_
 
         :param namespace: The name of the namespace. Omit this parameter to retrieve
             information about all service accounts. If you omit this parameter, you must
@@ -1967,7 +1967,7 @@ def get_service_credentials(
           Tokens with the same name from different nodes are assumed to be the same token and are only counted once towards the total number of service tokens.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-get-service-credentials>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-get-service-credentials>`_
 
         :param namespace: The name of the namespace.
         :param service: The service name.
@@ -2023,7 +2023,7 @@ def get_settings(
           </ul>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-get-settings>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-get-settings>`_
 
         :param master_timeout: Period to wait for a connection to the master node. If
             no response is received before the timeout expires, the request fails and
@@ -2099,7 +2099,7 @@ def get_token(
           If you want to invalidate a token immediately, you can do so by using the invalidate token API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-get-token>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-get-token>`_
 
         :param grant_type: The type of grant. Supported grant types are: `password`,
             `_kerberos`, `client_credentials`, and `refresh_token`.
@@ -2173,7 +2173,7 @@ def get_user(
           <p>Get information about users in the native realm and built-in users.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-get-user>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-get-user>`_
 
         :param username: An identifier for the user. You can specify multiple usernames
             as a comma-separated list. If you omit this parameter, the API retrieves
@@ -2213,13 +2213,10 @@ def get_user(
     def get_user_privileges(
         self,
         *,
-        application: 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,
-        priviledge: t.Optional[str] = None,
-        username: t.Optional[t.Union[None, str]] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
         .. raw:: html
@@ -2231,20 +2228,11 @@ def get_user_privileges(
           To check whether a user has a specific list of privileges, use the has privileges API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-get-user-privileges>`_
-
-        :param application: The name of the application. Application privileges are always
-            associated with exactly one application. If you do not specify this parameter,
-            the API returns information about all privileges for all applications.
-        :param priviledge: The name of the privilege. If you do not specify this parameter,
-            the API returns information about all privileges for the requested application.
-        :param username:
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-get-user-privileges>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_security/user/_privileges"
         __query: t.Dict[str, t.Any] = {}
-        if application is not None:
-            __query["application"] = application
         if error_trace is not None:
             __query["error_trace"] = error_trace
         if filter_path is not None:
@@ -2253,10 +2241,6 @@ def get_user_privileges(
             __query["human"] = human
         if pretty is not None:
             __query["pretty"] = pretty
-        if priviledge is not None:
-            __query["priviledge"] = priviledge
-        if username is not None:
-            __query["username"] = username
         __headers = {"accept": "application/json"}
         return self.perform_request(  # type: ignore[return-value]
             "GET",
@@ -2288,7 +2272,7 @@ def get_user_profile(
           Elastic reserves the right to change or remove this feature in future releases without prior notice.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-get-user-profile>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-get-user-profile>`_
 
         :param uid: A unique identifier for the user profile.
         :param data: A comma-separated list of filters for the `data` field of the profile
@@ -2345,6 +2329,9 @@ def grant_api_key(
         human: t.Optional[bool] = None,
         password: t.Optional[str] = None,
         pretty: t.Optional[bool] = None,
+        refresh: t.Optional[
+            t.Union[bool, str, t.Literal["false", "true", "wait_for"]]
+        ] = None,
         run_as: t.Optional[str] = None,
         username: t.Optional[str] = None,
         body: t.Optional[t.Dict[str, t.Any]] = None,
@@ -2372,7 +2359,7 @@ def grant_api_key(
           <p>By default, API keys never expire. You can specify expiration information when you create the API keys.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-grant-api-key>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-grant-api-key>`_
 
         :param api_key: The API key.
         :param grant_type: The type of grant. Supported grant types are: `access_token`,
@@ -2382,6 +2369,9 @@ def grant_api_key(
             types.
         :param password: The user's password. If you specify the `password` grant type,
             this parameter is required. It is not valid with other grant types.
+        :param refresh: If 'true', Elasticsearch refreshes the affected shards to make
+            this operation visible to search. If 'wait_for', it waits for a refresh to
+            make this operation visible to search. If 'false', nothing is done with refreshes.
         :param run_as: The name of the user to be impersonated.
         :param username: The user name that identifies the user. If you specify the `password`
             grant type, this parameter is required. It is not valid with other grant
@@ -2403,6 +2393,8 @@ def grant_api_key(
             __query["human"] = human
         if pretty is not None:
             __query["pretty"] = pretty
+        if refresh is not None:
+            __query["refresh"] = refresh
         if not __body:
             if api_key is not None:
                 __body["api_key"] = api_key
@@ -2519,7 +2511,7 @@ def has_privileges(
           To check the privileges of other users, you must use the run as feature.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-has-privileges>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-has-privileges>`_
 
         :param user: Username
         :param application:
@@ -2584,7 +2576,7 @@ def has_privileges_user_profile(
           Elastic reserves the right to change or remove this feature in future releases without prior notice.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-has-privileges-user-profile>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-has-privileges-user-profile>`_
 
         :param privileges: An object containing all the privileges to be checked.
         :param uids: A list of profile IDs. The privileges are checked for associated
@@ -2658,7 +2650,7 @@ def invalidate_api_key(
           </ul>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-invalidate-api-key>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-invalidate-api-key>`_
 
         :param id:
         :param ids: A list of API key ids. This parameter cannot be used with any of
@@ -2742,7 +2734,7 @@ def invalidate_token(
           If none of these two are specified, then <code>realm_name</code> and/or <code>username</code> need to be specified.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-invalidate-token>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-invalidate-token>`_
 
         :param realm_name: The name of an authentication realm. This parameter cannot
             be used with either `refresh_token` or `token`.
@@ -2810,7 +2802,7 @@ def oidc_authenticate(
           These APIs are used internally by Kibana in order to provide OpenID Connect based authentication, but can also be used by other, custom web applications or other clients.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-oidc-authenticate>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-oidc-authenticate>`_
 
         :param nonce: Associate a client session with an ID token and mitigate replay
             attacks. This value needs to be the same as the one that was provided to
@@ -2867,12 +2859,12 @@ def oidc_authenticate(
         )
 
     @_rewrite_parameters(
-        body_fields=("access_token", "refresh_token"),
+        body_fields=("token", "refresh_token"),
     )
     def oidc_logout(
         self,
         *,
-        access_token: t.Optional[str] = None,
+        token: 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,
@@ -2890,13 +2882,13 @@ def oidc_logout(
           These APIs are used internally by Kibana in order to provide OpenID Connect based authentication, but can also be used by other, custom web applications or other clients.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-oidc-logout>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-oidc-logout>`_
 
-        :param access_token: The access token to be invalidated.
+        :param token: The access token to be invalidated.
         :param refresh_token: The refresh token to be invalidated.
         """
-        if access_token is None and body is None:
-            raise ValueError("Empty value passed for parameter 'access_token'")
+        if token is None and body is None:
+            raise ValueError("Empty value passed for parameter 'token'")
         __path_parts: t.Dict[str, str] = {}
         __path = "/_security/oidc/logout"
         __query: t.Dict[str, t.Any] = {}
@@ -2910,8 +2902,8 @@ def oidc_logout(
         if pretty is not None:
             __query["pretty"] = pretty
         if not __body:
-            if access_token is not None:
-                __body["access_token"] = access_token
+            if token is not None:
+                __body["token"] = token
             if refresh_token is not None:
                 __body["refresh_token"] = refresh_token
         __headers = {"accept": "application/json", "content-type": "application/json"}
@@ -2952,7 +2944,7 @@ def oidc_prepare_authentication(
           These APIs are used internally by Kibana in order to provide OpenID Connect based authentication, but can also be used by other, custom web applications or other clients.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-oidc-prepare-authentication>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-oidc-prepare-authentication>`_
 
         :param iss: In the case of a third party initiated single sign on, this is the
             issuer identifier for the OP that the RP is to send the authentication request
@@ -3048,7 +3040,7 @@ def put_privileges(
           <p>Action names can contain any number of printable ASCII characters and must contain at least one of the following characters: <code>/</code>, <code>*</code>, <code>:</code>.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-put-privileges>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-put-privileges>`_
 
         :param privileges:
         :param refresh: If `true` (the default) then refresh the affected shards to make
@@ -3200,7 +3192,7 @@ def put_role(
           File-based role management is not available in Elastic Serverless.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-put-role>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-put-role>`_
 
         :param name: The name of the role that is being created or updated. On Elasticsearch
             Serverless, the role name must begin with a letter or digit and can only
@@ -3335,7 +3327,7 @@ def put_role_mapping(
           If the format of the template is set to &quot;json&quot; then the template is expected to produce a JSON string or an array of JSON strings for the role names.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-put-role-mapping>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-put-role-mapping>`_
 
         :param name: The distinct name that identifies the role mapping. The name is
             used solely as an identifier to facilitate interaction via the API; it does
@@ -3437,7 +3429,7 @@ def put_user(
           To change a user's password without updating any other fields, use the change password API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-put-user>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-put-user>`_
 
         :param username: An identifier for the user. NOTE: Usernames must be at least
             1 and no more than 507 characters. They can contain alphanumeric characters
@@ -3553,10 +3545,11 @@ def query_api_keys(
           You can optionally filter the results with a query.</p>
           <p>To use this API, you must have at least the <code>manage_own_api_key</code> or the <code>read_security</code> cluster privileges.
           If you have only the <code>manage_own_api_key</code> privilege, this API returns only the API keys that you own.
-          If you have the <code>read_security</code>, <code>manage_api_key</code>, or greater privileges (including <code>manage_security</code>), this API returns all API keys regardless of ownership.</p>
+          If you have the <code>read_security</code>, <code>manage_api_key</code>, or greater privileges (including <code>manage_security</code>), this API returns all API keys regardless of ownership.
+          Refer to the linked documentation for examples of how to find API keys:</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-query-api-keys>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-query-api-keys>`_
 
         :param aggregations: Any aggregations to run over the corpus of returned API
             keys. Aggregations and queries work together. Aggregations are computed only
@@ -3699,7 +3692,7 @@ def query_role(
           Also, the results can be paginated and sorted.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-query-role>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-query-role>`_
 
         :param from_: The starting document offset. It must not be negative. By default,
             you cannot page through more than 10,000 hits using the `from` and `size`
@@ -3792,7 +3785,7 @@ def query_user(
           This API is only for native users.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-query-user>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-query-user>`_
 
         :param from_: The starting document offset. It must not be negative. By default,
             you cannot page through more than 10,000 hits using the `from` and `size`
@@ -3885,7 +3878,7 @@ def saml_authenticate(
           This API endpoint essentially exchanges SAML responses that indicate successful authentication in the IdP for Elasticsearch access and refresh tokens, which can be used for authentication against Elasticsearch.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-saml-authenticate>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-saml-authenticate>`_
 
         :param content: The SAML response as it was sent by the user's browser, usually
             a Base64 encoded XML document.
@@ -3958,7 +3951,7 @@ def saml_complete_logout(
           The caller of this API must prepare the request accordingly so that this API can handle either of them.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-saml-complete-logout>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-saml-complete-logout>`_
 
         :param ids: A JSON array with all the valid SAML Request Ids that the caller
             of the API has for the current user.
@@ -4034,7 +4027,7 @@ def saml_invalidate(
           Thus the user can be redirected back to their IdP.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-saml-invalidate>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-saml-invalidate>`_
 
         :param query_string: The query part of the URL that the user was redirected to
             by the SAML IdP to initiate the Single Logout. This query should include
@@ -4109,7 +4102,7 @@ def saml_logout(
           If the SAML realm in Elasticsearch is configured accordingly and the SAML IdP supports this, the Elasticsearch response contains a URL to redirect the user to the IdP that contains a SAML logout request (starting an SP-initiated SAML Single Logout).</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-saml-logout>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-saml-logout>`_
 
         :param token: The access token that was returned as a response to calling the
             SAML authenticate API. Alternatively, the most recent token that was received
@@ -4179,7 +4172,7 @@ def saml_prepare_authentication(
           The caller of this API needs to store this identifier as it needs to be used in a following step of the authentication process.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-saml-prepare-authentication>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-saml-prepare-authentication>`_
 
         :param acs: The Assertion Consumer Service URL that matches the one of the SAML
             realms in Elasticsearch. The realm is used to generate the authentication
@@ -4240,7 +4233,7 @@ def saml_service_provider_metadata(
           This API generates Service Provider metadata based on the configuration of a SAML realm in Elasticsearch.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-saml-service-provider-metadata>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-saml-service-provider-metadata>`_
 
         :param realm_name: The name of the SAML realm in Elasticsearch.
         """
@@ -4293,7 +4286,7 @@ def suggest_user_profiles(
           Elastic reserves the right to change or remove this feature in future releases without prior notice.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-suggest-user-profiles>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-suggest-user-profiles>`_
 
         :param data: A comma-separated list of filters for the `data` field of the profile
             document. To return all content use `data=*`. To return a subset of content,
@@ -4380,7 +4373,7 @@ def update_api_key(
           This change can occur if the owner user's permissions have changed since the API key was created or last modified.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-update-api-key>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-update-api-key>`_
 
         :param id: The ID of the API key to update.
         :param expiration: The expiration time for the API key. By default, API keys
@@ -4466,9 +4459,10 @@ def update_cross_cluster_api_key(
           <p>This API supports updates to an API key's access scope, metadata, and expiration.
           The owner user's information, such as the <code>username</code> and <code>realm</code>, is also updated automatically on every call.</p>
           <p>NOTE: This API cannot update REST API keys, which should be updated by either the update API key or bulk update API keys API.</p>
+          <p>To learn more about how to use this API, refer to the <a href="https://www.elastic.co/docs/reference/elasticsearch/rest-apis/update-cc-api-key-examples">Update cross cluter API key API examples page</a>.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-update-cross-cluster-api-key>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-update-cross-cluster-api-key>`_
 
         :param id: The ID of the cross-cluster API key to update.
         :param access: The access to be granted to this API key. The access is composed
@@ -4547,7 +4541,7 @@ def update_settings(
           This API does not yet support configuring the settings for indices before they are in use.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-update-settings>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-update-settings>`_
 
         :param master_timeout: The period to wait for a connection to the master node.
             If no response is received before the timeout expires, the request fails
@@ -4632,7 +4626,7 @@ def update_user_profile_data(
           The <code>update_profile_data</code> global privilege grants privileges for updating only the allowed namespaces.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-update-user-profile-data>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-security-update-user-profile-data>`_
 
         :param uid: A unique identifier for the user profile.
         :param data: Non-searchable data that you want to associate with the user profile.
diff --git a/elasticsearch/_sync/client/shutdown.py b/elasticsearch/_sync/client/shutdown.py
index d7ec41511..b1166feb0 100644
--- a/elasticsearch/_sync/client/shutdown.py
+++ b/elasticsearch/_sync/client/shutdown.py
@@ -53,7 +53,7 @@ def delete_node(
           <p>If the operator privileges feature is enabled, you must be an operator to use this API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-shutdown-delete-node>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-shutdown-delete-node>`_
 
         :param node_id: The node id of node to be removed from the shutdown state
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -112,7 +112,7 @@ def get_node(
           <p>If the operator privileges feature is enabled, you must be an operator to use this API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-shutdown-get-node>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-shutdown-get-node>`_
 
         :param node_id: Which node for which to retrieve the shutdown status
         :param master_timeout: Period to wait for a connection to the master node. If
@@ -187,7 +187,7 @@ def put_node(
           Monitor the node shutdown status to determine when it is safe to stop Elasticsearch.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-shutdown-put-node>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-shutdown-put-node>`_
 
         :param node_id: The node identifier. This parameter is not validated against
             the cluster's active nodes. This enables you to register a node for shut
diff --git a/elasticsearch/_sync/client/simulate.py b/elasticsearch/_sync/client/simulate.py
index ed5442d97..db0a85092 100644
--- a/elasticsearch/_sync/client/simulate.py
+++ b/elasticsearch/_sync/client/simulate.py
@@ -35,7 +35,7 @@ class SimulateClient(NamespacedClient):
         body_fields=(
             "docs",
             "component_template_substitutions",
-            "index_template_subtitutions",
+            "index_template_substitutions",
             "mapping_addition",
             "pipeline_substitutions",
         ),
@@ -52,7 +52,7 @@ def ingest(
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         human: t.Optional[bool] = None,
-        index_template_subtitutions: t.Optional[
+        index_template_substitutions: t.Optional[
             t.Mapping[str, t.Mapping[str, t.Any]]
         ] = None,
         mapping_addition: t.Optional[t.Mapping[str, t.Any]] = None,
@@ -81,7 +81,7 @@ def ingest(
           These will be used in place of the pipeline definitions that are already in the system. This can be used to replace existing pipeline definitions or to create new ones. The pipeline substitutions are used only within this request.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-simulate-ingest>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-simulate-ingest>`_
 
         :param docs: Sample documents to test in the pipeline.
         :param index: The index to simulate ingesting into. This value can be overridden
@@ -90,7 +90,7 @@ def ingest(
             an index argument.
         :param component_template_substitutions: A map of component template names to
             substitute component template definition objects.
-        :param index_template_subtitutions: A map of index template names to substitute
+        :param index_template_substitutions: A map of index template names to substitute
             index template definition objects.
         :param mapping_addition:
         :param pipeline: The pipeline to use as the default pipeline. This value can
@@ -127,8 +127,8 @@ def ingest(
                 __body["component_template_substitutions"] = (
                     component_template_substitutions
                 )
-            if index_template_subtitutions is not None:
-                __body["index_template_subtitutions"] = index_template_subtitutions
+            if index_template_substitutions is not None:
+                __body["index_template_substitutions"] = index_template_substitutions
             if mapping_addition is not None:
                 __body["mapping_addition"] = mapping_addition
             if pipeline_substitutions is not None:
diff --git a/elasticsearch/_sync/client/slm.py b/elasticsearch/_sync/client/slm.py
index 9b701de80..201840fd5 100644
--- a/elasticsearch/_sync/client/slm.py
+++ b/elasticsearch/_sync/client/slm.py
@@ -45,7 +45,7 @@ def delete_lifecycle(
           This operation prevents any future snapshots from being taken but does not cancel in-progress snapshots or remove previously-taken snapshots.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-slm-delete-lifecycle>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-slm-delete-lifecycle>`_
 
         :param policy_id: The id of the snapshot lifecycle policy to remove
         :param master_timeout: The period to wait for a connection to the master node.
@@ -101,7 +101,7 @@ def execute_lifecycle(
           The snapshot policy is normally applied according to its schedule, but you might want to manually run a policy before performing an upgrade or other maintenance.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-slm-execute-lifecycle>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-slm-execute-lifecycle>`_
 
         :param policy_id: The id of the snapshot lifecycle policy to be executed
         :param master_timeout: The period to wait for a connection to the master node.
@@ -156,7 +156,7 @@ def execute_retention(
           The retention policy is normally applied according to its schedule.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-slm-execute-retention>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-slm-execute-retention>`_
 
         :param master_timeout: The period to wait for a connection to the master node.
             If no response is received before the timeout expires, the request fails
@@ -208,7 +208,7 @@ def get_lifecycle(
           Get snapshot lifecycle policy definitions and information about the latest snapshot attempts.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-slm-get-lifecycle>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-slm-get-lifecycle>`_
 
         :param policy_id: Comma-separated list of snapshot lifecycle policies to retrieve
         :param master_timeout: The period to wait for a connection to the master node.
@@ -265,7 +265,7 @@ def get_stats(
           Get global and policy-level statistics about actions taken by snapshot lifecycle management.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-slm-get-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-slm-get-stats>`_
 
         :param master_timeout: Period to wait for a connection to the master node. If
             no response is received before the timeout expires, the request fails and
@@ -315,7 +315,7 @@ def get_status(
           <p>Get the snapshot lifecycle management status.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-slm-get-status>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-slm-get-status>`_
 
         :param master_timeout: The period to wait for a connection to the master node.
             If no response is received before the timeout expires, the request fails
@@ -379,7 +379,7 @@ def put_lifecycle(
           Only the latest version of a policy is stored.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-slm-put-lifecycle>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-slm-put-lifecycle>`_
 
         :param policy_id: The identifier for the snapshot lifecycle policy you want to
             create or update.
@@ -465,7 +465,7 @@ def start(
           Manually starting SLM is necessary only if it has been stopped using the stop SLM API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-slm-start>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-slm-start>`_
 
         :param master_timeout: The period to wait for a connection to the master node.
             If no response is received before the timeout expires, the request fails
@@ -523,7 +523,7 @@ def stop(
           Use the get snapshot lifecycle management status API to see if SLM is running.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-slm-stop>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-slm-stop>`_
 
         :param master_timeout: The period to wait for a connection to the master node.
             If no response is received before the timeout expires, the request fails
diff --git a/elasticsearch/_sync/client/snapshot.py b/elasticsearch/_sync/client/snapshot.py
index 26c841765..476b54272 100644
--- a/elasticsearch/_sync/client/snapshot.py
+++ b/elasticsearch/_sync/client/snapshot.py
@@ -50,7 +50,7 @@ def cleanup_repository(
           Trigger the review of the contents of a snapshot repository and delete any stale data not referenced by existing snapshots.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-snapshot-cleanup-repository>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-snapshot-cleanup-repository>`_
 
         :param name: The name of the snapshot repository to clean up.
         :param master_timeout: The period to wait for a connection to the master node.
@@ -105,7 +105,6 @@ def clone(
         human: t.Optional[bool] = None,
         master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
-        timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         body: t.Optional[t.Dict[str, t.Any]] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
@@ -115,7 +114,7 @@ def clone(
           Clone part of all of a snapshot into another snapshot in the same repository.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-snapshot-clone>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-snapshot-clone>`_
 
         :param repository: The name of the snapshot repository that both source and target
             snapshot belong to.
@@ -126,8 +125,6 @@ def clone(
         :param master_timeout: The period to wait for the master node. If the master
             node is not available before the timeout expires, the request fails and returns
             an error. To indicate that the request should never timeout, set it to `-1`.
-        :param timeout: The period of time to wait for a response. If no response is
-            received before the timeout expires, the request fails and returns an error.
         """
         if repository in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'repository'")
@@ -155,8 +152,6 @@ def clone(
             __query["master_timeout"] = master_timeout
         if pretty is not None:
             __query["pretty"] = pretty
-        if timeout is not None:
-            __query["timeout"] = timeout
         if not __body:
             if indices is not None:
                 __body["indices"] = indices
@@ -216,7 +211,7 @@ def create(
           Take a snapshot of a cluster or of data streams and indices.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-snapshot-create>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-snapshot-create>`_
 
         :param repository: The name of the repository for the snapshot.
         :param snapshot: The name of the snapshot. It supportes date math. It must be
@@ -343,7 +338,7 @@ def create_repository(
           If both parameters are specified, only the query parameter is used.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-snapshot-create-repository>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-snapshot-create-repository>`_
 
         :param name: The name of the snapshot repository to register or update.
         :param repository:
@@ -408,6 +403,7 @@ def delete(
         human: t.Optional[bool] = None,
         master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
+        wait_for_completion: t.Optional[bool] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
         .. raw:: html
@@ -415,7 +411,7 @@ def delete(
           <p>Delete snapshots.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-snapshot-delete>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-snapshot-delete>`_
 
         :param repository: The name of the repository to delete a snapshot from.
         :param snapshot: A comma-separated list of snapshot names to delete. It also
@@ -423,6 +419,9 @@ def delete(
         :param master_timeout: The period to wait for the master node. If the master
             node is not available before the timeout expires, the request fails and returns
             an error. To indicate that the request should never timeout, set it to `-1`.
+        :param wait_for_completion: If `true`, the request returns a response when the
+            matching snapshots are all deleted. If `false`, the request returns a response
+            as soon as the deletes are scheduled.
         """
         if repository in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'repository'")
@@ -444,6 +443,8 @@ def delete(
             __query["master_timeout"] = master_timeout
         if pretty is not None:
             __query["pretty"] = pretty
+        if wait_for_completion is not None:
+            __query["wait_for_completion"] = wait_for_completion
         __headers = {"accept": "application/json"}
         return self.perform_request(  # type: ignore[return-value]
             "DELETE",
@@ -474,7 +475,7 @@ def delete_repository(
           The snapshots themselves are left untouched and in place.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-snapshot-delete-repository>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-snapshot-delete-repository>`_
 
         :param name: The ame of the snapshot repositories to unregister. Wildcard (`*`)
             patterns are supported.
@@ -560,7 +561,7 @@ def get(
           Snapshots concurrently created may be seen during an iteration.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-snapshot-get>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-snapshot-get>`_
 
         :param repository: A comma-separated list of snapshot repository names used to
             limit the request. Wildcard (`*`) expressions are supported.
@@ -686,7 +687,7 @@ def get_repository(
           <p>Get snapshot repository information.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-snapshot-get-repository>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-snapshot-get-repository>`_
 
         :param name: A comma-separated list of snapshot repository names used to limit
             the request. Wildcard (`*`) expressions are supported including combining
@@ -830,7 +831,7 @@ def repository_analyze(
           Some operations also verify the behavior on small blobs with sizes other than 8 bytes.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-snapshot-repository-analyze>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-snapshot-repository-analyze>`_
 
         :param name: The name of the repository.
         :param blob_count: The total number of blobs to write to the repository during
@@ -963,7 +964,7 @@ def repository_verify_integrity(
           The response body format is therefore not considered stable and may be different in newer versions.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-snapshot-repository-verify-integrity>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-snapshot-repository-verify-integrity>`_
 
         :param name: The name of the snapshot repository.
         :param blob_thread_pool_concurrency: If `verify_blob_contents` is `true`, this
@@ -1085,7 +1086,7 @@ def restore(
           <p>If your snapshot contains data from App Search or Workplace Search, you must restore the Enterprise Search encryption key before you restore the snapshot.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-snapshot-restore>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-snapshot-restore>`_
 
         :param repository: The name of the repository to restore a snapshot from.
         :param snapshot: The name of the snapshot to restore.
@@ -1235,7 +1236,7 @@ def status(
           These requests can also tax machine resources and, when using cloud storage, incur high processing costs.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-snapshot-status>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-snapshot-status>`_
 
         :param repository: The snapshot repository name used to limit the request. It
             supports wildcards (`*`) if `<snapshot>` isn't specified.
@@ -1303,7 +1304,7 @@ def verify_repository(
           Check for common misconfigurations in a snapshot repository.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-snapshot-verify-repository>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-snapshot-verify-repository>`_
 
         :param name: The name of the snapshot repository to verify.
         :param master_timeout: The period to wait for the master node. If the master
diff --git a/elasticsearch/_sync/client/sql.py b/elasticsearch/_sync/client/sql.py
index 90cb01681..3b844b0cd 100644
--- a/elasticsearch/_sync/client/sql.py
+++ b/elasticsearch/_sync/client/sql.py
@@ -44,7 +44,7 @@ def clear_cursor(
           <p>Clear an SQL search cursor.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-sql-clear-cursor>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-sql-clear-cursor>`_
 
         :param cursor: Cursor to clear.
         """
@@ -99,7 +99,7 @@ def delete_async(
           </ul>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-sql-delete-async>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-sql-delete-async>`_
 
         :param id: The identifier for the search.
         """
@@ -150,7 +150,7 @@ def get_async(
           <p>If the Elasticsearch security features are enabled, only the user who first submitted the SQL search can retrieve the search using this API.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-sql-get-async>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-sql-get-async>`_
 
         :param id: The identifier for the search.
         :param delimiter: The separator for CSV results. The API supports this parameter
@@ -212,7 +212,7 @@ def get_async_status(
           Get the current status of an async SQL search or a stored synchronous SQL search.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-sql-get-async-status>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-sql-get-async-status>`_
 
         :param id: The identifier for the search.
         """
@@ -283,7 +283,7 @@ def query(
         keep_alive: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         keep_on_completion: t.Optional[bool] = None,
         page_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
-        params: t.Optional[t.Mapping[str, t.Any]] = None,
+        params: t.Optional[t.Sequence[t.Any]] = None,
         pretty: t.Optional[bool] = None,
         query: t.Optional[str] = None,
         request_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
@@ -301,7 +301,7 @@ def query(
           Run an SQL request.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-sql-query>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-sql-query>`_
 
         :param allow_partial_search_results: If `true`, the response has partial results
             when there are shard request timeouts or shard failures. If `false`, the
@@ -427,7 +427,7 @@ def translate(
           It accepts the same request body parameters as the SQL search API, excluding <code>cursor</code>.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-sql-translate>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-sql-translate>`_
 
         :param query: The SQL query to run.
         :param fetch_size: The maximum number of rows (or entries) to return in one response.
diff --git a/elasticsearch/_sync/client/ssl.py b/elasticsearch/_sync/client/ssl.py
index 6a07966d4..173d56536 100644
--- a/elasticsearch/_sync/client/ssl.py
+++ b/elasticsearch/_sync/client/ssl.py
@@ -52,7 +52,7 @@ def certificates(
           <p>If Elasticsearch is configured to use a keystore or truststore, the API output includes all certificates in that store, even though some of the certificates might not be in active use within the cluster.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ssl-certificates>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-ssl-certificates>`_
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_ssl/certificates"
diff --git a/elasticsearch/_sync/client/synonyms.py b/elasticsearch/_sync/client/synonyms.py
index 1c9613196..9faefba56 100644
--- a/elasticsearch/_sync/client/synonyms.py
+++ b/elasticsearch/_sync/client/synonyms.py
@@ -53,7 +53,7 @@ def delete_synonym(
           When the synonyms set is not used in analyzers, you will be able to delete it.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-synonyms-delete-synonym>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-synonyms-delete-synonym>`_
 
         :param id: The synonyms set identifier to delete.
         """
@@ -98,7 +98,7 @@ def delete_synonym_rule(
           Delete a synonym rule from a synonym set.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-synonyms-delete-synonym-rule>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-synonyms-delete-synonym-rule>`_
 
         :param set_id: The ID of the synonym set to update.
         :param rule_id: The ID of the synonym rule to delete.
@@ -151,7 +151,7 @@ def get_synonym(
           <p>Get a synonym set.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-synonyms-get-synonym>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-synonyms-get-synonym>`_
 
         :param id: The synonyms set identifier to retrieve.
         :param from_: The starting offset for query rules to retrieve.
@@ -202,7 +202,7 @@ def get_synonym_rule(
           Get a synonym rule from a synonym set.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-synonyms-get-synonym-rule>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-synonyms-get-synonym-rule>`_
 
         :param set_id: The ID of the synonym set to retrieve the synonym rule from.
         :param rule_id: The ID of the synonym rule to retrieve.
@@ -255,7 +255,7 @@ def get_synonyms_sets(
           Get a summary of all defined synonym sets.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-synonyms-get-synonym>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-synonyms-get-synonym>`_
 
         :param from_: The starting offset for synonyms sets to retrieve.
         :param size: The maximum number of synonyms sets to retrieve.
@@ -309,9 +309,10 @@ def put_synonym(
           If you need to manage more synonym rules, you can create multiple synonym sets.</p>
           <p>When an existing synonyms set is updated, the search analyzers that use the synonyms set are reloaded automatically for all indices.
           This is equivalent to invoking the reload search analyzers API for all indices that use the synonyms set.</p>
+          <p>For practical examples of how to create or update a synonyms set, refer to the External documentation.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-synonyms-put-synonym>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-synonyms-put-synonym>`_
 
         :param id: The ID of the synonyms set to be created or updated.
         :param synonyms_set: The synonym rules definitions for the synonyms set.
@@ -370,7 +371,7 @@ def put_synonym_rule(
           <p>When you update a synonym rule, all analyzers using the synonyms set will be reloaded automatically to reflect the new rule.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-synonyms-put-synonym-rule>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-synonyms-put-synonym-rule>`_
 
         :param set_id: The ID of the synonym set.
         :param rule_id: The ID of the synonym rule to be updated or created.
diff --git a/elasticsearch/_sync/client/tasks.py b/elasticsearch/_sync/client/tasks.py
index e341b371c..d542e593b 100644
--- a/elasticsearch/_sync/client/tasks.py
+++ b/elasticsearch/_sync/client/tasks.py
@@ -60,7 +60,7 @@ def cancel(
           You can also use the node hot threads API to obtain detailed information about the work the system is doing instead of completing the cancelled task.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/group/endpoint-tasks>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/group/endpoint-tasks>`_
 
         :param task_id: The task identifier.
         :param actions: A comma-separated list or wildcard expression of actions that
@@ -128,7 +128,7 @@ def get(
           <p>If the task identifier is not found, a 404 response code indicates that there are no resources that match the request.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/group/endpoint-tasks>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/group/endpoint-tasks>`_
 
         :param task_id: The task identifier.
         :param timeout: The period to wait for a response. If no response is received
@@ -238,7 +238,7 @@ def list(
           The <code>X-Opaque-Id</code> in the children <code>headers</code> is the child task of the task that was initiated by the REST request.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/group/endpoint-tasks>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/group/endpoint-tasks>`_
 
         :param actions: A comma-separated list or wildcard expression of actions used
             to limit the request. For example, you can use `cluser:*` to retrieve all
diff --git a/elasticsearch/_sync/client/text_structure.py b/elasticsearch/_sync/client/text_structure.py
index fa3218f81..03884b9d3 100644
--- a/elasticsearch/_sync/client/text_structure.py
+++ b/elasticsearch/_sync/client/text_structure.py
@@ -72,7 +72,7 @@ def find_field_structure(
           It helps determine why the returned structure was chosen.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/group/endpoint-text_structure>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/group/endpoint-text_structure>`_
 
         :param field: The field that should be analyzed.
         :param index: The name of the index that contains the analyzed field.
@@ -259,7 +259,7 @@ def find_message_structure(
           It helps determine why the returned structure was chosen.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-text-structure-find-message-structure>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-text-structure-find-message-structure>`_
 
         :param messages: The list of messages you want to analyze.
         :param column_names: If the format is `delimited`, you can specify the column
@@ -433,7 +433,7 @@ def find_structure(
           However, you can optionally override some of the decisions about the text structure by specifying one or more query parameters.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-text-structure-find-structure>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-text-structure-find-structure>`_
 
         :param text_files:
         :param charset: The text's character set. It must be a character set that is
@@ -620,7 +620,7 @@ def test_grok_pattern(
           The API indicates whether the lines match the pattern together with the offsets and lengths of the matched substrings.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-text-structure-test-grok-pattern>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-text-structure-test-grok-pattern>`_
 
         :param grok_pattern: The Grok pattern to run on the text.
         :param text: The lines of text to run the Grok pattern on.
diff --git a/elasticsearch/_sync/client/transform.py b/elasticsearch/_sync/client/transform.py
index ea9941f74..1c02df1fc 100644
--- a/elasticsearch/_sync/client/transform.py
+++ b/elasticsearch/_sync/client/transform.py
@@ -44,7 +44,7 @@ def delete_transform(
           <p>Delete a transform.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-transform-delete-transform>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-transform-delete-transform>`_
 
         :param transform_id: Identifier for the transform.
         :param delete_dest_index: If this value is true, the destination index is deleted
@@ -108,7 +108,7 @@ def get_transform(
           Get configuration information for transforms.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-transform-get-transform>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-transform-get-transform>`_
 
         :param transform_id: Identifier for the transform. It can be a transform identifier
             or a wildcard expression. You can get information for all transforms by using
@@ -181,7 +181,7 @@ def get_transform_stats(
           <p>Get usage information for transforms.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-transform-get-transform-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-transform-get-transform-stats>`_
 
         :param transform_id: Identifier for the transform. It can be a transform identifier
             or a wildcard expression. You can get information for all transforms by using
@@ -269,7 +269,7 @@ def preview_transform(
           types of the source index and the transform aggregations.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-transform-preview-transform>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-transform-preview-transform>`_
 
         :param transform_id: Identifier for the transform to preview. If you specify
             this path parameter, you cannot provide transform configuration details in
@@ -406,7 +406,7 @@ def put_transform(
           give users any privileges on <code>.data-frame-internal*</code> indices.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-transform-put-transform>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-transform-put-transform>`_
 
         :param transform_id: Identifier for the transform. This identifier can contain
             lowercase alphanumeric characters (a-z and 0-9), hyphens, and underscores.
@@ -512,7 +512,7 @@ def reset_transform(
           If the destination index was created by the transform, it is deleted.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-transform-reset-transform>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-transform-reset-transform>`_
 
         :param transform_id: Identifier for the transform. This identifier can contain
             lowercase alphanumeric characters (a-z and 0-9), hyphens, and underscores.
@@ -572,7 +572,7 @@ def schedule_now_transform(
           is called again in the meantime.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-transform-schedule-now-transform>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-transform-schedule-now-transform>`_
 
         :param transform_id: Identifier for the transform.
         :param timeout: Controls the time to wait for the scheduling to take place
@@ -602,6 +602,66 @@ def schedule_now_transform(
             path_parts=__path_parts,
         )
 
+    @_rewrite_parameters()
+    def set_upgrade_mode(
+        self,
+        *,
+        enabled: t.Optional[bool] = None,
+        error_trace: t.Optional[bool] = None,
+        filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        human: t.Optional[bool] = None,
+        pretty: t.Optional[bool] = None,
+        timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
+    ) -> ObjectApiResponse[t.Any]:
+        """
+        .. raw:: html
+
+          <p>Set upgrade_mode for transform indices.
+          Sets a cluster wide upgrade_mode setting that prepares transform
+          indices for an upgrade.
+          When upgrading your cluster, in some circumstances you must restart your
+          nodes and reindex your transform indices. In those circumstances,
+          there must be no transforms running. You can close the transforms,
+          do the upgrade, then open all the transforms again. Alternatively,
+          you can use this API to temporarily halt tasks associated with the transforms
+          and prevent new transforms from opening. You can also use this API
+          during upgrades that do not require you to reindex your transform
+          indices, though stopping transforms is not a requirement in that case.
+          You can see the current value for the upgrade_mode setting by using the get
+          transform info API.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-transform-set-upgrade-mode>`_
+
+        :param enabled: When `true`, it enables `upgrade_mode` which temporarily halts
+            all transform tasks and prohibits new transform tasks from starting.
+        :param timeout: The time to wait for the request to be completed.
+        """
+        __path_parts: t.Dict[str, str] = {}
+        __path = "/_transform/set_upgrade_mode"
+        __query: t.Dict[str, t.Any] = {}
+        if enabled is not None:
+            __query["enabled"] = enabled
+        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
+        __headers = {"accept": "application/json"}
+        return self.perform_request(  # type: ignore[return-value]
+            "POST",
+            __path,
+            params=__query,
+            headers=__headers,
+            endpoint_id="transform.set_upgrade_mode",
+            path_parts=__path_parts,
+        )
+
     @_rewrite_parameters(
         parameter_aliases={"from": "from_"},
     )
@@ -635,7 +695,7 @@ def start_transform(
           destination indices, the transform fails when it attempts unauthorized operations.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-transform-start-transform>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-transform-start-transform>`_
 
         :param transform_id: Identifier for the transform.
         :param from_: Restricts the set of transformed entities to those changed after
@@ -693,7 +753,7 @@ def stop_transform(
           Stops one or more transforms.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-transform-stop-transform>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-transform-stop-transform>`_
 
         :param transform_id: Identifier for the transform. To stop multiple transforms,
             use a comma-separated list or a wildcard expression. To stop all transforms,
@@ -795,7 +855,7 @@ def update_transform(
           time of update and runs with those privileges.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-transform-update-transform>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-transform-update-transform>`_
 
         :param transform_id: Identifier for the transform.
         :param defer_validation: When true, deferrable validations are not run. This
@@ -890,7 +950,7 @@ def upgrade_transforms(
           You may want to perform a recent cluster backup prior to the upgrade.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-transform-upgrade-transforms>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-transform-upgrade-transforms>`_
 
         :param dry_run: When true, the request checks for updates but does not run them.
         :param timeout: Period to wait for a response. If no response is received before
diff --git a/elasticsearch/_sync/client/utils.py b/elasticsearch/_sync/client/utils.py
index 45f33fc6e..48ebcb217 100644
--- a/elasticsearch/_sync/client/utils.py
+++ b/elasticsearch/_sync/client/utils.py
@@ -134,7 +134,6 @@ def client_node_configs(
 
     def apply_node_options(node_config: NodeConfig) -> NodeConfig:
         """Needs special handling of headers since .replace() wipes out existing headers"""
-        nonlocal node_options
         headers = node_config.headers.copy()  # type: ignore[attr-defined]
 
         headers_to_add = node_options.pop("headers", ())
@@ -306,8 +305,6 @@ def _rewrite_parameters(
     def wrapper(api: F) -> F:
         @wraps(api)
         def wrapped(*args: Any, **kwargs: Any) -> Any:
-            nonlocal api, body_name, body_fields
-
             # Let's give a nicer error message when users pass positional arguments.
             if len(args) >= 2:
                 raise TypeError(
diff --git a/elasticsearch/_sync/client/watcher.py b/elasticsearch/_sync/client/watcher.py
index a266f54c4..130537743 100644
--- a/elasticsearch/_sync/client/watcher.py
+++ b/elasticsearch/_sync/client/watcher.py
@@ -45,10 +45,11 @@ def ack_watch(
           <p>IMPORTANT: If the specified watch is currently being executed, this API will return an error
           The reason for this behavior is to prevent overwriting the watch status from a watch execution.</p>
           <p>Acknowledging an action throttles further executions of that action until its <code>ack.state</code> is reset to <code>awaits_successful_execution</code>.
-          This happens when the condition of the watch is not met (the condition evaluates to false).</p>
+          This happens when the condition of the watch is not met (the condition evaluates to false).
+          To demonstrate how throttling works in practice and how it can be configured for individual actions within a watch, refer to External documentation.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-ack-watch>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-watcher-ack-watch>`_
 
         :param watch_id: The watch identifier.
         :param action_id: A comma-separated list of the action identifiers to acknowledge.
@@ -104,7 +105,7 @@ def activate_watch(
           A watch can be either active or inactive.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-activate-watch>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-watcher-activate-watch>`_
 
         :param watch_id: The watch identifier.
         """
@@ -148,7 +149,7 @@ def deactivate_watch(
           A watch can be either active or inactive.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-deactivate-watch>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-watcher-deactivate-watch>`_
 
         :param watch_id: The watch identifier.
         """
@@ -196,7 +197,7 @@ def delete_watch(
           When Elasticsearch security features are enabled, make sure no write privileges are granted to anyone for the <code>.watches</code> index.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-delete-watch>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-watcher-delete-watch>`_
 
         :param id: The watch identifier.
         """
@@ -274,10 +275,11 @@ def execute_watch(
           This serves as great tool for testing and debugging your watches prior to adding them to Watcher.</p>
           <p>When Elasticsearch security features are enabled on your cluster, watches are run with the privileges of the user that stored the watches.
           If your user is allowed to read index <code>a</code>, but not index <code>b</code>, then the exact same set of rules will apply during execution of a watch.</p>
-          <p>When using the run watch API, the authorization data of the user that called the API will be used as a base, instead of the information who stored the watch.</p>
+          <p>When using the run watch API, the authorization data of the user that called the API will be used as a base, instead of the information who stored the watch.
+          Refer to the external documentation for examples of watch execution requests, including existing, customized, and inline watches.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-execute-watch>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-watcher-execute-watch>`_
 
         :param id: The watch identifier.
         :param action_modes: Determines how to handle the watch actions as part of the
@@ -365,7 +367,7 @@ def get_settings(
           Only a subset of settings are shown, for example <code>index.auto_expand_replicas</code> and <code>index.number_of_replicas</code>.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-get-settings>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-watcher-get-settings>`_
 
         :param master_timeout: The period to wait for a connection to the master node.
             If no response is received before the timeout expires, the request fails
@@ -410,7 +412,7 @@ def get_watch(
           <p>Get a watch.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-get-watch>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-watcher-get-watch>`_
 
         :param id: The watch identifier.
         """
@@ -485,7 +487,7 @@ def put_watch(
           If the user is able to read index <code>a</code>, but not index <code>b</code>, the same will apply when the watch runs.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-put-watch>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-watcher-put-watch>`_
 
         :param id: The identifier for the watch.
         :param actions: The list of actions that will be run if the condition matches.
@@ -598,7 +600,7 @@ def query_watches(
           <p>Note that only the <code>_id</code> and <code>metadata.*</code> fields are queryable or sortable.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-query-watches>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-watcher-query-watches>`_
 
         :param from_: The offset from the first result to fetch. It must be non-negative.
         :param query: A query that filters the watches to be returned.
@@ -673,7 +675,7 @@ def start(
           Start the Watcher service if it is not already running.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-start>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-watcher-start>`_
 
         :param master_timeout: Period to wait for a connection to the master node.
         """
@@ -739,7 +741,7 @@ def stats(
           You retrieve more metrics by using the metric parameter.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-stats>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-watcher-stats>`_
 
         :param metric: Defines which additional metrics are included in the response.
         :param emit_stacktraces: Defines whether stack traces are generated for each
@@ -790,7 +792,7 @@ def stop(
           Stop the Watcher service if it is running.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-stop>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-watcher-stop>`_
 
         :param master_timeout: The period to wait for the master node. If the master
             node is not available before the timeout expires, the request fails and returns
@@ -845,10 +847,13 @@ def update_settings(
           <p>Update Watcher index settings.
           Update settings for the Watcher internal index (<code>.watches</code>).
           Only a subset of settings can be modified.
-          This includes <code>index.auto_expand_replicas</code> and <code>index.number_of_replicas</code>.</p>
+          This includes <code>index.auto_expand_replicas</code>, <code>index.number_of_replicas</code>, <code>index.routing.allocation.exclude.*</code>,
+          <code>index.routing.allocation.include.*</code> and <code>index.routing.allocation.require.*</code>.
+          Modification of <code>index.routing.allocation.include._tier_preference</code> is an exception and is not allowed as the
+          Watcher shards must always be in the <code>data_content</code> tier.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-update-settings>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-watcher-update-settings>`_
 
         :param index_auto_expand_replicas:
         :param index_number_of_replicas:
diff --git a/elasticsearch/_sync/client/xpack.py b/elasticsearch/_sync/client/xpack.py
index b44cd0909..a201f4570 100644
--- a/elasticsearch/_sync/client/xpack.py
+++ b/elasticsearch/_sync/client/xpack.py
@@ -54,7 +54,7 @@ def info(
           </ul>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-info>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-info>`_
 
         :param accept_enterprise: If this param is used it must be set to true
         :param categories: A comma-separated list of the information categories to include
@@ -103,7 +103,7 @@ def usage(
           The API also provides some usage statistics.</p>
 
 
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/group/endpoint-xpack>`_
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/group/endpoint-xpack>`_
 
         :param master_timeout: The period to wait for a connection to the master node.
             If no response is received before the timeout expires, the request fails
diff --git a/elasticsearch/_version.py b/elasticsearch/_version.py
index 00e2789aa..54dc641c4 100644
--- a/elasticsearch/_version.py
+++ b/elasticsearch/_version.py
@@ -15,4 +15,4 @@
 #  specific language governing permissions and limitations
 #  under the License.
 
-__versionstr__ = "8.17.2"
+__versionstr__ = "9.0.4"
diff --git a/elasticsearch/compat.py b/elasticsearch/compat.py
index 7639fd2bd..007971306 100644
--- a/elasticsearch/compat.py
+++ b/elasticsearch/compat.py
@@ -16,12 +16,15 @@
 #  under the License.
 
 import inspect
+import os
 import sys
 from pathlib import Path
 from typing import Tuple, Type, Union
 
 string_types: Tuple[Type[str], Type[bytes]] = (str, bytes)
 
+DISABLE_WARN_STACKLEVEL_ENV_VAR = "DISABLE_WARN_STACKLEVEL"
+
 
 def to_str(x: Union[str, bytes], encoding: str = "ascii") -> str:
     if not isinstance(x, str):
@@ -37,6 +40,8 @@ def to_bytes(x: Union[str, bytes], encoding: str = "ascii") -> bytes:
 
 def warn_stacklevel() -> int:
     """Dynamically determine warning stacklevel for warnings based on the call stack"""
+    if os.environ.get(DISABLE_WARN_STACKLEVEL_ENV_VAR) in ["1", "true", "True"]:
+        return 0
     try:
         # Grab the root module from the current module '__name__'
         module_name = __name__.partition(".")[0]
diff --git a/elasticsearch/dsl/__init__.py b/elasticsearch/dsl/__init__.py
index 860e2b761..59294d632 100644
--- a/elasticsearch/dsl/__init__.py
+++ b/elasticsearch/dsl/__init__.py
@@ -19,7 +19,7 @@
 from .aggs import A, Agg
 from .analysis import analyzer, char_filter, normalizer, token_filter, tokenizer
 from .document import AsyncDocument, Document
-from .document_base import InnerDoc, M, MetaField, mapped_field
+from .document_base import E, InnerDoc, M, MetaField, mapped_field
 from .exceptions import (
     ElasticsearchDslException,
     IllegalOperation,
@@ -38,23 +38,30 @@
     TermsFacet,
 )
 from .field import (
+    AggregateMetricDouble,
+    Alias,
     Binary,
     Boolean,
     Byte,
     Completion,
     ConstantKeyword,
+    CountedKeyword,
     CustomField,
     Date,
+    DateNanos,
     DateRange,
     DenseVector,
     Double,
     DoubleRange,
     Field,
+    Flattened,
     Float,
     FloatRange,
     GeoPoint,
     GeoShape,
     HalfFloat,
+    Histogram,
+    IcuCollationKeyword,
     Integer,
     IntegerRange,
     Ip,
@@ -63,21 +70,28 @@
     Keyword,
     Long,
     LongRange,
+    MatchOnlyText,
     Murmur3,
     Nested,
     Object,
+    Passthrough,
     Percolator,
     Point,
     RangeField,
     RankFeature,
     RankFeatures,
+    RankVectors,
     ScaledFloat,
     SearchAsYouType,
+    SemanticText,
     Shape,
     Short,
     SparseVector,
     Text,
     TokenCount,
+    UnsignedLong,
+    Version,
+    Wildcard,
     construct_field,
 )
 from .function import SF
@@ -108,6 +122,8 @@
     "A",
     "Agg",
     "AggResponse",
+    "AggregateMetricDouble",
+    "Alias",
     "AsyncComposableIndexTemplate",
     "AsyncDocument",
     "AsyncEmptySearch",
@@ -126,27 +142,33 @@
     "Completion",
     "ComposableIndexTemplate",
     "ConstantKeyword",
+    "CountedKeyword",
     "CustomField",
     "Date",
     "DateHistogramFacet",
+    "DateNanos",
     "DateRange",
     "DenseVector",
     "Document",
     "Double",
     "DoubleRange",
     "DslBase",
+    "E",
     "ElasticsearchDslException",
     "EmptySearch",
     "Facet",
     "FacetedResponse",
     "FacetedSearch",
     "Field",
+    "Flattened",
     "Float",
     "FloatRange",
     "GeoPoint",
     "GeoShape",
     "HalfFloat",
+    "Histogram",
     "HistogramFacet",
+    "IcuCollationKeyword",
     "IllegalOperation",
     "Index",
     "IndexTemplate",
@@ -161,12 +183,14 @@
     "LongRange",
     "M",
     "Mapping",
+    "MatchOnlyText",
     "MetaField",
     "MultiSearch",
     "Murmur3",
     "Nested",
     "NestedFacet",
     "Object",
+    "Passthrough",
     "Percolator",
     "Point",
     "Q",
@@ -176,11 +200,13 @@
     "RangeField",
     "RankFeature",
     "RankFeatures",
+    "RankVectors",
     "Response",
     "SF",
     "ScaledFloat",
     "Search",
     "SearchAsYouType",
+    "SemanticText",
     "Shape",
     "Short",
     "SparseVector",
@@ -188,9 +214,12 @@
     "Text",
     "TokenCount",
     "UnknownDslObject",
+    "UnsignedLong",
     "UpdateByQuery",
     "UpdateByQueryResponse",
     "ValidationException",
+    "Version",
+    "Wildcard",
     "analyzer",
     "async_connections",
     "char_filter",
diff --git a/elasticsearch/dsl/_async/document.py b/elasticsearch/dsl/_async/document.py
index 4b7654761..53b4f12c3 100644
--- a/elasticsearch/dsl/_async/document.py
+++ b/elasticsearch/dsl/_async/document.py
@@ -20,6 +20,7 @@
     TYPE_CHECKING,
     Any,
     AsyncIterable,
+    AsyncIterator,
     Dict,
     List,
     Optional,
@@ -42,6 +43,7 @@
 
 if TYPE_CHECKING:
     from elasticsearch import AsyncElasticsearch
+    from elasticsearch.esql.esql import ESQLBase
 
 
 class AsyncIndexMeta(DocumentMeta):
@@ -96,7 +98,7 @@ class AsyncDocument(DocumentBase, metaclass=AsyncIndexMeta):
 
     @classmethod
     def _get_using(cls, using: Optional[AsyncUsingType] = None) -> AsyncUsingType:
-        return cast(AsyncUsingType, using or cls._index._using)
+        return using or cls._index._using
 
     @classmethod
     def _get_connection(
@@ -520,3 +522,85 @@ async def __anext__(self) -> Dict[str, Any]:
                 return action
 
         return await async_bulk(es, Generate(actions), **kwargs)
+
+    @classmethod
+    async def esql_execute(
+        cls,
+        query: "ESQLBase",
+        return_additional: bool = False,
+        ignore_missing_fields: bool = False,
+        using: Optional[AsyncUsingType] = None,
+        **kwargs: Any,
+    ) -> AsyncIterator[Union[Self, Tuple[Self, Dict[str, Any]]]]:
+        """
+        Execute the given ES|QL query and return an iterator of 2-element tuples,
+        where the first element is an instance of this ``Document`` and the
+        second a dictionary with any remaining columns requested in the query.
+
+        :arg query: an ES|QL query object created with the ``esql_from()`` method.
+        :arg return_additional: if ``False`` (the default), this method returns
+            document objects. If set to ``True``, the method returns tuples with
+            a document in the first element and a dictionary with any additional
+            columns returned by the query in the second element.
+        :arg ignore_missing_fields: if ``False`` (the default), all the fields of
+            the document must be present in the query, or else an exception is
+            raised. Set to ``True`` to allow missing fields, which will result in
+            partially initialized document objects.
+        :arg using: connection alias to use, defaults to ``'default'``
+        :arg kwargs: additional options for the ``client.esql.query()`` function.
+        """
+        es = cls._get_connection(using)
+        response = await es.esql.query(query=str(query), **kwargs)
+        query_columns = [col["name"] for col in response.body.get("columns", [])]
+
+        # Here we get the list of columns defined in the document, which are the
+        # columns that we will take from each result to assemble the document
+        # object.
+        # When `for_esql=False` is passed below by default, the list will include
+        # nested fields, which ES|QL does not return, causing an error. When passing
+        # `ignore_missing_fields=True` the list will be generated with
+        # `for_esql=True`, so the error will not occur, but the documents will
+        # not have any Nested objects in them.
+        doc_fields = set(cls._get_field_names(for_esql=ignore_missing_fields))
+        if not ignore_missing_fields and not doc_fields.issubset(set(query_columns)):
+            raise ValueError(
+                f"Not all fields of {cls.__name__} were returned by the query. "
+                "Make sure your document does not use Nested fields, which are "
+                "currently not supported in ES|QL. To force the query to be "
+                "evaluated in spite of the missing fields, pass set the "
+                "ignore_missing_fields=True option in the esql_execute() call."
+            )
+        non_doc_fields: set[str] = set(query_columns) - doc_fields - {"_id"}
+        index_id = query_columns.index("_id")
+
+        results = response.body.get("values", [])
+        for column_values in results:
+            # create a dictionary with all the document fields, expanding the
+            # dot notation returned by ES|QL into the recursive dictionaries
+            # used by Document.from_dict()
+            doc_dict: Dict[str, Any] = {}
+            for col, val in zip(query_columns, column_values):
+                if col in doc_fields:
+                    cols = col.split(".")
+                    d = doc_dict
+                    for c in cols[:-1]:
+                        if c not in d:
+                            d[c] = {}
+                        d = d[c]
+                    d[cols[-1]] = val
+
+            # create the document instance
+            obj = cls(meta={"_id": column_values[index_id]})
+            obj._from_dict(doc_dict)
+
+            if return_additional:
+                # build a dict with any other values included in the response
+                other = {
+                    col: val
+                    for col, val in zip(query_columns, column_values)
+                    if col in non_doc_fields
+                }
+
+                yield obj, other
+            else:
+                yield obj
diff --git a/elasticsearch/dsl/_async/search.py b/elasticsearch/dsl/_async/search.py
index 42eb142fd..2ea277a07 100644
--- a/elasticsearch/dsl/_async/search.py
+++ b/elasticsearch/dsl/_async/search.py
@@ -107,9 +107,9 @@ async def scan(self) -> AsyncIterator[_R]:
         Turn the search into a scan search and return a generator that will
         iterate over all the documents matching the query.
 
-        Use ``params`` method to specify any additional arguments you with to
+        Use the ``params`` method to specify any additional arguments you wish to
         pass to the underlying ``scan`` helper from ``elasticsearch-py`` -
-        https://elasticsearch-py.readthedocs.io/en/master/helpers.html#elasticsearch.helpers.scan
+        https://elasticsearch-py.readthedocs.io/en/latest/helpers.html#scan
 
         The ``iterate()`` method should be preferred, as it provides similar
         functionality using an Elasticsearch point in time.
@@ -123,7 +123,11 @@ async def scan(self) -> AsyncIterator[_R]:
 
     async def delete(self) -> AttrDict[Any]:
         """
-        delete() executes the query by delegating to delete_by_query()
+        ``delete()`` executes the query by delegating to ``delete_by_query()``.
+
+        Use the ``params`` method to specify any additional arguments you wish to
+        pass to the underlying ``delete_by_query`` helper from ``elasticsearch-py`` -
+        https://elasticsearch-py.readthedocs.io/en/latest/api/elasticsearch.html#elasticsearch.Elasticsearch.delete_by_query
         """
 
         es = get_connection(self._using)
diff --git a/elasticsearch/dsl/_sync/document.py b/elasticsearch/dsl/_sync/document.py
index 316ece5cb..07bda6ec1 100644
--- a/elasticsearch/dsl/_sync/document.py
+++ b/elasticsearch/dsl/_sync/document.py
@@ -21,6 +21,7 @@
     Any,
     Dict,
     Iterable,
+    Iterator,
     List,
     Optional,
     Tuple,
@@ -42,6 +43,7 @@
 
 if TYPE_CHECKING:
     from elasticsearch import Elasticsearch
+    from elasticsearch.esql.esql import ESQLBase
 
 
 class IndexMeta(DocumentMeta):
@@ -92,7 +94,7 @@ class Document(DocumentBase, metaclass=IndexMeta):
 
     @classmethod
     def _get_using(cls, using: Optional[UsingType] = None) -> UsingType:
-        return cast(UsingType, using or cls._index._using)
+        return using or cls._index._using
 
     @classmethod
     def _get_connection(cls, using: Optional[UsingType] = None) -> "Elasticsearch":
@@ -512,3 +514,85 @@ def __next__(self) -> Dict[str, Any]:
                 return action
 
         return bulk(es, Generate(actions), **kwargs)
+
+    @classmethod
+    def esql_execute(
+        cls,
+        query: "ESQLBase",
+        return_additional: bool = False,
+        ignore_missing_fields: bool = False,
+        using: Optional[UsingType] = None,
+        **kwargs: Any,
+    ) -> Iterator[Union[Self, Tuple[Self, Dict[str, Any]]]]:
+        """
+        Execute the given ES|QL query and return an iterator of 2-element tuples,
+        where the first element is an instance of this ``Document`` and the
+        second a dictionary with any remaining columns requested in the query.
+
+        :arg query: an ES|QL query object created with the ``esql_from()`` method.
+        :arg return_additional: if ``False`` (the default), this method returns
+            document objects. If set to ``True``, the method returns tuples with
+            a document in the first element and a dictionary with any additional
+            columns returned by the query in the second element.
+        :arg ignore_missing_fields: if ``False`` (the default), all the fields of
+            the document must be present in the query, or else an exception is
+            raised. Set to ``True`` to allow missing fields, which will result in
+            partially initialized document objects.
+        :arg using: connection alias to use, defaults to ``'default'``
+        :arg kwargs: additional options for the ``client.esql.query()`` function.
+        """
+        es = cls._get_connection(using)
+        response = es.esql.query(query=str(query), **kwargs)
+        query_columns = [col["name"] for col in response.body.get("columns", [])]
+
+        # Here we get the list of columns defined in the document, which are the
+        # columns that we will take from each result to assemble the document
+        # object.
+        # When `for_esql=False` is passed below by default, the list will include
+        # nested fields, which ES|QL does not return, causing an error. When passing
+        # `ignore_missing_fields=True` the list will be generated with
+        # `for_esql=True`, so the error will not occur, but the documents will
+        # not have any Nested objects in them.
+        doc_fields = set(cls._get_field_names(for_esql=ignore_missing_fields))
+        if not ignore_missing_fields and not doc_fields.issubset(set(query_columns)):
+            raise ValueError(
+                f"Not all fields of {cls.__name__} were returned by the query. "
+                "Make sure your document does not use Nested fields, which are "
+                "currently not supported in ES|QL. To force the query to be "
+                "evaluated in spite of the missing fields, pass set the "
+                "ignore_missing_fields=True option in the esql_execute() call."
+            )
+        non_doc_fields: set[str] = set(query_columns) - doc_fields - {"_id"}
+        index_id = query_columns.index("_id")
+
+        results = response.body.get("values", [])
+        for column_values in results:
+            # create a dictionary with all the document fields, expanding the
+            # dot notation returned by ES|QL into the recursive dictionaries
+            # used by Document.from_dict()
+            doc_dict: Dict[str, Any] = {}
+            for col, val in zip(query_columns, column_values):
+                if col in doc_fields:
+                    cols = col.split(".")
+                    d = doc_dict
+                    for c in cols[:-1]:
+                        if c not in d:
+                            d[c] = {}
+                        d = d[c]
+                    d[cols[-1]] = val
+
+            # create the document instance
+            obj = cls(meta={"_id": column_values[index_id]})
+            obj._from_dict(doc_dict)
+
+            if return_additional:
+                # build a dict with any other values included in the response
+                other = {
+                    col: val
+                    for col, val in zip(query_columns, column_values)
+                    if col in non_doc_fields
+                }
+
+                yield obj, other
+            else:
+                yield obj
diff --git a/elasticsearch/dsl/_sync/search.py b/elasticsearch/dsl/_sync/search.py
index ae826a12f..4dfbdb92b 100644
--- a/elasticsearch/dsl/_sync/search.py
+++ b/elasticsearch/dsl/_sync/search.py
@@ -104,9 +104,9 @@ def scan(self) -> Iterator[_R]:
         Turn the search into a scan search and return a generator that will
         iterate over all the documents matching the query.
 
-        Use ``params`` method to specify any additional arguments you with to
+        Use the ``params`` method to specify any additional arguments you wish to
         pass to the underlying ``scan`` helper from ``elasticsearch-py`` -
-        https://elasticsearch-py.readthedocs.io/en/master/helpers.html#elasticsearch.helpers.scan
+        https://elasticsearch-py.readthedocs.io/en/latest/helpers.html#scan
 
         The ``iterate()`` method should be preferred, as it provides similar
         functionality using an Elasticsearch point in time.
@@ -118,7 +118,11 @@ def scan(self) -> Iterator[_R]:
 
     def delete(self) -> AttrDict[Any]:
         """
-        delete() executes the query by delegating to delete_by_query()
+        ``delete()`` executes the query by delegating to ``delete_by_query()``.
+
+        Use the ``params`` method to specify any additional arguments you wish to
+        pass to the underlying ``delete_by_query`` helper from ``elasticsearch-py`` -
+        https://elasticsearch-py.readthedocs.io/en/latest/api/elasticsearch.html#elasticsearch.Elasticsearch.delete_by_query
         """
 
         es = get_connection(self._using)
diff --git a/elasticsearch/dsl/aggs.py b/elasticsearch/dsl/aggs.py
index ba5150803..c01a6fafb 100644
--- a/elasticsearch/dsl/aggs.py
+++ b/elasticsearch/dsl/aggs.py
@@ -35,6 +35,7 @@
 
 from elastic_transport.client_utils import DEFAULT
 
+from . import wrappers
 from .query import Query
 from .response.aggs import AggResponse, BucketData, FieldBucketData, TopHitsData
 from .utils import _R, AttrDict, DslBase
@@ -642,6 +643,54 @@ def __init__(
         )
 
 
+class CartesianBounds(Agg[_R]):
+    """
+    A metric aggregation that computes the spatial bounding box containing
+    all values for a Point or Shape field.
+
+    :arg field: The field on which to run the aggregation.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg script:
+    """
+
+    name = "cartesian_bounds"
+
+    def __init__(
+        self,
+        *,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        missing: Union[str, int, float, bool, "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(field=field, missing=missing, script=script, **kwargs)
+
+
+class CartesianCentroid(Agg[_R]):
+    """
+    A metric aggregation that computes the weighted centroid from all
+    coordinate values for point and shape fields.
+
+    :arg field: The field on which to run the aggregation.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg script:
+    """
+
+    name = "cartesian_centroid"
+
+    def __init__(
+        self,
+        *,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        missing: Union[str, int, float, bool, "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(field=field, missing=missing, script=script, **kwargs)
+
+
 class CategorizeText(Bucket[_R]):
     """
     A multi-bucket aggregation that groups semi-structured text into
@@ -678,9 +727,8 @@ class CategorizeText(Bucket[_R]):
     :arg categorization_analyzer: The categorization analyzer specifies
         how the text is analyzed and tokenized before being categorized.
         The syntax is very similar to that used to define the analyzer in
-        the [Analyze endpoint](https://www.elastic.co/guide/en/elasticsear
-        ch/reference/8.0/indices-analyze.html). This property cannot be
-        used at the same time as categorization_filters.
+        the analyze API. This property cannot be used at the same time as
+        `categorization_filters`.
     :arg shard_size: The number of categorization buckets to return from
         each shard before merging all the results.
     :arg size: The number of buckets to return. Defaults to `10` if
@@ -725,6 +773,43 @@ def __init__(
         )
 
 
+class ChangePoint(Pipeline[_R]):
+    """
+    A sibling pipeline that detects, spikes, dips, and change points in a
+    metric. Given a distribution of values provided by the sibling multi-
+    bucket aggregation, this aggregation indicates the bucket of any spike
+    or dip and/or the bucket at which the largest change in the
+    distribution of values, if they are statistically significant. There
+    must be at least 22 bucketed values. Fewer than 1,000 is preferred.
+
+    :arg format: `DecimalFormat` pattern for the output value. If
+        specified, the formatted value is returned in the aggregation’s
+        `value_as_string` property.
+    :arg gap_policy: Policy to apply when gaps are found in the data.
+        Defaults to `skip` if omitted.
+    :arg buckets_path: Path to the buckets that contain one set of values
+        to correlate.
+    """
+
+    name = "change_point"
+
+    def __init__(
+        self,
+        *,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        gap_policy: Union[
+            Literal["skip", "insert_zeros", "keep_values"], "DefaultType"
+        ] = DEFAULT,
+        buckets_path: Union[
+            str, Sequence[str], Mapping[str, str], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            format=format, gap_policy=gap_policy, buckets_path=buckets_path, **kwargs
+        )
+
+
 class Children(Bucket[_R]):
     """
     A single bucket aggregation that selects child documents that have the
@@ -761,7 +846,7 @@ def __init__(
         *,
         after: Union[
             Mapping[
-                Union[str, "InstrumentedField"], Union[int, float, str, bool, None, Any]
+                Union[str, "InstrumentedField"], Union[int, float, str, bool, None]
             ],
             "DefaultType",
         ] = DEFAULT,
@@ -958,7 +1043,7 @@ def __init__(
         format: Union[str, "DefaultType"] = DEFAULT,
         missing: Union[str, int, float, bool, "DefaultType"] = DEFAULT,
         ranges: Union[
-            Sequence["types.DateRangeExpression"],
+            Sequence["wrappers.AggregationRange"],
             Sequence[Dict[str, Any]],
             "DefaultType",
         ] = DEFAULT,
@@ -1347,7 +1432,9 @@ def __init__(
             "DefaultType",
         ] = DEFAULT,
         ranges: Union[
-            Sequence["types.AggregationRange"], Sequence[Dict[str, Any]], "DefaultType"
+            Sequence["wrappers.AggregationRange"],
+            Sequence[Dict[str, Any]],
+            "DefaultType",
         ] = DEFAULT,
         unit: Union[
             Literal["in", "ft", "yd", "mi", "nmi", "km", "m", "cm", "mm"], "DefaultType"
@@ -2657,7 +2744,9 @@ def __init__(
         field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
         missing: Union[int, "DefaultType"] = DEFAULT,
         ranges: Union[
-            Sequence["types.AggregationRange"], Sequence[Dict[str, Any]], "DefaultType"
+            Sequence["wrappers.AggregationRange"],
+            Sequence[Dict[str, Any]],
+            "DefaultType",
         ] = DEFAULT,
         script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
         keyed: Union[bool, "DefaultType"] = DEFAULT,
@@ -2956,6 +3045,14 @@ class SignificantTerms(Bucket[_R]):
         the foreground sample with a term divided by the number of
         documents in the background with the term.
     :arg script_heuristic: Customized score, implemented via a script.
+    :arg p_value: Significant terms heuristic that calculates the p-value
+        between the term existing in foreground and background sets.  The
+        p-value is the probability of obtaining test results at least as
+        extreme as the results actually observed, under the assumption
+        that the null hypothesis is correct. The p-value is calculated
+        assuming that the foreground set and the background set are
+        independent https://en.wikipedia.org/wiki/Bernoulli_trial, with
+        the null hypothesis that the probabilities are the same.
     :arg shard_min_doc_count: Regulates the certainty a shard has if the
         term should actually be added to the candidate list or not with
         respect to the `min_doc_count`. Terms will only be considered if
@@ -3009,6 +3106,9 @@ def __init__(
         script_heuristic: Union[
             "types.ScriptedHeuristic", Dict[str, Any], "DefaultType"
         ] = DEFAULT,
+        p_value: Union[
+            "types.PValueHeuristic", Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
         shard_min_doc_count: Union[int, "DefaultType"] = DEFAULT,
         shard_size: Union[int, "DefaultType"] = DEFAULT,
         size: Union[int, "DefaultType"] = DEFAULT,
@@ -3027,6 +3127,7 @@ def __init__(
             mutual_information=mutual_information,
             percentage=percentage,
             script_heuristic=script_heuristic,
+            p_value=p_value,
             shard_min_doc_count=shard_min_doc_count,
             shard_size=shard_size,
             size=size,
diff --git a/elasticsearch/dsl/document_base.py b/elasticsearch/dsl/document_base.py
index b5e373741..242acb1ff 100644
--- a/elasticsearch/dsl/document_base.py
+++ b/elasticsearch/dsl/document_base.py
@@ -15,6 +15,7 @@
 #  specific language governing permissions and limitations
 #  under the License.
 
+import json
 from datetime import date, datetime
 from fnmatch import fnmatch
 from typing import (
@@ -27,6 +28,7 @@
     List,
     Optional,
     Tuple,
+    Type,
     TypeVar,
     Union,
     get_args,
@@ -48,6 +50,7 @@
 if TYPE_CHECKING:
     from elastic_transport import ObjectApiResponse
 
+    from ..esql.esql import ESQLBase
     from .index_base import IndexBase
 
 
@@ -56,7 +59,163 @@ def __init__(self, *args: Any, **kwargs: Any):
         self.args, self.kwargs = args, kwargs
 
 
-class InstrumentedField:
+class InstrumentedExpression:
+    """Proxy object for a ES|QL expression."""
+
+    def __init__(self, expr: str):
+        self._expr = expr
+
+    def _render_value(self, value: Any) -> str:
+        if isinstance(value, InstrumentedExpression):
+            return str(value)
+        return json.dumps(value)
+
+    def __str__(self) -> str:
+        return self._expr
+
+    def __repr__(self) -> str:
+        return f"InstrumentedExpression[{self._expr}]"
+
+    def __pos__(self) -> "InstrumentedExpression":
+        return self
+
+    def __neg__(self) -> "InstrumentedExpression":
+        return InstrumentedExpression(f"-({self._expr})")
+
+    def __eq__(self, value: Any) -> "InstrumentedExpression":  # type: ignore[override]
+        return InstrumentedExpression(f"{self._expr} == {self._render_value(value)}")
+
+    def __ne__(self, value: Any) -> "InstrumentedExpression":  # type: ignore[override]
+        return InstrumentedExpression(f"{self._expr} != {self._render_value(value)}")
+
+    def __lt__(self, value: Any) -> "InstrumentedExpression":
+        return InstrumentedExpression(f"{self._expr} < {self._render_value(value)}")
+
+    def __gt__(self, value: Any) -> "InstrumentedExpression":
+        return InstrumentedExpression(f"{self._expr} > {self._render_value(value)}")
+
+    def __le__(self, value: Any) -> "InstrumentedExpression":
+        return InstrumentedExpression(f"{self._expr} <= {self._render_value(value)}")
+
+    def __ge__(self, value: Any) -> "InstrumentedExpression":
+        return InstrumentedExpression(f"{self._expr} >= {self._render_value(value)}")
+
+    def __add__(self, value: Any) -> "InstrumentedExpression":
+        return InstrumentedExpression(f"{self._expr} + {self._render_value(value)}")
+
+    def __radd__(self, value: Any) -> "InstrumentedExpression":
+        return InstrumentedExpression(f"{self._render_value(value)} + {self._expr}")
+
+    def __sub__(self, value: Any) -> "InstrumentedExpression":
+        return InstrumentedExpression(f"{self._expr} - {self._render_value(value)}")
+
+    def __rsub__(self, value: Any) -> "InstrumentedExpression":
+        return InstrumentedExpression(f"{self._render_value(value)} - {self._expr}")
+
+    def __mul__(self, value: Any) -> "InstrumentedExpression":
+        return InstrumentedExpression(f"{self._expr} * {self._render_value(value)}")
+
+    def __rmul__(self, value: Any) -> "InstrumentedExpression":
+        return InstrumentedExpression(f"{self._render_value(value)} * {self._expr}")
+
+    def __truediv__(self, value: Any) -> "InstrumentedExpression":
+        return InstrumentedExpression(f"{self._expr} / {self._render_value(value)}")
+
+    def __rtruediv__(self, value: Any) -> "InstrumentedExpression":
+        return InstrumentedExpression(f"{self._render_value(value)} / {self._expr}")
+
+    def __mod__(self, value: Any) -> "InstrumentedExpression":
+        return InstrumentedExpression(f"{self._expr} % {self._render_value(value)}")
+
+    def __rmod__(self, value: Any) -> "InstrumentedExpression":
+        return InstrumentedExpression(f"{self._render_value(value)} % {self._expr}")
+
+    def is_null(self) -> "InstrumentedExpression":
+        """Compare the expression against NULL."""
+        return InstrumentedExpression(f"{self._expr} IS NULL")
+
+    def is_not_null(self) -> "InstrumentedExpression":
+        """Compare the expression against NOT NULL."""
+        return InstrumentedExpression(f"{self._expr} IS NOT NULL")
+
+    def in_(self, *values: Any) -> "InstrumentedExpression":
+        """Test if the expression equals one of the given values."""
+        rendered_values = ", ".join([f"{value}" for value in values])
+        return InstrumentedExpression(f"{self._expr} IN ({rendered_values})")
+
+    def like(self, *patterns: str) -> "InstrumentedExpression":
+        """Filter the expression using a string pattern."""
+        if len(patterns) == 1:
+            return InstrumentedExpression(
+                f"{self._expr} LIKE {self._render_value(patterns[0])}"
+            )
+        else:
+            return InstrumentedExpression(
+                f'{self._expr} LIKE ({", ".join([self._render_value(p) for p in patterns])})'
+            )
+
+    def rlike(self, *patterns: str) -> "InstrumentedExpression":
+        """Filter the expression using a regular expression."""
+        if len(patterns) == 1:
+            return InstrumentedExpression(
+                f"{self._expr} RLIKE {self._render_value(patterns[0])}"
+            )
+        else:
+            return InstrumentedExpression(
+                f'{self._expr} RLIKE ({", ".join([self._render_value(p) for p in patterns])})'
+            )
+
+    def match(self, query: str) -> "InstrumentedExpression":
+        """Perform a match query on the field."""
+        return InstrumentedExpression(f"{self._expr}:{self._render_value(query)}")
+
+    def asc(self) -> "InstrumentedExpression":
+        """Return the field name representation for ascending sort order.
+
+        For use in ES|QL queries only.
+        """
+        return InstrumentedExpression(f"{self._expr} ASC")
+
+    def desc(self) -> "InstrumentedExpression":
+        """Return the field name representation for descending sort order.
+
+        For use in ES|QL queries only.
+        """
+        return InstrumentedExpression(f"{self._expr} DESC")
+
+    def nulls_first(self) -> "InstrumentedExpression":
+        """Return the field name representation for nulls first sort order.
+
+        For use in ES|QL queries only.
+        """
+        return InstrumentedExpression(f"{self._expr} NULLS FIRST")
+
+    def nulls_last(self) -> "InstrumentedExpression":
+        """Return the field name representation for nulls last sort order.
+
+        For use in ES|QL queries only.
+        """
+        return InstrumentedExpression(f"{self._expr} NULLS LAST")
+
+    def where(
+        self, *expressions: Union[str, "InstrumentedExpression"]
+    ) -> "InstrumentedExpression":
+        """Add a condition to be met for the row to be included.
+
+        Use only in expressions given in the ``STATS`` command.
+        """
+        if len(expressions) == 1:
+            return InstrumentedExpression(f"{self._expr} WHERE {expressions[0]}")
+        else:
+            return InstrumentedExpression(
+                f'{self._expr} WHERE {" AND ".join([f"({expr})" for expr in expressions])}'
+            )
+
+
+E = InstrumentedExpression
+
+
+class InstrumentedField(InstrumentedExpression):
     """Proxy object for a mapped document field.
 
     An object of this instance is returned when a field is accessed as a class
@@ -71,8 +230,8 @@ class MyDocument(Document):
         s = s.sort(-MyDocument.name)  # sort by name in descending order
     """
 
-    def __init__(self, name: str, field: Field):
-        self._name = name
+    def __init__(self, name: str, field: Optional[Field]):
+        super().__init__(name)
         self._field = field
 
     # note that the return value type here assumes classes will only be used to
@@ -83,26 +242,29 @@ def __getattr__(self, attr: str) -> "InstrumentedField":
             # first let's see if this is an attribute of this object
             return super().__getattribute__(attr)  # type: ignore[no-any-return]
         except AttributeError:
-            try:
-                # next we see if we have a sub-field with this name
-                return InstrumentedField(f"{self._name}.{attr}", self._field[attr])
-            except KeyError:
-                # lastly we let the wrapped field resolve this attribute
-                return getattr(self._field, attr)  # type: ignore[no-any-return]
-
-    def __pos__(self) -> str:
+            if self._field:
+                try:
+                    # next we see if we have a sub-field with this name
+                    return InstrumentedField(f"{self._expr}.{attr}", self._field[attr])
+                except KeyError:
+                    # lastly we let the wrapped field resolve this attribute
+                    return getattr(self._field, attr)  # type: ignore[no-any-return]
+            else:
+                raise
+
+    def __pos__(self) -> str:  # type: ignore[override]
         """Return the field name representation for ascending sort order"""
-        return f"{self._name}"
+        return f"{self._expr}"
 
-    def __neg__(self) -> str:
+    def __neg__(self) -> str:  # type: ignore[override]
         """Return the field name representation for descending sort order"""
-        return f"-{self._name}"
+        return f"-{self._expr}"
 
     def __str__(self) -> str:
-        return self._name
+        return self._expr
 
     def __repr__(self) -> str:
-        return f"InstrumentedField[{self._name}]"
+        return f"InstrumentedField[{self._expr}]"
 
 
 class DocumentMeta(type):
@@ -442,3 +604,44 @@ def to_dict(self, include_meta: bool = False, skip_empty: bool = True) -> Dict[s
 
         meta["_source"] = d
         return meta
+
+    @classmethod
+    def _get_field_names(
+        cls, for_esql: bool = False, nested_class: Optional[Type[InnerDoc]] = None
+    ) -> List[str]:
+        """Return the list of field names used by this document.
+        If the document has nested objects, their fields are reported using dot
+        notation. If the ``for_esql`` argument is set to ``True``, the list omits
+        nested fields, which are currently unsupported in ES|QL.
+        """
+        fields = []
+        class_ = nested_class or cls
+        for field_name in class_._doc_type.mapping:
+            field = class_._doc_type.mapping[field_name]
+            if isinstance(field, Object):
+                if for_esql and isinstance(field, Nested):
+                    # ES|QL does not recognize Nested fields at this time
+                    continue
+                sub_fields = cls._get_field_names(
+                    for_esql=for_esql, nested_class=field._doc_class
+                )
+                for sub_field in sub_fields:
+                    fields.append(f"{field_name}.{sub_field}")
+            else:
+                fields.append(field_name)
+        return fields
+
+    @classmethod
+    def esql_from(cls) -> "ESQLBase":
+        """Return a base ES|QL query for instances of this document class.
+
+        The returned query is initialized with ``FROM`` and ``KEEP`` statements,
+        and can be completed as desired.
+        """
+        from ..esql import ESQL  # here to avoid circular imports
+
+        return (
+            ESQL.from_(cls)
+            .metadata("_id")
+            .keep("_id", *tuple(cls._get_field_names(for_esql=True)))
+        )
diff --git a/elasticsearch/dsl/faceted_search_base.py b/elasticsearch/dsl/faceted_search_base.py
index 5caa041bf..c70a5db0e 100644
--- a/elasticsearch/dsl/faceted_search_base.py
+++ b/elasticsearch/dsl/faceted_search_base.py
@@ -42,7 +42,7 @@
     from .response.aggs import BucketData
     from .search_base import SearchBase
 
-FilterValueType = Union[str, datetime, Sequence[str]]
+FilterValueType = Union[str, int, float, bool]
 
 __all__ = [
     "FacetedSearchBase",
@@ -396,10 +396,10 @@ def add_filter(
             ]
 
         # remember the filter values for use in FacetedResponse
-        self.filter_values[name] = filter_values  # type: ignore[assignment]
+        self.filter_values[name] = filter_values
 
         # get the filter from the facet
-        f = self.facets[name].add_filter(filter_values)  # type: ignore[arg-type]
+        f = self.facets[name].add_filter(filter_values)
         if f is None:
             return
 
@@ -469,7 +469,7 @@ def params(self, **kwargs: Any) -> None:
         """
         Specify query params to be used when executing the search. All the
         keyword arguments will override the current values. See
-        https://elasticsearch-py.readthedocs.io/en/master/api.html#elasticsearch.Elasticsearch.search
+        https://elasticsearch-py.readthedocs.io/en/latest/api/elasticsearch.html#elasticsearch.Elasticsearch.search
         for all available parameters.
         """
         self._s = self._s.params(**kwargs)
diff --git a/elasticsearch/dsl/field.py b/elasticsearch/dsl/field.py
index 50f30b405..16490c03d 100644
--- a/elasticsearch/dsl/field.py
+++ b/elasticsearch/dsl/field.py
@@ -119,9 +119,16 @@ def __init__(
     def __getitem__(self, subfield: str) -> "Field":
         return cast(Field, self._params.get("fields", {})[subfield])
 
-    def _serialize(self, data: Any) -> Any:
+    def _serialize(self, data: Any, skip_empty: bool) -> Any:
         return data
 
+    def _safe_serialize(self, data: Any, skip_empty: bool) -> Any:
+        try:
+            return self._serialize(data, skip_empty)
+        except TypeError:
+            # older method signature, without skip_empty
+            return self._serialize(data)  # type: ignore[call-arg]
+
     def _deserialize(self, data: Any) -> Any:
         return data
 
@@ -133,10 +140,16 @@ def empty(self) -> Optional[Any]:
             return AttrList([])
         return self._empty()
 
-    def serialize(self, data: Any) -> Any:
+    def serialize(self, data: Any, skip_empty: bool = True) -> Any:
         if isinstance(data, (list, AttrList, tuple)):
-            return list(map(self._serialize, cast(Iterable[Any], data)))
-        return self._serialize(data)
+            return list(
+                map(
+                    self._safe_serialize,
+                    cast(Iterable[Any], data),
+                    [skip_empty] * len(data),
+                )
+            )
+        return self._safe_serialize(data, skip_empty)
 
     def deserialize(self, data: Any) -> Any:
         if isinstance(data, (list, AttrList, tuple)):
@@ -186,7 +199,7 @@ def _deserialize(self, data: Any) -> Range["_SupportsComparison"]:
         data = {k: self._core_field.deserialize(v) for k, v in data.items()}  # type: ignore[union-attr]
         return Range(data)
 
-    def _serialize(self, data: Any) -> Optional[Dict[str, Any]]:
+    def _serialize(self, data: Any, skip_empty: bool) -> Optional[Dict[str, Any]]:
         if data is None:
             return None
         if not isinstance(data, collections.abc.Mapping):
@@ -280,7 +293,10 @@ def __init__(
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -387,7 +403,10 @@ def __init__(
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -437,7 +456,9 @@ def __init__(
         doc_class: Union[Type["InnerDoc"], "DefaultType"] = DEFAULT,
         *args: Any,
         enabled: Union[bool, "DefaultType"] = DEFAULT,
-        subobjects: Union[bool, "DefaultType"] = DEFAULT,
+        subobjects: Union[
+            Literal["true", "false", "auto"], bool, "DefaultType"
+        ] = DEFAULT,
         copy_to: Union[
             Union[str, "InstrumentedField"],
             Sequence[Union[str, "InstrumentedField"]],
@@ -461,7 +482,10 @@ def __init__(
         if subobjects is not DEFAULT:
             kwargs["subobjects"] = subobjects
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -539,7 +563,7 @@ def _deserialize(self, data: Any) -> "InnerDoc":
         return self._wrap(data)
 
     def _serialize(
-        self, data: Optional[Union[Dict[str, Any], "InnerDoc"]]
+        self, data: Optional[Union[Dict[str, Any], "InnerDoc"]], skip_empty: bool
     ) -> Optional[Dict[str, Any]]:
         if data is None:
             return None
@@ -548,7 +572,11 @@ def _serialize(
         if isinstance(data, collections.abc.Mapping):
             return data
 
-        return data.to_dict()
+        try:
+            return data.to_dict(skip_empty=skip_empty)
+        except TypeError:
+            # this would only happen if an AttrDict was given instead of an InnerDoc
+            return data.to_dict()
 
     def clean(self, data: Any) -> Any:
         data = super().clean(data)
@@ -573,6 +601,7 @@ class AggregateMetricDouble(Field):
     """
     :arg default_metric: (required)
     :arg metrics: (required)
+    :arg ignore_malformed:
     :arg time_series_metric:
     :arg meta: Metadata about the field.
     :arg properties:
@@ -593,6 +622,7 @@ def __init__(
         *args: Any,
         default_metric: Union[str, "DefaultType"] = DEFAULT,
         metrics: Union[Sequence[str], "DefaultType"] = DEFAULT,
+        ignore_malformed: Union[bool, "DefaultType"] = DEFAULT,
         time_series_metric: Union[
             Literal["gauge", "counter", "summary", "histogram", "position"],
             "DefaultType",
@@ -613,6 +643,8 @@ def __init__(
             kwargs["default_metric"] = default_metric
         if metrics is not DEFAULT:
             kwargs["metrics"] = metrics
+        if ignore_malformed is not DEFAULT:
+            kwargs["ignore_malformed"] = ignore_malformed
         if time_series_metric is not DEFAULT:
             kwargs["time_series_metric"] = time_series_metric
         if meta is not DEFAULT:
@@ -725,7 +757,10 @@ def __init__(
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -750,7 +785,7 @@ def clean(self, data: str) -> str:
     def _deserialize(self, data: Any) -> bytes:
         return base64.b64decode(data)
 
-    def _serialize(self, data: Any) -> Optional[str]:
+    def _serialize(self, data: Any, skip_empty: bool) -> Optional[str]:
         if data is None:
             return None
         return base64.b64encode(data).decode()
@@ -762,6 +797,11 @@ class Boolean(Field):
     :arg fielddata:
     :arg index:
     :arg null_value:
+    :arg ignore_malformed:
+    :arg script:
+    :arg on_script_error:
+    :arg time_series_dimension: For internal use by Elastic only. Marks
+        the field as a time series dimension. Defaults to false.
     :arg doc_values:
     :arg copy_to:
     :arg store:
@@ -789,6 +829,10 @@ def __init__(
         ] = DEFAULT,
         index: Union[bool, "DefaultType"] = DEFAULT,
         null_value: Union[bool, "DefaultType"] = DEFAULT,
+        ignore_malformed: Union[bool, "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        on_script_error: Union[Literal["fail", "continue"], "DefaultType"] = DEFAULT,
+        time_series_dimension: Union[bool, "DefaultType"] = DEFAULT,
         doc_values: Union[bool, "DefaultType"] = DEFAULT,
         copy_to: Union[
             Union[str, "InstrumentedField"],
@@ -816,10 +860,21 @@ def __init__(
             kwargs["index"] = index
         if null_value is not DEFAULT:
             kwargs["null_value"] = null_value
+        if ignore_malformed is not DEFAULT:
+            kwargs["ignore_malformed"] = ignore_malformed
+        if script is not DEFAULT:
+            kwargs["script"] = script
+        if on_script_error is not DEFAULT:
+            kwargs["on_script_error"] = on_script_error
+        if time_series_dimension is not DEFAULT:
+            kwargs["time_series_dimension"] = time_series_dimension
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -934,7 +989,10 @@ def __init__(
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -1024,7 +1082,10 @@ def __init__(
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -1092,6 +1153,56 @@ def __init__(
         super().__init__(*args, **kwargs)
 
 
+class CountedKeyword(Field):
+    """
+    :arg index:
+    :arg meta: Metadata about the field.
+    :arg properties:
+    :arg ignore_above:
+    :arg dynamic:
+    :arg fields:
+    :arg synthetic_source_keep:
+    """
+
+    name = "counted_keyword"
+    _param_defs = {
+        "properties": {"type": "field", "hash": True},
+        "fields": {"type": "field", "hash": True},
+    }
+
+    def __init__(
+        self,
+        *args: Any,
+        index: Union[bool, "DefaultType"] = DEFAULT,
+        meta: Union[Mapping[str, str], "DefaultType"] = DEFAULT,
+        properties: Union[Mapping[str, Field], "DefaultType"] = DEFAULT,
+        ignore_above: Union[int, "DefaultType"] = DEFAULT,
+        dynamic: Union[
+            Literal["strict", "runtime", "true", "false"], bool, "DefaultType"
+        ] = DEFAULT,
+        fields: Union[Mapping[str, Field], "DefaultType"] = DEFAULT,
+        synthetic_source_keep: Union[
+            Literal["none", "arrays", "all"], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        if index is not DEFAULT:
+            kwargs["index"] = index
+        if meta is not DEFAULT:
+            kwargs["meta"] = meta
+        if properties is not DEFAULT:
+            kwargs["properties"] = properties
+        if ignore_above is not DEFAULT:
+            kwargs["ignore_above"] = ignore_above
+        if dynamic is not DEFAULT:
+            kwargs["dynamic"] = dynamic
+        if fields is not DEFAULT:
+            kwargs["fields"] = fields
+        if synthetic_source_keep is not DEFAULT:
+            kwargs["synthetic_source_keep"] = synthetic_source_keep
+        super().__init__(*args, **kwargs)
+
+
 class Date(Field):
     """
     :arg default_timezone: timezone that will be automatically used for tz-naive values
@@ -1101,6 +1212,8 @@ class Date(Field):
     :arg format:
     :arg ignore_malformed:
     :arg index:
+    :arg script:
+    :arg on_script_error:
     :arg null_value:
     :arg precision_step:
     :arg locale:
@@ -1133,6 +1246,8 @@ def __init__(
         format: Union[str, "DefaultType"] = DEFAULT,
         ignore_malformed: Union[bool, "DefaultType"] = DEFAULT,
         index: Union[bool, "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        on_script_error: Union[Literal["fail", "continue"], "DefaultType"] = DEFAULT,
         null_value: Any = DEFAULT,
         precision_step: Union[int, "DefaultType"] = DEFAULT,
         locale: Union[str, "DefaultType"] = DEFAULT,
@@ -1165,6 +1280,10 @@ def __init__(
             kwargs["ignore_malformed"] = ignore_malformed
         if index is not DEFAULT:
             kwargs["index"] = index
+        if script is not DEFAULT:
+            kwargs["script"] = script
+        if on_script_error is not DEFAULT:
+            kwargs["on_script_error"] = on_script_error
         if null_value is not DEFAULT:
             kwargs["null_value"] = null_value
         if precision_step is not DEFAULT:
@@ -1174,7 +1293,10 @@ def __init__(
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -1213,7 +1335,7 @@ def _deserialize(self, data: Any) -> Union[datetime, date]:
         if isinstance(data, datetime):
             if self._default_timezone and data.tzinfo is None:
                 data = data.replace(tzinfo=self._default_timezone)
-            return data
+            return cast(datetime, data)
         if isinstance(data, date):
             return data
         if isinstance(data, int):
@@ -1229,6 +1351,8 @@ class DateNanos(Field):
     :arg format:
     :arg ignore_malformed:
     :arg index:
+    :arg script:
+    :arg on_script_error:
     :arg null_value:
     :arg precision_step:
     :arg doc_values:
@@ -1255,6 +1379,8 @@ def __init__(
         format: Union[str, "DefaultType"] = DEFAULT,
         ignore_malformed: Union[bool, "DefaultType"] = DEFAULT,
         index: Union[bool, "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        on_script_error: Union[Literal["fail", "continue"], "DefaultType"] = DEFAULT,
         null_value: Any = DEFAULT,
         precision_step: Union[int, "DefaultType"] = DEFAULT,
         doc_values: Union[bool, "DefaultType"] = DEFAULT,
@@ -1284,6 +1410,10 @@ def __init__(
             kwargs["ignore_malformed"] = ignore_malformed
         if index is not DEFAULT:
             kwargs["index"] = index
+        if script is not DEFAULT:
+            kwargs["script"] = script
+        if on_script_error is not DEFAULT:
+            kwargs["on_script_error"] = on_script_error
         if null_value is not DEFAULT:
             kwargs["null_value"] = null_value
         if precision_step is not DEFAULT:
@@ -1291,7 +1421,10 @@ def __init__(
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -1370,7 +1503,10 @@ def __init__(
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -1390,11 +1526,29 @@ def __init__(
 
 class DenseVector(Field):
     """
-    :arg element_type:
-    :arg dims:
-    :arg similarity:
-    :arg index:
-    :arg index_options:
+    :arg dims: Number of vector dimensions. Can't exceed `4096`. If `dims`
+        is not specified, it will be set to the length of the first vector
+        added to the field.
+    :arg element_type: The data type used to encode vectors. The supported
+        data types are `float` (default), `byte`, and `bit`. Defaults to
+        `float` if omitted.
+    :arg index: If `true`, you can search this field using the kNN search
+        API. Defaults to `True` if omitted.
+    :arg index_options: An optional section that configures the kNN
+        indexing algorithm. The HNSW algorithm has two internal parameters
+        that influence how the data structure is built. These can be
+        adjusted to improve the accuracy of results, at the expense of
+        slower indexing speed.  This parameter can only be specified when
+        `index` is `true`.
+    :arg similarity: The vector similarity metric to use in kNN search.
+        Documents are ranked by their vector field's similarity to the
+        query vector. The `_score` of each document will be derived from
+        the similarity, in a way that ensures scores are positive and that
+        a larger score corresponds to a higher ranking.  Defaults to
+        `l2_norm` when `element_type` is `bit` otherwise defaults to
+        `cosine`.  `bit` vectors only support `l2_norm` as their
+        similarity metric.  This parameter can only be specified when
+        `index` is `true`.
     :arg meta: Metadata about the field.
     :arg properties:
     :arg ignore_above:
@@ -1413,13 +1567,16 @@ class DenseVector(Field):
     def __init__(
         self,
         *args: Any,
-        element_type: Union[str, "DefaultType"] = DEFAULT,
         dims: Union[int, "DefaultType"] = DEFAULT,
-        similarity: Union[str, "DefaultType"] = DEFAULT,
+        element_type: Union[Literal["bit", "byte", "float"], "DefaultType"] = DEFAULT,
         index: Union[bool, "DefaultType"] = DEFAULT,
         index_options: Union[
             "types.DenseVectorIndexOptions", Dict[str, Any], "DefaultType"
         ] = DEFAULT,
+        similarity: Union[
+            Literal["cosine", "dot_product", "l2_norm", "max_inner_product"],
+            "DefaultType",
+        ] = DEFAULT,
         meta: Union[Mapping[str, str], "DefaultType"] = DEFAULT,
         properties: Union[Mapping[str, Field], "DefaultType"] = DEFAULT,
         ignore_above: Union[int, "DefaultType"] = DEFAULT,
@@ -1432,16 +1589,16 @@ def __init__(
         ] = DEFAULT,
         **kwargs: Any,
     ):
-        if element_type is not DEFAULT:
-            kwargs["element_type"] = element_type
         if dims is not DEFAULT:
             kwargs["dims"] = dims
-        if similarity is not DEFAULT:
-            kwargs["similarity"] = similarity
+        if element_type is not DEFAULT:
+            kwargs["element_type"] = element_type
         if index is not DEFAULT:
             kwargs["index"] = index
         if index_options is not DEFAULT:
             kwargs["index_options"] = index_options
+        if similarity is not DEFAULT:
+            kwargs["similarity"] = similarity
         if meta is not DEFAULT:
             kwargs["meta"] = meta
         if properties is not DEFAULT:
@@ -1552,7 +1709,10 @@ def __init__(
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -1627,7 +1787,10 @@ def __init__(
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -1656,6 +1819,7 @@ class Flattened(Field):
     :arg null_value:
     :arg similarity:
     :arg split_queries_on_whitespace:
+    :arg time_series_dimensions:
     :arg meta: Metadata about the field.
     :arg properties:
     :arg ignore_above:
@@ -1684,6 +1848,7 @@ def __init__(
         null_value: Union[str, "DefaultType"] = DEFAULT,
         similarity: Union[str, "DefaultType"] = DEFAULT,
         split_queries_on_whitespace: Union[bool, "DefaultType"] = DEFAULT,
+        time_series_dimensions: Union[Sequence[str], "DefaultType"] = DEFAULT,
         meta: Union[Mapping[str, str], "DefaultType"] = DEFAULT,
         properties: Union[Mapping[str, Field], "DefaultType"] = DEFAULT,
         ignore_above: Union[int, "DefaultType"] = DEFAULT,
@@ -1714,6 +1879,8 @@ def __init__(
             kwargs["similarity"] = similarity
         if split_queries_on_whitespace is not DEFAULT:
             kwargs["split_queries_on_whitespace"] = split_queries_on_whitespace
+        if time_series_dimensions is not DEFAULT:
+            kwargs["time_series_dimensions"] = time_series_dimensions
         if meta is not DEFAULT:
             kwargs["meta"] = meta
         if properties is not DEFAULT:
@@ -1786,7 +1953,10 @@ def __init__(
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -1812,6 +1982,7 @@ class GeoPoint(Field):
     :arg index:
     :arg on_script_error:
     :arg script:
+    :arg time_series_metric:
     :arg doc_values:
     :arg copy_to:
     :arg store:
@@ -1845,6 +2016,9 @@ def __init__(
         index: Union[bool, "DefaultType"] = DEFAULT,
         on_script_error: Union[Literal["fail", "continue"], "DefaultType"] = DEFAULT,
         script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        time_series_metric: Union[
+            Literal["gauge", "counter", "position"], "DefaultType"
+        ] = DEFAULT,
         doc_values: Union[bool, "DefaultType"] = DEFAULT,
         copy_to: Union[
             Union[str, "InstrumentedField"],
@@ -1876,10 +2050,15 @@ def __init__(
             kwargs["on_script_error"] = on_script_error
         if script is not DEFAULT:
             kwargs["script"] = script
+        if time_series_metric is not DEFAULT:
+            kwargs["time_series_metric"] = time_series_metric
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -1905,6 +2084,7 @@ class GeoShape(Field):
     :arg coerce:
     :arg ignore_malformed:
     :arg ignore_z_value:
+    :arg index:
     :arg orientation:
     :arg strategy:
     :arg doc_values:
@@ -1930,6 +2110,7 @@ def __init__(
         coerce: Union[bool, "DefaultType"] = DEFAULT,
         ignore_malformed: Union[bool, "DefaultType"] = DEFAULT,
         ignore_z_value: Union[bool, "DefaultType"] = DEFAULT,
+        index: Union[bool, "DefaultType"] = DEFAULT,
         orientation: Union[Literal["right", "left"], "DefaultType"] = DEFAULT,
         strategy: Union[Literal["recursive", "term"], "DefaultType"] = DEFAULT,
         doc_values: Union[bool, "DefaultType"] = DEFAULT,
@@ -1957,6 +2138,8 @@ def __init__(
             kwargs["ignore_malformed"] = ignore_malformed
         if ignore_z_value is not DEFAULT:
             kwargs["ignore_z_value"] = ignore_z_value
+        if index is not DEFAULT:
+            kwargs["index"] = index
         if orientation is not DEFAULT:
             kwargs["orientation"] = orientation
         if strategy is not DEFAULT:
@@ -1964,7 +2147,10 @@ def __init__(
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -2067,7 +2253,10 @@ def __init__(
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -2250,7 +2439,10 @@ def __init__(
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -2325,7 +2517,10 @@ def __init__(
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -2417,7 +2612,10 @@ def __init__(
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -2438,7 +2636,7 @@ def _deserialize(self, data: Any) -> Union["IPv4Address", "IPv6Address"]:
         # the ipaddress library for pypy only accepts unicode.
         return ipaddress.ip_address(unicode(data))
 
-    def _serialize(self, data: Any) -> Optional[str]:
+    def _serialize(self, data: Any, skip_empty: bool) -> Optional[str]:
         if data is None:
             return None
         return str(data)
@@ -2501,7 +2699,10 @@ def __init__(
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -2671,7 +2872,10 @@ def __init__(
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -2774,7 +2978,10 @@ def __init__(
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -2849,7 +3056,10 @@ def __init__(
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -2906,7 +3116,10 @@ def __init__(
         if meta is not DEFAULT:
             kwargs["meta"] = meta
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         super().__init__(*args, **kwargs)
 
 
@@ -2954,7 +3167,10 @@ def __init__(
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -3024,7 +3240,10 @@ def __init__(
         if include_in_root is not DEFAULT:
             kwargs["include_in_root"] = include_in_root
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -3043,6 +3262,79 @@ def __init__(
         super().__init__(*args, **kwargs)
 
 
+class Passthrough(Field):
+    """
+    :arg enabled:
+    :arg priority:
+    :arg time_series_dimension:
+    :arg copy_to:
+    :arg store:
+    :arg meta: Metadata about the field.
+    :arg properties:
+    :arg ignore_above:
+    :arg dynamic:
+    :arg fields:
+    :arg synthetic_source_keep:
+    """
+
+    name = "passthrough"
+    _param_defs = {
+        "properties": {"type": "field", "hash": True},
+        "fields": {"type": "field", "hash": True},
+    }
+
+    def __init__(
+        self,
+        *args: Any,
+        enabled: Union[bool, "DefaultType"] = DEFAULT,
+        priority: Union[int, "DefaultType"] = DEFAULT,
+        time_series_dimension: Union[bool, "DefaultType"] = DEFAULT,
+        copy_to: Union[
+            Union[str, "InstrumentedField"],
+            Sequence[Union[str, "InstrumentedField"]],
+            "DefaultType",
+        ] = DEFAULT,
+        store: Union[bool, "DefaultType"] = DEFAULT,
+        meta: Union[Mapping[str, str], "DefaultType"] = DEFAULT,
+        properties: Union[Mapping[str, Field], "DefaultType"] = DEFAULT,
+        ignore_above: Union[int, "DefaultType"] = DEFAULT,
+        dynamic: Union[
+            Literal["strict", "runtime", "true", "false"], bool, "DefaultType"
+        ] = DEFAULT,
+        fields: Union[Mapping[str, Field], "DefaultType"] = DEFAULT,
+        synthetic_source_keep: Union[
+            Literal["none", "arrays", "all"], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        if enabled is not DEFAULT:
+            kwargs["enabled"] = enabled
+        if priority is not DEFAULT:
+            kwargs["priority"] = priority
+        if time_series_dimension is not DEFAULT:
+            kwargs["time_series_dimension"] = time_series_dimension
+        if copy_to is not DEFAULT:
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
+        if store is not DEFAULT:
+            kwargs["store"] = store
+        if meta is not DEFAULT:
+            kwargs["meta"] = meta
+        if properties is not DEFAULT:
+            kwargs["properties"] = properties
+        if ignore_above is not DEFAULT:
+            kwargs["ignore_above"] = ignore_above
+        if dynamic is not DEFAULT:
+            kwargs["dynamic"] = dynamic
+        if fields is not DEFAULT:
+            kwargs["fields"] = fields
+        if synthetic_source_keep is not DEFAULT:
+            kwargs["synthetic_source_keep"] = synthetic_source_keep
+        super().__init__(*args, **kwargs)
+
+
 class Percolator(Field):
     """
     :arg meta: Metadata about the field.
@@ -3092,7 +3384,7 @@ def __init__(
     def _deserialize(self, data: Any) -> "Query":
         return Q(data)  # type: ignore[no-any-return]
 
-    def _serialize(self, data: Any) -> Optional[Dict[str, Any]]:
+    def _serialize(self, data: Any, skip_empty: bool) -> Optional[Dict[str, Any]]:
         if data is None:
             return None
         return data.to_dict()  # type: ignore[no-any-return]
@@ -3154,7 +3446,10 @@ def __init__(
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -3272,6 +3567,62 @@ def __init__(
         super().__init__(*args, **kwargs)
 
 
+class RankVectors(Field):
+    """
+    Technical preview
+
+    :arg element_type:
+    :arg dims:
+    :arg meta: Metadata about the field.
+    :arg properties:
+    :arg ignore_above:
+    :arg dynamic:
+    :arg fields:
+    :arg synthetic_source_keep:
+    """
+
+    name = "rank_vectors"
+    _param_defs = {
+        "properties": {"type": "field", "hash": True},
+        "fields": {"type": "field", "hash": True},
+    }
+
+    def __init__(
+        self,
+        *args: Any,
+        element_type: Union[Literal["byte", "float", "bit"], "DefaultType"] = DEFAULT,
+        dims: Union[int, "DefaultType"] = DEFAULT,
+        meta: Union[Mapping[str, str], "DefaultType"] = DEFAULT,
+        properties: Union[Mapping[str, Field], "DefaultType"] = DEFAULT,
+        ignore_above: Union[int, "DefaultType"] = DEFAULT,
+        dynamic: Union[
+            Literal["strict", "runtime", "true", "false"], bool, "DefaultType"
+        ] = DEFAULT,
+        fields: Union[Mapping[str, Field], "DefaultType"] = DEFAULT,
+        synthetic_source_keep: Union[
+            Literal["none", "arrays", "all"], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        if element_type is not DEFAULT:
+            kwargs["element_type"] = element_type
+        if dims is not DEFAULT:
+            kwargs["dims"] = dims
+        if meta is not DEFAULT:
+            kwargs["meta"] = meta
+        if properties is not DEFAULT:
+            kwargs["properties"] = properties
+        if ignore_above is not DEFAULT:
+            kwargs["ignore_above"] = ignore_above
+        if dynamic is not DEFAULT:
+            kwargs["dynamic"] = dynamic
+        if fields is not DEFAULT:
+            kwargs["fields"] = fields
+        if synthetic_source_keep is not DEFAULT:
+            kwargs["synthetic_source_keep"] = synthetic_source_keep
+        super().__init__(*args, **kwargs)
+
+
 class ScaledFloat(Float):
     """
     :arg null_value:
@@ -3361,7 +3712,10 @@ def __init__(
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -3477,7 +3831,10 @@ def __init__(
         if term_vector is not DEFAULT:
             kwargs["term_vector"] = term_vector
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -3497,8 +3854,18 @@ def __init__(
 
 class SemanticText(Field):
     """
-    :arg inference_id: (required)
     :arg meta:
+    :arg inference_id: Inference endpoint that will be used to generate
+        embeddings for the field. This parameter cannot be updated. Use
+        the Create inference API to create the endpoint. If
+        `search_inference_id` is specified, the inference endpoint will
+        only be used at index time. Defaults to `.elser-2-elasticsearch`
+        if omitted.
+    :arg search_inference_id: Inference endpoint that will be used to
+        generate embeddings at query time. You can update this parameter
+        by using the Update mapping API. Use the Create inference API to
+        create the endpoint. If not specified, the inference endpoint
+        defined by inference_id will be used at both index and query time.
     """
 
     name = "semantic_text"
@@ -3506,14 +3873,17 @@ class SemanticText(Field):
     def __init__(
         self,
         *args: Any,
-        inference_id: Union[str, "DefaultType"] = DEFAULT,
         meta: Union[Mapping[str, str], "DefaultType"] = DEFAULT,
+        inference_id: Union[str, "DefaultType"] = DEFAULT,
+        search_inference_id: Union[str, "DefaultType"] = DEFAULT,
         **kwargs: Any,
     ):
-        if inference_id is not DEFAULT:
-            kwargs["inference_id"] = inference_id
         if meta is not DEFAULT:
             kwargs["meta"] = meta
+        if inference_id is not DEFAULT:
+            kwargs["inference_id"] = inference_id
+        if search_inference_id is not DEFAULT:
+            kwargs["search_inference_id"] = search_inference_id
         super().__init__(*args, **kwargs)
 
 
@@ -3580,7 +3950,10 @@ def __init__(
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -3683,7 +4056,10 @@ def __init__(
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -3703,6 +4079,7 @@ def __init__(
 
 class SparseVector(Field):
     """
+    :arg store:
     :arg meta: Metadata about the field.
     :arg properties:
     :arg ignore_above:
@@ -3720,6 +4097,7 @@ class SparseVector(Field):
     def __init__(
         self,
         *args: Any,
+        store: Union[bool, "DefaultType"] = DEFAULT,
         meta: Union[Mapping[str, str], "DefaultType"] = DEFAULT,
         properties: Union[Mapping[str, Field], "DefaultType"] = DEFAULT,
         ignore_above: Union[int, "DefaultType"] = DEFAULT,
@@ -3732,6 +4110,8 @@ def __init__(
         ] = DEFAULT,
         **kwargs: Any,
     ):
+        if store is not DEFAULT:
+            kwargs["store"] = store
         if meta is not DEFAULT:
             kwargs["meta"] = meta
         if properties is not DEFAULT:
@@ -3867,7 +4247,10 @@ def __init__(
         if term_vector is not DEFAULT:
             kwargs["term_vector"] = term_vector
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -3950,7 +4333,10 @@ def __init__(
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -4053,7 +4439,10 @@ def __init__(
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -4115,7 +4504,10 @@ def __init__(
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
@@ -4181,7 +4573,10 @@ def __init__(
         if doc_values is not DEFAULT:
             kwargs["doc_values"] = doc_values
         if copy_to is not DEFAULT:
-            kwargs["copy_to"] = str(copy_to)
+            if isinstance(copy_to, list):
+                kwargs["copy_to"] = [str(field) for field in copy_to]
+            else:
+                kwargs["copy_to"] = str(copy_to)
         if store is not DEFAULT:
             kwargs["store"] = store
         if meta is not DEFAULT:
diff --git a/elasticsearch/dsl/query.py b/elasticsearch/dsl/query.py
index b5808959c..de57aac44 100644
--- a/elasticsearch/dsl/query.py
+++ b/elasticsearch/dsl/query.py
@@ -795,6 +795,28 @@ def __init__(
         )
 
 
+class GeoGrid(Query):
+    """
+    Matches `geo_point` and `geo_shape` values that intersect a grid cell
+    from a GeoGrid aggregation.
+
+    :arg _field: The field to use in this query.
+    :arg _value: The query value for the field.
+    """
+
+    name = "geo_grid"
+
+    def __init__(
+        self,
+        _field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        _value: Union["types.GeoGridQuery", Dict[str, Any], "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        if _field is not DEFAULT:
+            kwargs[str(_field)] = _value
+        super().__init__(**kwargs)
+
+
 class GeoPolygon(Query):
     """
     :arg _field: The field to use in this query.
@@ -1061,6 +1083,8 @@ class Knn(Query):
     :arg filter: Filters for the kNN search query
     :arg similarity: The minimum similarity for a vector to be considered
         a match
+    :arg rescore_vector: Apply oversampling and rescoring to quantized
+        vectors *
     :arg boost: Floating point number used to decrease or increase the
         relevance scores of the query. Boost values are relative to the
         default value of 1.0. A boost value between 0 and 1.0 decreases
@@ -1086,6 +1110,9 @@ def __init__(
         k: Union[int, "DefaultType"] = DEFAULT,
         filter: Union[Query, Sequence[Query], "DefaultType"] = DEFAULT,
         similarity: Union[float, "DefaultType"] = DEFAULT,
+        rescore_vector: Union[
+            "types.RescoreVector", Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
         boost: Union[float, "DefaultType"] = DEFAULT,
         _name: Union[str, "DefaultType"] = DEFAULT,
         **kwargs: Any,
@@ -1098,6 +1125,7 @@ def __init__(
             k=k,
             filter=filter,
             similarity=similarity,
+            rescore_vector=rescore_vector,
             boost=boost,
             _name=_name,
             **kwargs,
@@ -1354,7 +1382,49 @@ def __init__(
         min_term_freq: Union[int, "DefaultType"] = DEFAULT,
         min_word_length: Union[int, "DefaultType"] = DEFAULT,
         routing: Union[str, "DefaultType"] = DEFAULT,
-        stop_words: Union[str, Sequence[str], "DefaultType"] = DEFAULT,
+        stop_words: Union[
+            Literal[
+                "_arabic_",
+                "_armenian_",
+                "_basque_",
+                "_bengali_",
+                "_brazilian_",
+                "_bulgarian_",
+                "_catalan_",
+                "_cjk_",
+                "_czech_",
+                "_danish_",
+                "_dutch_",
+                "_english_",
+                "_estonian_",
+                "_finnish_",
+                "_french_",
+                "_galician_",
+                "_german_",
+                "_greek_",
+                "_hindi_",
+                "_hungarian_",
+                "_indonesian_",
+                "_irish_",
+                "_italian_",
+                "_latvian_",
+                "_lithuanian_",
+                "_norwegian_",
+                "_persian_",
+                "_portuguese_",
+                "_romanian_",
+                "_russian_",
+                "_serbian_",
+                "_sorani_",
+                "_spanish_",
+                "_swedish_",
+                "_thai_",
+                "_turkish_",
+                "_none_",
+            ],
+            Sequence[str],
+            "DefaultType",
+        ] = DEFAULT,
         unlike: Union[
             Union[str, "types.LikeDocument"],
             Sequence[Union[str, "types.LikeDocument"]],
@@ -1964,8 +2034,9 @@ def __init__(
 class Rule(Query):
     """
     :arg organic: (required)
-    :arg ruleset_ids: (required)
     :arg match_criteria: (required)
+    :arg ruleset_ids:
+    :arg ruleset_id:
     :arg boost: Floating point number used to decrease or increase the
         relevance scores of the query. Boost values are relative to the
         default value of 1.0. A boost value between 0 and 1.0 decreases
@@ -1983,16 +2054,18 @@ def __init__(
         self,
         *,
         organic: Union[Query, "DefaultType"] = DEFAULT,
-        ruleset_ids: Union[Sequence[str], "DefaultType"] = DEFAULT,
         match_criteria: Any = DEFAULT,
+        ruleset_ids: Union[str, Sequence[str], "DefaultType"] = DEFAULT,
+        ruleset_id: Union[str, "DefaultType"] = DEFAULT,
         boost: Union[float, "DefaultType"] = DEFAULT,
         _name: Union[str, "DefaultType"] = DEFAULT,
         **kwargs: Any,
     ):
         super().__init__(
             organic=organic,
-            ruleset_ids=ruleset_ids,
             match_criteria=match_criteria,
+            ruleset_ids=ruleset_ids,
+            ruleset_id=ruleset_id,
             boost=boost,
             _name=_name,
             **kwargs,
@@ -2628,7 +2701,7 @@ def __init__(
         self,
         _field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
         _value: Union[
-            Sequence[Union[int, float, str, bool, None, Any]],
+            Sequence[Union[int, float, str, bool, None]],
             "types.TermsLookup",
             Dict[str, Any],
             "DefaultType",
diff --git a/elasticsearch/dsl/response/__init__.py b/elasticsearch/dsl/response/__init__.py
index 2ae863fff..c4879b443 100644
--- a/elasticsearch/dsl/response/__init__.py
+++ b/elasticsearch/dsl/response/__init__.py
@@ -233,10 +233,13 @@ def search_after(self) -> "SearchBase[_R]":
     "types.SimpleValueAggregate",
     "types.DerivativeAggregate",
     "types.BucketMetricValueAggregate",
+    "types.ChangePointAggregate",
     "types.StatsAggregate",
     "types.StatsBucketAggregate",
     "types.ExtendedStatsAggregate",
     "types.ExtendedStatsBucketAggregate",
+    "types.CartesianBoundsAggregate",
+    "types.CartesianCentroidAggregate",
     "types.GeoBoundsAggregate",
     "types.GeoCentroidAggregate",
     "types.HistogramAggregate",
diff --git a/elasticsearch/dsl/response/aggs.py b/elasticsearch/dsl/response/aggs.py
index 8994fa761..51360f3f6 100644
--- a/elasticsearch/dsl/response/aggs.py
+++ b/elasticsearch/dsl/response/aggs.py
@@ -63,7 +63,7 @@ def _wrap_bucket(self, data: Dict[str, Any]) -> Bucket[_R]:
         )
 
     def __iter__(self) -> Iterator["Agg"]:  # type: ignore[override]
-        return iter(self.buckets)  # type: ignore[arg-type]
+        return iter(self.buckets)
 
     def __len__(self) -> int:
         return len(self.buckets)
diff --git a/elasticsearch/dsl/search_base.py b/elasticsearch/dsl/search_base.py
index c513fc78d..cd690ddae 100644
--- a/elasticsearch/dsl/search_base.py
+++ b/elasticsearch/dsl/search_base.py
@@ -72,6 +72,9 @@ def __nonzero__(self) -> bool:
     __bool__ = __nonzero__
 
     def __call__(self, *args: Any, **kwargs: Any) -> _S:
+        """
+        Add a query.
+        """
         s = self._search._clone()
 
         # we cannot use self._proxied since we just cloned self._search and
@@ -354,18 +357,22 @@ class SearchBase(Request[_R]):
     post_filter = ProxyDescriptor[Self]("post_filter")
     _response: Response[_R]
 
-    def __init__(self, **kwargs: Any):
+    def __init__(
+        self,
+        using: AnyUsingType = "default",
+        index: Optional[Union[str, List[str]]] = None,
+        **kwargs: Any,
+    ):
         """
         Search request to elasticsearch.
 
         :arg using: `Elasticsearch` instance to use
         :arg index: limit the search to index
-        :arg doc_type: only query this type.
 
         All the parameters supplied (or omitted) at creation type can be later
         overridden by methods (`using`, `index` and `doc_type` respectively).
         """
-        super().__init__(**kwargs)
+        super().__init__(using=using, index=index, **kwargs)
 
         self.aggs = AggsProxy[_R](self)
         self._sort: List[Union[str, Dict[str, Dict[str, str]]]] = []
@@ -383,9 +390,15 @@ def __init__(self, **kwargs: Any):
         self._post_filter_proxy = QueryProxy(self, "post_filter")
 
     def filter(self, *args: Any, **kwargs: Any) -> Self:
+        """
+        Add a query in filter context.
+        """
         return self.query(Bool(filter=[Q(*args, **kwargs)]))
 
     def exclude(self, *args: Any, **kwargs: Any) -> Self:
+        """
+        Add a negative query in filter context.
+        """
         return self.query(Bool(filter=[~Q(*args, **kwargs)]))
 
     def __getitem__(self, n: Union[int, slice]) -> Self:
diff --git a/elasticsearch/dsl/types.py b/elasticsearch/dsl/types.py
index d1c39003e..9885ff7fb 100644
--- a/elasticsearch/dsl/types.py
+++ b/elasticsearch/dsl/types.py
@@ -26,34 +26,6 @@
 PipeSeparatedFlags = str
 
 
-class AggregationRange(AttrDict[Any]):
-    """
-    :arg from: Start of the range (inclusive).
-    :arg key: Custom key to return the range with.
-    :arg to: End of the range (exclusive).
-    """
-
-    from_: Union[float, None, DefaultType]
-    key: Union[str, DefaultType]
-    to: Union[float, None, DefaultType]
-
-    def __init__(
-        self,
-        *,
-        from_: Union[float, None, DefaultType] = DEFAULT,
-        key: Union[str, DefaultType] = DEFAULT,
-        to: Union[float, None, DefaultType] = DEFAULT,
-        **kwargs: Any,
-    ):
-        if from_ is not DEFAULT:
-            kwargs["from_"] = from_
-        if key is not DEFAULT:
-            kwargs["key"] = key
-        if to is not DEFAULT:
-            kwargs["to"] = to
-        super().__init__(kwargs)
-
-
 class BucketCorrelationFunction(AttrDict[Any]):
     """
     :arg count_correlation: (required) The configuration to calculate a
@@ -334,64 +306,77 @@ def __init__(
         super().__init__(kwargs)
 
 
-class DateRangeExpression(AttrDict[Any]):
-    """
-    :arg from: Start of the range (inclusive).
-    :arg key: Custom key to return the range with.
-    :arg to: End of the range (exclusive).
-    """
-
-    from_: Union[str, float, DefaultType]
-    key: Union[str, DefaultType]
-    to: Union[str, float, DefaultType]
-
-    def __init__(
-        self,
-        *,
-        from_: Union[str, float, DefaultType] = DEFAULT,
-        key: Union[str, DefaultType] = DEFAULT,
-        to: Union[str, float, DefaultType] = DEFAULT,
-        **kwargs: Any,
-    ):
-        if from_ is not DEFAULT:
-            kwargs["from_"] = from_
-        if key is not DEFAULT:
-            kwargs["key"] = key
-        if to is not DEFAULT:
-            kwargs["to"] = to
-        super().__init__(kwargs)
-
-
 class DenseVectorIndexOptions(AttrDict[Any]):
     """
-    :arg type: (required)
-    :arg m:
-    :arg ef_construction:
-    :arg confidence_interval:
-    """
-
-    type: Union[str, DefaultType]
-    m: Union[int, DefaultType]
-    ef_construction: Union[int, DefaultType]
+    :arg type: (required) The type of kNN algorithm to use.
+    :arg confidence_interval: The confidence interval to use when
+        quantizing the vectors. Can be any value between and including
+        `0.90` and `1.0` or exactly `0`. When the value is `0`, this
+        indicates that dynamic quantiles should be calculated for
+        optimized quantization. When between `0.90` and `1.0`, this value
+        restricts the values used when calculating the quantization
+        thresholds.  For example, a value of `0.95` will only use the
+        middle `95%` of the values when calculating the quantization
+        thresholds (e.g. the highest and lowest `2.5%` of values will be
+        ignored).  Defaults to `1/(dims + 1)` for `int8` quantized vectors
+        and `0` for `int4` for dynamic quantile calculation.  Only
+        applicable to `int8_hnsw`, `int4_hnsw`, `int8_flat`, and
+        `int4_flat` index types.
+    :arg ef_construction: The number of candidates to track while
+        assembling the list of nearest neighbors for each new node.  Only
+        applicable to `hnsw`, `int8_hnsw`, `bbq_hnsw`, and `int4_hnsw`
+        index types. Defaults to `100` if omitted.
+    :arg m: The number of neighbors each node will be connected to in the
+        HNSW graph.  Only applicable to `hnsw`, `int8_hnsw`, `bbq_hnsw`,
+        and `int4_hnsw` index types. Defaults to `16` if omitted.
+    """
+
+    type: Union[
+        Literal[
+            "bbq_flat",
+            "bbq_hnsw",
+            "flat",
+            "hnsw",
+            "int4_flat",
+            "int4_hnsw",
+            "int8_flat",
+            "int8_hnsw",
+        ],
+        DefaultType,
+    ]
     confidence_interval: Union[float, DefaultType]
+    ef_construction: Union[int, DefaultType]
+    m: Union[int, DefaultType]
 
     def __init__(
         self,
         *,
-        type: Union[str, DefaultType] = DEFAULT,
-        m: Union[int, DefaultType] = DEFAULT,
-        ef_construction: Union[int, DefaultType] = DEFAULT,
+        type: Union[
+            Literal[
+                "bbq_flat",
+                "bbq_hnsw",
+                "flat",
+                "hnsw",
+                "int4_flat",
+                "int4_hnsw",
+                "int8_flat",
+                "int8_hnsw",
+            ],
+            DefaultType,
+        ] = DEFAULT,
         confidence_interval: Union[float, DefaultType] = DEFAULT,
+        ef_construction: Union[int, DefaultType] = DEFAULT,
+        m: Union[int, DefaultType] = DEFAULT,
         **kwargs: Any,
     ):
         if type is not DEFAULT:
             kwargs["type"] = type
-        if m is not DEFAULT:
-            kwargs["m"] = m
-        if ef_construction is not DEFAULT:
-            kwargs["ef_construction"] = ef_construction
         if confidence_interval is not DEFAULT:
             kwargs["confidence_interval"] = confidence_interval
+        if ef_construction is not DEFAULT:
+            kwargs["ef_construction"] = ef_construction
+        if m is not DEFAULT:
+            kwargs["m"] = m
         super().__init__(kwargs)
 
 
@@ -568,6 +553,7 @@ class FieldSort(AttrDict[Any]):
             "completion",
             "nested",
             "object",
+            "passthrough",
             "version",
             "murmur3",
             "token_count",
@@ -594,6 +580,7 @@ class FieldSort(AttrDict[Any]):
             "shape",
             "histogram",
             "constant_keyword",
+            "counted_keyword",
             "aggregate_metric_double",
             "dense_vector",
             "semantic_text",
@@ -631,6 +618,7 @@ def __init__(
                 "completion",
                 "nested",
                 "object",
+                "passthrough",
                 "version",
                 "murmur3",
                 "token_count",
@@ -657,6 +645,7 @@ def __init__(
                 "shape",
                 "histogram",
                 "constant_keyword",
+                "counted_keyword",
                 "aggregate_metric_double",
                 "dense_vector",
                 "semantic_text",
@@ -880,6 +869,48 @@ def __init__(
         super().__init__(kwargs)
 
 
+class GeoGridQuery(AttrDict[Any]):
+    """
+    :arg geotile:
+    :arg geohash:
+    :arg geohex:
+    :arg boost: Floating point number used to decrease or increase the
+        relevance scores of the query. Boost values are relative to the
+        default value of 1.0. A boost value between 0 and 1.0 decreases
+        the relevance score. A value greater than 1.0 increases the
+        relevance score. Defaults to `1` if omitted.
+    :arg _name:
+    """
+
+    geotile: Union[str, DefaultType]
+    geohash: Union[str, DefaultType]
+    geohex: Union[str, DefaultType]
+    boost: Union[float, DefaultType]
+    _name: Union[str, DefaultType]
+
+    def __init__(
+        self,
+        *,
+        geotile: Union[str, DefaultType] = DEFAULT,
+        geohash: Union[str, DefaultType] = DEFAULT,
+        geohex: Union[str, DefaultType] = DEFAULT,
+        boost: Union[float, DefaultType] = DEFAULT,
+        _name: Union[str, DefaultType] = DEFAULT,
+        **kwargs: Any,
+    ):
+        if geotile is not DEFAULT:
+            kwargs["geotile"] = geotile
+        if geohash is not DEFAULT:
+            kwargs["geohash"] = geohash
+        if geohex is not DEFAULT:
+            kwargs["geohex"] = geohex
+        if boost is not DEFAULT:
+            kwargs["boost"] = boost
+        if _name is not DEFAULT:
+            kwargs["_name"] = _name
+        super().__init__(kwargs)
+
+
 class GeoHashLocation(AttrDict[Any]):
     """
     :arg geohash: (required)
@@ -1530,11 +1561,7 @@ class InnerHits(AttrDict[Any]):
         DefaultType,
     ]
     seq_no_primary_term: Union[bool, DefaultType]
-    fields: Union[
-        Union[str, InstrumentedField],
-        Sequence[Union[str, InstrumentedField]],
-        DefaultType,
-    ]
+    fields: Union[Sequence[Union[str, InstrumentedField]], DefaultType]
     sort: Union[
         Union[Union[str, InstrumentedField], "SortOptions"],
         Sequence[Union[Union[str, InstrumentedField], "SortOptions"]],
@@ -1569,11 +1596,7 @@ def __init__(
             DefaultType,
         ] = DEFAULT,
         seq_no_primary_term: Union[bool, DefaultType] = DEFAULT,
-        fields: Union[
-            Union[str, InstrumentedField],
-            Sequence[Union[str, InstrumentedField]],
-            DefaultType,
-        ] = DEFAULT,
+        fields: Union[Sequence[Union[str, InstrumentedField]], DefaultType] = DEFAULT,
         sort: Union[
             Union[Union[str, InstrumentedField], "SortOptions"],
             Sequence[Union[Union[str, InstrumentedField], "SortOptions"]],
@@ -1702,6 +1725,8 @@ class IntervalsContainer(AttrDict[Any]):
     :arg match: Matches analyzed text.
     :arg prefix: Matches terms that start with a specified set of
         characters.
+    :arg range:
+    :arg regexp:
     :arg wildcard: Matches terms using a wildcard pattern.
     """
 
@@ -1710,6 +1735,8 @@ class IntervalsContainer(AttrDict[Any]):
     fuzzy: Union["IntervalsFuzzy", Dict[str, Any], DefaultType]
     match: Union["IntervalsMatch", Dict[str, Any], DefaultType]
     prefix: Union["IntervalsPrefix", Dict[str, Any], DefaultType]
+    range: Union["IntervalsRange", Dict[str, Any], DefaultType]
+    regexp: Union["IntervalsRegexp", Dict[str, Any], DefaultType]
     wildcard: Union["IntervalsWildcard", Dict[str, Any], DefaultType]
 
     def __init__(
@@ -1720,6 +1747,8 @@ def __init__(
         fuzzy: Union["IntervalsFuzzy", Dict[str, Any], DefaultType] = DEFAULT,
         match: Union["IntervalsMatch", Dict[str, Any], DefaultType] = DEFAULT,
         prefix: Union["IntervalsPrefix", Dict[str, Any], DefaultType] = DEFAULT,
+        range: Union["IntervalsRange", Dict[str, Any], DefaultType] = DEFAULT,
+        regexp: Union["IntervalsRegexp", Dict[str, Any], DefaultType] = DEFAULT,
         wildcard: Union["IntervalsWildcard", Dict[str, Any], DefaultType] = DEFAULT,
         **kwargs: Any,
     ):
@@ -1733,6 +1762,10 @@ def __init__(
             kwargs["match"] = match
         if prefix is not DEFAULT:
             kwargs["prefix"] = prefix
+        if range is not DEFAULT:
+            kwargs["range"] = range
+        if regexp is not DEFAULT:
+            kwargs["regexp"] = regexp
         if wildcard is not DEFAULT:
             kwargs["wildcard"] = wildcard
         super().__init__(kwargs)
@@ -1953,6 +1986,8 @@ class IntervalsQuery(AttrDict[Any]):
     :arg match: Matches analyzed text.
     :arg prefix: Matches terms that start with a specified set of
         characters.
+    :arg range:
+    :arg regexp:
     :arg wildcard: Matches terms using a wildcard pattern.
     :arg boost: Floating point number used to decrease or increase the
         relevance scores of the query. Boost values are relative to the
@@ -1967,6 +2002,8 @@ class IntervalsQuery(AttrDict[Any]):
     fuzzy: Union["IntervalsFuzzy", Dict[str, Any], DefaultType]
     match: Union["IntervalsMatch", Dict[str, Any], DefaultType]
     prefix: Union["IntervalsPrefix", Dict[str, Any], DefaultType]
+    range: Union["IntervalsRange", Dict[str, Any], DefaultType]
+    regexp: Union["IntervalsRegexp", Dict[str, Any], DefaultType]
     wildcard: Union["IntervalsWildcard", Dict[str, Any], DefaultType]
     boost: Union[float, DefaultType]
     _name: Union[str, DefaultType]
@@ -1979,6 +2016,8 @@ def __init__(
         fuzzy: Union["IntervalsFuzzy", Dict[str, Any], DefaultType] = DEFAULT,
         match: Union["IntervalsMatch", Dict[str, Any], DefaultType] = DEFAULT,
         prefix: Union["IntervalsPrefix", Dict[str, Any], DefaultType] = DEFAULT,
+        range: Union["IntervalsRange", Dict[str, Any], DefaultType] = DEFAULT,
+        regexp: Union["IntervalsRegexp", Dict[str, Any], DefaultType] = DEFAULT,
         wildcard: Union["IntervalsWildcard", Dict[str, Any], DefaultType] = DEFAULT,
         boost: Union[float, DefaultType] = DEFAULT,
         _name: Union[str, DefaultType] = DEFAULT,
@@ -1994,6 +2033,10 @@ def __init__(
             kwargs["match"] = match
         if prefix is not DEFAULT:
             kwargs["prefix"] = prefix
+        if range is not DEFAULT:
+            kwargs["range"] = range
+        if regexp is not DEFAULT:
+            kwargs["regexp"] = regexp
         if wildcard is not DEFAULT:
             kwargs["wildcard"] = wildcard
         if boost is not DEFAULT:
@@ -2003,6 +2046,83 @@ def __init__(
         super().__init__(kwargs)
 
 
+class IntervalsRange(AttrDict[Any]):
+    """
+    :arg analyzer: Analyzer used to analyze the `prefix`.
+    :arg gte: Lower term, either gte or gt must be provided.
+    :arg gt: Lower term, either gte or gt must be provided.
+    :arg lte: Upper term, either lte or lt must be provided.
+    :arg lt: Upper term, either lte or lt must be provided.
+    :arg use_field: If specified, match intervals from this field rather
+        than the top-level field. The `prefix` is normalized using the
+        search analyzer from this field, unless `analyzer` is specified
+        separately.
+    """
+
+    analyzer: Union[str, DefaultType]
+    gte: Union[str, DefaultType]
+    gt: Union[str, DefaultType]
+    lte: Union[str, DefaultType]
+    lt: Union[str, DefaultType]
+    use_field: Union[str, InstrumentedField, DefaultType]
+
+    def __init__(
+        self,
+        *,
+        analyzer: Union[str, DefaultType] = DEFAULT,
+        gte: Union[str, DefaultType] = DEFAULT,
+        gt: Union[str, DefaultType] = DEFAULT,
+        lte: Union[str, DefaultType] = DEFAULT,
+        lt: Union[str, DefaultType] = DEFAULT,
+        use_field: Union[str, InstrumentedField, DefaultType] = DEFAULT,
+        **kwargs: Any,
+    ):
+        if analyzer is not DEFAULT:
+            kwargs["analyzer"] = analyzer
+        if gte is not DEFAULT:
+            kwargs["gte"] = gte
+        if gt is not DEFAULT:
+            kwargs["gt"] = gt
+        if lte is not DEFAULT:
+            kwargs["lte"] = lte
+        if lt is not DEFAULT:
+            kwargs["lt"] = lt
+        if use_field is not DEFAULT:
+            kwargs["use_field"] = str(use_field)
+        super().__init__(kwargs)
+
+
+class IntervalsRegexp(AttrDict[Any]):
+    """
+    :arg pattern: (required) Regex pattern.
+    :arg analyzer: Analyzer used to analyze the `prefix`.
+    :arg use_field: If specified, match intervals from this field rather
+        than the top-level field. The `prefix` is normalized using the
+        search analyzer from this field, unless `analyzer` is specified
+        separately.
+    """
+
+    pattern: Union[str, DefaultType]
+    analyzer: Union[str, DefaultType]
+    use_field: Union[str, InstrumentedField, DefaultType]
+
+    def __init__(
+        self,
+        *,
+        pattern: Union[str, DefaultType] = DEFAULT,
+        analyzer: Union[str, DefaultType] = DEFAULT,
+        use_field: Union[str, InstrumentedField, DefaultType] = DEFAULT,
+        **kwargs: Any,
+    ):
+        if pattern is not DEFAULT:
+            kwargs["pattern"] = pattern
+        if analyzer is not DEFAULT:
+            kwargs["analyzer"] = analyzer
+        if use_field is not DEFAULT:
+            kwargs["use_field"] = str(use_field)
+        super().__init__(kwargs)
+
+
 class IntervalsWildcard(AttrDict[Any]):
     """
     :arg pattern: (required) Wildcard pattern used to find matching terms.
@@ -2553,6 +2673,31 @@ def __init__(
         super().__init__(kwargs)
 
 
+class PValueHeuristic(AttrDict[Any]):
+    """
+    :arg background_is_superset:
+    :arg normalize_above: Should the results be normalized when above the
+        given value. Allows for consistent significance results at various
+        scales. Note: `0` is a special value which means no normalization
+    """
+
+    background_is_superset: Union[bool, DefaultType]
+    normalize_above: Union[int, DefaultType]
+
+    def __init__(
+        self,
+        *,
+        background_is_superset: Union[bool, DefaultType] = DEFAULT,
+        normalize_above: Union[int, DefaultType] = DEFAULT,
+        **kwargs: Any,
+    ):
+        if background_is_superset is not DEFAULT:
+            kwargs["background_is_superset"] = background_is_superset
+        if normalize_above is not DEFAULT:
+            kwargs["normalize_above"] = normalize_above
+        super().__init__(kwargs)
+
+
 class PercentageScoreHeuristic(AttrDict[Any]):
     pass
 
@@ -2560,7 +2705,7 @@ class PercentageScoreHeuristic(AttrDict[Any]):
 class PinnedDoc(AttrDict[Any]):
     """
     :arg _id: (required) The unique document ID.
-    :arg _index: (required) The index that contains the document.
+    :arg _index: The index that contains the document.
     """
 
     _id: Union[str, DefaultType]
@@ -2785,6 +2930,22 @@ def __init__(
         super().__init__(kwargs)
 
 
+class RescoreVector(AttrDict[Any]):
+    """
+    :arg oversample: (required) Applies the specified oversample factor to
+        k on the approximate kNN search
+    """
+
+    oversample: Union[float, DefaultType]
+
+    def __init__(
+        self, *, oversample: Union[float, DefaultType] = DEFAULT, **kwargs: Any
+    ):
+        if oversample is not DEFAULT:
+            kwargs["oversample"] = oversample
+        super().__init__(kwargs)
+
+
 class ScoreSort(AttrDict[Any]):
     """
     :arg order:
@@ -2815,7 +2976,7 @@ class Script(AttrDict[Any]):
     :arg options:
     """
 
-    source: Union[str, DefaultType]
+    source: Union[str, Dict[str, Any], DefaultType]
     id: Union[str, DefaultType]
     params: Union[Mapping[str, Any], DefaultType]
     lang: Union[Literal["painless", "expression", "mustache", "java"], DefaultType]
@@ -2824,7 +2985,7 @@ class Script(AttrDict[Any]):
     def __init__(
         self,
         *,
-        source: Union[str, DefaultType] = DEFAULT,
+        source: Union[str, Dict[str, Any], DefaultType] = DEFAULT,
         id: Union[str, DefaultType] = DEFAULT,
         params: Union[Mapping[str, Any], DefaultType] = DEFAULT,
         lang: Union[
@@ -3423,14 +3584,14 @@ class SpanTermQuery(AttrDict[Any]):
     :arg _name:
     """
 
-    value: Union[str, DefaultType]
+    value: Union[int, float, str, bool, None, DefaultType]
     boost: Union[float, DefaultType]
     _name: Union[str, DefaultType]
 
     def __init__(
         self,
         *,
-        value: Union[str, DefaultType] = DEFAULT,
+        value: Union[int, float, str, bool, None, DefaultType] = DEFAULT,
         boost: Union[float, DefaultType] = DEFAULT,
         _name: Union[str, DefaultType] = DEFAULT,
         **kwargs: Any,
@@ -3548,7 +3709,7 @@ class TermQuery(AttrDict[Any]):
     :arg _name:
     """
 
-    value: Union[int, float, str, bool, None, Any, DefaultType]
+    value: Union[int, float, str, bool, None, DefaultType]
     case_insensitive: Union[bool, DefaultType]
     boost: Union[float, DefaultType]
     _name: Union[str, DefaultType]
@@ -3556,7 +3717,7 @@ class TermQuery(AttrDict[Any]):
     def __init__(
         self,
         *,
-        value: Union[int, float, str, bool, None, Any, DefaultType] = DEFAULT,
+        value: Union[int, float, str, bool, None, DefaultType] = DEFAULT,
         case_insensitive: Union[bool, DefaultType] = DEFAULT,
         boost: Union[float, DefaultType] = DEFAULT,
         _name: Union[str, DefaultType] = DEFAULT,
@@ -3647,7 +3808,7 @@ class TermsSetQuery(AttrDict[Any]):
     :arg _name:
     """
 
-    terms: Union[Sequence[str], DefaultType]
+    terms: Union[Sequence[Union[int, float, str, bool, None]], DefaultType]
     minimum_should_match: Union[int, str, DefaultType]
     minimum_should_match_field: Union[str, InstrumentedField, DefaultType]
     minimum_should_match_script: Union["Script", Dict[str, Any], DefaultType]
@@ -3657,7 +3818,9 @@ class TermsSetQuery(AttrDict[Any]):
     def __init__(
         self,
         *,
-        terms: Union[Sequence[str], DefaultType] = DEFAULT,
+        terms: Union[
+            Sequence[Union[int, float, str, bool, None]], DefaultType
+        ] = DEFAULT,
         minimum_should_match: Union[int, str, DefaultType] = DEFAULT,
         minimum_should_match_field: Union[
             str, InstrumentedField, DefaultType
@@ -3715,24 +3878,25 @@ def __init__(
 
 class TextEmbedding(AttrDict[Any]):
     """
-    :arg model_id: (required)
     :arg model_text: (required)
+    :arg model_id: Model ID is required for all dense_vector fields but
+        may be inferred for semantic_text fields
     """
 
-    model_id: Union[str, DefaultType]
     model_text: Union[str, DefaultType]
+    model_id: Union[str, DefaultType]
 
     def __init__(
         self,
         *,
-        model_id: Union[str, DefaultType] = DEFAULT,
         model_text: Union[str, DefaultType] = DEFAULT,
+        model_id: Union[str, DefaultType] = DEFAULT,
         **kwargs: Any,
     ):
-        if model_id is not DEFAULT:
-            kwargs["model_id"] = model_id
         if model_text is not DEFAULT:
             kwargs["model_text"] = model_text
+        if model_id is not DEFAULT:
+            kwargs["model_id"] = model_id
         super().__init__(kwargs)
 
 
@@ -4252,7 +4416,7 @@ class ArrayPercentilesItem(AttrDict[Any]):
     :arg value_as_string:
     """
 
-    key: str
+    key: float
     value: Union[float, None]
     value_as_string: str
 
@@ -4363,6 +4527,82 @@ class CardinalityAggregate(AttrDict[Any]):
     meta: Mapping[str, Any]
 
 
+class CartesianBoundsAggregate(AttrDict[Any]):
+    """
+    :arg bounds:
+    :arg meta:
+    """
+
+    bounds: "TopLeftBottomRightGeoBounds"
+    meta: Mapping[str, Any]
+
+
+class CartesianCentroidAggregate(AttrDict[Any]):
+    """
+    :arg count: (required)
+    :arg location:
+    :arg meta:
+    """
+
+    count: int
+    location: "CartesianPoint"
+    meta: Mapping[str, Any]
+
+
+class CartesianPoint(AttrDict[Any]):
+    """
+    :arg x: (required)
+    :arg y: (required)
+    """
+
+    x: float
+    y: float
+
+
+class ChangePointAggregate(AttrDict[Any]):
+    """
+    :arg type: (required)
+    :arg bucket:
+    :arg meta:
+    """
+
+    type: "ChangeType"
+    bucket: "ChangePointBucket"
+    meta: Mapping[str, Any]
+
+
+class ChangePointBucket(AttrDict[Any]):
+    """
+    :arg key: (required)
+    :arg doc_count: (required)
+    """
+
+    key: Union[int, float, str, bool, None]
+    doc_count: int
+
+
+class ChangeType(AttrDict[Any]):
+    """
+    :arg dip:
+    :arg distribution_change:
+    :arg indeterminable:
+    :arg non_stationary:
+    :arg spike:
+    :arg stationary:
+    :arg step_change:
+    :arg trend_change:
+    """
+
+    dip: "Dip"
+    distribution_change: "DistributionChange"
+    indeterminable: "Indeterminable"
+    non_stationary: "NonStationary"
+    spike: "Spike"
+    stationary: "Stationary"
+    step_change: "StepChange"
+    trend_change: "TrendChange"
+
+
 class ChildrenAggregate(AttrDict[Any]):
     """
     :arg doc_count: (required)
@@ -4479,7 +4719,7 @@ class CompositeAggregate(AttrDict[Any]):
     :arg meta:
     """
 
-    after_key: Mapping[str, Union[int, float, str, bool, None, Any]]
+    after_key: Mapping[str, Union[int, float, str, bool, None]]
     buckets: Sequence["CompositeBucket"]
     meta: Mapping[str, Any]
 
@@ -4494,7 +4734,7 @@ class CompositeBucket(AttrDict[Any]):
     :arg doc_count: (required)
     """
 
-    key: Mapping[str, Union[int, float, str, bool, None, Any]]
+    key: Mapping[str, Union[int, float, str, bool, None]]
     doc_count: int
 
 
@@ -4640,6 +4880,26 @@ class DfsStatisticsProfile(AttrDict[Any]):
     children: Sequence["DfsStatisticsProfile"]
 
 
+class Dip(AttrDict[Any]):
+    """
+    :arg p_value: (required)
+    :arg change_point: (required)
+    """
+
+    p_value: float
+    change_point: int
+
+
+class DistributionChange(AttrDict[Any]):
+    """
+    :arg p_value: (required)
+    :arg change_point: (required)
+    """
+
+    p_value: float
+    change_point: int
+
+
 class DoubleTermsAggregate(AttrDict[Any]):
     """
     Result of a `terms` aggregation when the field is some kind of decimal
@@ -4691,7 +4951,7 @@ class ErrorCause(AttrDict[Any]):
     """
 
     type: str
-    reason: str
+    reason: Union[str, None]
     stack_trace: str
     caused_by: "ErrorCause"
     root_cause: Sequence["ErrorCause"]
@@ -4907,9 +5167,11 @@ def buckets_as_dict(self) -> Mapping[str, "FiltersBucket"]:
 class FiltersBucket(AttrDict[Any]):
     """
     :arg doc_count: (required)
+    :arg key:
     """
 
     doc_count: int
+    key: str
 
 
 class FrequentItemSetsAggregate(AttrDict[Any]):
@@ -5096,7 +5358,9 @@ class HdrPercentileRanksAggregate(AttrDict[Any]):
     :arg meta:
     """
 
-    values: Union[Mapping[str, Union[str, int, None]], Sequence["ArrayPercentilesItem"]]
+    values: Union[
+        Mapping[str, Union[str, float, None]], Sequence["ArrayPercentilesItem"]
+    ]
     meta: Mapping[str, Any]
 
 
@@ -5106,7 +5370,9 @@ class HdrPercentilesAggregate(AttrDict[Any]):
     :arg meta:
     """
 
-    values: Union[Mapping[str, Union[str, int, None]], Sequence["ArrayPercentilesItem"]]
+    values: Union[
+        Mapping[str, Union[str, float, None]], Sequence["ArrayPercentilesItem"]
+    ]
     meta: Mapping[str, Any]
 
 
@@ -5170,9 +5436,7 @@ class Hit(AttrDict[Any]):
     matched_queries: Union[Sequence[str], Mapping[str, float]]
     nested: "NestedIdentity"
     ignored: Sequence[str]
-    ignored_field_values: Mapping[
-        str, Sequence[Union[int, float, str, bool, None, Any]]
-    ]
+    ignored_field_values: Mapping[str, Sequence[Any]]
     shard: str
     node: str
     routing: str
@@ -5181,7 +5445,7 @@ class Hit(AttrDict[Any]):
     seq_no: int
     primary_term: int
     version: int
-    sort: Sequence[Union[int, float, str, bool, None, Any]]
+    sort: Sequence[Union[int, float, str, bool, None]]
 
 
 class HitsMetadata(AttrDict[Any]):
@@ -5197,6 +5461,14 @@ class HitsMetadata(AttrDict[Any]):
     max_score: Union[float, None]
 
 
+class Indeterminable(AttrDict[Any]):
+    """
+    :arg reason: (required)
+    """
+
+    reason: str
+
+
 class InferenceAggregate(AttrDict[Any]):
     """
     :arg value:
@@ -5206,7 +5478,7 @@ class InferenceAggregate(AttrDict[Any]):
     :arg meta:
     """
 
-    value: Union[int, float, str, bool, None, Any]
+    value: Union[int, float, str, bool, None]
     feature_importance: Sequence["InferenceFeatureImportance"]
     top_classes: Sequence["InferenceTopClassEntry"]
     warning: str
@@ -5242,7 +5514,7 @@ class InferenceTopClassEntry(AttrDict[Any]):
     :arg class_score: (required)
     """
 
-    class_name: Union[int, float, str, bool, None, Any]
+    class_name: Union[int, float, str, bool, None]
     class_probability: float
     class_score: float
 
@@ -5571,7 +5843,7 @@ class MultiTermsBucket(AttrDict[Any]):
     :arg doc_count_error_upper_bound:
     """
 
-    key: Sequence[Union[int, float, str, bool, None, Any]]
+    key: Sequence[Union[int, float, str, bool, None]]
     doc_count: int
     key_as_string: str
     doc_count_error_upper_bound: int
@@ -5599,6 +5871,18 @@ class NestedIdentity(AttrDict[Any]):
     _nested: "NestedIdentity"
 
 
+class NonStationary(AttrDict[Any]):
+    """
+    :arg p_value: (required)
+    :arg r_value: (required)
+    :arg trend: (required)
+    """
+
+    p_value: float
+    r_value: float
+    trend: str
+
+
 class ParentAggregate(AttrDict[Any]):
     """
     :arg doc_count: (required)
@@ -5615,7 +5899,9 @@ class PercentilesBucketAggregate(AttrDict[Any]):
     :arg meta:
     """
 
-    values: Union[Mapping[str, Union[str, int, None]], Sequence["ArrayPercentilesItem"]]
+    values: Union[
+        Mapping[str, Union[str, float, None]], Sequence["ArrayPercentilesItem"]
+    ]
     meta: Mapping[str, Any]
 
 
@@ -5816,17 +6102,19 @@ class SearchProfile(AttrDict[Any]):
 class ShardFailure(AttrDict[Any]):
     """
     :arg reason: (required)
-    :arg shard: (required)
     :arg index:
     :arg node:
+    :arg shard:
     :arg status:
+    :arg primary:
     """
 
     reason: "ErrorCause"
-    shard: int
     index: str
     node: str
+    shard: int
     status: str
+    primary: bool
 
 
 class ShardProfile(AttrDict[Any]):
@@ -5952,6 +6240,16 @@ class SimpleValueAggregate(AttrDict[Any]):
     meta: Mapping[str, Any]
 
 
+class Spike(AttrDict[Any]):
+    """
+    :arg p_value: (required)
+    :arg change_point: (required)
+    """
+
+    p_value: float
+    change_point: int
+
+
 class StandardDeviationBounds(AttrDict[Any]):
     """
     :arg upper: (required)
@@ -5988,6 +6286,10 @@ class StandardDeviationBoundsAsString(AttrDict[Any]):
     lower_sampling: str
 
 
+class Stationary(AttrDict[Any]):
+    pass
+
+
 class StatsAggregate(AttrDict[Any]):
     """
     Statistics aggregation result. `min`, `max` and `avg` are missing if
@@ -6043,6 +6345,16 @@ class StatsBucketAggregate(AttrDict[Any]):
     meta: Mapping[str, Any]
 
 
+class StepChange(AttrDict[Any]):
+    """
+    :arg p_value: (required)
+    :arg change_point: (required)
+    """
+
+    p_value: float
+    change_point: int
+
+
 class StringRareTermsAggregate(AttrDict[Any]):
     """
     Result of the `rare_terms` aggregation when the field is a string.
@@ -6122,7 +6434,7 @@ class StringTermsBucket(AttrDict[Any]):
     :arg doc_count_error_upper_bound:
     """
 
-    key: Union[int, float, str, bool, None, Any]
+    key: Union[int, float, str, bool, None]
     doc_count: int
     doc_count_error_upper_bound: int
 
@@ -6150,7 +6462,9 @@ class TDigestPercentileRanksAggregate(AttrDict[Any]):
     :arg meta:
     """
 
-    values: Union[Mapping[str, Union[str, int, None]], Sequence["ArrayPercentilesItem"]]
+    values: Union[
+        Mapping[str, Union[str, float, None]], Sequence["ArrayPercentilesItem"]
+    ]
     meta: Mapping[str, Any]
 
 
@@ -6160,7 +6474,9 @@ class TDigestPercentilesAggregate(AttrDict[Any]):
     :arg meta:
     """
 
-    values: Union[Mapping[str, Union[str, int, None]], Sequence["ArrayPercentilesItem"]]
+    values: Union[
+        Mapping[str, Union[str, float, None]], Sequence["ArrayPercentilesItem"]
+    ]
     meta: Mapping[str, Any]
 
 
@@ -6226,7 +6542,7 @@ class TimeSeriesBucket(AttrDict[Any]):
     :arg doc_count: (required)
     """
 
-    key: Mapping[str, Union[int, float, str, bool, None, Any]]
+    key: Mapping[str, Union[int, float, str, bool, None]]
     doc_count: int
 
 
@@ -6246,8 +6562,8 @@ class TopMetrics(AttrDict[Any]):
     :arg metrics: (required)
     """
 
-    sort: Sequence[Union[Union[int, float, str, bool, None, Any], None]]
-    metrics: Mapping[str, Union[Union[int, float, str, bool, None, Any], None]]
+    sort: Sequence[Union[Union[int, float, str, bool, None], None]]
+    metrics: Mapping[str, Union[Union[int, float, str, bool, None], None]]
 
 
 class TopMetricsAggregate(AttrDict[Any]):
@@ -6270,6 +6586,18 @@ class TotalHits(AttrDict[Any]):
     value: int
 
 
+class TrendChange(AttrDict[Any]):
+    """
+    :arg p_value: (required)
+    :arg r_value: (required)
+    :arg change_point: (required)
+    """
+
+    p_value: float
+    r_value: float
+    change_point: int
+
+
 class UnmappedRareTermsAggregate(AttrDict[Any]):
     """
     Result of a `rare_terms` aggregation when the field is unmapped.
diff --git a/elasticsearch/dsl/utils.py b/elasticsearch/dsl/utils.py
index b52ec63a0..cce3c052c 100644
--- a/elasticsearch/dsl/utils.py
+++ b/elasticsearch/dsl/utils.py
@@ -333,7 +333,7 @@ def __init__(self, _expand__to_dot: Optional[bool] = None, **params: Any) -> Non
             _expand__to_dot = EXPAND__TO_DOT
         self._params: Dict[str, Any] = {}
         for pname, pvalue in params.items():
-            if pvalue == DEFAULT:
+            if pvalue is DEFAULT:
                 continue
             # expand "__" to dots
             if "__" in pname and _expand__to_dot:
@@ -603,7 +603,7 @@ def to_dict(self, skip_empty: bool = True) -> Dict[str, Any]:
             # if this is a mapped field,
             f = self.__get_field(k)
             if f and f._coerce:
-                v = f.serialize(v)
+                v = f.serialize(v, skip_empty=skip_empty)
 
             # if someone assigned AttrList, unwrap it
             if isinstance(v, AttrList):
diff --git a/elasticsearch/dsl/wrappers.py b/elasticsearch/dsl/wrappers.py
index ecd2e1363..52e7af257 100644
--- a/elasticsearch/dsl/wrappers.py
+++ b/elasticsearch/dsl/wrappers.py
@@ -18,6 +18,7 @@
 import operator
 from typing import (
     TYPE_CHECKING,
+    Any,
     Callable,
     ClassVar,
     Dict,
@@ -117,3 +118,27 @@ def lower(self) -> Union[Tuple[RangeValT, bool], Tuple[None, Literal[False]]]:
         if "gte" in self._d_:
             return self._d_["gte"], True
         return None, False
+
+
+class AggregationRange(AttrDict[Any]):
+    """
+    :arg from: Start of the range (inclusive).
+    :arg key: Custom key to return the range with.
+    :arg to: End of the range (exclusive).
+    """
+
+    def __init__(
+        self,
+        *,
+        from_: Any = None,
+        key: Optional[str] = None,
+        to: Any = None,
+        **kwargs: Any,
+    ):
+        if from_ is not None:
+            kwargs["from_"] = from_
+        if key is not None:
+            kwargs["key"] = key
+        if to is not None:
+            kwargs["to"] = to
+        super().__init__(kwargs)
diff --git a/elasticsearch/esql/__init__.py b/elasticsearch/esql/__init__.py
new file mode 100644
index 000000000..4a843ad59
--- /dev/null
+++ b/elasticsearch/esql/__init__.py
@@ -0,0 +1,19 @@
+#  Licensed to Elasticsearch B.V. under one or more contributor
+#  license agreements. See the NOTICE file distributed with
+#  this work for additional information regarding copyright
+#  ownership. Elasticsearch B.V. licenses this file to you under
+#  the Apache License, Version 2.0 (the "License"); you may
+#  not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+# 	http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing,
+#  software distributed under the License is distributed on an
+#  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+#  KIND, either express or implied.  See the License for the
+#  specific language governing permissions and limitations
+#  under the License.
+
+from ..dsl import E  # noqa: F401
+from .esql import ESQL, ESQLBase, and_, not_, or_  # noqa: F401
diff --git a/elasticsearch/esql/esql.py b/elasticsearch/esql/esql.py
new file mode 100644
index 000000000..367ec971d
--- /dev/null
+++ b/elasticsearch/esql/esql.py
@@ -0,0 +1,1156 @@
+#  Licensed to Elasticsearch B.V. under one or more contributor
+#  license agreements. See the NOTICE file distributed with
+#  this work for additional information regarding copyright
+#  ownership. Elasticsearch B.V. licenses this file to you under
+#  the Apache License, Version 2.0 (the "License"); you may
+#  not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+# 	http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing,
+#  software distributed under the License is distributed on an
+#  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+#  KIND, either express or implied.  See the License for the
+#  specific language governing permissions and limitations
+#  under the License.
+
+import json
+import re
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Optional, Tuple, Type, Union
+
+from ..dsl.document_base import DocumentBase, InstrumentedExpression, InstrumentedField
+
+FieldType = Union[InstrumentedField, str]
+IndexType = Union[Type[DocumentBase], str]
+ExpressionType = Any
+
+
+class ESQL(ABC):
+    """The static methods of the ``ESQL`` class provide access to the ES|QL source
+    commands, used to create ES|QL queries.
+
+    These methods return an instance of class ``ESQLBase``, which provides access to
+    the ES|QL processing commands.
+    """
+
+    @staticmethod
+    def from_(*indices: IndexType) -> "From":
+        """The ``FROM`` source command returns a table with data from a data stream, index, or alias.
+
+        :param indices: A list of indices, data streams or aliases. Supports wildcards and date math.
+
+        Examples::
+
+            query1 = ESQL.from_("employees")
+            query2 = ESQL.from_("<logs-{now/d}>")
+            query3 = ESQL.from_("employees-00001", "other-employees-*")
+            query4 = ESQL.from_("cluster_one:employees-00001", "cluster_two:other-employees-*")
+            query5 = ESQL.from_("employees").metadata("_id")
+        """
+        return From(*indices)
+
+    @staticmethod
+    def row(**params: ExpressionType) -> "Row":
+        """The ``ROW`` source command produces a row with one or more columns with values that you specify.
+        This can be useful for testing.
+
+        :param params: the column values to produce, given as keyword arguments.
+
+        Examples::
+
+            query1 = ESQL.row(a=1, b="two", c=None)
+            query2 = ESQL.row(a=[1, 2])
+            query3 = ESQL.row(a=functions.round(1.23, 0))
+        """
+        return Row(**params)
+
+    @staticmethod
+    def show(item: str) -> "Show":
+        """The ``SHOW`` source command returns information about the deployment and its capabilities.
+
+        :param item: Can only be ``INFO``.
+
+        Examples::
+
+            query = ESQL.show("INFO")
+        """
+        return Show(item)
+
+    @staticmethod
+    def branch() -> "Branch":
+        """This method can only be used inside a ``FORK`` command to create each branch.
+
+        Examples::
+
+            query = ESQL.from_("employees").fork(
+                ESQL.branch().where("emp_no == 10001"),
+                ESQL.branch().where("emp_no == 10002"),
+            )
+        """
+        return Branch()
+
+
+class ESQLBase(ABC):
+    """The methods of the ``ESQLBase`` class provide access to the ES|QL processing
+    commands, used to build ES|QL queries.
+    """
+
+    def __init__(self, parent: Optional["ESQLBase"] = None):
+        self._parent = parent
+
+    def __repr__(self) -> str:
+        return self.render()
+
+    def render(self) -> str:
+        return (
+            self._parent.render() + "\n| " if self._parent else ""
+        ) + self._render_internal()
+
+    @abstractmethod
+    def _render_internal(self) -> str:
+        pass
+
+    @staticmethod
+    def _format_index(index: IndexType) -> str:
+        return index._index._name if hasattr(index, "_index") else str(index)
+
+    @staticmethod
+    def _format_id(id: FieldType, allow_patterns: bool = False) -> str:
+        s = str(id)  # in case it is an InstrumentedField
+        if allow_patterns and "*" in s:
+            return s  # patterns cannot be escaped
+        if re.fullmatch(r"[a-zA-Z_@][a-zA-Z0-9_\.]*", s):
+            return s
+        # this identifier needs to be escaped
+        s = s.replace("`", "``")
+        return f"`{s}`"
+
+    @staticmethod
+    def _format_expr(expr: ExpressionType) -> str:
+        return (
+            json.dumps(expr)
+            if not isinstance(expr, (str, InstrumentedExpression))
+            else str(expr)
+        )
+
+    def _is_forked(self) -> bool:
+        if self.__class__.__name__ == "Fork":
+            return True
+        if self._parent:
+            return self._parent._is_forked()
+        return False
+
+    def change_point(self, value: FieldType) -> "ChangePoint":
+        """`CHANGE_POINT` detects spikes, dips, and change points in a metric.
+
+        :param value: The column with the metric in which you want to detect a change point.
+
+        Examples::
+
+            query = (
+                ESQL.row(key=list(range(1, 26)))
+                .mv_expand("key")
+                .eval(value=functions.case("key<13", 0, 42))
+                .change_point("value")
+                .on("key")
+                .where("type IS NOT NULL")
+            )
+        """
+        return ChangePoint(self, value)
+
+    def completion(
+        self, *prompt: ExpressionType, **named_prompt: ExpressionType
+    ) -> "Completion":
+        """The `COMPLETION` command allows you to send prompts and context to a Large
+        Language Model (LLM) directly within your ES|QL queries, to perform text
+        generation tasks.
+
+        :param prompt: The input text or expression used to prompt the LLM. This can
+                       be a string literal or a reference to a column containing text.
+        :param named_prompt: The input text or expresion, given as a keyword argument.
+                             The argument name is used for the column name. If not
+                             specified, the results will be stored in a column named
+                             `completion`. If the specified column already exists, it
+                             will be overwritten with the new results.
+
+        Examples::
+
+            query1 = (
+                ESQL.row(question="What is Elasticsearch?")
+                .completion("question").with_("test_completion_model")
+                .keep("question", "completion")
+            )
+            query2 = (
+                ESQL.row(question="What is Elasticsearch?")
+                .completion(answer="question").with_("test_completion_model")
+                .keep("question", "answer")
+            )
+            query3 = (
+                ESQL.from_("movies")
+                .sort("rating DESC")
+                .limit(10)
+                .eval(prompt=\"\"\"CONCAT(
+                    "Summarize this movie using the following information: \\n",
+                    "Title: ", title, "\\n",
+                    "Synopsis: ", synopsis, "\\n",
+                    "Actors: ", MV_CONCAT(actors, ", "), "\\n",
+                )\"\"\")
+                .completion(summary="prompt").with_("test_completion_model")
+                .keep("title", "summary", "rating")
+            )
+        """
+        return Completion(self, *prompt, **named_prompt)
+
+    def dissect(self, input: FieldType, pattern: str) -> "Dissect":
+        """``DISSECT`` enables you to extract structured data out of a string.
+
+        :param input: The column that contains the string you want to structure. If
+                      the column has multiple values, ``DISSECT`` will process each value.
+        :param pattern: A dissect pattern. If a field name conflicts with an existing
+                        column, the existing column is dropped. If a field name is used
+                        more than once, only the rightmost duplicate creates a column.
+
+        Examples::
+
+            query = (
+                ESQL.row(a="2023-01-23T12:15:00.000Z - some text - 127.0.0.1")
+                .dissect("a", "%{date} - %{msg} - %{ip}")
+                .keep("date", "msg", "ip")
+                .eval(date="TO_DATETIME(date)")
+            )
+        """
+        return Dissect(self, input, pattern)
+
+    def drop(self, *columns: FieldType) -> "Drop":
+        """The ``DROP`` processing command removes one or more columns.
+
+        :param columns: The columns to drop, given as positional arguments. Supports wildcards.
+
+        Examples::
+
+            query1 = ESQL.from_("employees").drop("height")
+            query2 = ESQL.from_("employees").drop("height*")
+        """
+        return Drop(self, *columns)
+
+    def enrich(self, policy: str) -> "Enrich":
+        """``ENRICH`` enables you to add data from existing indices as new columns using an
+        enrich policy.
+
+        :param policy: The name of the enrich policy. You need to create and execute the
+                       enrich policy first.
+
+        Examples::
+
+            query1 = (
+                ESQL.row(a="1")
+                .enrich("languages_policy").on("a").with_("language_name")
+            )
+            query2 = (
+                ESQL.row(a="1")
+                .enrich("languages_policy").on("a").with_(name="language_name")
+            )
+        """
+        return Enrich(self, policy)
+
+    def eval(self, *columns: ExpressionType, **named_columns: ExpressionType) -> "Eval":
+        """The ``EVAL`` processing command enables you to append new columns with calculated values.
+
+        :param columns: The values for the columns, given as positional arguments. Can be literals,
+                        expressions, or functions. Can use columns defined left of this one.
+        :param named_columns: The values for the new columns, given as keyword arguments. The name
+                              of the arguments is used as column name. If a column with the same
+                              name already exists, the existing column is dropped. If a column name
+                              is used more than once, only the rightmost duplicate creates a column.
+
+        Examples::
+
+            query1 = (
+                ESQL.from_("employees")
+                .sort("emp_no")
+                .keep("first_name", "last_name", "height")
+                .eval(height_feet="height * 3.281", height_cm="height * 100")
+            )
+            query2 = (
+                ESQL.from_("employees")
+                .eval("height * 3.281")
+                .stats(avg_height_feet=functions.avg("`height * 3.281`"))
+            )
+        """
+        return Eval(self, *columns, **named_columns)
+
+    def fork(
+        self,
+        fork1: "ESQLBase",
+        fork2: Optional["ESQLBase"] = None,
+        fork3: Optional["ESQLBase"] = None,
+        fork4: Optional["ESQLBase"] = None,
+        fork5: Optional["ESQLBase"] = None,
+        fork6: Optional["ESQLBase"] = None,
+        fork7: Optional["ESQLBase"] = None,
+        fork8: Optional["ESQLBase"] = None,
+    ) -> "Fork":
+        """The ``FORK`` processing command creates multiple execution branches to operate on the
+        same input data and combines the results in a single output table.
+
+        :param fork<n>: Up to 8 execution branches, created with the ``ESQL.branch()`` method.
+
+        Examples::
+
+            query = (
+                ESQL.from_("employees")
+                .fork(
+                    ESQL.branch().where("emp_no == 10001"),
+                    ESQL.branch().where("emp_no == 10002"),
+                )
+                .keep("emp_no", "_fork")
+                .sort("emp_no")
+            )
+        """
+        if self._is_forked():
+            raise ValueError("a query can only have one fork")
+        return Fork(self, fork1, fork2, fork3, fork4, fork5, fork6, fork7, fork8)
+
+    def grok(self, input: FieldType, pattern: str) -> "Grok":
+        """``GROK`` enables you to extract structured data out of a string.
+
+        :param input: The column that contains the string you want to structure. If the
+                      column has multiple values, ``GROK`` will process each value.
+        :param pattern: A grok pattern. If a field name conflicts with an existing column,
+                        the existing column is discarded. If a field name is used more than
+                        once, a multi-valued column will be created with one value per each
+                        occurrence of the field name.
+
+        Examples::
+
+            query1 = (
+                ESQL.row(a="2023-01-23T12:15:00.000Z 127.0.0.1 some.email@foo.com 42")
+                .grok("a", "%{TIMESTAMP_ISO8601:date} %{IP:ip} %{EMAILADDRESS:email} %{NUMBER:num}")
+                .keep("date", "ip", "email", "num")
+            )
+            query2 = (
+                ESQL.row(a="2023-01-23T12:15:00.000Z 127.0.0.1 some.email@foo.com 42")
+                .grok(
+                    "a",
+                    "%{TIMESTAMP_ISO8601:date} %{IP:ip} %{EMAILADDRESS:email} %{NUMBER:num:int}",
+                )
+                .keep("date", "ip", "email", "num")
+                .eval(date=functions.to_datetime("date"))
+            )
+            query3 = (
+                ESQL.from_("addresses")
+                .keep("city.name", "zip_code")
+                .grok("zip_code", "%{WORD:zip_parts} %{WORD:zip_parts}")
+            )
+        """
+        return Grok(self, input, pattern)
+
+    def keep(self, *columns: FieldType) -> "Keep":
+        """The ``KEEP`` processing command enables you to specify what columns are returned
+        and the order in which they are returned.
+
+        :param columns: The columns to keep, given as positional arguments. Supports
+                        wildcards.
+
+        Examples::
+
+            query1 = ESQL.from_("employees").keep("emp_no", "first_name", "last_name", "height")
+            query2 = ESQL.from_("employees").keep("h*")
+            query3 = ESQL.from_("employees").keep("h*", "*")
+        """
+        return Keep(self, *columns)
+
+    def limit(self, max_number_of_rows: int) -> "Limit":
+        """The ``LIMIT`` processing command enables you to limit the number of rows that are
+        returned.
+
+        :param max_number_of_rows: The maximum number of rows to return.
+
+        Examples::
+
+            query1 = ESQL.from_("employees").sort("emp_no ASC").limit(5)
+            query2 = ESQL.from_("index").stats(functions.avg("field1")).by("field2").limit(20000)
+        """
+        return Limit(self, max_number_of_rows)
+
+    def lookup_join(self, lookup_index: IndexType) -> "LookupJoin":
+        """`LOOKUP JOIN` enables you to add data from another index, AKA a 'lookup' index,
+        to your ES|QL query results, simplifying data enrichment and analysis workflows.
+
+        :param lookup_index: The name of the lookup index. This must be a specific index
+                             name - wildcards, aliases, and remote cluster references are
+                             not supported. Indices used for lookups must be configured
+                             with the lookup index mode.
+
+        Examples::
+
+            query1 = (
+                ESQL.from_("firewall_logs")
+                .lookup_join("threat_list").on("source.IP")
+                .where("threat_level IS NOT NULL")
+            )
+            query2 = (
+                ESQL.from_("system_metrics")
+                .lookup_join("host_inventory").on("host.name")
+                .lookup_join("ownerships").on("host.name")
+            )
+            query3 = (
+                ESQL.from_("app_logs")
+                .lookup_join("service_owners").on("service_id")
+            )
+            query4 = (
+                ESQL.from_("employees")
+                .eval(language_code="languages")
+                .where("emp_no >= 10091 AND emp_no < 10094")
+                .lookup_join("languages_lookup").on("language_code")
+            )
+        """
+        return LookupJoin(self, lookup_index)
+
+    def mv_expand(self, column: FieldType) -> "MvExpand":
+        """The `MV_EXPAND` processing command expands multivalued columns into one row per
+        value, duplicating other columns.
+
+        :param column: The multivalued column to expand.
+
+        Examples::
+
+            query = ESQL.row(a=[1, 2, 3], b="b", j=["a", "b"]).mv_expand("a")
+        """
+        return MvExpand(self, column)
+
+    def rename(self, **columns: FieldType) -> "Rename":
+        """The ``RENAME`` processing command renames one or more columns.
+
+        :param columns: The old and new column name pairs, given as keyword arguments.
+                        If a name conflicts with an existing column name, the existing column
+                        is dropped. If multiple columns are renamed to the same name, all but
+                        the rightmost column with the same new name are dropped.
+
+        Examples::
+
+            query = (
+                ESQL.from_("employees")
+                .keep("first_name", "last_name", "still_hired")
+                .rename(still_hired="employed")
+            )
+        """
+        return Rename(self, **columns)
+
+    def sample(self, probability: float) -> "Sample":
+        """The ``SAMPLE`` command samples a fraction of the table rows.
+
+        :param probability: The probability that a row is included in the sample. The value
+                            must be between 0 and 1, exclusive.
+
+        Examples::
+
+            query = ESQL.from_("employees").keep("emp_no").sample(0.05)
+        """
+        return Sample(self, probability)
+
+    def sort(self, *columns: ExpressionType) -> "Sort":
+        """The ``SORT`` processing command sorts a table on one or more columns.
+
+        :param columns: The columns to sort on.
+
+        Examples::
+
+            query1 = (
+                ESQL.from_("employees")
+                .keep("first_name", "last_name", "height")
+                .sort("height")
+            )
+            query2 =  (
+                ESQL.from_("employees")
+                .keep("first_name", "last_name", "height")
+                .sort("height DESC")
+            )
+            query3 = (
+                ESQL.from_("employees")
+                .keep("first_name", "last_name", "height")
+                .sort("height DESC", "first_name ASC")
+            )
+            query4 = (
+                ESQL.from_("employees")
+                .keep("first_name", "last_name", "height")
+                .sort("first_name ASC NULLS FIRST")
+            )
+        """
+        return Sort(self, *columns)
+
+    def stats(
+        self, *expressions: ExpressionType, **named_expressions: ExpressionType
+    ) -> "Stats":
+        """The ``STATS`` processing command groups rows according to a common value and
+        calculates one or more aggregated values over the grouped rows.
+
+        :param expressions: A list of expressions, given as positional arguments.
+        :param named_expressions: A list of expressions, given as keyword arguments. The
+                                  argument names are used for the returned aggregated values.
+
+        Note that only one of `expressions` and `named_expressions` must be provided.
+
+        Examples::
+
+            query1 = (
+                ESQL.from_("employees")
+                .stats(count=functions.count("emp_no")).by("languages")
+                .sort("languages")
+            )
+            query2 = (
+                ESQL.from_("employees")
+                .stats(avg_lang=functions.avg("languages"))
+            )
+            query3 = (
+                ESQL.from_("employees")
+                .stats(
+                    avg_lang=functions.avg("languages"),
+                    max_lang=functions.max("languages")
+                )
+            )
+            query4 = (
+                ESQL.from_("employees")
+                .stats(
+                    avg50s=functions.avg("salary").where('birth_date < "1960-01-01"'),
+                    avg60s=functions.avg("salary").where('birth_date >= "1960-01-01"'),
+                ).by("gender")
+                .sort("gender")
+            )
+            query5 = (
+                ESQL.from_("employees")
+                .eval(Ks="salary / 1000")
+                .stats(
+                    under_40K=functions.count("*").where("Ks < 40"),
+                    inbetween=functions.count("*").where("40 <= Ks AND Ks < 60"),
+                    over_60K=functions.count("*").where("60 <= Ks"),
+                    total=f.count("*")
+                )
+            )
+            query6 = (
+                ESQL.row(i=1, a=["a", "b"])
+                .stats(functions.min("i")).by("a")
+                .sort("a ASC")
+            )
+            query7 = (
+                ESQL.from_("employees")
+                .eval(hired=functions.date_format("hire_date", "yyyy"))
+                .stats(avg_salary=functions.avg("salary")).by("hired", "languages.long")
+                .eval(avg_salary=functions.round("avg_salary"))
+                .sort("hired", "languages.long")
+
+            )
+        """
+        return Stats(self, *expressions, **named_expressions)
+
+    def where(self, *expressions: ExpressionType) -> "Where":
+        """The ``WHERE`` processing command produces a table that contains all the rows
+        from the input table for which the provided condition evaluates to `true`.
+
+        :param expressions: A list of boolean expressions, given as positional arguments.
+                            These expressions are combined with an ``AND`` logical operator.
+
+        Examples::
+
+            query1 = (
+                ESQL.from_("employees")
+                .keep("first_name", "last_name", "still_hired")
+                .where("still_hired == true")
+            )
+            query2 = (
+                ESQL.from_("sample_data")
+                .where("@timestamp > NOW() - 1 hour")
+            )
+            query3 = (
+                ESQL.from_("employees")
+                .keep("first_name", "last_name", "height")
+                .where("LENGTH(first_name) < 4")
+            )
+        """
+        return Where(self, *expressions)
+
+
+class From(ESQLBase):
+    """Implementation of the ``FROM`` source command.
+
+    This class inherits from :class:`ESQLBase <elasticsearch.esql.esql.ESQLBase>`,
+    to make it possible to chain all the commands that belong to an ES|QL query
+    in a single expression.
+    """
+
+    def __init__(self, *indices: IndexType):
+        super().__init__()
+        self._indices = indices
+        self._metadata_fields: Tuple[FieldType, ...] = tuple()
+
+    def metadata(self, *fields: FieldType) -> "From":
+        """Continuation of the ``FROM`` source command.
+
+        :param fields: metadata fields to retrieve, given as positional arguments.
+        """
+        self._metadata_fields = fields
+        return self
+
+    def _render_internal(self) -> str:
+        indices = [self._format_index(index) for index in self._indices]
+        s = f'{self.__class__.__name__.upper()} {", ".join(indices)}'
+        if self._metadata_fields:
+            s = (
+                s
+                + f' METADATA {", ".join([self._format_id(field) for field in self._metadata_fields])}'
+            )
+        return s
+
+
+class Row(ESQLBase):
+    """Implementation of the ``ROW`` source command.
+
+    This class inherits from :class:`ESQLBase <elasticsearch.esql.esql.ESQLBase>`,
+    to make it possible to chain all the commands that belong to an ES|QL query
+    in a single expression.
+    """
+
+    def __init__(self, **params: ExpressionType):
+        super().__init__()
+        self._params = {
+            self._format_id(k): (
+                json.dumps(v)
+                if not isinstance(v, InstrumentedExpression)
+                else self._format_expr(v)
+            )
+            for k, v in params.items()
+        }
+
+    def _render_internal(self) -> str:
+        return "ROW " + ", ".join([f"{k} = {v}" for k, v in self._params.items()])
+
+
+class Show(ESQLBase):
+    """Implementation of the ``SHOW`` source command.
+
+    This class inherits from :class:`ESQLBase <elasticsearch.esql.esql.ESQLBase>`,
+    which makes it possible to chain all the commands that belong to an ES|QL query
+    in a single expression.
+    """
+
+    def __init__(self, item: str):
+        super().__init__()
+        self._item = item
+
+    def _render_internal(self) -> str:
+        return f"SHOW {self._format_id(self._item)}"
+
+
+class Branch(ESQLBase):
+    """Implementation of a branch inside a ``FORK`` processing command.
+
+    This class inherits from :class:`ESQLBase <elasticsearch.esql.esql.ESQLBase>`,
+    which makes it possible to chain all the commands that belong to the branch
+    in a single expression.
+    """
+
+    def _render_internal(self) -> str:
+        return ""
+
+
+class ChangePoint(ESQLBase):
+    """Implementation of the ``CHANGE POINT`` processing command.
+
+    This class inherits from :class:`ESQLBase <elasticsearch.esql.esql.ESQLBase>`,
+    to make it possible to chain all the commands that belong to an ES|QL query
+    in a single expression.
+    """
+
+    def __init__(self, parent: ESQLBase, value: FieldType):
+        super().__init__(parent)
+        self._value = value
+        self._key: Optional[FieldType] = None
+        self._type_name: Optional[str] = None
+        self._pvalue_name: Optional[str] = None
+
+    def on(self, key: FieldType) -> "ChangePoint":
+        """Continuation of the `CHANGE_POINT` command.
+
+        :param key: The column with the key to order the values by. If not specified,
+                    `@timestamp` is used.
+        """
+        self._key = key
+        return self
+
+    def as_(self, type_name: str, pvalue_name: str) -> "ChangePoint":
+        """Continuation of the `CHANGE_POINT` command.
+
+        :param type_name: The name of the output column with the change point type.
+                          If not specified, `type` is used.
+        :param pvalue_name: The name of the output column with the p-value that indicates
+                            how extreme the change point is. If not specified, `pvalue` is used.
+        """
+        self._type_name = type_name
+        self._pvalue_name = pvalue_name
+        return self
+
+    def _render_internal(self) -> str:
+        key = "" if not self._key else f" ON {self._format_id(self._key)}"
+        names = (
+            ""
+            if not self._type_name and not self._pvalue_name
+            else f' AS {self._format_id(self._type_name or "type")}, {self._format_id(self._pvalue_name or "pvalue")}'
+        )
+        return f"CHANGE_POINT {self._value}{key}{names}"
+
+
+class Completion(ESQLBase):
+    """Implementation of the ``COMPLETION`` processing command.
+
+    This class inherits from :class:`ESQLBase <elasticsearch.esql.esql.ESQLBase>`,
+    to make it possible to chain all the commands that belong to an ES|QL query
+    in a single expression.
+    """
+
+    def __init__(
+        self, parent: ESQLBase, *prompt: ExpressionType, **named_prompt: ExpressionType
+    ):
+        if len(prompt) + len(named_prompt) > 1:
+            raise ValueError(
+                "this method requires either one positional or one keyword argument only"
+            )
+        super().__init__(parent)
+        self._prompt = prompt
+        self._named_prompt = named_prompt
+        self._inference_id: Optional[str] = None
+
+    def with_(self, inference_id: str) -> "Completion":
+        """Continuation of the `COMPLETION` command.
+
+        :param inference_id: The ID of the inference endpoint to use for the task. The
+                             inference endpoint must be configured with the completion
+                             task type.
+        """
+        self._inference_id = inference_id
+        return self
+
+    def _render_internal(self) -> str:
+        if self._inference_id is None:
+            raise ValueError("The completion command requires an inference ID")
+        with_ = {"inference_id": self._inference_id}
+        if self._named_prompt:
+            column = list(self._named_prompt.keys())[0]
+            prompt = list(self._named_prompt.values())[0]
+            return f"COMPLETION {self._format_id(column)} = {self._format_id(prompt)} WITH {json.dumps(with_)}"
+        else:
+            return f"COMPLETION {self._format_id(self._prompt[0])} WITH {json.dumps(with_)}"
+
+
+class Dissect(ESQLBase):
+    """Implementation of the ``DISSECT`` processing command.
+
+    This class inherits from :class:`ESQLBase <elasticsearch.esql.esql.ESQLBase>`,
+    to make it possible to chain all the commands that belong to an ES|QL query
+    in a single expression.
+    """
+
+    def __init__(self, parent: ESQLBase, input: FieldType, pattern: str):
+        super().__init__(parent)
+        self._input = input
+        self._pattern = pattern
+        self._separator: Optional[str] = None
+
+    def append_separator(self, separator: str) -> "Dissect":
+        """Continuation of the ``DISSECT`` command.
+
+        :param separator: A string used as the separator between appended values,
+                          when using the append modifier.
+        """
+        self._separator = separator
+        return self
+
+    def _render_internal(self) -> str:
+        sep = (
+            ""
+            if self._separator is None
+            else f" APPEND_SEPARATOR={json.dumps(self._separator)}"
+        )
+        return (
+            f"DISSECT {self._format_id(self._input)} {json.dumps(self._pattern)}{sep}"
+        )
+
+
+class Drop(ESQLBase):
+    """Implementation of the ``DROP`` processing command.
+
+    This class inherits from :class:`ESQLBase <elasticsearch.esql.esql.ESQLBase>`,
+    to make it possible to chain all the commands that belong to an ES|QL query
+    in a single expression.
+    """
+
+    def __init__(self, parent: ESQLBase, *columns: FieldType):
+        super().__init__(parent)
+        self._columns = columns
+
+    def _render_internal(self) -> str:
+        return f'DROP {", ".join([self._format_id(col, allow_patterns=True) for col in self._columns])}'
+
+
+class Enrich(ESQLBase):
+    """Implementation of the ``ENRICH`` processing command.
+
+    This class inherits from :class:`ESQLBase <elasticsearch.esql.esql.ESQLBase>`,
+    to make it possible to chain all the commands that belong to an ES|QL query
+    in a single expression.
+    """
+
+    def __init__(self, parent: ESQLBase, policy: str):
+        super().__init__(parent)
+        self._policy = policy
+        self._match_field: Optional[FieldType] = None
+        self._fields: Optional[Tuple[FieldType, ...]] = None
+        self._named_fields: Optional[Dict[str, FieldType]] = None
+
+    def on(self, match_field: FieldType) -> "Enrich":
+        """Continuation of the ``ENRICH`` command.
+
+        :param match_field: The match field. ``ENRICH`` uses its value to look for records
+                            in the enrich index. If not specified, the match will be
+                            performed on the column with the same name as the
+                            `match_field` defined in the enrich policy.
+        """
+        self._match_field = match_field
+        return self
+
+    def with_(self, *fields: FieldType, **named_fields: FieldType) -> "Enrich":
+        """Continuation of the ``ENRICH`` command.
+
+        :param fields: The enrich fields from the enrich index that are added to the result
+                       as new columns, given as positional arguments. If a column with the
+                       same name as the enrich field already exists, the existing column will
+                       be replaced by the new column. If not specified, each of the enrich
+                       fields defined in the policy is added. A column with the same name as
+                       the enrich field will be dropped unless the enrich field is renamed.
+        :param named_fields: The enrich fields from the enrich index that are added to the
+                             result as new columns, given as keyword arguments. The name of
+                             the keyword arguments are used as column names. If a column has
+                             the same name as the new name, it will be discarded. If a name
+                             (new or original) occurs more than once, only the rightmost
+                             duplicate creates a new column.
+        """
+        if fields and named_fields:
+            raise ValueError(
+                "this method supports positional or keyword arguments but not both"
+            )
+        self._fields = fields
+        self._named_fields = named_fields
+        return self
+
+    def _render_internal(self) -> str:
+        on = (
+            ""
+            if self._match_field is None
+            else f" ON {self._format_id(self._match_field)}"
+        )
+        with_ = ""
+        if self._named_fields:
+            with_ = f' WITH {", ".join([f"{self._format_id(name)} = {self._format_id(field)}" for name, field in self._named_fields.items()])}'
+        elif self._fields is not None:
+            with_ = (
+                f' WITH {", ".join([self._format_id(field) for field in self._fields])}'
+            )
+        return f"ENRICH {self._policy}{on}{with_}"
+
+
+class Eval(ESQLBase):
+    """Implementation of the ``EVAL`` processing command.
+
+    This class inherits from :class:`ESQLBase <elasticsearch.esql.esql.ESQLBase>`,
+    to make it possible to chain all the commands that belong to an ES|QL query
+    in a single expression.
+    """
+
+    def __init__(
+        self,
+        parent: ESQLBase,
+        *columns: ExpressionType,
+        **named_columns: ExpressionType,
+    ):
+        if columns and named_columns:
+            raise ValueError(
+                "this method supports positional or keyword arguments but not both"
+            )
+        super().__init__(parent)
+        self._columns = columns or named_columns
+
+    def _render_internal(self) -> str:
+        if isinstance(self._columns, dict):
+            cols = ", ".join(
+                [
+                    f"{self._format_id(name)} = {self._format_expr(value)}"
+                    for name, value in self._columns.items()
+                ]
+            )
+        else:
+            cols = ", ".join([f"{self._format_expr(col)}" for col in self._columns])
+        return f"EVAL {cols}"
+
+
+class Fork(ESQLBase):
+    """Implementation of the ``FORK`` processing command.
+
+    This class inherits from :class:`ESQLBase <elasticsearch.esql.esql.ESQLBase>`,
+    to make it possible to chain all the commands that belong to an ES|QL query
+    in a single expression.
+    """
+
+    def __init__(
+        self,
+        parent: ESQLBase,
+        fork1: ESQLBase,
+        fork2: Optional[ESQLBase] = None,
+        fork3: Optional[ESQLBase] = None,
+        fork4: Optional[ESQLBase] = None,
+        fork5: Optional[ESQLBase] = None,
+        fork6: Optional[ESQLBase] = None,
+        fork7: Optional[ESQLBase] = None,
+        fork8: Optional[ESQLBase] = None,
+    ):
+        super().__init__(parent)
+        self._branches = [fork1, fork2, fork3, fork4, fork5, fork6, fork7, fork8]
+
+    def _render_internal(self) -> str:
+        cmds = ""
+        for branch in self._branches:
+            if branch:
+                cmd = branch.render()[3:].replace("\n", " ")
+                if cmds == "":
+                    cmds = f"( {cmd} )"
+                else:
+                    cmds += f"\n       ( {cmd} )"
+        return f"FORK {cmds}"
+
+
+class Grok(ESQLBase):
+    """Implementation of the ``GROK`` processing command.
+
+    This class inherits from :class:`ESQLBase <elasticsearch.esql.esql.ESQLBase>`,
+    to make it possible to chain all the commands that belong to an ES|QL query
+    in a single expression.
+    """
+
+    def __init__(self, parent: ESQLBase, input: FieldType, pattern: str):
+        super().__init__(parent)
+        self._input = input
+        self._pattern = pattern
+
+    def _render_internal(self) -> str:
+        return f"GROK {self._format_id(self._input)} {json.dumps(self._pattern)}"
+
+
+class Keep(ESQLBase):
+    """Implementation of the ``KEEP`` processing command.
+
+    This class inherits from :class:`ESQLBase <elasticsearch.esql.esql.ESQLBase>`,
+    to make it possible to chain all the commands that belong to an ES|QL query
+    in a single expression.
+    """
+
+    def __init__(self, parent: ESQLBase, *columns: FieldType):
+        super().__init__(parent)
+        self._columns = columns
+
+    def _render_internal(self) -> str:
+        return f'KEEP {", ".join([f"{self._format_id(col, allow_patterns=True)}" for col in self._columns])}'
+
+
+class Limit(ESQLBase):
+    """Implementation of the ``LIMIT`` processing command.
+
+    This class inherits from :class:`ESQLBase <elasticsearch.esql.esql.ESQLBase>`,
+    to make it possible to chain all the commands that belong to an ES|QL query
+    in a single expression.
+    """
+
+    def __init__(self, parent: ESQLBase, max_number_of_rows: int):
+        super().__init__(parent)
+        self._max_number_of_rows = max_number_of_rows
+
+    def _render_internal(self) -> str:
+        return f"LIMIT {json.dumps(self._max_number_of_rows)}"
+
+
+class LookupJoin(ESQLBase):
+    """Implementation of the ``LOOKUP JOIN`` processing command.
+
+    This class inherits from :class:`ESQLBase <elasticsearch.esql.esql.ESQLBase>`,
+    to make it possible to chain all the commands that belong to an ES|QL query
+    in a single expression.
+    """
+
+    def __init__(self, parent: ESQLBase, lookup_index: IndexType):
+        super().__init__(parent)
+        self._lookup_index = lookup_index
+        self._field: Optional[FieldType] = None
+
+    def on(self, field: FieldType) -> "LookupJoin":
+        """Continuation of the `LOOKUP_JOIN` command.
+
+        :param field: The field to join on. This field must exist in both your current query
+                      results and in the lookup index. If the field contains multi-valued
+                      entries, those entries will not match anything (the added fields will
+                      contain null for those rows).
+        """
+        self._field = field
+        return self
+
+    def _render_internal(self) -> str:
+        if self._field is None:
+            raise ValueError("Joins require a field to join on.")
+        index = (
+            self._lookup_index
+            if isinstance(self._lookup_index, str)
+            else self._lookup_index._index._name
+        )
+        return (
+            f"LOOKUP JOIN {self._format_index(index)} ON {self._format_id(self._field)}"
+        )
+
+
+class MvExpand(ESQLBase):
+    """Implementation of the ``MV_EXPAND`` processing command.
+
+    This class inherits from :class:`ESQLBase <elasticsearch.esql.esql.ESQLBase>`,
+    to make it possible to chain all the commands that belong to an ES|QL query
+    in a single expression.
+    """
+
+    def __init__(self, parent: ESQLBase, column: FieldType):
+        super().__init__(parent)
+        self._column = column
+
+    def _render_internal(self) -> str:
+        return f"MV_EXPAND {self._format_id(self._column)}"
+
+
+class Rename(ESQLBase):
+    """Implementation of the ``RENAME`` processing command.
+
+    This class inherits from :class:`ESQLBase <elasticsearch.esql.esql.ESQLBase>`,
+    to make it possible to chain all the commands that belong to an ES|QL query
+    in a single expression.
+    """
+
+    def __init__(self, parent: ESQLBase, **columns: FieldType):
+        super().__init__(parent)
+        self._columns = columns
+
+    def _render_internal(self) -> str:
+        return f'RENAME {", ".join([f"{self._format_id(old_name)} AS {self._format_id(new_name)}" for old_name, new_name in self._columns.items()])}'
+
+
+class Sample(ESQLBase):
+    """Implementation of the ``SAMPLE`` processing command.
+
+    This class inherits from :class:`ESQLBase <elasticsearch.esql.esql.ESQLBase>`,
+    to make it possible to chain all the commands that belong to an ES|QL query
+    in a single expression.
+    """
+
+    def __init__(self, parent: ESQLBase, probability: float):
+        super().__init__(parent)
+        self._probability = probability
+
+    def _render_internal(self) -> str:
+        return f"SAMPLE {json.dumps(self._probability)}"
+
+
+class Sort(ESQLBase):
+    """Implementation of the ``SORT`` processing command.
+
+    This class inherits from :class:`ESQLBase <elasticsearch.esql.esql.ESQLBase>`,
+    to make it possible to chain all the commands that belong to an ES|QL query
+    in a single expression.
+    """
+
+    def __init__(self, parent: ESQLBase, *columns: ExpressionType):
+        super().__init__(parent)
+        self._columns = columns
+
+    def _render_internal(self) -> str:
+        sorts = [
+            " ".join([self._format_id(term) for term in str(col).split(" ")])
+            for col in self._columns
+        ]
+        return f'SORT {", ".join([f"{sort}" for sort in sorts])}'
+
+
+class Stats(ESQLBase):
+    """Implementation of the ``STATS`` processing command.
+
+    This class inherits from :class:`ESQLBase <elasticsearch.esql.esql.ESQLBase>`,
+    to make it possible to chain all the commands that belong to an ES|QL query
+    in a single expression.
+    """
+
+    def __init__(
+        self,
+        parent: ESQLBase,
+        *expressions: ExpressionType,
+        **named_expressions: ExpressionType,
+    ):
+        if expressions and named_expressions:
+            raise ValueError(
+                "this method supports positional or keyword arguments but not both"
+            )
+        super().__init__(parent)
+        self._expressions = expressions or named_expressions
+        self._grouping_expressions: Optional[Tuple[ExpressionType, ...]] = None
+
+    def by(self, *grouping_expressions: ExpressionType) -> "Stats":
+        self._grouping_expressions = grouping_expressions
+        return self
+
+    def _render_internal(self) -> str:
+        if isinstance(self._expressions, dict):
+            exprs = [
+                f"{self._format_id(key)} = {self._format_expr(value)}"
+                for key, value in self._expressions.items()
+            ]
+        else:
+            exprs = [f"{self._format_expr(expr)}" for expr in self._expressions]
+        expression_separator = ",\n        "
+        by = (
+            ""
+            if self._grouping_expressions is None
+            else f'\n        BY {", ".join([f"{self._format_expr(expr)}" for expr in self._grouping_expressions])}'
+        )
+        return f'STATS {expression_separator.join([f"{expr}" for expr in exprs])}{by}'
+
+
+class Where(ESQLBase):
+    """Implementation of the ``WHERE`` processing command.
+
+    This class inherits from :class:`ESQLBase <elasticsearch.esql.esql.ESQLBase>`,
+    to make it possible to chain all the commands that belong to an ES|QL query
+    in a single expression.
+    """
+
+    def __init__(self, parent: ESQLBase, *expressions: ExpressionType):
+        super().__init__(parent)
+        self._expressions = expressions
+
+    def _render_internal(self) -> str:
+        return f'WHERE {" AND ".join([f"{self._format_expr(expr)}" for expr in self._expressions])}'
+
+
+def and_(*expressions: InstrumentedExpression) -> "InstrumentedExpression":
+    """Combine two or more expressions with the AND operator."""
+    return InstrumentedExpression(" AND ".join([f"({expr})" for expr in expressions]))
+
+
+def or_(*expressions: InstrumentedExpression) -> "InstrumentedExpression":
+    """Combine two or more expressions with the OR operator."""
+    return InstrumentedExpression(" OR ".join([f"({expr})" for expr in expressions]))
+
+
+def not_(expression: InstrumentedExpression) -> "InstrumentedExpression":
+    """Negate an expression."""
+    return InstrumentedExpression(f"NOT ({expression})")
diff --git a/elasticsearch/esql/functions.py b/elasticsearch/esql/functions.py
new file mode 100644
index 000000000..162d7b95e
--- /dev/null
+++ b/elasticsearch/esql/functions.py
@@ -0,0 +1,1750 @@
+#  Licensed to Elasticsearch B.V. under one or more contributor
+#  license agreements. See the NOTICE file distributed with
+#  this work for additional information regarding copyright
+#  ownership. Elasticsearch B.V. licenses this file to you under
+#  the Apache License, Version 2.0 (the "License"); you may
+#  not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+# 	http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing,
+#  software distributed under the License is distributed on an
+#  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+#  KIND, either express or implied.  See the License for the
+#  specific language governing permissions and limitations
+#  under the License.
+
+import json
+from typing import Any
+
+from elasticsearch.dsl.document_base import InstrumentedExpression
+from elasticsearch.esql.esql import ESQLBase, ExpressionType
+
+
+def _render(v: Any) -> str:
+    return (
+        json.dumps(v)
+        if not isinstance(v, InstrumentedExpression)
+        else ESQLBase._format_expr(v)
+    )
+
+
+def abs(number: ExpressionType) -> InstrumentedExpression:
+    """Returns the absolute value.
+
+    :param number: Numeric expression. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"ABS({_render(number)})")
+
+
+def acos(number: ExpressionType) -> InstrumentedExpression:
+    """Returns the arccosine of `n` as an angle, expressed in radians.
+
+    :param number: Number between -1 and 1. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"ACOS({_render(number)})")
+
+
+def asin(number: ExpressionType) -> InstrumentedExpression:
+    """Returns the arcsine of the input numeric expression as an angle,
+    expressed in radians.
+
+    :param number: Number between -1 and 1. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"ASIN({_render(number)})")
+
+
+def atan(number: ExpressionType) -> InstrumentedExpression:
+    """Returns the arctangent of the input numeric expression as an angle,
+    expressed in radians.
+
+    :param number: Numeric expression. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"ATAN({_render(number)})")
+
+
+def atan2(
+    y_coordinate: ExpressionType, x_coordinate: ExpressionType
+) -> InstrumentedExpression:
+    """The angle between the positive x-axis and the ray from the origin to the
+    point (x , y) in the Cartesian plane, expressed in radians.
+
+    :param y_coordinate: y coordinate. If `null`, the function returns `null`.
+    :param x_coordinate: x coordinate. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(
+        f"ATAN2({_render(y_coordinate)}, {_render(x_coordinate)})"
+    )
+
+
+def avg(number: ExpressionType) -> InstrumentedExpression:
+    """The average of a numeric field.
+
+    :param number: Expression that outputs values to average.
+    """
+    return InstrumentedExpression(f"AVG({_render(number)})")
+
+
+def avg_over_time(number: ExpressionType) -> InstrumentedExpression:
+    """The average over time of a numeric field.
+
+    :param number: Expression that outputs values to average.
+    """
+    return InstrumentedExpression(f"AVG_OVER_TIME({_render(number)})")
+
+
+def bit_length(string: ExpressionType) -> InstrumentedExpression:
+    """Returns the bit length of a string.
+
+    :param string: String expression. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"BIT_LENGTH({_render(string)})")
+
+
+def bucket(
+    field: ExpressionType,
+    buckets: ExpressionType,
+    from_: ExpressionType,
+    to: ExpressionType,
+) -> InstrumentedExpression:
+    """Creates groups of values - buckets - out of a datetime or numeric input.
+    The size of the buckets can either be provided directly, or chosen based on
+    a recommended count and values range.
+
+    :param field: Numeric or date expression from which to derive buckets.
+    :param buckets: Target number of buckets, or desired bucket size if `from`
+                    and `to` parameters are omitted.
+    :param from_: Start of the range. Can be a number, a date or a date expressed
+                  as a string.
+    :param to: End of the range. Can be a number, a date or a date expressed as a string.
+    """
+    return InstrumentedExpression(
+        f"BUCKET({_render(field)}, {_render(buckets)}, {_render(from_)}, {_render(to)})"
+    )
+
+
+def byte_length(string: ExpressionType) -> InstrumentedExpression:
+    """Returns the byte length of a string.
+
+    :param string: String expression. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"BYTE_LENGTH({_render(string)})")
+
+
+def case(*conditions: ExpressionType) -> InstrumentedExpression:
+    """Accepts pairs of conditions and values. The function returns the value
+    that belongs to the first condition that evaluates to `true`.  If the
+    number of arguments is odd, the last argument is the default value which is
+    returned when no condition matches. If the number of arguments is even, and
+    no condition matches, the function returns `null`.
+    """
+    return InstrumentedExpression(
+        f'CASE({", ".join([_render(c) for c in conditions])})'
+    )
+
+
+def categorize(field: ExpressionType) -> InstrumentedExpression:
+    """Groups text messages into categories of similarly formatted text values.
+
+    :param field: Expression to categorize
+    """
+    return InstrumentedExpression(f"CATEGORIZE({_render(field)})")
+
+
+def cbrt(number: ExpressionType) -> InstrumentedExpression:
+    """Returns the cube root of a number. The input can be any numeric value,
+    the return value is always a double. Cube roots of infinities are null.
+
+    :param number: Numeric expression. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"CBRT({_render(number)})")
+
+
+def ceil(number: ExpressionType) -> InstrumentedExpression:
+    """Round a number up to the nearest integer.
+
+    :param number: Numeric expression. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"CEIL({_render(number)})")
+
+
+def cidr_match(ip: ExpressionType, block_x: ExpressionType) -> InstrumentedExpression:
+    """Returns true if the provided IP is contained in one of the provided CIDR blocks.
+
+    :param ip: IP address of type `ip` (both IPv4 and IPv6 are supported).
+    :param block_x: CIDR block to test the IP against.
+    """
+    return InstrumentedExpression(f"CIDR_MATCH({_render(ip)}, {_render(block_x)})")
+
+
+def coalesce(first: ExpressionType, rest: ExpressionType) -> InstrumentedExpression:
+    """Returns the first of its arguments that is not null. If all arguments
+    are null, it returns `null`.
+
+    :param first: Expression to evaluate.
+    :param rest: Other expression to evaluate.
+    """
+    return InstrumentedExpression(f"COALESCE({_render(first)}, {_render(rest)})")
+
+
+def concat(*strings: ExpressionType) -> InstrumentedExpression:
+    """Concatenates two or more strings."""
+    return InstrumentedExpression(
+        f'CONCAT({", ".join([f"{_render(s)}" for s in strings])})'
+    )
+
+
+def cos(angle: ExpressionType) -> InstrumentedExpression:
+    """Returns the cosine of an angle.
+
+    :param angle: An angle, in radians. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"COS({_render(angle)})")
+
+
+def cosh(number: ExpressionType) -> InstrumentedExpression:
+    """Returns the hyperbolic cosine of a number.
+
+    :param number: Numeric expression. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"COSH({_render(number)})")
+
+
+def count(field: ExpressionType) -> InstrumentedExpression:
+    """Returns the total number (count) of input values.
+
+    :param field: Expression that outputs values to be counted. If omitted,
+                  equivalent to `COUNT(*)` (the number of rows).
+    """
+    return InstrumentedExpression(f"COUNT({_render(field)})")
+
+
+def count_distinct(
+    field: ExpressionType, precision: ExpressionType
+) -> InstrumentedExpression:
+    """Returns the approximate number of distinct values.
+
+    :param field: Column or literal for which to count the number of distinct values.
+    :param precision: Precision threshold. The maximum supported value is 40000. Thresholds
+                      above this number will have the same effect as a threshold of 40000.
+                      The default value is 3000.
+    """
+    return InstrumentedExpression(
+        f"COUNT_DISTINCT({_render(field)}, {_render(precision)})"
+    )
+
+
+def count_distinct_over_time(
+    field: ExpressionType, precision: ExpressionType
+) -> InstrumentedExpression:
+    """The count of distinct values over time for a field.
+
+    :param field:
+    :param precision: Precision threshold. The maximum supported value is 40000. Thresholds
+                      above this number will have the same effect as a threshold of 40000. The
+                      default value is 3000.
+    """
+    return InstrumentedExpression(
+        f"COUNT_DISTINCT_OVER_TIME({_render(field)}, {_render(precision)})"
+    )
+
+
+def count_over_time(field: ExpressionType) -> InstrumentedExpression:
+    """The count over time value of a field.
+
+    :param field:
+    """
+    return InstrumentedExpression(f"COUNT_OVER_TIME({_render(field)})")
+
+
+def date_diff(
+    unit: ExpressionType, start_timestamp: ExpressionType, end_timestamp: ExpressionType
+) -> InstrumentedExpression:
+    """Subtracts the `startTimestamp` from the `endTimestamp` and returns the
+    difference in multiples of `unit`. If `startTimestamp` is later than the
+    `endTimestamp`, negative values are returned.
+
+    :param unit: Time difference unit
+    :param start_timestamp: A string representing a start timestamp
+    :param end_timestamp: A string representing an end timestamp
+    """
+    return InstrumentedExpression(
+        f"DATE_DIFF({_render(unit)}, {_render(start_timestamp)}, {_render(end_timestamp)})"
+    )
+
+
+def date_extract(
+    date_part: ExpressionType, date: ExpressionType
+) -> InstrumentedExpression:
+    """Extracts parts of a date, like year, month, day, hour.
+
+    :param date_part: Part of the date to extract.  Can be:
+        `aligned_day_of_week_in_month`, `aligned_day_of_week_in_year`,
+        `aligned_week_of_month`, `aligned_week_of_year`, `ampm_of_day`,
+        `clock_hour_of_ampm`, `clock_hour_of_day`, `day_of_month`, `day_of_week`,
+        `day_of_year`, `epoch_day`, `era`, `hour_of_ampm`, `hour_of_day`,
+        `instant_seconds`, `micro_of_day`, `micro_of_second`, `milli_of_day`,
+        `milli_of_second`, `minute_of_day`, `minute_of_hour`, `month_of_year`,
+        `nano_of_day`, `nano_of_second`, `offset_seconds`, `proleptic_month`,
+        `second_of_day`, `second_of_minute`, `year`, or `year_of_era`. If `null`,
+        the function returns `null`.
+    :param date: Date expression. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(
+        f"DATE_EXTRACT({_render(date_part)}, {_render(date)})"
+    )
+
+
+def date_format(
+    date: ExpressionType,
+    date_format: ExpressionType = None,
+) -> InstrumentedExpression:
+    """Returns a string representation of a date, in the provided format.
+
+    :param date_format: Date format (optional).  If no format is specified, the
+                        `yyyy-MM-dd'T'HH:mm:ss.SSSZ` format is used. If `null`, the
+                        function returns `null`.
+    :param date: Date expression. If `null`, the function returns `null`.
+    """
+    if date_format is not None:
+        return InstrumentedExpression(
+            f"DATE_FORMAT({_render(date_format)}, {_render(date)})"
+        )
+    else:
+        return InstrumentedExpression(f"DATE_FORMAT({_render(date)})")
+
+
+def date_parse(
+    date_pattern: ExpressionType, date_string: ExpressionType
+) -> InstrumentedExpression:
+    """Returns a date by parsing the second argument using the format specified
+    in the first argument.
+
+    :param date_pattern: The date format. If `null`, the function returns `null`.
+    :param date_string: Date expression as a string. If `null` or an empty
+                        string, the function returns `null`.
+    """
+    return InstrumentedExpression(
+        f"DATE_PARSE({_render(date_pattern)}, {_render(date_string)})"
+    )
+
+
+def date_trunc(
+    interval: ExpressionType, date: ExpressionType
+) -> InstrumentedExpression:
+    """Rounds down a date to the closest interval since epoch, which starts at `0001-01-01T00:00:00Z`.
+
+    :param interval: Interval; expressed using the timespan literal syntax.
+    :param date: Date expression
+    """
+    return InstrumentedExpression(f"DATE_TRUNC({_render(interval)}, {_render(date)})")
+
+
+def e() -> InstrumentedExpression:
+    """Returns Euler’s number)."""
+    return InstrumentedExpression("E()")
+
+
+def ends_with(str: ExpressionType, suffix: ExpressionType) -> InstrumentedExpression:
+    """Returns a boolean that indicates whether a keyword string ends with
+    another string.
+
+    :param str: String expression. If `null`, the function returns `null`.
+    :param suffix: String expression. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"ENDS_WITH({_render(str)}, {_render(suffix)})")
+
+
+def exp(number: ExpressionType) -> InstrumentedExpression:
+    """Returns the value of e raised to the power of the given number.
+
+    :param number: Numeric expression. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"EXP({_render(number)})")
+
+
+def first_over_time(field: ExpressionType) -> InstrumentedExpression:
+    """The earliest value of a field, where recency determined by the
+    `@timestamp` field.
+
+    :param field:
+    """
+    return InstrumentedExpression(f"FIRST_OVER_TIME({_render(field)})")
+
+
+def floor(number: ExpressionType) -> InstrumentedExpression:
+    """Round a number down to the nearest integer.
+
+    :param number: Numeric expression. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"FLOOR({_render(number)})")
+
+
+def from_base64(string: ExpressionType) -> InstrumentedExpression:
+    """Decode a base64 string.
+
+    :param string: A base64 string.
+    """
+    return InstrumentedExpression(f"FROM_BASE64({_render(string)})")
+
+
+def greatest(first: ExpressionType, rest: ExpressionType) -> InstrumentedExpression:
+    """Returns the maximum value from multiple columns. This is similar to
+    `MV_MAX` except it is intended to run on multiple columns at once.
+
+    :param first: First of the columns to evaluate.
+    :param rest: The rest of the columns to evaluate.
+    """
+    return InstrumentedExpression(f"GREATEST({_render(first)}, {_render(rest)})")
+
+
+def hash(algorithm: ExpressionType, input: ExpressionType) -> InstrumentedExpression:
+    """Computes the hash of the input using various algorithms such as MD5,
+    SHA, SHA-224, SHA-256, SHA-384, SHA-512.
+
+    :param algorithm: Hash algorithm to use.
+    :param input: Input to hash.
+    """
+    return InstrumentedExpression(f"HASH({_render(algorithm)}, {_render(input)})")
+
+
+def hypot(number1: ExpressionType, number2: ExpressionType) -> InstrumentedExpression:
+    """Returns the hypotenuse of two numbers. The input can be any numeric
+    values, the return value is always a double. Hypotenuses of infinities are null.
+
+    :param number1: Numeric expression. If `null`, the function returns `null`.
+    :param number2: Numeric expression. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"HYPOT({number1}, {number2})")
+
+
+def ip_prefix(
+    ip: ExpressionType,
+    prefix_length_v4: ExpressionType,
+    prefix_length_v6: ExpressionType,
+) -> InstrumentedExpression:
+    """Truncates an IP to a given prefix length.
+
+    :param ip: IP address of type `ip` (both IPv4 and IPv6 are supported).
+    :param prefix_length_v4: Prefix length for IPv4 addresses.
+    :param prefix_length_v6: Prefix length for IPv6 addresses.
+    """
+    return InstrumentedExpression(
+        f"IP_PREFIX({_render(ip)}, {prefix_length_v4}, {prefix_length_v6})"
+    )
+
+
+def knn(
+    field: ExpressionType, query: ExpressionType, options: ExpressionType = None
+) -> InstrumentedExpression:
+    """Finds the k nearest vectors to a query vector, as measured by a
+    similarity metric. knn function finds nearest vectors through approximate
+    search on indexed dense_vectors.
+
+    :param field: Field that the query will target.
+    :param query: Vector value to find top nearest neighbours for.
+    :param options: (Optional) kNN additional options as function named parameters.
+    """
+    if options is not None:
+        return InstrumentedExpression(
+            f"KNN({_render(field)}, {_render(query)}, {_render(options)})"
+        )
+    else:
+        return InstrumentedExpression(f"KNN({_render(field)}, {_render(query)})")
+
+
+def kql(query: ExpressionType) -> InstrumentedExpression:
+    """Performs a KQL query. Returns true if the provided KQL query string
+    matches the row.
+
+    :param query: Query string in KQL query string format.
+    """
+    return InstrumentedExpression(f"KQL({_render(query)})")
+
+
+def last_over_time(field: ExpressionType) -> InstrumentedExpression:
+    """The latest value of a field, where recency determined by the
+    `@timestamp` field.
+
+    :param field:
+    """
+    return InstrumentedExpression(f"LAST_OVER_TIME({_render(field)})")
+
+
+def least(first: ExpressionType, rest: ExpressionType) -> InstrumentedExpression:
+    """Returns the minimum value from multiple columns. This is similar to
+    `MV_MIN` except it is intended to run on multiple columns at once.
+
+    :param first: First of the columns to evaluate.
+    :param rest: The rest of the columns to evaluate.
+    """
+    return InstrumentedExpression(f"LEAST({_render(first)}, {_render(rest)})")
+
+
+def left(string: ExpressionType, length: ExpressionType) -> InstrumentedExpression:
+    """Returns the substring that extracts *length* chars from *string*
+    starting from the left.
+
+    :param string: The string from which to return a substring.
+    :param length: The number of characters to return.
+    """
+    return InstrumentedExpression(f"LEFT({_render(string)}, {_render(length)})")
+
+
+def length(string: ExpressionType) -> InstrumentedExpression:
+    """Returns the character length of a string.
+
+    :param string: String expression. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"LENGTH({_render(string)})")
+
+
+def locate(
+    string: ExpressionType, substring: ExpressionType, start: ExpressionType
+) -> InstrumentedExpression:
+    """Returns an integer that indicates the position of a keyword substring
+    within another string. Returns `0` if the substring cannot be found. Note
+    that string positions start from `1`.
+
+    :param string: An input string
+    :param substring: A substring to locate in the input string
+    :param start: The start index
+    """
+    return InstrumentedExpression(
+        f"LOCATE({_render(string)}, {_render(substring)}, {_render(start)})"
+    )
+
+
+def log(base: ExpressionType, number: ExpressionType) -> InstrumentedExpression:
+    """Returns the logarithm of a value to a base. The input can be any numeric
+    value, the return value is always a double.  Logs of zero, negative
+    numbers, and base of one return `null` as well as a warning.
+
+    :param base: Base of logarithm. If `null`, the function returns `null`. If
+                 not provided, this function returns the natural logarithm (base e) of a value.
+    :param number: Numeric expression. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"LOG({_render(base)}, {_render(number)})")
+
+
+def log10(number: ExpressionType) -> InstrumentedExpression:
+    """Returns the logarithm of a value to base 10. The input can be any
+    numeric value, the return value is always a double.  Logs of 0 and negative
+    numbers return `null` as well as a warning.
+
+    :param number: Numeric expression. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"LOG10({_render(number)})")
+
+
+def ltrim(string: ExpressionType) -> InstrumentedExpression:
+    """Removes leading whitespaces from a string.
+
+    :param string: String expression. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"LTRIM({_render(string)})")
+
+
+def match(
+    field: ExpressionType, query: ExpressionType, options: ExpressionType = None
+) -> InstrumentedExpression:
+    """Use `MATCH` to perform a match query on the specified field. Using
+    `MATCH` is equivalent to using the `match` query in the Elasticsearch Query DSL.
+
+    :param field: Field that the query will target.
+    :param query: Value to find in the provided field.
+    :param options: (Optional) Match additional options as function named parameters.
+    """
+    if options is not None:
+        return InstrumentedExpression(
+            f"MATCH({_render(field)}, {_render(query)}, {_render(options)})"
+        )
+    else:
+        return InstrumentedExpression(f"MATCH({_render(field)}, {_render(query)})")
+
+
+def match_phrase(
+    field: ExpressionType, query: ExpressionType, options: ExpressionType = None
+) -> InstrumentedExpression:
+    """Use `MATCH_PHRASE` to perform a `match_phrase` on the specified field.
+    Using `MATCH_PHRASE` is equivalent to using the `match_phrase` query in the
+    Elasticsearch Query DSL.
+
+    :param field: Field that the query will target.
+    :param query: Value to find in the provided field.
+    :param options: (Optional) MatchPhrase additional options as function named parameters.
+    """
+    if options is not None:
+        return InstrumentedExpression(
+            f"MATCH_PHRASE({_render(field)}, {_render(query)}, {_render(options)})"
+        )
+    else:
+        return InstrumentedExpression(
+            f"MATCH_PHRASE({_render(field)}, {_render(query)})"
+        )
+
+
+def max(field: ExpressionType) -> InstrumentedExpression:
+    """The maximum value of a field.
+
+    :param field:
+    """
+    return InstrumentedExpression(f"MAX({_render(field)})")
+
+
+def max_over_time(field: ExpressionType) -> InstrumentedExpression:
+    """The maximum over time value of a field.
+
+    :param field:
+    """
+    return InstrumentedExpression(f"MAX_OVER_TIME({_render(field)})")
+
+
+def md5(input: ExpressionType) -> InstrumentedExpression:
+    """Computes the MD5 hash of the input.
+
+    :param input: Input to hash.
+    """
+    return InstrumentedExpression(f"MD5({_render(input)})")
+
+
+def median(number: ExpressionType) -> InstrumentedExpression:
+    """The value that is greater than half of all values and less than half of
+    all values, also known as the 50% `PERCENTILE`.
+
+    :param number: Expression that outputs values to calculate the median of.
+    """
+    return InstrumentedExpression(f"MEDIAN({_render(number)})")
+
+
+def median_absolute_deviation(number: ExpressionType) -> InstrumentedExpression:
+    """Returns the median absolute deviation, a measure of variability. It is a
+    robust statistic, meaning that it is useful for describing data that may
+    have outliers, or may not be normally distributed. For such data it can be
+    more descriptive than standard deviation.  It is calculated as the median
+    of each data point’s deviation from the median of the entire sample. That
+    is, for a random variable `X`, the median absolute deviation is
+    `median(|median(X) - X|)`.
+
+    :param number:
+    """
+    return InstrumentedExpression(f"MEDIAN_ABSOLUTE_DEVIATION({_render(number)})")
+
+
+def min(field: ExpressionType) -> InstrumentedExpression:
+    """The minimum value of a field.
+
+    :param field:
+    """
+    return InstrumentedExpression(f"MIN({_render(field)})")
+
+
+def min_over_time(field: ExpressionType) -> InstrumentedExpression:
+    """The minimum over time value of a field.
+
+    :param field:
+    """
+    return InstrumentedExpression(f"MIN_OVER_TIME({_render(field)})")
+
+
+def multi_match(
+    query: ExpressionType, *fields: ExpressionType, options: ExpressionType = None
+) -> InstrumentedExpression:
+    """Use `MULTI_MATCH` to perform a multi-match query on the specified field.
+    The multi_match query builds on the match query to allow multi-field queries.
+
+    :param query: Value to find in the provided fields.
+    :param fields: Fields to use for matching
+    :param options: (Optional) Additional options for MultiMatch, passed as function
+                    named parameters
+    """
+    if options is not None:
+        return InstrumentedExpression(
+            f'MULTI_MATCH({_render(query)}, {", ".join([_render(c) for c in fields])}, {_render(options)})'
+        )
+    else:
+        return InstrumentedExpression(
+            f'MULTI_MATCH({_render(query)}, {", ".join([_render(c) for c in fields])})'
+        )
+
+
+def mv_append(field1: ExpressionType, field2: ExpressionType) -> InstrumentedExpression:
+    """Concatenates values of two multi-value fields.
+
+    :param field1:
+    :param field2:
+    """
+    return InstrumentedExpression(f"MV_APPEND({field1}, {field2})")
+
+
+def mv_avg(number: ExpressionType) -> InstrumentedExpression:
+    """Converts a multivalued field into a single valued field containing the
+    average of all of the values.
+
+    :param number: Multivalue expression.
+    """
+    return InstrumentedExpression(f"MV_AVG({_render(number)})")
+
+
+def mv_concat(string: ExpressionType, delim: ExpressionType) -> InstrumentedExpression:
+    """Converts a multivalued string expression into a single valued column
+    containing the concatenation of all values separated by a delimiter.
+
+    :param string: Multivalue expression.
+    :param delim: Delimiter.
+    """
+    return InstrumentedExpression(f"MV_CONCAT({_render(string)}, {_render(delim)})")
+
+
+def mv_count(field: ExpressionType) -> InstrumentedExpression:
+    """Converts a multivalued expression into a single valued column containing
+    a count of the number of values.
+
+    :param field: Multivalue expression.
+    """
+    return InstrumentedExpression(f"MV_COUNT({_render(field)})")
+
+
+def mv_dedupe(field: ExpressionType) -> InstrumentedExpression:
+    """Remove duplicate values from a multivalued field.
+
+    :param field: Multivalue expression.
+    """
+    return InstrumentedExpression(f"MV_DEDUPE({_render(field)})")
+
+
+def mv_first(field: ExpressionType) -> InstrumentedExpression:
+    """Converts a multivalued expression into a single valued column containing
+    the first value. This is most useful when reading from a function that
+    emits multivalued columns in a known order like `SPLIT`.
+
+    :param field: Multivalue expression.
+    """
+    return InstrumentedExpression(f"MV_FIRST({_render(field)})")
+
+
+def mv_last(field: ExpressionType) -> InstrumentedExpression:
+    """Converts a multivalue expression into a single valued column containing
+    the last value. This is most useful when reading from a function that emits
+    multivalued columns in a known order like `SPLIT`.
+
+    :param field: Multivalue expression.
+    """
+    return InstrumentedExpression(f"MV_LAST({_render(field)})")
+
+
+def mv_max(field: ExpressionType) -> InstrumentedExpression:
+    """Converts a multivalued expression into a single valued column containing
+    the maximum value.
+
+    :param field: Multivalue expression.
+    """
+    return InstrumentedExpression(f"MV_MAX({_render(field)})")
+
+
+def mv_median(number: ExpressionType) -> InstrumentedExpression:
+    """Converts a multivalued field into a single valued field containing the
+    median value.
+
+    :param number: Multivalue expression.
+    """
+    return InstrumentedExpression(f"MV_MEDIAN({_render(number)})")
+
+
+def mv_median_absolute_deviation(number: ExpressionType) -> InstrumentedExpression:
+    """Converts a multivalued field into a single valued field containing the
+    median absolute deviation.  It is calculated as the median of each data
+    point’s deviation from the median of the entire sample. That is, for a
+    random variable `X`, the median absolute deviation is `median(|median(X) - X|)`.
+
+    :param number: Multivalue expression.
+    """
+    return InstrumentedExpression(f"MV_MEDIAN_ABSOLUTE_DEVIATION({_render(number)})")
+
+
+def mv_min(field: ExpressionType) -> InstrumentedExpression:
+    """Converts a multivalued expression into a single valued column containing
+    the minimum value.
+
+    :param field: Multivalue expression.
+    """
+    return InstrumentedExpression(f"MV_MIN({_render(field)})")
+
+
+def mv_percentile(
+    number: ExpressionType, percentile: ExpressionType
+) -> InstrumentedExpression:
+    """Converts a multivalued field into a single valued field containing the
+    value at which a certain percentage of observed values occur.
+
+    :param number: Multivalue expression.
+    :param percentile: The percentile to calculate. Must be a number between 0
+                       and 100. Numbers out of range will return a null instead.
+    """
+    return InstrumentedExpression(
+        f"MV_PERCENTILE({_render(number)}, {_render(percentile)})"
+    )
+
+
+def mv_pseries_weighted_sum(
+    number: ExpressionType, p: ExpressionType
+) -> InstrumentedExpression:
+    """Converts a multivalued expression into a single-valued column by
+    multiplying every element on the input list by its corresponding term in
+    P-Series and computing the sum.
+
+    :param number: Multivalue expression.
+    :param p: It is a constant number that represents the *p* parameter in the
+              P-Series. It impacts every element’s contribution to the weighted sum.
+    """
+    return InstrumentedExpression(
+        f"MV_PSERIES_WEIGHTED_SUM({_render(number)}, {_render(p)})"
+    )
+
+
+def mv_slice(
+    field: ExpressionType, start: ExpressionType, end: ExpressionType = None
+) -> InstrumentedExpression:
+    """Returns a subset of the multivalued field using the start and end index
+    values. This is most useful when reading from a function that emits
+    multivalued columns in a known order like `SPLIT` or `MV_SORT`.
+
+    :param field: Multivalue expression. If `null`, the function returns `null`.
+    :param start: Start position. If `null`, the function returns `null`. The
+                  start argument can be negative. An index of -1 is used to specify
+                  the last value in the list.
+    :param end: End position(included). Optional; if omitted, the position at
+                `start` is returned. The end argument can be negative. An index of -1
+                is used to specify the last value in the list.
+    """
+    if end is not None:
+        return InstrumentedExpression(
+            f"MV_SLICE({_render(field)}, {_render(start)}, {_render(end)})"
+        )
+    else:
+        return InstrumentedExpression(f"MV_SLICE({_render(field)}, {_render(start)})")
+
+
+def mv_sort(field: ExpressionType, order: ExpressionType) -> InstrumentedExpression:
+    """Sorts a multivalued field in lexicographical order.
+
+    :param field: Multivalue expression. If `null`, the function returns `null`.
+    :param order: Sort order. The valid options are ASC and DESC, the default is ASC.
+    """
+    return InstrumentedExpression(f"MV_SORT({_render(field)}, {_render(order)})")
+
+
+def mv_sum(number: ExpressionType) -> InstrumentedExpression:
+    """Converts a multivalued field into a single valued field containing the
+    sum of all of the values.
+
+    :param number: Multivalue expression.
+    """
+    return InstrumentedExpression(f"MV_SUM({_render(number)})")
+
+
+def mv_zip(
+    string1: ExpressionType, string2: ExpressionType, delim: ExpressionType = None
+) -> InstrumentedExpression:
+    """Combines the values from two multivalued fields with a delimiter that
+    joins them together.
+
+    :param string1: Multivalue expression.
+    :param string2: Multivalue expression.
+    :param delim: Delimiter. Optional; if omitted, `,` is used as a default delimiter.
+    """
+    if delim is not None:
+        return InstrumentedExpression(f"MV_ZIP({string1}, {string2}, {_render(delim)})")
+    else:
+        return InstrumentedExpression(f"MV_ZIP({string1}, {string2})")
+
+
+def now() -> InstrumentedExpression:
+    """Returns current date and time."""
+    return InstrumentedExpression("NOW()")
+
+
+def percentile(
+    number: ExpressionType, percentile: ExpressionType
+) -> InstrumentedExpression:
+    """Returns the value at which a certain percentage of observed values
+    occur. For example, the 95th percentile is the value which is greater than
+    95% of the observed values and the 50th percentile is the `MEDIAN`.
+
+    :param number:
+    :param percentile:
+    """
+    return InstrumentedExpression(
+        f"PERCENTILE({_render(number)}, {_render(percentile)})"
+    )
+
+
+def pi() -> InstrumentedExpression:
+    """Returns Pi, the ratio of a circle’s circumference to its diameter."""
+    return InstrumentedExpression("PI()")
+
+
+def pow(base: ExpressionType, exponent: ExpressionType) -> InstrumentedExpression:
+    """Returns the value of `base` raised to the power of `exponent`.
+
+    :param base: Numeric expression for the base. If `null`, the function returns `null`.
+    :param exponent: Numeric expression for the exponent. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"POW({_render(base)}, {_render(exponent)})")
+
+
+def qstr(
+    query: ExpressionType, options: ExpressionType = None
+) -> InstrumentedExpression:
+    """Performs a query string query. Returns true if the provided query string
+    matches the row.
+
+    :param query: Query string in Lucene query string format.
+    :param options: (Optional) Additional options for Query String as function named
+                    parameters.
+    """
+    if options is not None:
+        return InstrumentedExpression(f"QSTR({_render(query)}, {_render(options)})")
+    else:
+        return InstrumentedExpression(f"QSTR({_render(query)})")
+
+
+def rate(field: ExpressionType) -> InstrumentedExpression:
+    """The rate of a counter field.
+
+    :param field:
+    """
+    return InstrumentedExpression(f"RATE({_render(field)})")
+
+
+def repeat(string: ExpressionType, number: ExpressionType) -> InstrumentedExpression:
+    """Returns a string constructed by concatenating `string` with itself the
+    specified `number` of times.
+
+    :param string: String expression.
+    :param number: Number times to repeat.
+    """
+    return InstrumentedExpression(f"REPEAT({_render(string)}, {_render(number)})")
+
+
+def replace(
+    string: ExpressionType, regex: ExpressionType, new_string: ExpressionType
+) -> InstrumentedExpression:
+    """The function substitutes in the string `str` any match of the regular
+    expression `regex` with the replacement string `newStr`.
+
+    :param string: String expression.
+    :param regex: Regular expression.
+    :param new_string: Replacement string.
+    """
+    return InstrumentedExpression(
+        f"REPLACE({_render(string)}, {_render(regex)}, {_render(new_string)})"
+    )
+
+
+def reverse(str: ExpressionType) -> InstrumentedExpression:
+    """Returns a new string representing the input string in reverse order.
+
+    :param str: String expression. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"REVERSE({_render(str)})")
+
+
+def right(string: ExpressionType, length: ExpressionType) -> InstrumentedExpression:
+    """Return the substring that extracts *length* chars from *str* starting
+    from the right.
+
+    :param string: The string from which to returns a substring.
+    :param length: The number of characters to return.
+    """
+    return InstrumentedExpression(f"RIGHT({_render(string)}, {_render(length)})")
+
+
+def round(
+    number: ExpressionType, decimals: ExpressionType = None
+) -> InstrumentedExpression:
+    """Rounds a number to the specified number of decimal places. Defaults to
+    0, which returns the nearest integer. If the precision is a negative
+    number, rounds to the number of digits left of the decimal point.
+
+    :param number: The numeric value to round. If `null`, the function returns `null`.
+    :param decimals: The number of decimal places to round to. Defaults to 0. If
+                     `null`, the function returns `null`.
+    """
+    if decimals is not None:
+        return InstrumentedExpression(f"ROUND({_render(number)}, {_render(decimals)})")
+    else:
+        return InstrumentedExpression(f"ROUND({_render(number)})")
+
+
+def round_to(field: ExpressionType, points: ExpressionType) -> InstrumentedExpression:
+    """Rounds down to one of a list of fixed points.
+
+    :param field: The numeric value to round. If `null`, the function returns `null`.
+    :param points: Remaining rounding points. Must be constants.
+    """
+    return InstrumentedExpression(f"ROUND_TO({_render(field)}, {_render(points)})")
+
+
+def rtrim(string: ExpressionType) -> InstrumentedExpression:
+    """Removes trailing whitespaces from a string.
+
+    :param string: String expression. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"RTRIM({_render(string)})")
+
+
+def sample(field: ExpressionType, limit: ExpressionType) -> InstrumentedExpression:
+    """Collects sample values for a field.
+
+    :param field: The field to collect sample values for.
+    :param limit: The maximum number of values to collect.
+    """
+    return InstrumentedExpression(f"SAMPLE({_render(field)}, {_render(limit)})")
+
+
+def scalb(d: ExpressionType, scale_factor: ExpressionType) -> InstrumentedExpression:
+    """Returns the result of `d * 2 ^ scaleFactor`, Similar to Java's `scalb`
+    function. Result is rounded as if performed by a single correctly rounded
+    floating-point multiply to a member of the double value set.
+
+    :param d: Numeric expression for the multiplier. If `null`, the function
+              returns `null`.
+    :param scale_factor: Numeric expression for the scale factor. If `null`, the
+                         function returns `null`.
+    """
+    return InstrumentedExpression(f"SCALB({_render(d)}, {_render(scale_factor)})")
+
+
+def sha1(input: ExpressionType) -> InstrumentedExpression:
+    """Computes the SHA1 hash of the input.
+
+    :param input: Input to hash.
+    """
+    return InstrumentedExpression(f"SHA1({_render(input)})")
+
+
+def sha256(input: ExpressionType) -> InstrumentedExpression:
+    """Computes the SHA256 hash of the input.
+
+    :param input: Input to hash.
+    """
+    return InstrumentedExpression(f"SHA256({_render(input)})")
+
+
+def signum(number: ExpressionType) -> InstrumentedExpression:
+    """Returns the sign of the given number. It returns `-1` for negative
+    numbers, `0` for `0` and `1` for positive numbers.
+
+    :param number: Numeric expression. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"SIGNUM({_render(number)})")
+
+
+def sin(angle: ExpressionType) -> InstrumentedExpression:
+    """Returns the sine of an angle.
+
+    :param angle: An angle, in radians. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"SIN({_render(angle)})")
+
+
+def sinh(number: ExpressionType) -> InstrumentedExpression:
+    """Returns the hyperbolic sine of a number.
+
+    :param number: Numeric expression. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"SINH({_render(number)})")
+
+
+def space(number: ExpressionType) -> InstrumentedExpression:
+    """Returns a string made of `number` spaces.
+
+    :param number: Number of spaces in result.
+    """
+    return InstrumentedExpression(f"SPACE({_render(number)})")
+
+
+def split(string: ExpressionType, delim: ExpressionType) -> InstrumentedExpression:
+    """Split a single valued string into multiple strings.
+
+    :param string: String expression. If `null`, the function returns `null`.
+    :param delim: Delimiter. Only single byte delimiters are currently supported.
+    """
+    return InstrumentedExpression(f"SPLIT({_render(string)}, {_render(delim)})")
+
+
+def sqrt(number: ExpressionType) -> InstrumentedExpression:
+    """Returns the square root of a number. The input can be any numeric value,
+    the return value is always a double. Square roots of negative numbers and
+    infinities are null.
+
+    :param number: Numeric expression. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"SQRT({_render(number)})")
+
+
+def starts_with(str: ExpressionType, prefix: ExpressionType) -> InstrumentedExpression:
+    """Returns a boolean that indicates whether a keyword string starts with
+    another string.
+
+    :param str: String expression. If `null`, the function returns `null`.
+    :param prefix: String expression. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"STARTS_WITH({_render(str)}, {_render(prefix)})")
+
+
+def std_dev(number: ExpressionType) -> InstrumentedExpression:
+    """The population standard deviation of a numeric field.
+
+    :param number:
+    """
+    return InstrumentedExpression(f"STD_DEV({_render(number)})")
+
+
+def st_centroid_agg(field: ExpressionType) -> InstrumentedExpression:
+    """Calculate the spatial centroid over a field with spatial point geometry type.
+
+    :param field:
+    """
+    return InstrumentedExpression(f"ST_CENTROID_AGG({_render(field)})")
+
+
+def st_contains(
+    geom_a: ExpressionType, geom_b: ExpressionType
+) -> InstrumentedExpression:
+    """Returns whether the first geometry contains the second geometry. This is
+    the inverse of the ST_WITHIN function.
+
+    :param geom_a: Expression of type `geo_point`, `cartesian_point`,
+                   `geo_shape` or `cartesian_shape`. If `null`, the function returns
+                   `null`.
+    :param geom_b: Expression of type `geo_point`, `cartesian_point`, `geo_shape`
+                   or `cartesian_shape`. If `null`, the function returns `null`. The
+                   second parameter must also have the same coordinate system as the
+                   first. This means it is not possible to combine `geo_*` and
+                   `cartesian_*` parameters.
+    """
+    return InstrumentedExpression(f"ST_CONTAINS({_render(geom_a)}, {_render(geom_b)})")
+
+
+def st_disjoint(
+    geom_a: ExpressionType, geom_b: ExpressionType
+) -> InstrumentedExpression:
+    """Returns whether the two geometries or geometry columns are disjoint.
+    This is the inverse of the ST_INTERSECTS function. In mathematical terms:
+    ST_Disjoint(A, B) ⇔ A ⋂ B = ∅
+
+    :param geom_a: Expression of type `geo_point`, `cartesian_point`,
+                   `geo_shape` or `cartesian_shape`. If `null`, the function returns
+                   `null`.
+    :param geom_b: Expression of type `geo_point`, `cartesian_point`, `geo_shape`
+                   or `cartesian_shape`. If `null`, the function returns `null`. The
+                   second parameter must also have the same coordinate system as the
+                   first. This means it is not possible to combine `geo_*` and
+                   `cartesian_*` parameters.
+    """
+    return InstrumentedExpression(f"ST_DISJOINT({_render(geom_a)}, {_render(geom_b)})")
+
+
+def st_distance(
+    geom_a: ExpressionType, geom_b: ExpressionType
+) -> InstrumentedExpression:
+    """Computes the distance between two points. For cartesian geometries, this
+    is the pythagorean distance in the same units as the original coordinates.
+    For geographic geometries, this is the circular distance along the great
+    circle in meters.
+
+    :param geom_a: Expression of type `geo_point` or `cartesian_point`. If
+                   `null`, the function returns `null`.
+    :param geom_b: Expression of type `geo_point` or `cartesian_point`. If
+                   `null`, the function returns `null`. The second parameter must
+                   also have the same coordinate system as the first. This means it
+                   is not possible to combine `geo_point` and `cartesian_point` parameters.
+    """
+    return InstrumentedExpression(f"ST_DISTANCE({_render(geom_a)}, {_render(geom_b)})")
+
+
+def st_envelope(geometry: ExpressionType) -> InstrumentedExpression:
+    """Determines the minimum bounding box of the supplied geometry.
+
+    :param geometry: Expression of type `geo_point`, `geo_shape`,
+                     `cartesian_point` or `cartesian_shape`. If `null`, the function
+                     returns `null`.
+    """
+    return InstrumentedExpression(f"ST_ENVELOPE({_render(geometry)})")
+
+
+def st_extent_agg(field: ExpressionType) -> InstrumentedExpression:
+    """Calculate the spatial extent over a field with geometry type. Returns a
+    bounding box for all values of the field.
+
+    :param field:
+    """
+    return InstrumentedExpression(f"ST_EXTENT_AGG({_render(field)})")
+
+
+def st_geohash(
+    geometry: ExpressionType, precision: ExpressionType, bounds: ExpressionType = None
+) -> InstrumentedExpression:
+    """Calculates the `geohash` of the supplied geo_point at the specified
+    precision. The result is long encoded. Use ST_GEOHASH_TO_STRING to convert
+    the result to a string.  These functions are related to the `geo_grid`
+    query and the `geohash_grid` aggregation.
+
+    :param geometry: Expression of type `geo_point`. If `null`, the function
+                     returns `null`.
+    :param precision: Expression of type `integer`. If `null`, the function
+                      returns `null`. Valid values are between 1 and 12.
+    :param bounds: Optional bounds to filter the grid tiles, a `geo_shape` of
+                   type `BBOX`. Use `ST_ENVELOPE` if the `geo_shape` is of any
+                   other type.
+    """
+    if bounds is not None:
+        return InstrumentedExpression(
+            f"ST_GEOHASH({_render(geometry)}, {_render(precision)}, {_render(bounds)})"
+        )
+    else:
+        return InstrumentedExpression(
+            f"ST_GEOHASH({_render(geometry)}, {_render(precision)})"
+        )
+
+
+def st_geohash_to_long(grid_id: ExpressionType) -> InstrumentedExpression:
+    """Converts an input value representing a geohash grid-ID in string format
+    into a long.
+
+    :param grid_id: Input geohash grid-id. The input can be a single- or
+                    multi-valued column or an expression.
+    """
+    return InstrumentedExpression(f"ST_GEOHASH_TO_LONG({_render(grid_id)})")
+
+
+def st_geohash_to_string(grid_id: ExpressionType) -> InstrumentedExpression:
+    """Converts an input value representing a geohash grid-ID in long format
+    into a string.
+
+    :param grid_id: Input geohash grid-id. The input can be a single- or
+                    multi-valued column or an expression.
+    """
+    return InstrumentedExpression(f"ST_GEOHASH_TO_STRING({_render(grid_id)})")
+
+
+def st_geohex(
+    geometry: ExpressionType, precision: ExpressionType, bounds: ExpressionType = None
+) -> InstrumentedExpression:
+    """Calculates the `geohex`, the H3 cell-id, of the supplied geo_point at
+    the specified precision. The result is long encoded. Use
+    ST_GEOHEX_TO_STRING to convert the result to a string.  These functions are
+    related to the `geo_grid` query and the `geohex_grid` aggregation.
+
+    :param geometry: Expression of type `geo_point`. If `null`, the function
+                     returns `null`.
+    :param precision: Expression of type `integer`. If `null`, the function
+                      returns `null`. Valid values are between 0 and 15.
+    :param bounds: Optional bounds to filter the grid tiles, a `geo_shape` of
+                   type `BBOX`. Use `ST_ENVELOPE` if the `geo_shape`
+                   is of any other type.
+    """
+    if bounds is not None:
+        return InstrumentedExpression(
+            f"ST_GEOHEX({_render(geometry)}, {_render(precision)}, {_render(bounds)})"
+        )
+    else:
+        return InstrumentedExpression(
+            f"ST_GEOHEX({_render(geometry)}, {_render(precision)})"
+        )
+
+
+def st_geohex_to_long(grid_id: ExpressionType) -> InstrumentedExpression:
+    """Converts an input value representing a geohex grid-ID in string format
+    into a long.
+
+    :param grid_id: Input geohex grid-id. The input can be a single- or
+                    multi-valued column or an expression.
+    """
+    return InstrumentedExpression(f"ST_GEOHEX_TO_LONG({_render(grid_id)})")
+
+
+def st_geohex_to_string(grid_id: ExpressionType) -> InstrumentedExpression:
+    """Converts an input value representing a Geohex grid-ID in long format
+    into a string.
+
+    :param grid_id: Input Geohex grid-id. The input can be a single- or
+                    multi-valued column or an expression.
+    """
+    return InstrumentedExpression(f"ST_GEOHEX_TO_STRING({_render(grid_id)})")
+
+
+def st_geotile(
+    geometry: ExpressionType, precision: ExpressionType, bounds: ExpressionType = None
+) -> InstrumentedExpression:
+    """Calculates the `geotile` of the supplied geo_point at the specified
+    precision. The result is long encoded. Use ST_GEOTILE_TO_STRING to convert
+    the result to a string.  These functions are related to the `geo_grid`
+    query and the `geotile_grid` aggregation.
+
+    :param geometry: Expression of type `geo_point`. If `null`, the function
+                     returns `null`.
+    :param precision: Expression of type `integer`. If `null`, the function
+                      returns `null`. Valid values are between 0 and 29.
+    :param bounds: Optional bounds to filter the grid tiles, a `geo_shape` of
+                   type `BBOX`. Use `ST_ENVELOPE` if the `geo_shape` is of any
+                   other type.
+    """
+    if bounds is not None:
+        return InstrumentedExpression(
+            f"ST_GEOTILE({_render(geometry)}, {_render(precision)}, {_render(bounds)})"
+        )
+    else:
+        return InstrumentedExpression(
+            f"ST_GEOTILE({_render(geometry)}, {_render(precision)})"
+        )
+
+
+def st_geotile_to_long(grid_id: ExpressionType) -> InstrumentedExpression:
+    """Converts an input value representing a geotile grid-ID in string format
+    into a long.
+
+    :param grid_id: Input geotile grid-id. The input can be a single- or
+                    multi-valued column or an expression.
+    """
+    return InstrumentedExpression(f"ST_GEOTILE_TO_LONG({_render(grid_id)})")
+
+
+def st_geotile_to_string(grid_id: ExpressionType) -> InstrumentedExpression:
+    """Converts an input value representing a geotile grid-ID in long format
+    into a string.
+
+    :param grid_id: Input geotile grid-id. The input can be a single- or
+                    multi-valued column or an expression.
+    """
+    return InstrumentedExpression(f"ST_GEOTILE_TO_STRING({_render(grid_id)})")
+
+
+def st_intersects(
+    geom_a: ExpressionType, geom_b: ExpressionType
+) -> InstrumentedExpression:
+    """Returns true if two geometries intersect. They intersect if they have
+    any point in common, including their interior points (points along lines or
+    within polygons). This is the inverse of the ST_DISJOINT function. In
+    mathematical terms: ST_Intersects(A, B) ⇔ A ⋂ B ≠ ∅
+
+    :param geom_a: Expression of type `geo_point`, `cartesian_point`,
+                   `geo_shape` or `cartesian_shape`. If `null`, the function returns
+                   `null`.
+    :param geom_b: Expression of type `geo_point`, `cartesian_point`, `geo_shape`
+                   or `cartesian_shape`. If `null`, the function returns `null`. The
+                   second parameter must also have the same coordinate system as the
+                   first. This means it is not possible to combine `geo_*` and
+                   `cartesian_*` parameters.
+    """
+    return InstrumentedExpression(
+        f"ST_INTERSECTS({_render(geom_a)}, {_render(geom_b)})"
+    )
+
+
+def st_within(geom_a: ExpressionType, geom_b: ExpressionType) -> InstrumentedExpression:
+    """Returns whether the first geometry is within the second geometry. This
+    is the inverse of the ST_CONTAINS function.
+
+    :param geom_a: Expression of type `geo_point`, `cartesian_point`,
+                   `geo_shape` or `cartesian_shape`. If `null`, the function returns
+                   `null`.
+    :param geom_b: Expression of type `geo_point`, `cartesian_point`, `geo_shape`
+                   or `cartesian_shape`. If `null`, the function returns `null`. The
+                   second parameter must also have the same coordinate system as the
+                   first. This means it is not possible to combine `geo_*` and
+                   `cartesian_*` parameters.
+    """
+    return InstrumentedExpression(f"ST_WITHIN({_render(geom_a)}, {_render(geom_b)})")
+
+
+def st_x(point: ExpressionType) -> InstrumentedExpression:
+    """Extracts the `x` coordinate from the supplied point. If the points is of
+    type `geo_point` this is equivalent to extracting the `longitude` value.
+
+    :param point: Expression of type `geo_point` or `cartesian_point`. If
+                  `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"ST_X({_render(point)})")
+
+
+def st_xmax(point: ExpressionType) -> InstrumentedExpression:
+    """Extracts the maximum value of the `x` coordinates from the supplied
+    geometry. If the geometry is of type `geo_point` or `geo_shape` this is
+    equivalent to extracting the maximum `longitude` value.
+
+    :param point: Expression of type `geo_point`, `geo_shape`, `cartesian_point`
+                  or `cartesian_shape`. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"ST_XMAX({_render(point)})")
+
+
+def st_xmin(point: ExpressionType) -> InstrumentedExpression:
+    """Extracts the minimum value of the `x` coordinates from the supplied
+    geometry. If the geometry is of type `geo_point` or `geo_shape` this is
+    equivalent to extracting the minimum `longitude` value.
+
+    :param point: Expression of type `geo_point`, `geo_shape`, `cartesian_point`
+                  or `cartesian_shape`. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"ST_XMIN({_render(point)})")
+
+
+def st_y(point: ExpressionType) -> InstrumentedExpression:
+    """Extracts the `y` coordinate from the supplied point. If the points is of
+    type `geo_point` this is equivalent to extracting the `latitude` value.
+
+    :param point: Expression of type `geo_point` or `cartesian_point`. If
+                  `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"ST_Y({_render(point)})")
+
+
+def st_ymax(point: ExpressionType) -> InstrumentedExpression:
+    """Extracts the maximum value of the `y` coordinates from the supplied
+    geometry. If the geometry is of type `geo_point` or `geo_shape` this is
+    equivalent to extracting the maximum `latitude` value.
+
+    :param point: Expression of type `geo_point`, `geo_shape`, `cartesian_point`
+                  or `cartesian_shape`. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"ST_YMAX({_render(point)})")
+
+
+def st_ymin(point: ExpressionType) -> InstrumentedExpression:
+    """Extracts the minimum value of the `y` coordinates from the supplied
+    geometry. If the geometry is of type `geo_point` or `geo_shape` this is
+    equivalent to extracting the minimum `latitude` value.
+
+    :param point: Expression of type `geo_point`, `geo_shape`, `cartesian_point`
+                  or `cartesian_shape`. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"ST_YMIN({_render(point)})")
+
+
+def substring(
+    string: ExpressionType, start: ExpressionType, length: ExpressionType = None
+) -> InstrumentedExpression:
+    """Returns a substring of a string, specified by a start position and an
+    optional length.
+
+    :param string: String expression. If `null`, the function returns `null`.
+    :param start: Start position.
+    :param length: Length of the substring from the start position. Optional; if
+                   omitted, all positions after `start` are returned.
+    """
+    if length is not None:
+        return InstrumentedExpression(
+            f"SUBSTRING({_render(string)}, {_render(start)}, {_render(length)})"
+        )
+    else:
+        return InstrumentedExpression(f"SUBSTRING({_render(string)}, {_render(start)})")
+
+
+def sum(number: ExpressionType) -> InstrumentedExpression:
+    """The sum of a numeric expression.
+
+    :param number:
+    """
+    return InstrumentedExpression(f"SUM({_render(number)})")
+
+
+def tan(angle: ExpressionType) -> InstrumentedExpression:
+    """Returns the tangent of an angle.
+
+    :param angle: An angle, in radians. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"TAN({_render(angle)})")
+
+
+def tanh(number: ExpressionType) -> InstrumentedExpression:
+    """Returns the hyperbolic tangent of a number.
+
+    :param number: Numeric expression. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"TANH({_render(number)})")
+
+
+def tau() -> InstrumentedExpression:
+    """Returns the ratio of a circle’s circumference to its radius."""
+    return InstrumentedExpression("TAU()")
+
+
+def term(field: ExpressionType, query: ExpressionType) -> InstrumentedExpression:
+    """Performs a Term query on the specified field. Returns true if the
+    provided term matches the row.
+
+    :param field: Field that the query will target.
+    :param query: Term you wish to find in the provided field.
+    """
+    return InstrumentedExpression(f"TERM({_render(field)}, {_render(query)})")
+
+
+def top(
+    field: ExpressionType, limit: ExpressionType, order: ExpressionType
+) -> InstrumentedExpression:
+    """Collects the top values for a field. Includes repeated values.
+
+    :param field: The field to collect the top values for.
+    :param limit: The maximum number of values to collect.
+    :param order: The order to calculate the top values. Either `asc` or `desc`.
+    """
+    return InstrumentedExpression(
+        f"TOP({_render(field)}, {_render(limit)}, {_render(order)})"
+    )
+
+
+def to_aggregate_metric_double(number: ExpressionType) -> InstrumentedExpression:
+    """Encode a numeric to an aggregate_metric_double.
+
+    :param number: Input value. The input can be a single- or multi-valued
+                   column or an expression.
+    """
+    return InstrumentedExpression(f"TO_AGGREGATE_METRIC_DOUBLE({_render(number)})")
+
+
+def to_base64(string: ExpressionType) -> InstrumentedExpression:
+    """Encode a string to a base64 string.
+
+    :param string: A string.
+    """
+    return InstrumentedExpression(f"TO_BASE64({_render(string)})")
+
+
+def to_boolean(field: ExpressionType) -> InstrumentedExpression:
+    """Converts an input value to a boolean value. A string value of `true`
+    will be case-insensitive converted to the Boolean `true`. For anything
+    else, including the empty string, the function will return `false`. The
+    numerical value of `0` will be converted to `false`, anything else will be
+    converted to `true`.
+
+    :param field: Input value. The input can be a single- or multi-valued column
+                  or an expression.
+    """
+    return InstrumentedExpression(f"TO_BOOLEAN({_render(field)})")
+
+
+def to_cartesianpoint(field: ExpressionType) -> InstrumentedExpression:
+    """Converts an input value to a `cartesian_point` value. A string will only
+    be successfully converted if it respects the WKT Point format.
+
+    :param field: Input value. The input can be a single- or multi-valued column
+                  or an expression.
+    """
+    return InstrumentedExpression(f"TO_CARTESIANPOINT({_render(field)})")
+
+
+def to_cartesianshape(field: ExpressionType) -> InstrumentedExpression:
+    """Converts an input value to a `cartesian_shape` value. A string will only
+    be successfully converted if it respects the WKT format.
+
+    :param field: Input value. The input can be a single- or multi-valued column
+                  or an expression.
+    """
+    return InstrumentedExpression(f"TO_CARTESIANSHAPE({_render(field)})")
+
+
+def to_dateperiod(field: ExpressionType) -> InstrumentedExpression:
+    """Converts an input value into a `date_period` value.
+
+    :param field: Input value. The input is a valid constant date period expression.
+    """
+    return InstrumentedExpression(f"TO_DATEPERIOD({_render(field)})")
+
+
+def to_datetime(field: ExpressionType) -> InstrumentedExpression:
+    """Converts an input value to a date value. A string will only be
+    successfully converted if it’s respecting the format
+    `yyyy-MM-dd'T'HH:mm:ss.SSS'Z'`. To convert dates in other formats, use `DATE_PARSE`.
+
+    :param field: Input value. The input can be a single- or multi-valued column
+                  or an expression.
+    """
+    return InstrumentedExpression(f"TO_DATETIME({_render(field)})")
+
+
+def to_date_nanos(field: ExpressionType) -> InstrumentedExpression:
+    """Converts an input to a nanosecond-resolution date value (aka date_nanos).
+
+    :param field: Input value. The input can be a single- or multi-valued column
+                  or an expression.
+    """
+    return InstrumentedExpression(f"TO_DATE_NANOS({_render(field)})")
+
+
+def to_degrees(number: ExpressionType) -> InstrumentedExpression:
+    """Converts a number in radians to degrees).
+
+    :param number: Input value. The input can be a single- or multi-valued
+                   column or an expression.
+    """
+    return InstrumentedExpression(f"TO_DEGREES({_render(number)})")
+
+
+def to_double(field: ExpressionType) -> InstrumentedExpression:
+    """Converts an input value to a double value. If the input parameter is of
+    a date type, its value will be interpreted as milliseconds since the Unix
+    epoch, converted to double. Boolean `true` will be converted to double
+    `1.0`, `false` to `0.0`.
+
+    :param field: Input value. The input can be a single- or multi-valued column
+                  or an expression.
+    """
+    return InstrumentedExpression(f"TO_DOUBLE({_render(field)})")
+
+
+def to_geopoint(field: ExpressionType) -> InstrumentedExpression:
+    """Converts an input value to a `geo_point` value. A string will only be
+    successfully converted if it respects the WKT Point format.
+
+    :param field: Input value. The input can be a single- or multi-valued column
+                  or an expression.
+    """
+    return InstrumentedExpression(f"TO_GEOPOINT({_render(field)})")
+
+
+def to_geoshape(field: ExpressionType) -> InstrumentedExpression:
+    """Converts an input value to a `geo_shape` value. A string will only be
+    successfully converted if it respects the WKT format.
+
+    :param field: Input value. The input can be a single- or multi-valued column
+                  or an expression.
+    """
+    return InstrumentedExpression(f"TO_GEOSHAPE({_render(field)})")
+
+
+def to_integer(field: ExpressionType) -> InstrumentedExpression:
+    """Converts an input value to an integer value. If the input parameter is
+    of a date type, its value will be interpreted as milliseconds since the
+    Unix epoch, converted to integer. Boolean `true` will be converted to
+    integer `1`, `false` to `0`.
+
+    :param field: Input value. The input can be a single- or multi-valued column
+                  or an expression.
+    """
+    return InstrumentedExpression(f"TO_INTEGER({_render(field)})")
+
+
+def to_ip(
+    field: ExpressionType, options: ExpressionType = None
+) -> InstrumentedExpression:
+    """Converts an input string to an IP value.
+
+    :param field: Input value. The input can be a single- or multi-valued column
+                  or an expression.
+    :param options: (Optional) Additional options.
+    """
+    if options is not None:
+        return InstrumentedExpression(f"TO_IP({_render(field)}, {_render(options)})")
+    else:
+        return InstrumentedExpression(f"TO_IP({_render(field)})")
+
+
+def to_long(field: ExpressionType) -> InstrumentedExpression:
+    """Converts an input value to a long value. If the input parameter is of a
+    date type, its value will be interpreted as milliseconds since the Unix
+    epoch, converted to long. Boolean `true` will be converted to long `1`,
+    `false` to `0`.
+
+    :param field: Input value. The input can be a single- or multi-valued column
+                  or an expression.
+    """
+    return InstrumentedExpression(f"TO_LONG({_render(field)})")
+
+
+def to_lower(str: ExpressionType) -> InstrumentedExpression:
+    """Returns a new string representing the input string converted to lower case.
+
+    :param str: String expression. If `null`, the function returns `null`. The
+                input can be a single-valued column or expression, or a multi-valued
+                column or expression.
+    """
+    return InstrumentedExpression(f"TO_LOWER({_render(str)})")
+
+
+def to_radians(number: ExpressionType) -> InstrumentedExpression:
+    """Converts a number in degrees) to radians.
+
+    :param number: Input value. The input can be a single- or multi-valued
+                   column or an expression.
+    """
+    return InstrumentedExpression(f"TO_RADIANS({_render(number)})")
+
+
+def to_string(field: ExpressionType) -> InstrumentedExpression:
+    """Converts an input value into a string.
+
+    :param field: Input value. The input can be a single- or multi-valued column
+                  or an expression.
+    """
+    return InstrumentedExpression(f"TO_STRING({_render(field)})")
+
+
+def to_timeduration(field: ExpressionType) -> InstrumentedExpression:
+    """Converts an input value into a `time_duration` value.
+
+    :param field: Input value. The input is a valid constant time duration expression.
+    """
+    return InstrumentedExpression(f"TO_TIMEDURATION({_render(field)})")
+
+
+def to_unsigned_long(field: ExpressionType) -> InstrumentedExpression:
+    """Converts an input value to an unsigned long value. If the input
+    parameter is of a date type, its value will be interpreted as milliseconds
+    since the Unix epoch, converted to unsigned long. Boolean `true` will be
+    converted to unsigned long `1`, `false` to `0`.
+
+    :param field: Input value. The input can be a single- or multi-valued column
+                  or an expression.
+    """
+    return InstrumentedExpression(f"TO_UNSIGNED_LONG({_render(field)})")
+
+
+def to_upper(str: ExpressionType) -> InstrumentedExpression:
+    """Returns a new string representing the input string converted to upper case.
+
+    :param str: String expression. If `null`, the function returns `null`. The
+                input can be a single-valued column or expression, or a multi-valued
+                column or expression.
+    """
+    return InstrumentedExpression(f"TO_UPPER({_render(str)})")
+
+
+def to_version(field: ExpressionType) -> InstrumentedExpression:
+    """Converts an input string to a version value.
+
+    :param field: Input value. The input can be a single- or multi-valued column
+                  or an expression.
+    """
+    return InstrumentedExpression(f"TO_VERSION({_render(field)})")
+
+
+def trim(string: ExpressionType) -> InstrumentedExpression:
+    """Removes leading and trailing whitespaces from a string.
+
+    :param string: String expression. If `null`, the function returns `null`.
+    """
+    return InstrumentedExpression(f"TRIM({_render(string)})")
+
+
+def values(field: ExpressionType) -> InstrumentedExpression:
+    """Returns unique values as a multivalued field. The order of the returned
+    values isn’t guaranteed. If you need the values returned in order use `MV_SORT`.
+
+    :param field:
+    """
+    return InstrumentedExpression(f"VALUES({_render(field)})")
+
+
+def weighted_avg(
+    number: ExpressionType, weight: ExpressionType
+) -> InstrumentedExpression:
+    """The weighted average of a numeric expression.
+
+    :param number: A numeric value.
+    :param weight: A numeric weight.
+    """
+    return InstrumentedExpression(f"WEIGHTED_AVG({_render(number)}, {_render(weight)})")
diff --git a/elasticsearch/exceptions.py b/elasticsearch/exceptions.py
index dc410ae30..70738d5af 100644
--- a/elasticsearch/exceptions.py
+++ b/elasticsearch/exceptions.py
@@ -61,6 +61,7 @@ def __str__(self) -> str:
             if self.body and isinstance(self.body, dict) and "error" in self.body:
                 if isinstance(self.body["error"], dict):
                     root_cause = self.body["error"]["root_cause"][0]
+                    caused_by = self.body["error"].get("caused_by", {})
                     cause = ", ".join(
                         filter(
                             None,
@@ -68,6 +69,7 @@ def __str__(self) -> str:
                                 repr(root_cause["reason"]),
                                 root_cause.get("resource.id"),
                                 root_cause.get("resource.type"),
+                                caused_by.get("reason"),
                             ],
                         )
                     )
diff --git a/elasticsearch/transport.py b/elasticsearch/transport.py
deleted file mode 100644
index 5d84866aa..000000000
--- a/elasticsearch/transport.py
+++ /dev/null
@@ -1,57 +0,0 @@
-#  Licensed to Elasticsearch B.V. under one or more contributor
-#  license agreements. See the NOTICE file distributed with
-#  this work for additional information regarding copyright
-#  ownership. Elasticsearch B.V. licenses this file to you under
-#  the Apache License, Version 2.0 (the "License"); you may
-#  not use this file except in compliance with the License.
-#  You may obtain a copy of the License at
-#
-# 	http://www.apache.org/licenses/LICENSE-2.0
-#
-#  Unless required by applicable law or agreed to in writing,
-#  software distributed under the License is distributed on an
-#  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-#  KIND, either express or implied.  See the License for the
-#  specific language governing permissions and limitations
-#  under the License.
-
-import warnings
-from typing import Any, Dict, Optional, Union
-
-from elastic_transport import AsyncTransport, Transport  # noqa: F401
-
-# This file exists for backwards compatibility.
-warnings.warn(
-    "Importing from the 'elasticsearch.transport' module is deprecated. "
-    "Instead import from 'elastic_transport'",
-    category=DeprecationWarning,
-    stacklevel=2,
-)
-
-
-def get_host_info(
-    node_info: Dict[str, Any], host: Dict[str, Union[int, str]]
-) -> Optional[Dict[str, Union[int, str]]]:
-    """
-    Simple callback that takes the node info from `/_cluster/nodes` and a
-    parsed connection information and return the connection information. If
-    `None` is returned this node will be skipped.
-    Useful for filtering nodes (by proximity for example) or if additional
-    information needs to be provided for the :class:`~elasticsearch.Connection`
-    class. By default master only nodes are filtered out since they shouldn't
-    typically be used for API operations.
-    :arg node_info: node information from `/_cluster/nodes`
-    :arg host: connection information (host, port) extracted from the node info
-    """
-
-    warnings.warn(
-        "The 'get_host_info' function is deprecated. Instead "
-        "use the 'sniff_node_callback' parameter on the client",
-        category=DeprecationWarning,
-        stacklevel=2,
-    )
-
-    # ignore master only nodes
-    if node_info.get("roles", []) == ["master"]:
-        return None
-    return host
diff --git a/examples/dsl/async/esql_employees.py b/examples/dsl/async/esql_employees.py
new file mode 100644
index 000000000..986c84235
--- /dev/null
+++ b/examples/dsl/async/esql_employees.py
@@ -0,0 +1,170 @@
+#  Licensed to Elasticsearch B.V. under one or more contributor
+#  license agreements. See the NOTICE file distributed with
+#  this work for additional information regarding copyright
+#  ownership. Elasticsearch B.V. licenses this file to you under
+#  the Apache License, Version 2.0 (the "License"); you may
+#  not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+# 	http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing,
+#  software distributed under the License is distributed on an
+#  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+#  KIND, either express or implied.  See the License for the
+#  specific language governing permissions and limitations
+#  under the License.
+
+"""
+# ES|QL query builder example
+
+Requirements:
+
+$ pip install "elasticsearch[async]" faker
+
+To run the example:
+
+$ python esql_employees.py "name to search"
+
+The index will be created automatically with a list of 1000 randomly generated
+employees if it does not exist. Add `--recreate-index` or `-r` to the command
+to regenerate it.
+
+Examples:
+
+$ python esql_employees "Mark"  # employees named Mark (first or last names)
+$ python esql_employees "Sarah" --limit 10  # up to 10 employees named Sarah
+$ python esql_employees "Sam" --sort height  # sort results by height
+$ python esql_employees "Sam" --sort name  # sort results by last name
+"""
+
+import argparse
+import asyncio
+import os
+import random
+
+from faker import Faker
+
+from elasticsearch.dsl import AsyncDocument, InnerDoc, M, async_connections
+from elasticsearch.esql import ESQLBase
+from elasticsearch.esql.functions import concat, multi_match
+
+fake = Faker()
+
+
+class Address(InnerDoc):
+    address: M[str]
+    city: M[str]
+    zip_code: M[str]
+
+
+class Employee(AsyncDocument):
+    emp_no: M[int]
+    first_name: M[str]
+    last_name: M[str]
+    height: M[float]
+    still_hired: M[bool]
+    address: M[Address]
+
+    class Index:
+        name = "employees"
+
+    @property
+    def name(self) -> str:
+        return f"{self.first_name} {self.last_name}"
+
+    def __repr__(self) -> str:
+        return f"<Employee[{self.meta.id}]: {self.first_name} {self.last_name}>"
+
+
+async def create(num_employees: int = 1000) -> None:
+    print("Creating a new employee index...")
+    if await Employee._index.exists():
+        await Employee._index.delete()
+    await Employee.init()
+
+    for i in range(num_employees):
+        address = Address(
+            address=fake.address(), city=fake.city(), zip_code=fake.zipcode()
+        )
+        emp = Employee(
+            emp_no=10000 + i,
+            first_name=fake.first_name(),
+            last_name=fake.last_name(),
+            height=int((random.random() * 0.8 + 1.5) * 1000) / 1000,
+            still_hired=random.random() >= 0.5,
+            address=address,
+        )
+        await emp.save()
+    await Employee._index.refresh()
+
+
+async def search(query: str, limit: int, sort: str) -> None:
+    q: ESQLBase = (
+        Employee.esql_from()
+        .where(multi_match(query, Employee.first_name, Employee.last_name))
+        .eval(full_name=concat(Employee.first_name, " ", Employee.last_name))
+    )
+    if sort == "height":
+        q = q.sort(Employee.height.desc())
+    elif sort == "name":
+        q = q.sort(Employee.last_name.asc())
+    q = q.limit(limit)
+    async for result in Employee.esql_execute(q, return_additional=True):
+        assert type(result) == tuple
+        employee = result[0]
+        full_name = result[1]["full_name"]
+        print(
+            f"{full_name:<20}",
+            f"{'Hired' if employee.still_hired else 'Not hired':<10}",
+            f"{employee.height:5.2f}m",
+            f"{employee.address.city:<20}",
+        )
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Employee ES|QL example")
+    parser.add_argument(
+        "--recreate-index",
+        "-r",
+        action="http://github.com/store_true",
+        help="Recreate and populate the index",
+    )
+    parser.add_argument(
+        "--limit",
+        action="http://github.com/store",
+        type=int,
+        default=100,
+        help="Maximum number or employees to return (default: 100)",
+    )
+    parser.add_argument(
+        "--sort",
+        action="http://github.com/store",
+        type=str,
+        default=None,
+        help='Sort by "name" (ascending) or by "height" (descending) (default: no sorting)',
+    )
+    parser.add_argument(
+        "query", action="http://github.com/store", help="The name or partial name to search for"
+    )
+    return parser.parse_args()
+
+
+async def main() -> None:
+    args = parse_args()
+
+    # initiate the default connection to elasticsearch
+    async_connections.create_connection(hosts=[os.environ["ELASTICSEARCH_URL"]])
+
+    if args.recreate_index or not await Employee._index.exists():
+        await create()
+    await Employee.init()
+
+    await search(args.query, args.limit, args.sort)
+
+    # close the connection
+    await async_connections.get_connection().close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/examples/dsl/esql_employees.py b/examples/dsl/esql_employees.py
new file mode 100644
index 000000000..364a2c2d5
--- /dev/null
+++ b/examples/dsl/esql_employees.py
@@ -0,0 +1,169 @@
+#  Licensed to Elasticsearch B.V. under one or more contributor
+#  license agreements. See the NOTICE file distributed with
+#  this work for additional information regarding copyright
+#  ownership. Elasticsearch B.V. licenses this file to you under
+#  the Apache License, Version 2.0 (the "License"); you may
+#  not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+# 	http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing,
+#  software distributed under the License is distributed on an
+#  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+#  KIND, either express or implied.  See the License for the
+#  specific language governing permissions and limitations
+#  under the License.
+
+"""
+# ES|QL query builder example
+
+Requirements:
+
+$ pip install elasticsearch faker
+
+To run the example:
+
+$ python esql_employees.py "name to search"
+
+The index will be created automatically with a list of 1000 randomly generated
+employees if it does not exist. Add `--recreate-index` or `-r` to the command
+to regenerate it.
+
+Examples:
+
+$ python esql_employees "Mark"  # employees named Mark (first or last names)
+$ python esql_employees "Sarah" --limit 10  # up to 10 employees named Sarah
+$ python esql_employees "Sam" --sort height  # sort results by height
+$ python esql_employees "Sam" --sort name  # sort results by last name
+"""
+
+import argparse
+import os
+import random
+
+from faker import Faker
+
+from elasticsearch.dsl import Document, InnerDoc, M, connections
+from elasticsearch.esql import ESQLBase
+from elasticsearch.esql.functions import concat, multi_match
+
+fake = Faker()
+
+
+class Address(InnerDoc):
+    address: M[str]
+    city: M[str]
+    zip_code: M[str]
+
+
+class Employee(Document):
+    emp_no: M[int]
+    first_name: M[str]
+    last_name: M[str]
+    height: M[float]
+    still_hired: M[bool]
+    address: M[Address]
+
+    class Index:
+        name = "employees"
+
+    @property
+    def name(self) -> str:
+        return f"{self.first_name} {self.last_name}"
+
+    def __repr__(self) -> str:
+        return f"<Employee[{self.meta.id}]: {self.first_name} {self.last_name}>"
+
+
+def create(num_employees: int = 1000) -> None:
+    print("Creating a new employee index...")
+    if Employee._index.exists():
+        Employee._index.delete()
+    Employee.init()
+
+    for i in range(num_employees):
+        address = Address(
+            address=fake.address(), city=fake.city(), zip_code=fake.zipcode()
+        )
+        emp = Employee(
+            emp_no=10000 + i,
+            first_name=fake.first_name(),
+            last_name=fake.last_name(),
+            height=int((random.random() * 0.8 + 1.5) * 1000) / 1000,
+            still_hired=random.random() >= 0.5,
+            address=address,
+        )
+        emp.save()
+    Employee._index.refresh()
+
+
+def search(query: str, limit: int, sort: str) -> None:
+    q: ESQLBase = (
+        Employee.esql_from()
+        .where(multi_match(query, Employee.first_name, Employee.last_name))
+        .eval(full_name=concat(Employee.first_name, " ", Employee.last_name))
+    )
+    if sort == "height":
+        q = q.sort(Employee.height.desc())
+    elif sort == "name":
+        q = q.sort(Employee.last_name.asc())
+    q = q.limit(limit)
+    for result in Employee.esql_execute(q, return_additional=True):
+        assert type(result) == tuple
+        employee = result[0]
+        full_name = result[1]["full_name"]
+        print(
+            f"{full_name:<20}",
+            f"{'Hired' if employee.still_hired else 'Not hired':<10}",
+            f"{employee.height:5.2f}m",
+            f"{employee.address.city:<20}",
+        )
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Employee ES|QL example")
+    parser.add_argument(
+        "--recreate-index",
+        "-r",
+        action="http://github.com/store_true",
+        help="Recreate and populate the index",
+    )
+    parser.add_argument(
+        "--limit",
+        action="http://github.com/store",
+        type=int,
+        default=100,
+        help="Maximum number or employees to return (default: 100)",
+    )
+    parser.add_argument(
+        "--sort",
+        action="http://github.com/store",
+        type=str,
+        default=None,
+        help='Sort by "name" (ascending) or by "height" (descending) (default: no sorting)',
+    )
+    parser.add_argument(
+        "query", action="http://github.com/store", help="The name or partial name to search for"
+    )
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+
+    # initiate the default connection to elasticsearch
+    connections.create_connection(hosts=[os.environ["ELASTICSEARCH_URL"]])
+
+    if args.recreate_index or not Employee._index.exists():
+        create()
+    Employee.init()
+
+    search(args.query, args.limit, args.sort)
+
+    # close the connection
+    connections.get_connection().close()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/dsl/semantic_text.py b/examples/dsl/semantic_text.py
index 8d552a2aa..6f4bb8f7d 100644
--- a/examples/dsl/semantic_text.py
+++ b/examples/dsl/semantic_text.py
@@ -21,7 +21,7 @@
 
 Requirements:
 
-$ pip install "elasticsearch" tqdm
+$ pip install elasticsearch tqdm
 
 Before running this example, an ELSER inference endpoint must be created in the
 Elasticsearch cluster. This can be done manually from Kibana, or with the
diff --git a/examples/dsl/sparse_vectors.py b/examples/dsl/sparse_vectors.py
index a92e82026..c328769eb 100644
--- a/examples/dsl/sparse_vectors.py
+++ b/examples/dsl/sparse_vectors.py
@@ -20,7 +20,7 @@
 
 Requirements:
 
-$ pip install nltk tqdm "elasticsearch"
+$ pip install nltk tqdm elasticsearch
 
 Before running this example, the ELSER v2 model must be downloaded and deployed
 to the Elasticsearch cluster, and an ingest pipeline must be defined. This can
diff --git a/examples/dsl/vectors.py b/examples/dsl/vectors.py
index 3afd76991..b4c700b71 100644
--- a/examples/dsl/vectors.py
+++ b/examples/dsl/vectors.py
@@ -20,7 +20,7 @@
 
 Requirements:
 
-$ pip install nltk sentence_transformers tqdm "elasticsearch"
+$ pip install nltk sentence_transformers tqdm elasticsearch
 
 To run the example:
 
diff --git a/pyproject.toml b/pyproject.toml
index 0c66e2f50..26a22ea96 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -78,8 +78,6 @@ dev = [
     "pandas",
     "mapbox-vector-tile",
     "jinja2",
-    "nltk",
-    "sentence_transformers",
     "tqdm",
     "mypy",
     "pyright",
diff --git a/test_elasticsearch/test_async/test_transport.py b/test_elasticsearch/test_async/test_transport.py
index 76a71f50b..cf9b8600a 100644
--- a/test_elasticsearch/test_async/test_transport.py
+++ b/test_elasticsearch/test_async/test_transport.py
@@ -19,7 +19,7 @@
 import asyncio
 import re
 import warnings
-from typing import Any, Dict, Optional, Union
+from typing import Any, Dict, Optional
 
 import pytest
 from elastic_transport import (
@@ -256,7 +256,7 @@ async def test_client_meta_header_not_sent(self):
         calls = client.transport.node_pool.get().calls
         assert 1 == len(calls)
         assert calls[0][1]["headers"] == {
-            "accept": "application/vnd.elasticsearch+json; compatible-with=8",
+            "accept": "application/vnd.elasticsearch+json; compatible-with=9",
         }
 
     async def test_body_surrogates_replaced_encoded_into_bytes(self):
@@ -426,7 +426,7 @@ async def test_sniff_on_start_ignores_sniff_timeout(self):
             {
                 "body": None,
                 "headers": {
-                    "accept": "application/vnd.elasticsearch+json; compatible-with=8"
+                    "accept": "application/vnd.elasticsearch+json; compatible-with=9"
                 },
                 "request_timeout": None,  # <-- Should be None instead of 12
             },
@@ -454,7 +454,7 @@ async def test_sniff_uses_sniff_timeout(self):
             {
                 "body": None,
                 "headers": {
-                    "accept": "application/vnd.elasticsearch+json; compatible-with=8",
+                    "accept": "application/vnd.elasticsearch+json; compatible-with=9",
                 },
                 "request_timeout": DEFAULT,
             },
@@ -464,7 +464,7 @@ async def test_sniff_uses_sniff_timeout(self):
             {
                 "body": None,
                 "headers": {
-                    "accept": "application/vnd.elasticsearch+json; compatible-with=8"
+                    "accept": "application/vnd.elasticsearch+json; compatible-with=9"
                 },
                 "request_timeout": 12,
             },
@@ -527,7 +527,8 @@ async def test_sniff_on_node_failure_triggers(self, extra_key, extra_value):
         assert request_failed_in_error
         assert len(client.transport.node_pool) == 3
 
-    async def test_sniff_after_n_seconds(self, event_loop):
+    async def test_sniff_after_n_seconds(self):
+        event_loop = asyncio.get_running_loop()
         client = AsyncElasticsearch(  # noqa: F821
             [NodeConfig("http", "localhost", 9200, _extras={"data": CLUSTER_NODES})],
             node_class=DummyNode,
@@ -562,10 +563,8 @@ async def test_sniff_after_n_seconds(self, event_loop):
         "kwargs",
         [
             {"sniff_on_start": True},
-            {"sniff_on_connection_fail": True},
             {"sniff_on_node_failure": True},
             {"sniff_before_requests": True},
-            {"sniffer_timeout": 1},
             {"sniff_timeout": 1},
         ],
     )
@@ -581,7 +580,8 @@ async def test_sniffing_disabled_on_elastic_cloud(self, kwargs):
             == "Sniffing should not be enabled when connecting to Elastic Cloud"
         )
 
-    async def test_sniff_on_start_close_unlocks_async_calls(self, event_loop):
+    async def test_sniff_on_start_close_unlocks_async_calls(self):
+        event_loop = asyncio.get_running_loop()
         client = AsyncElasticsearch(  # noqa: F821
             [
                 NodeConfig(
@@ -660,42 +660,6 @@ def sniffed_node_callback(
         ports = {node.config.port for node in client.transport.node_pool.all()}
         assert ports == {9200, 124}
 
-    async def test_sniffing_deprecated_host_info_callback(self):
-        def host_info_callback(
-            node_info: Dict[str, Any], host: Dict[str, Union[int, str]]
-        ) -> Dict[str, Any]:
-            return (
-                host if node_info["http"]["publish_address"].endswith(":124") else None
-            )
-
-        with warnings.catch_warnings(record=True) as w:
-            client = AsyncElasticsearch(  # noqa: F821
-                [
-                    NodeConfig(
-                        "http",
-                        "localhost",
-                        9200,
-                        _extras={"data": CLUSTER_NODES_MASTER_ONLY},
-                    )
-                ],
-                node_class=DummyNode,
-                sniff_on_start=True,
-                host_info_callback=host_info_callback,
-            )
-            await client.transport._async_call()
-
-        assert len(w) == 1
-        assert w[0].category == DeprecationWarning
-        assert (
-            str(w[0].message)
-            == "The 'host_info_callback' parameter is deprecated in favor of 'sniffed_node_callback'"
-        )
-
-        assert len(client.transport.node_pool) == 2
-
-        ports = {node.config.port for node in client.transport.node_pool.all()}
-        assert ports == {9200, 124}
-
 
 @pytest.mark.parametrize("headers", [{}, {"X-elastic-product": "BAD HEADER"}])
 async def test_unsupported_product_error(headers):
@@ -719,7 +683,7 @@ async def test_unsupported_product_error(headers):
         {
             "body": None,
             "headers": {
-                "accept": "application/vnd.elasticsearch+json; compatible-with=8",
+                "accept": "application/vnd.elasticsearch+json; compatible-with=9",
             },
             "request_timeout": DEFAULT,
         },
diff --git a/test_elasticsearch/test_client/test_deprecated_options.py b/test_elasticsearch/test_client/test_deprecated_options.py
index 3b4e0b9ed..bbde2e90b 100644
--- a/test_elasticsearch/test_client/test_deprecated_options.py
+++ b/test_elasticsearch/test_client/test_deprecated_options.py
@@ -19,85 +19,7 @@
 
 import pytest
 
-from elasticsearch import Elasticsearch, JsonSerializer
-
-EXPECTED_SERIALIZERS = {
-    "application/vnd.mapbox-vector-tile",
-    "application/x-ndjson",
-    "application/json",
-    "text/*",
-    "application/vnd.elasticsearch+json",
-    "application/vnd.elasticsearch+x-ndjson",
-}
-
-
-try:
-    import pyarrow as pa
-
-    EXPECTED_SERIALIZERS.add("application/vnd.apache.arrow.stream")
-except ImportError:
-    pa = None
-
-
-def test_sniff_on_connection_fail():
-    with warnings.catch_warnings(record=True) as w:
-        client = Elasticsearch("http://localhost:9200/", sniff_on_connection_fail=True)
-    assert client.transport._sniff_on_node_failure is True
-    assert len(w) == 1
-    assert w[0].category == DeprecationWarning
-    assert str(w[0].message) == (
-        "The 'sniff_on_connection_fail' parameter is deprecated in favor of 'sniff_on_node_failure'"
-    )
-
-    with pytest.raises(ValueError) as e:
-        Elasticsearch(
-            "http://localhost:9200/",
-            sniff_on_connection_fail=True,
-            sniff_on_node_failure=True,
-        )
-    assert (
-        str(e.value)
-        == "Can't specify both 'sniff_on_connection_fail' and 'sniff_on_node_failure', instead only specify 'sniff_on_node_failure'"
-    )
-
-
-def test_sniffer_timeout():
-    with warnings.catch_warnings(record=True) as w:
-        client = Elasticsearch("http://localhost:9200/", sniffer_timeout=1)
-    assert client.transport._min_delay_between_sniffing == 1
-    assert len(w) == 1
-    assert w[0].category == DeprecationWarning
-    assert str(w[0].message) == (
-        "The 'sniffer_timeout' parameter is deprecated in favor of 'min_delay_between_sniffing'"
-    )
-
-    with pytest.raises(ValueError) as e:
-        Elasticsearch(
-            "http://localhost:9200/", sniffer_timeout=1, min_delay_between_sniffing=1
-        )
-    assert (
-        str(e.value)
-        == "Can't specify both 'sniffer_timeout' and 'min_delay_between_sniffing', instead only specify 'min_delay_between_sniffing'"
-    )
-
-
-def test_randomize_hosts():
-    with warnings.catch_warnings(record=True) as w:
-        Elasticsearch("http://localhost:9200/", randomize_hosts=True)
-    assert len(w) == 1
-    assert w[0].category == DeprecationWarning
-    assert str(w[0].message) == (
-        "The 'randomize_hosts' parameter is deprecated in favor of 'randomize_nodes_in_pool'"
-    )
-
-    with pytest.raises(ValueError) as e:
-        Elasticsearch(
-            "http://localhost:9200/", randomize_hosts=True, randomize_nodes_in_pool=True
-        )
-    assert (
-        str(e.value)
-        == "Can't specify both 'randomize_hosts' and 'randomize_nodes_in_pool', instead only specify 'randomize_nodes_in_pool'"
-    )
+from elasticsearch import Elasticsearch
 
 
 def test_http_auth():
@@ -124,40 +46,3 @@ def test_http_auth():
         str(e.value)
         == "Can't specify both 'http_auth' and 'basic_auth', instead only specify 'basic_auth'"
     )
-
-
-def test_serializer_and_serializers():
-    with pytest.raises(ValueError) as e:
-        Elasticsearch(
-            "http://localhost:9200/",
-            serializer=JsonSerializer(),
-            serializers={"application/json": JsonSerializer()},
-        )
-    assert str(e.value) == (
-        "Can't specify both 'serializer' and 'serializers' parameters together. "
-        "Instead only specify one of the other."
-    )
-
-    class CustomSerializer(JsonSerializer):
-        pass
-
-    client = Elasticsearch("http://localhost:9200/", serializer=CustomSerializer())
-    assert isinstance(
-        client.transport.serializers.get_serializer("application/json"),
-        CustomSerializer,
-    )
-    assert set(client.transport.serializers.serializers.keys()) == EXPECTED_SERIALIZERS
-
-    client = Elasticsearch(
-        "http://localhost:9200/",
-        serializers={
-            "application/json": CustomSerializer(),
-            "application/cbor": CustomSerializer(),
-        },
-    )
-    assert isinstance(
-        client.transport.serializers.get_serializer("application/json"),
-        CustomSerializer,
-    )
-    expected = EXPECTED_SERIALIZERS | {"application/cbor"}
-    assert set(client.transport.serializers.serializers.keys()) == expected
diff --git a/test_elasticsearch/test_client/test_options.py b/test_elasticsearch/test_client/test_options.py
index b7fa3cfda..4c719edb0 100644
--- a/test_elasticsearch/test_client/test_options.py
+++ b/test_elasticsearch/test_client/test_options.py
@@ -19,7 +19,7 @@
 from elastic_transport import OpenTelemetrySpan
 from elastic_transport.client_utils import DEFAULT
 
-from elasticsearch import AsyncElasticsearch, Elasticsearch
+from elasticsearch import AsyncElasticsearch, Elasticsearch, JsonSerializer
 from elasticsearch._sync.client.utils import USER_AGENT
 from test_elasticsearch.test_cases import (
     DummyAsyncTransport,
@@ -27,6 +27,22 @@
     DummyTransportTestCase,
 )
 
+EXPECTED_SERIALIZERS = {
+    "application/vnd.mapbox-vector-tile",
+    "application/x-ndjson",
+    "application/json",
+    "text/*",
+    "application/vnd.elasticsearch+json",
+    "application/vnd.elasticsearch+x-ndjson",
+}
+
+try:
+    import pyarrow as pa
+
+    EXPECTED_SERIALIZERS.add("application/vnd.apache.arrow.stream")
+except ImportError:
+    pa = None
+
 
 class TestOptions(DummyTransportTestCase):
     def assert_called_with_headers(self, client, method, target, headers):
@@ -140,7 +156,7 @@ def test_options_passed_to_perform_request(self):
         assert isinstance(call.pop("otel_span"), OpenTelemetrySpan)
         assert call == {
             "headers": {
-                "accept": "application/vnd.elasticsearch+json; compatible-with=8",
+                "accept": "application/vnd.elasticsearch+json; compatible-with=9",
             },
             "body": None,
         }
@@ -159,7 +175,7 @@ def test_options_passed_to_perform_request(self):
         assert isinstance(call.pop("otel_span"), OpenTelemetrySpan)
         assert call == {
             "headers": {
-                "accept": "application/vnd.elasticsearch+json; compatible-with=8",
+                "accept": "application/vnd.elasticsearch+json; compatible-with=9",
             },
             "body": None,
             "request_timeout": 1,
@@ -185,7 +201,7 @@ def test_options_passed_to_perform_request(self):
         assert isinstance(call.pop("otel_span"), OpenTelemetrySpan)
         assert call == {
             "headers": {
-                "accept": "application/vnd.elasticsearch+json; compatible-with=8",
+                "accept": "application/vnd.elasticsearch+json; compatible-with=9",
             },
             "body": None,
             "request_timeout": 1,
@@ -213,7 +229,7 @@ async def test_options_passed_to_async_perform_request(self):
         assert isinstance(call.pop("otel_span"), OpenTelemetrySpan)
         assert call == {
             "headers": {
-                "accept": "application/vnd.elasticsearch+json; compatible-with=8",
+                "accept": "application/vnd.elasticsearch+json; compatible-with=9",
             },
             "body": None,
         }
@@ -232,7 +248,7 @@ async def test_options_passed_to_async_perform_request(self):
         assert isinstance(call.pop("otel_span"), OpenTelemetrySpan)
         assert call == {
             "headers": {
-                "accept": "application/vnd.elasticsearch+json; compatible-with=8",
+                "accept": "application/vnd.elasticsearch+json; compatible-with=9",
             },
             "body": None,
             "request_timeout": 1,
@@ -258,7 +274,7 @@ async def test_options_passed_to_async_perform_request(self):
         assert isinstance(call.pop("otel_span"), OpenTelemetrySpan)
         assert call == {
             "headers": {
-                "accept": "application/vnd.elasticsearch+json; compatible-with=8",
+                "accept": "application/vnd.elasticsearch+json; compatible-with=9",
             },
             "body": None,
             "request_timeout": 1,
@@ -300,7 +316,7 @@ def test_http_headers_overrides(self):
 
         assert call["headers"] == {
             "key": "val",
-            "accept": "application/vnd.elasticsearch+json; compatible-with=8",
+            "accept": "application/vnd.elasticsearch+json; compatible-with=9",
         }
 
         client.options(headers={"key1": "val"}).indices.get(index="2")
@@ -309,7 +325,7 @@ def test_http_headers_overrides(self):
         assert call["headers"] == {
             "key": "val",
             "key1": "val",
-            "accept": "application/vnd.elasticsearch+json; compatible-with=8",
+            "accept": "application/vnd.elasticsearch+json; compatible-with=9",
         }
 
         client.options(headers={"key": "val2"}).indices.get(index="3")
@@ -317,7 +333,7 @@ def test_http_headers_overrides(self):
 
         assert call["headers"] == {
             "key": "val2",
-            "accept": "application/vnd.elasticsearch+json; compatible-with=8",
+            "accept": "application/vnd.elasticsearch+json; compatible-with=9",
         }
 
         client = Elasticsearch(
@@ -344,14 +360,14 @@ def test_user_agent_override(self):
         call = calls[("GET", "/1")][0]
         assert call["headers"] == {
             "user-agent": "custom1",
-            "accept": "application/vnd.elasticsearch+json; compatible-with=8",
+            "accept": "application/vnd.elasticsearch+json; compatible-with=9",
         }
 
         client.indices.get(index="2", headers={"user-agent": "custom2"})
         call = calls[("GET", "/2")][0]
         assert call["headers"] == {
             "user-agent": "custom2",
-            "accept": "application/vnd.elasticsearch+json; compatible-with=8",
+            "accept": "application/vnd.elasticsearch+json; compatible-with=9",
         }
 
         client = Elasticsearch(
@@ -365,14 +381,14 @@ def test_user_agent_override(self):
         call = calls[("GET", "/1")][0]
         assert call["headers"] == {
             "user-agent": "custom3",
-            "accept": "application/vnd.elasticsearch+json; compatible-with=8",
+            "accept": "application/vnd.elasticsearch+json; compatible-with=9",
         }
 
         client.indices.get(index="2", headers={"user-agent": "custom4"})
         call = calls[("GET", "/2")][0]
         assert call["headers"] == {
             "user-agent": "custom4",
-            "accept": "application/vnd.elasticsearch+json; compatible-with=8",
+            "accept": "application/vnd.elasticsearch+json; compatible-with=9",
         }
 
     def test_options_timeout_parameters(self):
@@ -394,7 +410,7 @@ def test_options_timeout_parameters(self):
         assert isinstance(call.pop("otel_span"), OpenTelemetrySpan)
         assert call == {
             "headers": {
-                "accept": "application/vnd.elasticsearch+json; compatible-with=8",
+                "accept": "application/vnd.elasticsearch+json; compatible-with=9",
             },
             "body": None,
             "request_timeout": 1,
@@ -424,7 +440,7 @@ def test_options_timeout_parameters(self):
         assert isinstance(call.pop("otel_span"), OpenTelemetrySpan)
         assert call == {
             "headers": {
-                "accept": "application/vnd.elasticsearch+json; compatible-with=8",
+                "accept": "application/vnd.elasticsearch+json; compatible-with=9",
             },
             "body": None,
             "request_timeout": 2,
@@ -449,7 +465,7 @@ def test_options_timeout_parameters(self):
         assert isinstance(call.pop("otel_span"), OpenTelemetrySpan)
         assert call == {
             "headers": {
-                "accept": "application/vnd.elasticsearch+json; compatible-with=8",
+                "accept": "application/vnd.elasticsearch+json; compatible-with=9",
             },
             "body": None,
         }
@@ -471,7 +487,7 @@ def test_options_timeout_parameters(self):
         assert isinstance(call.pop("otel_span"), OpenTelemetrySpan)
         assert call == {
             "headers": {
-                "accept": "application/vnd.elasticsearch+json; compatible-with=8",
+                "accept": "application/vnd.elasticsearch+json; compatible-with=9",
             },
             "body": None,
             "request_timeout": 1,
@@ -479,3 +495,41 @@ def test_options_timeout_parameters(self):
             "retry_on_status": (404,),
             "retry_on_timeout": True,
         }
+
+    def test_serializer_and_serializers(self):
+        with pytest.raises(ValueError) as e:
+            Elasticsearch(
+                "http://localhost:9200/",
+                serializer=JsonSerializer(),
+                serializers={"application/json": JsonSerializer()},
+            )
+        assert str(e.value) == (
+            "Can't specify both 'serializer' and 'serializers' parameters together. "
+            "Instead only specify one of the other."
+        )
+
+        class CustomSerializer(JsonSerializer):
+            pass
+
+        client = Elasticsearch("http://localhost:9200/", serializer=CustomSerializer())
+        assert isinstance(
+            client.transport.serializers.get_serializer("application/json"),
+            CustomSerializer,
+        )
+        assert (
+            set(client.transport.serializers.serializers.keys()) == EXPECTED_SERIALIZERS
+        )
+
+        client = Elasticsearch(
+            "http://localhost:9200/",
+            serializers={
+                "application/json": CustomSerializer(),
+                "application/cbor": CustomSerializer(),
+            },
+        )
+        assert isinstance(
+            client.transport.serializers.get_serializer("application/json"),
+            CustomSerializer,
+        )
+        expected = EXPECTED_SERIALIZERS | {"application/cbor"}
+        assert set(client.transport.serializers.serializers.keys()) == expected
diff --git a/test_elasticsearch/test_client/test_serializers.py b/test_elasticsearch/test_client/test_serializers.py
index 986160b92..192c561f8 100644
--- a/test_elasticsearch/test_client/test_serializers.py
+++ b/test_elasticsearch/test_client/test_serializers.py
@@ -46,22 +46,22 @@ def test_compat_mode_on_by_default(self):
         self.client.get(index="test0", id="1")
         assert len(calls) == 1
         assert calls[("GET", "/test0/_doc/1")][0]["headers"] == {
-            "Accept": "application/vnd.elasticsearch+json; compatible-with=8"
+            "Accept": "application/vnd.elasticsearch+json; compatible-with=9"
         }
 
         # Search with body
         self.client.search(index="test1", query={"match_all": {}})
         assert len(calls) == 2
         assert calls[("POST", "/test1/_search")][0]["headers"] == {
-            "Accept": "application/vnd.elasticsearch+json; compatible-with=8",
-            "Content-Type": "application/vnd.elasticsearch+json; compatible-with=8",
+            "Accept": "application/vnd.elasticsearch+json; compatible-with=9",
+            "Content-Type": "application/vnd.elasticsearch+json; compatible-with=9",
         }
 
         # Search without body
         self.client.search(index="test2")
         assert len(calls) == 3
         assert calls[("POST", "/test2/_search")][0]["headers"] == {
-            "Accept": "application/vnd.elasticsearch+json; compatible-with=8",
+            "Accept": "application/vnd.elasticsearch+json; compatible-with=9",
         }
 
         # Multiple mimetypes in Accept
@@ -69,15 +69,15 @@ def test_compat_mode_on_by_default(self):
         assert len(calls) == 4
         assert calls[("GET", "/_cat/nodes")][0]["headers"] == {
             # text/plain isn't modified.
-            "Accept": "text/plain,application/vnd.elasticsearch+json; compatible-with=8",
+            "Accept": "text/plain,application/vnd.elasticsearch+json; compatible-with=9",
         }
 
         # Bulk uses x-ndjson
         self.client.bulk(operations=[])
         assert len(calls) == 5
         assert calls[("PUT", "/_bulk")][0]["headers"] == {
-            "Accept": "application/vnd.elasticsearch+json; compatible-with=8",
-            "Content-Type": "application/vnd.elasticsearch+x-ndjson; compatible-with=8",
+            "Accept": "application/vnd.elasticsearch+json; compatible-with=9",
+            "Content-Type": "application/vnd.elasticsearch+x-ndjson; compatible-with=9",
         }
 
         # Mapbox vector tiles
@@ -91,8 +91,8 @@ def test_compat_mode_on_by_default(self):
         )
         assert len(calls) == 6
         assert calls[("POST", "/test3/_mvt/field/z/x/y")][0]["headers"] == {
-            "Accept": "application/vnd.elasticsearch+vnd.mapbox-vector-tile; compatible-with=8",
-            "Content-Type": "application/vnd.elasticsearch+json; compatible-with=8",
+            "Accept": "application/vnd.elasticsearch+vnd.mapbox-vector-tile; compatible-with=9",
+            "Content-Type": "application/vnd.elasticsearch+json; compatible-with=9",
         }
 
     @pytest.mark.parametrize("mime_subtype", ["json", "x-ndjson"])
diff --git a/test_elasticsearch/test_dsl/test_field.py b/test_elasticsearch/test_dsl/test_field.py
index 423936ae3..181de6256 100644
--- a/test_elasticsearch/test_dsl/test_field.py
+++ b/test_elasticsearch/test_dsl/test_field.py
@@ -23,7 +23,15 @@
 import pytest
 from dateutil import tz
 
-from elasticsearch.dsl import InnerDoc, Range, ValidationException, field
+from elasticsearch import dsl
+from elasticsearch.dsl import (
+    AttrDict,
+    AttrList,
+    InnerDoc,
+    Range,
+    ValidationException,
+    field,
+)
 
 
 def test_date_range_deserialization() -> None:
@@ -232,3 +240,46 @@ class Inner(InnerDoc):
 
     with pytest.raises(ValidationException):
         field.Object(doc_class=Inner, dynamic=False)
+
+
+def test_dynamic_object() -> None:
+    f = field.Object(dynamic=True)
+    assert f.deserialize({"a": "b"}).to_dict() == {"a": "b"}
+    assert f.deserialize(AttrDict({"a": "b"})).to_dict() == {"a": "b"}
+    assert f.serialize({"a": "b"}) == {"a": "b"}
+    assert f.serialize(AttrDict({"a": "b"})) == {"a": "b"}
+
+
+def test_dynamic_nested() -> None:
+    f = field.Nested(dynamic=True)
+    assert f.deserialize([{"a": "b"}, {"c": "d"}]) == [{"a": "b"}, {"c": "d"}]
+    assert f.deserialize([AttrDict({"a": "b"}), {"c": "d"}]) == [
+        {"a": "b"},
+        {"c": "d"},
+    ]
+    assert f.deserialize(AttrList([AttrDict({"a": "b"}), {"c": "d"}])) == [
+        {"a": "b"},
+        {"c": "d"},
+    ]
+    assert f.serialize([{"a": "b"}, {"c": "d"}]) == [{"a": "b"}, {"c": "d"}]
+    assert f.serialize([AttrDict({"a": "b"}), {"c": "d"}]) == [{"a": "b"}, {"c": "d"}]
+    assert f.serialize(AttrList([AttrDict({"a": "b"}), {"c": "d"}])) == [
+        {"a": "b"},
+        {"c": "d"},
+    ]
+
+
+def test_all_fields_exported() -> None:
+    """Make sure that all the generated field classes are exported at the top-level"""
+    fields = [
+        f
+        for f in dir(field)
+        if isinstance(getattr(field, f), type)
+        and issubclass(getattr(field, f), field.Field)
+    ]
+    all = dir(dsl)
+    not_found = []
+    for f in fields:
+        if f not in all:
+            not_found.append(f)
+    assert not_found == []
diff --git a/test_elasticsearch/test_dsl/test_integration/_async/test_document.py b/test_elasticsearch/test_dsl/test_integration/_async/test_document.py
index e72955a0a..36f055583 100644
--- a/test_elasticsearch/test_dsl/test_integration/_async/test_document.py
+++ b/test_elasticsearch/test_dsl/test_integration/_async/test_document.py
@@ -23,7 +23,7 @@
 
 from datetime import datetime
 from ipaddress import ip_address
-from typing import TYPE_CHECKING, Any, AsyncIterator, Dict, List, Tuple, Union
+from typing import TYPE_CHECKING, Any, AsyncIterator, Dict, List, Optional, Tuple, Union
 
 import pytest
 from pytest import raises
@@ -33,6 +33,7 @@
 from elasticsearch.dsl import (
     AsyncDocument,
     AsyncSearch,
+    AttrDict,
     Binary,
     Boolean,
     Date,
@@ -42,6 +43,7 @@
     Ip,
     Keyword,
     Long,
+    M,
     Mapping,
     MetaField,
     Nested,
@@ -52,6 +54,8 @@
     analyzer,
     mapped_field,
 )
+from elasticsearch.dsl.query import Match
+from elasticsearch.dsl.types import MatchQuery
 from elasticsearch.dsl.utils import AttrList
 from elasticsearch.helpers.errors import BulkIndexError
 
@@ -624,22 +628,50 @@ async def test_can_save_to_different_index(
 
 
 @pytest.mark.asyncio
+@pytest.mark.parametrize("validate", (True, False))
 async def test_save_without_skip_empty_will_include_empty_fields(
     async_write_client: AsyncElasticsearch,
+    validate: bool,
 ) -> None:
-    test_repo = Repository(field_1=[], field_2=None, field_3={}, meta={"id": 42})
-    assert await test_repo.save(index="test-document", skip_empty=False)
+    test_repo = Repository(
+        field_1=[], field_2=None, field_3={}, owner={"name": None}, meta={"id": 42}
+    )
+    assert await test_repo.save(
+        index="test-document", skip_empty=False, validate=validate
+    )
 
     assert_doc_equals(
         {
             "found": True,
             "_index": "test-document",
             "_id": "42",
-            "_source": {"field_1": [], "field_2": None, "field_3": {}},
+            "_source": {
+                "field_1": [],
+                "field_2": None,
+                "field_3": {},
+                "owner": {"name": None},
+            },
         },
         await async_write_client.get(index="test-document", id=42),
     )
 
+    test_repo = Repository(owner=AttrDict({"name": None}), meta={"id": 43})
+    assert await test_repo.save(
+        index="test-document", skip_empty=False, validate=validate
+    )
+
+    assert_doc_equals(
+        {
+            "found": True,
+            "_index": "test-document",
+            "_id": "43",
+            "_source": {
+                "owner": {"name": None},
+            },
+        },
+        await async_write_client.get(index="test-document", id=43),
+    )
+
 
 @pytest.mark.asyncio
 async def test_delete(async_write_client: AsyncElasticsearch) -> None:
@@ -850,3 +882,51 @@ class Index:
     assert docs[0].float_vector == doc.float_vector
     assert docs[0].byte_vector == doc.byte_vector
     assert docs[0].bit_vector == doc.bit_vector
+
+
+@pytest.mark.asyncio
+async def test_copy_to(async_client: AsyncElasticsearch) -> None:
+    class Person(AsyncDocument):
+        first_name: M[str] = mapped_field(Text(copy_to=["full_name", "all"]))
+        last_name: M[str] = mapped_field(Text(copy_to=["full_name", "all"]))
+        birth_place: M[str] = mapped_field(Text(copy_to="all"))
+        full_name: M[Optional[str]] = mapped_field(init=False)
+        all: M[Optional[str]] = mapped_field(init=False)
+
+        class Index:
+            name = "people"
+
+    await Person._index.delete(ignore_unavailable=True)
+    await Person.init()
+
+    person = Person(first_name="Jane", last_name="Doe", birth_place="Springfield")
+    await person.save()
+    await Person._index.refresh()
+
+    match = (
+        await Person.search()
+        .query(Match(Person.full_name, MatchQuery(query="Jane")))
+        .execute()
+    )
+    assert len(match) == 1
+
+    match = (
+        await Person.search()
+        .query(Match(Person.all, MatchQuery(query="Doe")))
+        .execute()
+    )
+    assert len(match) == 1
+
+    match = (
+        await Person.search()
+        .query(Match(Person.full_name, MatchQuery(query="Springfield")))
+        .execute()
+    )
+    assert len(match) == 0
+
+    match = (
+        await Person.search()
+        .query(Match(Person.all, MatchQuery(query="Springfield")))
+        .execute()
+    )
+    assert len(match) == 1
diff --git a/test_elasticsearch/test_dsl/test_integration/_async/test_esql.py b/test_elasticsearch/test_dsl/test_integration/_async/test_esql.py
new file mode 100644
index 000000000..ae99873f8
--- /dev/null
+++ b/test_elasticsearch/test_dsl/test_integration/_async/test_esql.py
@@ -0,0 +1,254 @@
+#  Licensed to Elasticsearch B.V. under one or more contributor
+#  license agreements. See the NOTICE file distributed with
+#  this work for additional information regarding copyright
+#  ownership. Elasticsearch B.V. licenses this file to you under
+#  the Apache License, Version 2.0 (the "License"); you may
+#  not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+# 	http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing,
+#  software distributed under the License is distributed on an
+#  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+#  KIND, either express or implied.  See the License for the
+#  specific language governing permissions and limitations
+#  under the License.
+
+import pytest
+
+from elasticsearch.dsl import AsyncDocument, InnerDoc, M
+from elasticsearch.esql import ESQL, E, functions
+
+
+class Address(InnerDoc):
+    address: M[str]
+    city: M[str]
+
+
+class Employee(AsyncDocument):
+    emp_no: M[int]
+    first_name: M[str]
+    last_name: M[str]
+    height: M[float]
+    still_hired: M[bool]
+    address: M[Address]
+
+    class Index:
+        name = "employees"
+
+
+async def load_db():
+    data = [
+        [
+            10000,
+            "Joseph",
+            "Wall",
+            2.2,
+            True,
+            Address(address="8875 Long Shoals Suite 441", city="Marcville, TX"),
+        ],
+        [
+            10001,
+            "Stephanie",
+            "Ward",
+            1.749,
+            True,
+            Address(address="90162 Carter Harbor Suite 099", city="Davisborough, DE"),
+        ],
+        [
+            10002,
+            "David",
+            "Keller",
+            1.872,
+            True,
+            Address(address="6697 Patrick Union Suite 797", city="Fuentesmouth, SD"),
+        ],
+        [
+            10003,
+            "Roger",
+            "Hinton",
+            1.694,
+            False,
+            Address(address="809 Kelly Mountains", city="South Megan, DE"),
+        ],
+        [
+            10004,
+            "Joshua",
+            "Garcia",
+            1.661,
+            False,
+            Address(address="718 Angela Forks", city="Port Erinland, MA"),
+        ],
+        [
+            10005,
+            "Matthew",
+            "Richards",
+            1.633,
+            False,
+            Address(address="2869 Brown Mountains", city="New Debra, NH"),
+        ],
+        [
+            10006,
+            "Maria",
+            "Luna",
+            1.893,
+            True,
+            Address(address="5861 Morgan Springs", city="Lake Daniel, WI"),
+        ],
+        [
+            10007,
+            "Angela",
+            "Navarro",
+            1.604,
+            False,
+            Address(address="2848 Allen Station", city="Saint Joseph, OR"),
+        ],
+        [
+            10008,
+            "Maria",
+            "Cannon",
+            2.079,
+            False,
+            Address(address="322 NW Johnston", city="Bakerburgh, MP"),
+        ],
+        [
+            10009,
+            "Joseph",
+            "Sutton",
+            2.025,
+            True,
+            Address(address="77 Cardinal E", city="Lakestown, IL"),
+        ],
+    ]
+    if await Employee._index.exists():
+        await Employee._index.delete()
+    await Employee.init()
+
+    for e in data:
+        employee = Employee(
+            emp_no=e[0],
+            first_name=e[1],
+            last_name=e[2],
+            height=e[3],
+            still_hired=e[4],
+            address=e[5],
+        )
+        await employee.save()
+    await Employee._index.refresh()
+
+
+@pytest.mark.asyncio
+async def test_esql(async_client):
+    await load_db()
+
+    # get the full names of the employees
+    query = (
+        ESQL.from_(Employee)
+        .eval(full_name=functions.concat(Employee.first_name, " ", Employee.last_name))
+        .keep("full_name")
+        .sort("full_name")
+        .limit(10)
+    )
+    r = await async_client.esql.query(query=str(query))
+    assert r.body["values"] == [
+        ["Angela Navarro"],
+        ["David Keller"],
+        ["Joseph Sutton"],
+        ["Joseph Wall"],
+        ["Joshua Garcia"],
+        ["Maria Cannon"],
+        ["Maria Luna"],
+        ["Matthew Richards"],
+        ["Roger Hinton"],
+        ["Stephanie Ward"],
+    ]
+
+    # get the average height of all hired employees
+    query = ESQL.from_(Employee).stats(
+        avg_height=functions.round(functions.avg(Employee.height), 2).where(
+            Employee.still_hired == True  # noqa: E712
+        )
+    )
+    r = await async_client.esql.query(query=str(query))
+    assert r.body["values"] == [[1.95]]
+
+    # find employees by name using a parameter
+    query = (
+        ESQL.from_(Employee)
+        .where(Employee.first_name == E("?"))
+        .keep(Employee.last_name)
+        .sort(Employee.last_name.desc())
+    )
+    r = await async_client.esql.query(query=str(query), params=["Maria"])
+    assert r.body["values"] == [["Luna"], ["Cannon"]]
+
+
+@pytest.mark.asyncio
+async def test_esql_dsl(async_client):
+    await load_db()
+
+    # get employees with first name "Maria"
+    query = (
+        Employee.esql_from()
+        .where(Employee.first_name == "Maria")
+        .sort("last_name")
+        .limit(10)
+    )
+    marias = []
+    async for emp in Employee.esql_execute(query):
+        marias.append(emp)
+    assert len(marias) == 2
+    assert marias[0].last_name == "Cannon"
+    assert marias[0].address.address == "322 NW Johnston"
+    assert marias[0].address.city == "Bakerburgh, MP"
+    assert marias[1].last_name == "Luna"
+    assert marias[1].address.address == "5861 Morgan Springs"
+    assert marias[1].address.city == "Lake Daniel, WI"
+
+    # run a query with a missing field
+    query = (
+        Employee.esql_from()
+        .where(Employee.first_name == "Maria")
+        .drop(Employee.address.city)
+        .sort("last_name")
+        .limit(10)
+    )
+    with pytest.raises(ValueError):
+        await Employee.esql_execute(query).__anext__()
+    marias = []
+    async for emp in Employee.esql_execute(query, ignore_missing_fields=True):
+        marias.append(emp)
+    assert marias[0].last_name == "Cannon"
+    assert marias[0].address.address == "322 NW Johnston"
+    assert marias[0].address.city is None
+    assert marias[1].last_name == "Luna"
+    assert marias[1].address.address == "5861 Morgan Springs"
+    assert marias[1].address.city is None
+
+    # run a query with additional calculated fields
+    query = (
+        Employee.esql_from()
+        .where(Employee.first_name == "Maria")
+        .eval(
+            full_name=functions.concat(Employee.first_name, " ", Employee.last_name),
+            height_cm=functions.to_integer(Employee.height * 100),
+        )
+        .sort("last_name")
+        .limit(10)
+    )
+    assert isinstance(await Employee.esql_execute(query).__anext__(), Employee)
+    assert isinstance(
+        await Employee.esql_execute(query, return_additional=True).__anext__(), tuple
+    )
+    marias = []
+    async for emp, extra in Employee.esql_execute(query, return_additional=True):
+        marias.append([emp, extra])
+    assert marias[0][0].last_name == "Cannon"
+    assert marias[0][0].address.address == "322 NW Johnston"
+    assert marias[0][0].address.city == "Bakerburgh, MP"
+    assert marias[0][1] == {"full_name": "Maria Cannon", "height_cm": 208}
+    assert marias[1][0].last_name == "Luna"
+    assert marias[1][0].address.address == "5861 Morgan Springs"
+    assert marias[1][0].address.city == "Lake Daniel, WI"
+    assert marias[1][1] == {"full_name": "Maria Luna", "height_cm": 189}
diff --git a/test_elasticsearch/test_dsl/test_integration/_sync/test_document.py b/test_elasticsearch/test_dsl/test_integration/_sync/test_document.py
index 13b60f71b..62857cd9a 100644
--- a/test_elasticsearch/test_dsl/test_integration/_sync/test_document.py
+++ b/test_elasticsearch/test_dsl/test_integration/_sync/test_document.py
@@ -23,7 +23,7 @@
 
 from datetime import datetime
 from ipaddress import ip_address
-from typing import TYPE_CHECKING, Any, Dict, Iterator, List, Tuple, Union
+from typing import TYPE_CHECKING, Any, Dict, Iterator, List, Optional, Tuple, Union
 
 import pytest
 from pytest import raises
@@ -31,6 +31,7 @@
 
 from elasticsearch import ConflictError, Elasticsearch, NotFoundError
 from elasticsearch.dsl import (
+    AttrDict,
     Binary,
     Boolean,
     Date,
@@ -41,6 +42,7 @@
     Ip,
     Keyword,
     Long,
+    M,
     Mapping,
     MetaField,
     Nested,
@@ -52,6 +54,8 @@
     analyzer,
     mapped_field,
 )
+from elasticsearch.dsl.query import Match
+from elasticsearch.dsl.types import MatchQuery
 from elasticsearch.dsl.utils import AttrList
 from elasticsearch.helpers.errors import BulkIndexError
 
@@ -618,22 +622,46 @@ def test_can_save_to_different_index(
 
 
 @pytest.mark.sync
+@pytest.mark.parametrize("validate", (True, False))
 def test_save_without_skip_empty_will_include_empty_fields(
     write_client: Elasticsearch,
+    validate: bool,
 ) -> None:
-    test_repo = Repository(field_1=[], field_2=None, field_3={}, meta={"id": 42})
-    assert test_repo.save(index="test-document", skip_empty=False)
+    test_repo = Repository(
+        field_1=[], field_2=None, field_3={}, owner={"name": None}, meta={"id": 42}
+    )
+    assert test_repo.save(index="test-document", skip_empty=False, validate=validate)
 
     assert_doc_equals(
         {
             "found": True,
             "_index": "test-document",
             "_id": "42",
-            "_source": {"field_1": [], "field_2": None, "field_3": {}},
+            "_source": {
+                "field_1": [],
+                "field_2": None,
+                "field_3": {},
+                "owner": {"name": None},
+            },
         },
         write_client.get(index="test-document", id=42),
     )
 
+    test_repo = Repository(owner=AttrDict({"name": None}), meta={"id": 43})
+    assert test_repo.save(index="test-document", skip_empty=False, validate=validate)
+
+    assert_doc_equals(
+        {
+            "found": True,
+            "_index": "test-document",
+            "_id": "43",
+            "_source": {
+                "owner": {"name": None},
+            },
+        },
+        write_client.get(index="test-document", id=43),
+    )
+
 
 @pytest.mark.sync
 def test_delete(write_client: Elasticsearch) -> None:
@@ -842,3 +870,47 @@ class Index:
     assert docs[0].float_vector == doc.float_vector
     assert docs[0].byte_vector == doc.byte_vector
     assert docs[0].bit_vector == doc.bit_vector
+
+
+@pytest.mark.sync
+def test_copy_to(client: Elasticsearch) -> None:
+    class Person(Document):
+        first_name: M[str] = mapped_field(Text(copy_to=["full_name", "all"]))
+        last_name: M[str] = mapped_field(Text(copy_to=["full_name", "all"]))
+        birth_place: M[str] = mapped_field(Text(copy_to="all"))
+        full_name: M[Optional[str]] = mapped_field(init=False)
+        all: M[Optional[str]] = mapped_field(init=False)
+
+        class Index:
+            name = "people"
+
+    Person._index.delete(ignore_unavailable=True)
+    Person.init()
+
+    person = Person(first_name="Jane", last_name="Doe", birth_place="Springfield")
+    person.save()
+    Person._index.refresh()
+
+    match = (
+        Person.search()
+        .query(Match(Person.full_name, MatchQuery(query="Jane")))
+        .execute()
+    )
+    assert len(match) == 1
+
+    match = Person.search().query(Match(Person.all, MatchQuery(query="Doe"))).execute()
+    assert len(match) == 1
+
+    match = (
+        Person.search()
+        .query(Match(Person.full_name, MatchQuery(query="Springfield")))
+        .execute()
+    )
+    assert len(match) == 0
+
+    match = (
+        Person.search()
+        .query(Match(Person.all, MatchQuery(query="Springfield")))
+        .execute()
+    )
+    assert len(match) == 1
diff --git a/test_elasticsearch/test_dsl/test_integration/_sync/test_esql.py b/test_elasticsearch/test_dsl/test_integration/_sync/test_esql.py
new file mode 100644
index 000000000..d02484013
--- /dev/null
+++ b/test_elasticsearch/test_dsl/test_integration/_sync/test_esql.py
@@ -0,0 +1,254 @@
+#  Licensed to Elasticsearch B.V. under one or more contributor
+#  license agreements. See the NOTICE file distributed with
+#  this work for additional information regarding copyright
+#  ownership. Elasticsearch B.V. licenses this file to you under
+#  the Apache License, Version 2.0 (the "License"); you may
+#  not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+# 	http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing,
+#  software distributed under the License is distributed on an
+#  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+#  KIND, either express or implied.  See the License for the
+#  specific language governing permissions and limitations
+#  under the License.
+
+import pytest
+
+from elasticsearch.dsl import Document, InnerDoc, M
+from elasticsearch.esql import ESQL, E, functions
+
+
+class Address(InnerDoc):
+    address: M[str]
+    city: M[str]
+
+
+class Employee(Document):
+    emp_no: M[int]
+    first_name: M[str]
+    last_name: M[str]
+    height: M[float]
+    still_hired: M[bool]
+    address: M[Address]
+
+    class Index:
+        name = "employees"
+
+
+def load_db():
+    data = [
+        [
+            10000,
+            "Joseph",
+            "Wall",
+            2.2,
+            True,
+            Address(address="8875 Long Shoals Suite 441", city="Marcville, TX"),
+        ],
+        [
+            10001,
+            "Stephanie",
+            "Ward",
+            1.749,
+            True,
+            Address(address="90162 Carter Harbor Suite 099", city="Davisborough, DE"),
+        ],
+        [
+            10002,
+            "David",
+            "Keller",
+            1.872,
+            True,
+            Address(address="6697 Patrick Union Suite 797", city="Fuentesmouth, SD"),
+        ],
+        [
+            10003,
+            "Roger",
+            "Hinton",
+            1.694,
+            False,
+            Address(address="809 Kelly Mountains", city="South Megan, DE"),
+        ],
+        [
+            10004,
+            "Joshua",
+            "Garcia",
+            1.661,
+            False,
+            Address(address="718 Angela Forks", city="Port Erinland, MA"),
+        ],
+        [
+            10005,
+            "Matthew",
+            "Richards",
+            1.633,
+            False,
+            Address(address="2869 Brown Mountains", city="New Debra, NH"),
+        ],
+        [
+            10006,
+            "Maria",
+            "Luna",
+            1.893,
+            True,
+            Address(address="5861 Morgan Springs", city="Lake Daniel, WI"),
+        ],
+        [
+            10007,
+            "Angela",
+            "Navarro",
+            1.604,
+            False,
+            Address(address="2848 Allen Station", city="Saint Joseph, OR"),
+        ],
+        [
+            10008,
+            "Maria",
+            "Cannon",
+            2.079,
+            False,
+            Address(address="322 NW Johnston", city="Bakerburgh, MP"),
+        ],
+        [
+            10009,
+            "Joseph",
+            "Sutton",
+            2.025,
+            True,
+            Address(address="77 Cardinal E", city="Lakestown, IL"),
+        ],
+    ]
+    if Employee._index.exists():
+        Employee._index.delete()
+    Employee.init()
+
+    for e in data:
+        employee = Employee(
+            emp_no=e[0],
+            first_name=e[1],
+            last_name=e[2],
+            height=e[3],
+            still_hired=e[4],
+            address=e[5],
+        )
+        employee.save()
+    Employee._index.refresh()
+
+
+@pytest.mark.sync
+def test_esql(client):
+    load_db()
+
+    # get the full names of the employees
+    query = (
+        ESQL.from_(Employee)
+        .eval(full_name=functions.concat(Employee.first_name, " ", Employee.last_name))
+        .keep("full_name")
+        .sort("full_name")
+        .limit(10)
+    )
+    r = client.esql.query(query=str(query))
+    assert r.body["values"] == [
+        ["Angela Navarro"],
+        ["David Keller"],
+        ["Joseph Sutton"],
+        ["Joseph Wall"],
+        ["Joshua Garcia"],
+        ["Maria Cannon"],
+        ["Maria Luna"],
+        ["Matthew Richards"],
+        ["Roger Hinton"],
+        ["Stephanie Ward"],
+    ]
+
+    # get the average height of all hired employees
+    query = ESQL.from_(Employee).stats(
+        avg_height=functions.round(functions.avg(Employee.height), 2).where(
+            Employee.still_hired == True  # noqa: E712
+        )
+    )
+    r = client.esql.query(query=str(query))
+    assert r.body["values"] == [[1.95]]
+
+    # find employees by name using a parameter
+    query = (
+        ESQL.from_(Employee)
+        .where(Employee.first_name == E("?"))
+        .keep(Employee.last_name)
+        .sort(Employee.last_name.desc())
+    )
+    r = client.esql.query(query=str(query), params=["Maria"])
+    assert r.body["values"] == [["Luna"], ["Cannon"]]
+
+
+@pytest.mark.sync
+def test_esql_dsl(client):
+    load_db()
+
+    # get employees with first name "Maria"
+    query = (
+        Employee.esql_from()
+        .where(Employee.first_name == "Maria")
+        .sort("last_name")
+        .limit(10)
+    )
+    marias = []
+    for emp in Employee.esql_execute(query):
+        marias.append(emp)
+    assert len(marias) == 2
+    assert marias[0].last_name == "Cannon"
+    assert marias[0].address.address == "322 NW Johnston"
+    assert marias[0].address.city == "Bakerburgh, MP"
+    assert marias[1].last_name == "Luna"
+    assert marias[1].address.address == "5861 Morgan Springs"
+    assert marias[1].address.city == "Lake Daniel, WI"
+
+    # run a query with a missing field
+    query = (
+        Employee.esql_from()
+        .where(Employee.first_name == "Maria")
+        .drop(Employee.address.city)
+        .sort("last_name")
+        .limit(10)
+    )
+    with pytest.raises(ValueError):
+        Employee.esql_execute(query).__next__()
+    marias = []
+    for emp in Employee.esql_execute(query, ignore_missing_fields=True):
+        marias.append(emp)
+    assert marias[0].last_name == "Cannon"
+    assert marias[0].address.address == "322 NW Johnston"
+    assert marias[0].address.city is None
+    assert marias[1].last_name == "Luna"
+    assert marias[1].address.address == "5861 Morgan Springs"
+    assert marias[1].address.city is None
+
+    # run a query with additional calculated fields
+    query = (
+        Employee.esql_from()
+        .where(Employee.first_name == "Maria")
+        .eval(
+            full_name=functions.concat(Employee.first_name, " ", Employee.last_name),
+            height_cm=functions.to_integer(Employee.height * 100),
+        )
+        .sort("last_name")
+        .limit(10)
+    )
+    assert isinstance(Employee.esql_execute(query).__next__(), Employee)
+    assert isinstance(
+        Employee.esql_execute(query, return_additional=True).__next__(), tuple
+    )
+    marias = []
+    for emp, extra in Employee.esql_execute(query, return_additional=True):
+        marias.append([emp, extra])
+    assert marias[0][0].last_name == "Cannon"
+    assert marias[0][0].address.address == "322 NW Johnston"
+    assert marias[0][0].address.city == "Bakerburgh, MP"
+    assert marias[0][1] == {"full_name": "Maria Cannon", "height_cm": 208}
+    assert marias[1][0].last_name == "Luna"
+    assert marias[1][0].address.address == "5861 Morgan Springs"
+    assert marias[1][0].address.city == "Lake Daniel, WI"
+    assert marias[1][1] == {"full_name": "Maria Luna", "height_cm": 189}
diff --git a/test_elasticsearch/test_dsl/test_integration/test_examples/_async/test_vectors.py b/test_elasticsearch/test_dsl/test_integration/test_examples/_async/test_vectors.py
index dc45ceb52..3af9a877f 100644
--- a/test_elasticsearch/test_dsl/test_integration/test_examples/_async/test_vectors.py
+++ b/test_elasticsearch/test_dsl/test_integration/test_examples/_async/test_vectors.py
@@ -15,27 +15,27 @@
 #  specific language governing permissions and limitations
 #  under the License.
 
+import sys
 from hashlib import md5
 from typing import Any, List, Tuple
 from unittest import SkipTest
+from unittest.mock import Mock, patch
 
 import pytest
 
 from elasticsearch import AsyncElasticsearch
 
-from ..async_examples import vectors
-
 
 @pytest.mark.asyncio
 async def test_vector_search(
-    async_write_client: AsyncElasticsearch, es_version: Tuple[int, ...], mocker: Any
+    async_write_client: AsyncElasticsearch, es_version: Tuple[int, ...]
 ) -> None:
     # this test only runs on Elasticsearch >= 8.11 because the example uses
     # a dense vector without specifying an explicit size
     if es_version < (8, 11):
         raise SkipTest("This test requires Elasticsearch 8.11 or newer")
 
-    class MockModel:
+    class MockSentenceTransformer:
         def __init__(self, model: Any):
             pass
 
@@ -44,9 +44,22 @@ def encode(self, text: str) -> List[float]:
             total = sum(vector)
             return [float(v) / total for v in vector]
 
-    mocker.patch.object(vectors, "SentenceTransformer", new=MockModel)
+    def mock_nltk_tokenize(content: str):
+        return content.split("\n")
+
+    # mock sentence_transformers and nltk, because they are quite big and
+    # irrelevant for testing the example logic
+    with patch.dict(
+        sys.modules,
+        {
+            "sentence_transformers": Mock(SentenceTransformer=MockSentenceTransformer),
+            "nltk": Mock(sent_tokenize=mock_nltk_tokenize),
+        },
+    ):
+        # import the example after the dependencies are mocked
+        from ..async_examples import vectors
 
-    await vectors.create()
-    await vectors.WorkplaceDoc._index.refresh()
-    results = await (await vectors.search("Welcome to our team!")).execute()
-    assert results[0].name == "New Employee Onboarding Guide"
+        await vectors.create()
+        await vectors.WorkplaceDoc._index.refresh()
+        results = await (await vectors.search("Welcome to our team!")).execute()
+        assert results[0].name == "Intellectual Property Policy"
diff --git a/test_elasticsearch/test_dsl/test_integration/test_examples/_sync/test_vectors.py b/test_elasticsearch/test_dsl/test_integration/test_examples/_sync/test_vectors.py
index 4b14c89a0..e8e61b5a0 100644
--- a/test_elasticsearch/test_dsl/test_integration/test_examples/_sync/test_vectors.py
+++ b/test_elasticsearch/test_dsl/test_integration/test_examples/_sync/test_vectors.py
@@ -15,27 +15,27 @@
 #  specific language governing permissions and limitations
 #  under the License.
 
+import sys
 from hashlib import md5
 from typing import Any, List, Tuple
 from unittest import SkipTest
+from unittest.mock import Mock, patch
 
 import pytest
 
 from elasticsearch import Elasticsearch
 
-from ..examples import vectors
-
 
 @pytest.mark.sync
 def test_vector_search(
-    write_client: Elasticsearch, es_version: Tuple[int, ...], mocker: Any
+    write_client: Elasticsearch, es_version: Tuple[int, ...]
 ) -> None:
     # this test only runs on Elasticsearch >= 8.11 because the example uses
     # a dense vector without specifying an explicit size
     if es_version < (8, 11):
         raise SkipTest("This test requires Elasticsearch 8.11 or newer")
 
-    class MockModel:
+    class MockSentenceTransformer:
         def __init__(self, model: Any):
             pass
 
@@ -44,9 +44,22 @@ def encode(self, text: str) -> List[float]:
             total = sum(vector)
             return [float(v) / total for v in vector]
 
-    mocker.patch.object(vectors, "SentenceTransformer", new=MockModel)
+    def mock_nltk_tokenize(content: str):
+        return content.split("\n")
+
+    # mock sentence_transformers and nltk, because they are quite big and
+    # irrelevant for testing the example logic
+    with patch.dict(
+        sys.modules,
+        {
+            "sentence_transformers": Mock(SentenceTransformer=MockSentenceTransformer),
+            "nltk": Mock(sent_tokenize=mock_nltk_tokenize),
+        },
+    ):
+        # import the example after the dependencies are mocked
+        from ..examples import vectors
 
-    vectors.create()
-    vectors.WorkplaceDoc._index.refresh()
-    results = (vectors.search("Welcome to our team!")).execute()
-    assert results[0].name == "New Employee Onboarding Guide"
+        vectors.create()
+        vectors.WorkplaceDoc._index.refresh()
+        results = (vectors.search("Welcome to our team!")).execute()
+        assert results[0].name == "Intellectual Property Policy"
diff --git a/test_elasticsearch/test_esql.py b/test_elasticsearch/test_esql.py
new file mode 100644
index 000000000..35b026fb5
--- /dev/null
+++ b/test_elasticsearch/test_esql.py
@@ -0,0 +1,723 @@
+#  Licensed to Elasticsearch B.V. under one or more contributor
+#  license agreements. See the NOTICE file distributed with
+#  this work for additional information regarding copyright
+#  ownership. Elasticsearch B.V. licenses this file to you under
+#  the Apache License, Version 2.0 (the "License"); you may
+#  not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+# 	http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing,
+#  software distributed under the License is distributed on an
+#  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+#  KIND, either express or implied.  See the License for the
+#  specific language governing permissions and limitations
+#  under the License.
+
+from elasticsearch.dsl import E
+from elasticsearch.esql import ESQL, and_, functions, not_, or_
+
+
+def test_from():
+    query = ESQL.from_("employees")
+    assert query.render() == "FROM employees"
+
+    query = ESQL.from_("<logs-{now/d}>")
+    assert query.render() == "FROM <logs-{now/d}>"
+
+    query = ESQL.from_("employees-00001", "other-employees-*")
+    assert query.render() == "FROM employees-00001, other-employees-*"
+
+    query = ESQL.from_("cluster_one:employees-00001", "cluster_two:other-employees-*")
+    assert (
+        query.render()
+        == "FROM cluster_one:employees-00001, cluster_two:other-employees-*"
+    )
+
+    query = ESQL.from_("employees").metadata("_id")
+    assert query.render() == "FROM employees METADATA _id"
+
+
+def test_row():
+    query = ESQL.row(a=1, b="two", c=None)
+    assert query.render() == 'ROW a = 1, b = "two", c = null'
+
+    query = ESQL.row(a=[2, 1])
+    assert query.render() == "ROW a = [2, 1]"
+
+    query = ESQL.row(a=functions.round(1.23, 0))
+    assert query.render() == "ROW a = ROUND(1.23, 0)"
+
+
+def test_show():
+    query = ESQL.show("INFO")
+    assert query.render() == "SHOW INFO"
+
+
+def test_change_point():
+    query = (
+        ESQL.row(key=list(range(1, 26)))
+        .mv_expand("key")
+        .eval(value=functions.case(E("key") < 13, 0, 42))
+        .change_point("value")
+        .on("key")
+        .where("type IS NOT NULL")
+    )
+    assert (
+        query.render()
+        == """ROW key = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]
+| MV_EXPAND key
+| EVAL value = CASE(key < 13, 0, 42)
+| CHANGE_POINT value ON key
+| WHERE type IS NOT NULL"""
+    )
+
+
+def test_completion():
+    query = (
+        ESQL.row(question="What is Elasticsearch?")
+        .completion("question")
+        .with_("test_completion_model")
+        .keep("question", "completion")
+    )
+    assert (
+        query.render()
+        == """ROW question = "What is Elasticsearch?"
+| COMPLETION question WITH {"inference_id": "test_completion_model"}
+| KEEP question, completion"""
+    )
+
+    query = (
+        ESQL.row(question="What is Elasticsearch?")
+        .completion(answer=E("question"))
+        .with_("test_completion_model")
+        .keep("question", "answer")
+    )
+    assert (
+        query.render()
+        == """ROW question = "What is Elasticsearch?"
+| COMPLETION answer = question WITH {"inference_id": "test_completion_model"}
+| KEEP question, answer"""
+    )
+
+    query = (
+        ESQL.from_("movies")
+        .sort("rating DESC")
+        .limit(10)
+        .eval(
+            prompt="""CONCAT(
+      "Summarize this movie using the following information: \\n",
+      "Title: ", title, "\\n",
+      "Synopsis: ", synopsis, "\\n",
+      "Actors: ", MV_CONCAT(actors, ", "), "\\n",
+  )"""
+        )
+        .completion(summary="prompt")
+        .with_("test_completion_model")
+        .keep("title", "summary", "rating")
+    )
+    assert (
+        query.render()
+        == """FROM movies
+| SORT rating DESC
+| LIMIT 10
+| EVAL prompt = CONCAT(
+      "Summarize this movie using the following information: \\n",
+      "Title: ", title, "\\n",
+      "Synopsis: ", synopsis, "\\n",
+      "Actors: ", MV_CONCAT(actors, ", "), "\\n",
+  )
+| COMPLETION summary = prompt WITH {"inference_id": "test_completion_model"}
+| KEEP title, summary, rating"""
+    )
+
+    query = (
+        ESQL.from_("movies")
+        .sort("rating DESC")
+        .limit(10)
+        .eval(
+            prompt=functions.concat(
+                "Summarize this movie using the following information: \n",
+                "Title: ",
+                E("title"),
+                "\n",
+                "Synopsis: ",
+                E("synopsis"),
+                "\n",
+                "Actors: ",
+                functions.mv_concat(E("actors"), ", "),
+                "\n",
+            )
+        )
+        .completion(summary="prompt")
+        .with_("test_completion_model")
+        .keep("title", "summary", "rating")
+    )
+    assert (
+        query.render()
+        == """FROM movies
+| SORT rating DESC
+| LIMIT 10
+| EVAL prompt = CONCAT("Summarize this movie using the following information: \\n", "Title: ", title, "\\n", "Synopsis: ", synopsis, "\\n", "Actors: ", MV_CONCAT(actors, ", "), "\\n")
+| COMPLETION summary = prompt WITH {"inference_id": "test_completion_model"}
+| KEEP title, summary, rating"""
+    )
+
+
+def test_dissect():
+    query = (
+        ESQL.row(a="2023-01-23T12:15:00.000Z - some text - 127.0.0.1")
+        .dissect("a", "%{date} - %{msg} - %{ip}")
+        .keep("date", "msg", "ip")
+    )
+    assert (
+        query.render()
+        == """ROW a = "2023-01-23T12:15:00.000Z - some text - 127.0.0.1"
+| DISSECT a "%{date} - %{msg} - %{ip}"
+| KEEP date, msg, ip"""
+    )
+
+
+def test_drop():
+    query = ESQL.from_("employees").drop("height")
+    assert query.render() == "FROM employees\n| DROP height"
+    query = ESQL.from_("employees").drop("height*")
+    assert query.render() == "FROM employees\n| DROP height*"
+
+
+def test_enrich():
+    query = ESQL.row(language_code="1").enrich("languages_policy")
+    assert (
+        query.render()
+        == """ROW language_code = "1"
+| ENRICH languages_policy"""
+    )
+
+    query = ESQL.row(language_code="1").enrich("languages_policy").on("a")
+    assert (
+        query.render()
+        == """ROW language_code = "1"
+| ENRICH languages_policy ON a"""
+    )
+
+    query = (
+        ESQL.row(language_code="1")
+        .enrich("languages_policy")
+        .on("a")
+        .with_(name="language_name")
+    )
+    assert (
+        query.render()
+        == """ROW language_code = "1"
+| ENRICH languages_policy ON a WITH name = language_name"""
+    )
+
+
+def test_eval():
+    query = (
+        ESQL.from_("employees")
+        .sort("emp_no")
+        .keep("first_name", "last_name", "height")
+        .eval(height_feet=E("height") * 3.281, height_cm=E("height") * 100)
+    )
+    assert (
+        query.render()
+        == """FROM employees
+| SORT emp_no
+| KEEP first_name, last_name, height
+| EVAL height_feet = height * 3.281, height_cm = height * 100"""
+    )
+
+    query = (
+        ESQL.from_("employees")
+        .sort("emp_no")
+        .keep("first_name", "last_name", "height")
+        .eval(E("height") * 3.281)
+    )
+    assert (
+        query.render()
+        == """FROM employees
+| SORT emp_no
+| KEEP first_name, last_name, height
+| EVAL height * 3.281"""
+    )
+
+    query = (
+        ESQL.from_("employees")
+        .eval("height * 3.281")
+        .stats(avg_height_feet=functions.avg(E("`height * 3.281`")))
+    )
+    assert (
+        query.render()
+        == """FROM employees
+| EVAL height * 3.281
+| STATS avg_height_feet = AVG(`height * 3.281`)"""
+    )
+
+
+def test_fork():
+    query = (
+        ESQL.from_("employees")
+        .fork(
+            ESQL.branch().where(E("emp_no") == 10001),
+            ESQL.branch().where("emp_no == 10002"),
+        )
+        .keep("emp_no", "_fork")
+        .sort("emp_no")
+    )
+    assert (
+        query.render()
+        == """FROM employees
+| FORK ( WHERE emp_no == 10001 )
+       ( WHERE emp_no == 10002 )
+| KEEP emp_no, _fork
+| SORT emp_no"""
+    )
+
+
+def test_grok():
+    query = (
+        ESQL.row(a="2023-01-23T12:15:00.000Z 127.0.0.1 some.email@foo.com 42")
+        .grok(
+            "a",
+            "%{TIMESTAMP_ISO8601:date} %{IP:ip} %{EMAILADDRESS:email} %{NUMBER:num}",
+        )
+        .keep("date", "ip", "email", "num")
+    )
+    assert (
+        query.render()
+        == """ROW a = "2023-01-23T12:15:00.000Z 127.0.0.1 some.email@foo.com 42"
+| GROK a "%{TIMESTAMP_ISO8601:date} %{IP:ip} %{EMAILADDRESS:email} %{NUMBER:num}"
+| KEEP date, ip, email, num"""
+    )
+
+    query = (
+        ESQL.row(a="2023-01-23T12:15:00.000Z 127.0.0.1 some.email@foo.com 42")
+        .grok(
+            "a",
+            "%{TIMESTAMP_ISO8601:date} %{IP:ip} %{EMAILADDRESS:email} %{NUMBER:num:int}",
+        )
+        .keep("date", "ip", "email", "num")
+        .eval(date=functions.to_datetime(E("date")))
+    )
+    assert (
+        query.render()
+        == """ROW a = "2023-01-23T12:15:00.000Z 127.0.0.1 some.email@foo.com 42"
+| GROK a "%{TIMESTAMP_ISO8601:date} %{IP:ip} %{EMAILADDRESS:email} %{NUMBER:num:int}"
+| KEEP date, ip, email, num
+| EVAL date = TO_DATETIME(date)"""
+    )
+
+    query = (
+        ESQL.from_("addresses")
+        .keep("city.name", "zip_code")
+        .grok("zip_code", "%{WORD:zip_parts} %{WORD:zip_parts}")
+    )
+    assert (
+        query.render()
+        == """FROM addresses
+| KEEP city.name, zip_code
+| GROK zip_code "%{WORD:zip_parts} %{WORD:zip_parts}\""""
+    )
+
+
+def test_keep():
+    query = ESQL.from_("employees").keep("emp_no", "first_name", "last_name", "height")
+    assert (
+        query.render() == "FROM employees\n| KEEP emp_no, first_name, last_name, height"
+    )
+
+    query = ESQL.from_("employees").keep("h*")
+    assert query.render() == "FROM employees\n| KEEP h*"
+
+    query = ESQL.from_("employees").keep("*", "first_name")
+    assert query.render() == "FROM employees\n| KEEP *, first_name"
+
+
+def test_limit():
+    query = ESQL.from_("index").where(E("field") == "value").limit(1000)
+    assert query.render() == 'FROM index\n| WHERE field == "value"\n| LIMIT 1000'
+
+    query = (
+        ESQL.from_("index").stats(functions.avg(E("field1"))).by("field2").limit(20000)
+    )
+    assert (
+        query.render()
+        == "FROM index\n| STATS AVG(field1)\n        BY field2\n| LIMIT 20000"
+    )
+
+
+def test_lookup_join():
+    query = (
+        ESQL.from_("firewall_logs")
+        .lookup_join("threat_list")
+        .on("source.IP")
+        .where("threat_level IS NOT NULL")
+    )
+    assert (
+        query.render()
+        == """FROM firewall_logs
+| LOOKUP JOIN threat_list ON source.IP
+| WHERE threat_level IS NOT NULL"""
+    )
+
+    query = (
+        ESQL.from_("system_metrics")
+        .lookup_join("host_inventory")
+        .on("host.name")
+        .lookup_join("ownerships")
+        .on("host.name")
+    )
+    assert (
+        query.render()
+        == """FROM system_metrics
+| LOOKUP JOIN host_inventory ON host.name
+| LOOKUP JOIN ownerships ON host.name"""
+    )
+
+    query = ESQL.from_("app_logs").lookup_join("service_owners").on("service_id")
+    assert (
+        query.render()
+        == """FROM app_logs
+| LOOKUP JOIN service_owners ON service_id"""
+    )
+
+    query = (
+        ESQL.from_("employees")
+        .eval(language_code="languages")
+        .where(E("emp_no") >= 10091, E("emp_no") < 10094)
+        .lookup_join("languages_lookup")
+        .on("language_code")
+    )
+    assert (
+        query.render()
+        == """FROM employees
+| EVAL language_code = languages
+| WHERE emp_no >= 10091 AND emp_no < 10094
+| LOOKUP JOIN languages_lookup ON language_code"""
+    )
+
+
+def test_mv_expand():
+    query = ESQL.row(a=[1, 2, 3], b="b", j=["a", "b"]).mv_expand("a")
+    assert (
+        query.render()
+        == """ROW a = [1, 2, 3], b = "b", j = ["a", "b"]
+| MV_EXPAND a"""
+    )
+
+
+def test_rename():
+    query = (
+        ESQL.from_("employees")
+        .keep("first_name", "last_name", "still_hired")
+        .rename(still_hired="employed")
+    )
+    assert (
+        query.render()
+        == """FROM employees
+| KEEP first_name, last_name, still_hired
+| RENAME still_hired AS employed"""
+    )
+
+
+def test_sample():
+    query = ESQL.from_("employees").keep("emp_no").sample(0.05)
+    assert (
+        query.render()
+        == """FROM employees
+| KEEP emp_no
+| SAMPLE 0.05"""
+    )
+
+
+def test_sort():
+    query = (
+        ESQL.from_("employees").keep("first_name", "last_name", "height").sort("height")
+    )
+    assert (
+        query.render()
+        == """FROM employees
+| KEEP first_name, last_name, height
+| SORT height"""
+    )
+
+    query = (
+        ESQL.from_("employees")
+        .keep("first_name", "last_name", "height")
+        .sort("height DESC")
+    )
+    assert (
+        query.render()
+        == """FROM employees
+| KEEP first_name, last_name, height
+| SORT height DESC"""
+    )
+
+    query = (
+        ESQL.from_("employees")
+        .keep("first_name", "last_name", "height")
+        .sort("height DESC", "first_name ASC")
+    )
+    assert (
+        query.render()
+        == """FROM employees
+| KEEP first_name, last_name, height
+| SORT height DESC, first_name ASC"""
+    )
+
+    query = (
+        ESQL.from_("employees")
+        .keep("first_name", "last_name", "height")
+        .sort("first_name ASC NULLS FIRST")
+    )
+    assert (
+        query.render()
+        == """FROM employees
+| KEEP first_name, last_name, height
+| SORT first_name ASC NULLS FIRST"""
+    )
+
+
+def test_stats():
+    query = (
+        ESQL.from_("employees")
+        .stats(count=functions.count(E("emp_no")))
+        .by("languages")
+        .sort("languages")
+    )
+    assert (
+        query.render()
+        == """FROM employees
+| STATS count = COUNT(emp_no)
+        BY languages
+| SORT languages"""
+    )
+
+    query = ESQL.from_("employees").stats(avg_lang=functions.avg(E("languages")))
+    assert (
+        query.render()
+        == """FROM employees
+| STATS avg_lang = AVG(languages)"""
+    )
+
+    query = ESQL.from_("employees").stats(
+        avg_lang=functions.avg(E("languages")), max_lang=functions.max(E("languages"))
+    )
+    assert (
+        query.render()
+        == """FROM employees
+| STATS avg_lang = AVG(languages),
+        max_lang = MAX(languages)"""
+    )
+
+    query = (
+        ESQL.from_("employees")
+        .stats(
+            avg50s=functions.avg(E("salary")).where('birth_date < "1960-01-01"'),
+            avg60s=functions.avg(E("salary")).where('birth_date >= "1960-01-01"'),
+        )
+        .by("gender")
+        .sort("gender")
+    )
+    assert (
+        query.render()
+        == """FROM employees
+| STATS avg50s = AVG(salary) WHERE birth_date < "1960-01-01",
+        avg60s = AVG(salary) WHERE birth_date >= "1960-01-01"
+        BY gender
+| SORT gender"""
+    )
+
+    query = (
+        ESQL.from_("employees")
+        .eval(Ks="salary / 1000")
+        .stats(
+            under_40K=functions.count(E("*")).where("Ks < 40"),
+            inbetween=functions.count(E("*")).where("40 <= Ks", "Ks < 60"),
+            over_60K=functions.count(E("*")).where("60 <= Ks"),
+            total=functions.count(E("*")),
+        )
+    )
+    assert (
+        query.render()
+        == """FROM employees
+| EVAL Ks = salary / 1000
+| STATS under_40K = COUNT(*) WHERE Ks < 40,
+        inbetween = COUNT(*) WHERE (40 <= Ks) AND (Ks < 60),
+        over_60K = COUNT(*) WHERE 60 <= Ks,
+        total = COUNT(*)"""
+    )
+
+    query = (
+        ESQL.row(i=1, a=["a", "b"]).stats(functions.min(E("i"))).by("a").sort("a ASC")
+    )
+    assert (
+        query.render()
+        == 'ROW i = 1, a = ["a", "b"]\n| STATS MIN(i)\n        BY a\n| SORT a ASC'
+    )
+
+    query = (
+        ESQL.from_("employees")
+        .eval(hired=functions.date_format(E("hire_date"), "yyyy"))
+        .stats(avg_salary=functions.avg(E("salary")))
+        .by("hired", "languages.long")
+        .eval(avg_salary=functions.round(E("avg_salary")))
+        .sort("hired", "languages.long")
+    )
+    assert (
+        query.render()
+        == """FROM employees
+| EVAL hired = DATE_FORMAT("yyyy", hire_date)
+| STATS avg_salary = AVG(salary)
+        BY hired, languages.long
+| EVAL avg_salary = ROUND(avg_salary)
+| SORT hired, languages.long"""
+    )
+
+
+def test_where():
+    query = (
+        ESQL.from_("employees")
+        .keep("first_name", "last_name", "still_hired")
+        .where("still_hired == true")
+    )
+    assert (
+        query.render()
+        == """FROM employees
+| KEEP first_name, last_name, still_hired
+| WHERE still_hired == true"""
+    )
+
+    query = ESQL.from_("sample_data").where("@timestamp > NOW() - 1 hour")
+    assert (
+        query.render()
+        == """FROM sample_data
+| WHERE @timestamp > NOW() - 1 hour"""
+    )
+
+    query = (
+        ESQL.from_("employees")
+        .keep("first_name", "last_name", "height")
+        .where("LENGTH(first_name) < 4")
+    )
+    assert (
+        query.render()
+        == """FROM employees
+| KEEP first_name, last_name, height
+| WHERE LENGTH(first_name) < 4"""
+    )
+
+
+def test_and_operator():
+    query = ESQL.from_("index").where(
+        and_(E("age") > 30, E("age") < 40, E("name").is_not_null())
+    )
+    assert (
+        query.render()
+        == """FROM index
+| WHERE (age > 30) AND (age < 40) AND (name IS NOT NULL)"""
+    )
+
+
+def test_or_operator():
+    query = ESQL.from_("index").where(
+        or_(E("age") < 30, E("age") > 40, E("name").is_null())
+    )
+    assert (
+        query.render()
+        == """FROM index
+| WHERE (age < 30) OR (age > 40) OR (name IS NULL)"""
+    )
+
+
+def test_not_operator():
+    query = ESQL.from_("index").where(not_(E("age") > 40))
+    assert (
+        query.render()
+        == """FROM index
+| WHERE NOT (age > 40)"""
+    )
+
+
+def test_in_operator():
+    query = ESQL.row(a=1, b=4, c=3).where((E("c") - E("a")).in_(3, E("b") / 2, "a"))
+    assert (
+        query.render()
+        == """ROW a = 1, b = 4, c = 3
+| WHERE c - a IN (3, b / 2, a)"""
+    )
+
+
+def test_like_operator():
+    query = (
+        ESQL.from_("employees")
+        .where(E("first_name").like("?b*"))
+        .keep("first_name", "last_name")
+    )
+    assert (
+        query.render()
+        == """FROM employees
+| WHERE first_name LIKE "?b*"
+| KEEP first_name, last_name"""
+    )
+
+    query = ESQL.row(message="foo * bar").where(E("message").like("foo \\* bar"))
+    assert (
+        query.render()
+        == """ROW message = "foo * bar"
+| WHERE message LIKE "foo \\\\* bar\""""
+    )
+
+    query = ESQL.row(message="foobar").where(E("message").like("foo*", "bar?"))
+    assert (
+        query.render()
+        == """ROW message = "foobar"
+| WHERE message LIKE ("foo*", "bar?")"""
+    )
+
+
+def test_rlike_operator():
+    query = (
+        ESQL.from_("employees")
+        .where(E("first_name").rlike(".leja*"))
+        .keep("first_name", "last_name")
+    )
+    assert (
+        query.render()
+        == """FROM employees
+| WHERE first_name RLIKE ".leja*"
+| KEEP first_name, last_name"""
+    )
+
+    query = ESQL.row(message="foo ( bar").where(E("message").rlike("foo \\( bar"))
+    assert (
+        query.render()
+        == """ROW message = "foo ( bar"
+| WHERE message RLIKE "foo \\\\( bar\""""
+    )
+
+    query = ESQL.row(message="foobar").where(E("message").rlike("foo.*", "bar."))
+    assert (
+        query.render()
+        == """ROW message = "foobar"
+| WHERE message RLIKE ("foo.*", "bar.")"""
+    )
+
+
+def test_match_operator():
+    query = ESQL.from_("books").where(E("author").match("Faulkner"))
+    assert (
+        query.render()
+        == """FROM books
+| WHERE author:"Faulkner\""""
+    )
+
+
+def test_parameters():
+    query = ESQL.from_("employees").where("name == ?")
+    assert query.render() == "FROM employees\n| WHERE name == ?"
+
+    query = ESQL.from_("employees").where(E("name") == E("?"))
+    assert query.render() == "FROM employees\n| WHERE name == ?"
diff --git a/test_elasticsearch/test_exceptions.py b/test_elasticsearch/test_exceptions.py
index 00e8015c7..938aded3d 100644
--- a/test_elasticsearch/test_exceptions.py
+++ b/test_elasticsearch/test_exceptions.py
@@ -46,3 +46,33 @@ def test_transform_error_parse_with_error_string(self):
         assert (
             str(e) == "ApiError(500, 'InternalServerError', 'something error message')"
         )
+
+    def test_transform_invalid_media_type_error(self):
+        e = ApiError(
+            message="InvalidMediaType",
+            meta=error_meta,
+            body={
+                "error": {
+                    "root_cause": [
+                        {
+                            "type": "media_type_header_exception",
+                            "reason": "Invalid media-type value on headers [Accept, Content-Type]",
+                        }
+                    ],
+                    "type": "media_type_header_exception",
+                    "reason": "Invalid media-type value on headers [Accept, Content-Type]",
+                    "caused_by": {
+                        "type": "status_exception",
+                        "reason": "Accept version must be either version 8 or 7, but found 9. Accept=application/vnd.elasticsearch+json; compatible-with=9",
+                    },
+                },
+                "status": 400,
+            },
+        )
+
+        assert str(e) == (
+            "ApiError(500, 'InvalidMediaType', "
+            "'Invalid media-type value on headers [Accept, Content-Type]', "
+            "Accept version must be either version 8 or 7, but found 9. "
+            "Accept=application/vnd.elasticsearch+json; compatible-with=9)"
+        )
diff --git a/test_elasticsearch/test_serializer.py b/test_elasticsearch/test_serializer.py
index 21c6b94b5..311605c3a 100644
--- a/test_elasticsearch/test_serializer.py
+++ b/test_elasticsearch/test_serializer.py
@@ -223,10 +223,10 @@ def test_deserializes_text_with_correct_ct(self, data):
 
     def test_deserialize_compatibility_header(self):
         for content_type in (
-            "application/vnd.elasticsearch+json;compatible-with=7",
-            "application/vnd.elasticsearch+json; compatible-with=7",
             "application/vnd.elasticsearch+json;compatible-with=8",
             "application/vnd.elasticsearch+json; compatible-with=8",
+            "application/vnd.elasticsearch+json;compatible-with=9",
+            "application/vnd.elasticsearch+json; compatible-with=9",
         ):
             assert {"some": "data"} == self.serializers.loads(
                 '{"some":"data"}', content_type
@@ -236,10 +236,10 @@ def test_deserialize_compatibility_header(self):
             )
 
         for content_type in (
-            "application/vnd.elasticsearch+x-ndjson;compatible-with=7",
-            "application/vnd.elasticsearch+x-ndjson; compatible-with=7",
             "application/vnd.elasticsearch+x-ndjson;compatible-with=8",
             "application/vnd.elasticsearch+x-ndjson; compatible-with=8",
+            "application/vnd.elasticsearch+x-ndjson;compatible-with=9",
+            "application/vnd.elasticsearch+x-ndjson; compatible-with=9",
         ):
             assert b'{"some":"data"}\n{"some":"data"}\n' == self.serializers.dumps(
                 ['{"some":"data"}', {"some": "data"}], content_type
diff --git a/test_elasticsearch/test_server/test_rest_api_spec.py b/test_elasticsearch/test_server/test_rest_api_spec.py
index 0b602684a..bf566d503 100644
--- a/test_elasticsearch/test_server/test_rest_api_spec.py
+++ b/test_elasticsearch/test_server/test_rest_api_spec.py
@@ -24,6 +24,7 @@
 import json
 import os
 import re
+import subprocess
 import warnings
 import zipfile
 from typing import Tuple, Union
@@ -34,6 +35,7 @@
 
 from elasticsearch import ApiError, ElasticsearchWarning, RequestError
 from elasticsearch._sync.client.utils import _base64_auth_header
+from elasticsearch._version import __versionstr__
 from elasticsearch.compat import string_types
 
 # some params had to be changed in python, keep track of them so we can rename
@@ -78,6 +80,7 @@
     "cluster/voting_config_exclusions",
     "entsearch/10_basic",
     "indices/clone",
+    "indices/data_stream_mappings[0]",
     "indices/resolve_cluster",
     "indices/settings",
     "indices/split",
@@ -280,8 +283,6 @@ def run_catch(self, catch, exception):
         self.last_response = exception.body
 
     def run_skip(self, skip):
-        global IMPLEMENTED_FEATURES
-
         if "features" in skip:
             features = skip["features"]
             if not isinstance(features, (tuple, list)):
@@ -408,16 +409,21 @@ def _resolve(self, value):
         return value
 
     def _lookup(self, path):
-        # fetch the possibly nested value from last_response
-        value = self.last_response
         if path == "$body":
-            return value
+            return self.last_response
+        if path.startswith("$"):
+            value = None
+        else:
+            value = self.last_response
         path = path.replace(r"\.", "\1")
         for step in path.split("."):
             if not step:
                 continue
             # We check body again to handle E.g. '$body.$backing_index.data_stream'
-            if step.startswith("$body"):
+            if step == "$body":
+                assert value is None
+                # fetch the possibly nested value from last_response
+                value = self.last_response
                 continue
             step = step.replace("\1", ".")
             step = self._resolve(step)
@@ -429,15 +435,19 @@ def _lookup(self, path):
                 step = int(step)
                 assert isinstance(value, list)
                 assert len(value) > step
+                value = value[step]
             elif step == "_arbitrary_key_":
                 return list(value.keys())[0]
-            else:
+            elif isinstance(step, string_types) and isinstance(value, dict):
                 assert step in value
-            value = value[step]
+                value = value[step]
+            else:
+                assert value is None
+                value = step
         return value
 
     def _feature_enabled(self, name):
-        global XPACK_FEATURES, IMPLEMENTED_FEATURES
+        global XPACK_FEATURES
         if XPACK_FEATURES is None:
             try:
                 xinfo = self.client.xpack.info()
@@ -496,14 +506,31 @@ def remove_implicit_resolver(cls, tag_to_remove):
 # Try loading the REST API test specs from the Elastic Artifacts API
 try:
     # Construct the HTTP and Elasticsearch client
-    http = urllib3.PoolManager(retries=10)
-
-    yaml_tests_url = (
-        "https://api.github.com/repos/elastic/elasticsearch-clients-tests/zipball/main"
-    )
+    http = urllib3.PoolManager(retries=urllib3.Retry(total=10))
+
+    branch_candidates = []
+    if "ES_YAML_TESTS_BRANCH" in os.environ and os.environ["ES_YAML_TESTS_BRANCH"]:
+        branch_candidates.append(os.environ["ES_YAML_TESTS_BRANCH"])
+    git_branch = subprocess.getoutput("git branch --show-current")
+    if git_branch and git_branch not in branch_candidates:
+        branch_candidates.append(git_branch)
+    package_version = __versionstr__.rsplit(".", 1)[0]
+    if package_version and package_version not in branch_candidates:
+        branch_candidates.append(package_version)
+    if "main" not in branch_candidates:
+        branch_candidates.append("main")
+
+    response = None
+    branch = "main"
+    for branch in branch_candidates:
+        yaml_tests_url = f"https://api.github.com/repos/elastic/elasticsearch-clients-tests/zipball/%7Bbranch%7D"
+        response = http.request("GET", yaml_tests_url)
+        if response.status != 404:
+            break
+    assert response is not None
 
     # Download the zip and start reading YAML from the files in memory
-    package_zip = zipfile.ZipFile(io.BytesIO(http.request("GET", yaml_tests_url).data))
+    package_zip = zipfile.ZipFile(io.BytesIO(response.data))
 
     for yaml_file in package_zip.namelist():
         if not re.match(r"^.*\/tests\/.*\.ya?ml$", yaml_file):
@@ -561,7 +588,9 @@ def remove_implicit_resolver(cls, tag_to_remove):
             elif pytest_test_name in SKIPPED_TESTS or pytest_param_id in SKIPPED_TESTS:
                 pytest_param["skip"] = True
 
-            YAML_TEST_SPECS.append(pytest.param(pytest_param, id=pytest_param_id))
+            YAML_TEST_SPECS.append(
+                pytest.param(pytest_param, id=f"[{branch}]{pytest_param_id}")
+            )
 
 except Exception as e:
     warnings.warn(f"Could not load REST API tests: {str(e)}")
diff --git a/test_elasticsearch/test_transport.py b/test_elasticsearch/test_transport.py
index 5161cd8e1..237f21ac1 100644
--- a/test_elasticsearch/test_transport.py
+++ b/test_elasticsearch/test_transport.py
@@ -18,7 +18,7 @@
 import re
 import time
 import warnings
-from typing import Any, Dict, Optional, Union
+from typing import Any, Dict, Optional
 
 import pytest
 from elastic_transport import (
@@ -38,7 +38,6 @@
     ElasticsearchWarning,
     UnsupportedProductError,
 )
-from elasticsearch.transport import get_host_info
 
 
 class DummyNode(BaseNode):
@@ -167,23 +166,6 @@ def mark_live(self, connection):
 }"""
 
 
-class TestHostsInfoCallback:
-    def test_master_only_nodes_are_ignored(self):
-        nodes = [
-            {"roles": ["master"]},
-            {"roles": ["master", "data", "ingest"]},
-            {"roles": ["data", "ingest"]},
-            {"roles": []},
-            {},
-        ]
-        chosen = [
-            i
-            for i, node_info in enumerate(nodes)
-            if get_host_info(node_info, i) is not None
-        ]
-        assert [1, 2, 3, 4] == chosen
-
-
 class TestTransport:
     def test_request_timeout_extracted_from_params_and_passed(self):
         client = Elasticsearch(
@@ -285,7 +267,7 @@ def test_client_meta_header_not_sent(self):
         calls = client.transport.node_pool.get().calls
         assert 1 == len(calls)
         assert calls[0][1]["headers"] == {
-            "accept": "application/vnd.elasticsearch+json; compatible-with=8",
+            "accept": "application/vnd.elasticsearch+json; compatible-with=9",
         }
 
     def test_meta_header_type_error(self):
@@ -446,7 +428,7 @@ def test_sniff_on_start_ignores_sniff_timeout(self):
             {
                 "body": None,
                 "headers": {
-                    "accept": "application/vnd.elasticsearch+json; compatible-with=8"
+                    "accept": "application/vnd.elasticsearch+json; compatible-with=9"
                 },
                 "request_timeout": None,  # <-- Should be None instead of 12
             },
@@ -470,7 +452,7 @@ def test_sniff_uses_sniff_timeout(self):
             {
                 "body": None,
                 "headers": {
-                    "accept": "application/vnd.elasticsearch+json; compatible-with=8"
+                    "accept": "application/vnd.elasticsearch+json; compatible-with=9"
                 },
                 "request_timeout": 12,
             },
@@ -480,7 +462,7 @@ def test_sniff_uses_sniff_timeout(self):
             {
                 "body": None,
                 "headers": {
-                    "accept": "application/vnd.elasticsearch+json; compatible-with=8",
+                    "accept": "application/vnd.elasticsearch+json; compatible-with=9",
                 },
                 "request_timeout": DEFAULT,
             },
@@ -525,10 +507,8 @@ def test_sniff_after_n_seconds(self):
         "kwargs",
         [
             {"sniff_on_start": True},
-            {"sniff_on_connection_fail": True},
             {"sniff_on_node_failure": True},
             {"sniff_before_requests": True},
-            {"sniffer_timeout": 1},
             {"sniff_timeout": 1},
         ],
     )
@@ -589,41 +569,6 @@ def sniffed_node_callback(
         ports = {node.config.port for node in client.transport.node_pool.all()}
         assert ports == {9200, 124}
 
-    def test_sniffing_deprecated_host_info_callback(self):
-        def host_info_callback(
-            node_info: Dict[str, Any], host: Dict[str, Union[int, str]]
-        ) -> Dict[str, Any]:
-            return (
-                host if node_info["http"]["publish_address"].endswith(":124") else None
-            )
-
-        with warnings.catch_warnings(record=True) as w:
-            client = Elasticsearch(  # noqa: F821
-                [
-                    NodeConfig(
-                        "http",
-                        "localhost",
-                        9200,
-                        _extras={"data": CLUSTER_NODES_MASTER_ONLY},
-                    )
-                ],
-                node_class=DummyNode,
-                sniff_on_start=True,
-                host_info_callback=host_info_callback,
-            )
-
-        assert len(w) == 1
-        assert w[0].category == DeprecationWarning
-        assert (
-            str(w[0].message)
-            == "The 'host_info_callback' parameter is deprecated in favor of 'sniffed_node_callback'"
-        )
-
-        assert len(client.transport.node_pool) == 2
-
-        ports = {node.config.port for node in client.transport.node_pool.all()}
-        assert ports == {9200, 124}
-
 
 @pytest.mark.parametrize("headers", [{}, {"X-elastic-product": "BAD HEADER"}])
 def test_unsupported_product_error(headers):
@@ -647,7 +592,7 @@ def test_unsupported_product_error(headers):
         {
             "body": None,
             "headers": {
-                "accept": "application/vnd.elasticsearch+json; compatible-with=8",
+                "accept": "application/vnd.elasticsearch+json; compatible-with=9",
             },
             "request_timeout": DEFAULT,
         },
diff --git a/test_elasticsearch/test_types/aliased_types.py b/test_elasticsearch/test_types/aliased_types.py
index 0b5c97f98..ff0aa994a 100644
--- a/test_elasticsearch/test_types/aliased_types.py
+++ b/test_elasticsearch/test_types/aliased_types.py
@@ -34,9 +34,7 @@
     [{"host": "localhost", "port": 9443}],
     transport_class=Transport,
     sniff_on_start=True,
-    sniffer_timeout=0.1,
     sniff_timeout=1,
-    sniff_on_connection_fail=False,
     max_retries=1,
     retry_on_status={100, 400, 503},
     retry_on_timeout=True,
@@ -103,9 +101,7 @@ def reindex_types() -> None:
 es2 = AsyncElasticsearch(
     [{"host": "localhost", "port": 9443}],
     sniff_on_start=True,
-    sniffer_timeout=0.1,
     sniff_timeout=1,
-    sniff_on_connection_fail=False,
     max_retries=1,
     retry_on_status={100, 400, 503},
     retry_on_timeout=True,
diff --git a/test_elasticsearch/test_types/async_types.py b/test_elasticsearch/test_types/async_types.py
index ac7eed19a..1743fde2d 100644
--- a/test_elasticsearch/test_types/async_types.py
+++ b/test_elasticsearch/test_types/async_types.py
@@ -28,9 +28,7 @@
 es = AsyncElasticsearch(
     [{"host": "localhost", "port": 9443}],
     sniff_on_start=True,
-    sniffer_timeout=0.1,
     sniff_timeout=1,
-    sniff_on_connection_fail=False,
     max_retries=1,
     retry_on_status={100, 400, 503},
     retry_on_timeout=True,
diff --git a/test_elasticsearch/test_types/sync_types.py b/test_elasticsearch/test_types/sync_types.py
index f4582ddba..8166e50ee 100644
--- a/test_elasticsearch/test_types/sync_types.py
+++ b/test_elasticsearch/test_types/sync_types.py
@@ -23,9 +23,7 @@
 es = Elasticsearch(
     [{"host": "localhost", "port": 9443}],
     sniff_on_start=True,
-    sniffer_timeout=0.1,
     sniff_timeout=1,
-    sniff_on_connection_fail=False,
     max_retries=1,
     retry_on_status={100, 400, 503},
     retry_on_timeout=True,
diff --git a/test_elasticsearch/utils.py b/test_elasticsearch/utils.py
index 8a13ff62f..cfcb5259c 100644
--- a/test_elasticsearch/utils.py
+++ b/test_elasticsearch/utils.py
@@ -22,10 +22,8 @@
 from typing import Optional, Tuple
 
 from elasticsearch import (
-    AuthorizationException,
     ConnectionError,
     Elasticsearch,
-    NotFoundError,
 )
 
 SOURCE_DIR = Path(__file__).absolute().parent.parent
@@ -118,40 +116,15 @@ def wipe_cluster(client):
     except ImportError:
         pass
 
-    is_xpack = True
-    if is_xpack:
-        wipe_rollup_jobs(client)
-        wait_for_pending_tasks(client, filter="xpack/rollup/job")
-        wipe_slm_policies(client)
-
-        # Searchable snapshot indices start in 7.8+
-        if es_version(client) >= (7, 8):
-            wipe_searchable_snapshot_indices(client)
-
     wipe_snapshots(client)
-    if is_xpack:
-        wipe_data_streams(client)
+    wipe_data_streams(client)
     wipe_indices(client)
 
-    if is_xpack:
-        wipe_xpack_templates(client)
-    else:
-        client.indices.delete_template(name="*")
-        client.indices.delete_index_template(name="*")
-        client.cluster.delete_component_template(name="*")
+    client.indices.delete_template(name="*")
+    client.indices.delete_index_template(name="*")
 
     wipe_cluster_settings(client)
 
-    if is_xpack:
-        wipe_ilm_policies(client)
-        wipe_auto_follow_patterns(client)
-        wipe_tasks(client)
-        wipe_node_shutdown_metadata(client)
-        wait_for_pending_datafeeds_and_jobs(client)
-        wipe_calendars(client)
-        wipe_filters(client)
-        wipe_transforms(client)
-
     wait_for_cluster_state_updates_to_finish(client)
     if close_after_wipe:
         client.close()
@@ -169,16 +142,6 @@ def wipe_cluster_settings(client):
         client.cluster.put_settings(body=new_settings)
 
 
-def wipe_rollup_jobs(client):
-    rollup_jobs = client.rollup.get_jobs(id="_all").get("jobs", ())
-    for job in rollup_jobs:
-        job_id = job["config"]["id"]
-        client.options(ignore_status=404).rollup.stop_job(
-            id=job_id, wait_for_completion=True
-        )
-        client.options(ignore_status=404).rollup.delete_job(id=job_id)
-
-
 def wipe_snapshots(client):
     """Deletes all the snapshots and repositories from the cluster"""
     in_progress_snapshots = []
@@ -216,266 +179,15 @@ def wipe_data_streams(client):
 def wipe_indices(client):
     indices = client.cat.indices().strip().splitlines()
     if len(indices) > 0:
-        index_names = [i.split(" ")[2] for i in indices]
+        index_names = [i.split()[2] for i in indices]
         client.options(ignore_status=404).indices.delete(
             index=",".join(index_names),
             expand_wildcards="all",
         )
 
 
-def wipe_searchable_snapshot_indices(client):
-    cluster_metadata = client.cluster.state(
-        metric="metadata",
-        filter_path="metadata.indices.*.settings.index.store.snapshot",
-    )
-    if cluster_metadata:
-        for index in cluster_metadata["metadata"]["indices"].keys():
-            client.indices.delete(index=index)
-
-
-def wipe_xpack_templates(client):
-    # Delete index templates (including legacy)
-    templates = [
-        x.strip() for x in client.cat.templates(h="name").split("\n") if x.strip()
-    ]
-    for template in templates:
-        if is_xpack_template(template):
-            continue
-        try:
-            client.indices.delete_template(name=template)
-        except NotFoundError as e:
-            if f"index_template [{template}] missing" in str(e):
-                client.indices.delete_index_template(name=template)
-
-    # Delete component templates
-    templates = client.cluster.get_component_template()["component_templates"]
-    templates_to_delete = [
-        template["name"]
-        for template in templates
-        if not is_xpack_template(template["name"])
-    ]
-    if templates_to_delete:
-        client.cluster.delete_component_template(name=",".join(templates_to_delete))
-
-
-def wipe_ilm_policies(client):
-    for policy in client.ilm.get_lifecycle():
-        if (
-            policy
-            not in {
-                "ilm-history-ilm-policy",
-                "slm-history-ilm-policy",
-                "watch-history-ilm-policy",
-                "watch-history-ilm-policy-16",
-                "ml-size-based-ilm-policy",
-                "logs",
-                "metrics",
-                "synthetics",
-                "7-days-default",
-                "30-days-default",
-                "90-days-default",
-                "180-days-default",
-                "365-days-default",
-                ".fleet-actions-results-ilm-policy",
-                ".deprecation-indexing-ilm-policy",
-                ".monitoring-8-ilm-policy",
-            }
-            and "-history-ilm-polcy" not in policy
-            and "-meta-ilm-policy" not in policy
-            and "-data-ilm-policy" not in policy
-            and "@lifecycle" not in policy
-        ):
-            client.ilm.delete_lifecycle(name=policy)
-
-
-def wipe_slm_policies(client):
-    policies = client.slm.get_lifecycle()
-    for policy in policies:
-        if policy not in {"cloud-snapshot-policy"}:
-            client.slm.delete_lifecycle(policy_id=policy)
-
-
-def wipe_auto_follow_patterns(client):
-    for pattern in client.ccr.get_auto_follow_pattern()["patterns"]:
-        client.ccr.delete_auto_follow_pattern(name=pattern["name"])
-
-
-def wipe_node_shutdown_metadata(client):
-    try:
-        shutdown_status = client.shutdown.get_node()
-        # If response contains these two keys the feature flag isn't enabled
-        # on this cluster so skip this step now.
-        if "_nodes" in shutdown_status and "cluster_name" in shutdown_status:
-            return
-
-        for shutdown_node in shutdown_status.get("nodes", []):
-            node_id = shutdown_node["node_id"]
-            client.shutdown.delete_node(node_id=node_id)
-
-    # Elastic Cloud doesn't allow this so we skip.
-    except AuthorizationException:
-        pass
-
-
-def wipe_tasks(client):
-    tasks = client.tasks.list()
-    for node_name, node in tasks.get("node", {}).items():
-        for task_id in node.get("tasks", ()):
-            client.tasks.cancel(task_id=task_id, wait_for_completion=True)
-
-
-def wait_for_pending_tasks(client, filter, timeout=30):
-    end_time = time.time() + timeout
-    while time.time() < end_time:
-        tasks = client.cat.tasks(detailed=True).split("\n")
-        if not any(filter in task for task in tasks):
-            break
-
-
-def wait_for_pending_datafeeds_and_jobs(client: Elasticsearch, timeout=30):
-    end_time = time.time() + timeout
-    while time.time() < end_time:
-        resp = client.ml.get_datafeeds(datafeed_id="*", allow_no_match=True)
-        if resp["count"] == 0:
-            break
-        for datafeed in resp["datafeeds"]:
-            client.options(ignore_status=404).ml.delete_datafeed(
-                datafeed_id=datafeed["datafeed_id"]
-            )
-
-    end_time = time.time() + timeout
-    while time.time() < end_time:
-        resp = client.ml.get_jobs(job_id="*", allow_no_match=True)
-        if resp["count"] == 0:
-            break
-        for job in resp["jobs"]:
-            client.options(ignore_status=404).ml.close_job(job_id=job["job_id"])
-            client.options(ignore_status=404).ml.delete_job(job_id=job["job_id"])
-
-    end_time = time.time() + timeout
-    while time.time() < end_time:
-        resp = client.ml.get_data_frame_analytics(id="*")
-        if resp["count"] == 0:
-            break
-        for job in resp["data_frame_analytics"]:
-            client.options(ignore_status=404).ml.stop_data_frame_analytics(id=job["id"])
-            client.options(ignore_status=404).ml.delete_data_frame_analytics(
-                id=job["id"]
-            )
-
-
-def wipe_filters(client: Elasticsearch, timeout=30):
-    end_time = time.time() + timeout
-    while time.time() < end_time:
-        resp = client.ml.get_filters(filter_id="*")
-        if resp["count"] == 0:
-            break
-        for filter in resp["filters"]:
-            client.options(ignore_status=404).ml.delete_filter(
-                filter_id=filter["filter_id"]
-            )
-
-
-def wipe_calendars(client: Elasticsearch, timeout=30):
-    end_time = time.time() + timeout
-    while time.time() < end_time:
-        resp = client.ml.get_calendars(calendar_id="*")
-        if resp["count"] == 0:
-            break
-        for calendar in resp["calendars"]:
-            client.options(ignore_status=404).ml.delete_calendar(
-                calendar_id=calendar["calendar_id"]
-            )
-
-
-def wipe_transforms(client: Elasticsearch, timeout=30):
-    end_time = time.time() + timeout
-    while time.time() < end_time:
-        resp = client.transform.get_transform(transform_id="*")
-        if resp["count"] == 0:
-            break
-        for trasnform in resp["transforms"]:
-            client.options(ignore_status=404).transform.stop_transform(
-                transform_id=trasnform["id"]
-            )
-            client.options(ignore_status=404).transform.delete_transform(
-                transform_id=trasnform["id"]
-            )
-
-
 def wait_for_cluster_state_updates_to_finish(client, timeout=30):
     end_time = time.time() + timeout
     while time.time() < end_time:
         if not client.cluster.pending_tasks().get("tasks", ()):
             break
-
-
-def is_xpack_template(name):
-    if name.startswith("."):
-        return True
-    elif name.startswith("behavioral_analytics-events"):
-        return True
-    elif name.startswith("elastic-connectors-"):
-        return True
-    elif name.startswith("entities_v1_"):
-        return True
-    elif name.endswith("@ilm"):
-        return True
-    elif name.endswith("@template"):
-        return True
-
-    return name in {
-        "agentless",
-        "agentless@mappings",
-        "agentless@settings",
-        "apm-10d@lifecycle",
-        "apm-180d@lifecycle",
-        "apm-390d@lifecycle",
-        "apm-90d@lifecycle",
-        "apm@mappings",
-        "apm@settings",
-        "data-streams-mappings",
-        "data-streams@mappings",
-        "elastic-connectors",
-        "ecs@dynamic_templates",
-        "ecs@mappings",
-        "ilm-history-7",
-        "kibana-reporting@settings",
-        "logs",
-        "logs-apm.error@mappings",
-        "logs-apm@settings",
-        "logs-mappings",
-        "logs@mappings",
-        "logs-settings",
-        "logs@settings",
-        "metrics",
-        "metrics-apm@mappings",
-        "metrics-apm.service_destination@mappings",
-        "metrics-apm.service_summary@mappings",
-        "metrics-apm.service_transaction@mappings",
-        "metrics-apm@settings",
-        "metrics-apm.transaction@mappings",
-        "metrics-mappings",
-        "metrics@mappings",
-        "metrics-settings",
-        "metrics@settings",
-        "metrics-tsdb-settings",
-        "metrics@tsdb-settings",
-        "search-acl-filter",
-        "synthetics",
-        "synthetics-mappings",
-        "synthetics@mappings",
-        "synthetics-settings",
-        "synthetics@settings",
-        "traces-apm@mappings",
-        "traces-apm.rum@mappings",
-        "traces@mappings",
-        "traces@settings",
-        # otel
-        "metrics-otel@mappings",
-        "semconv-resource-to-ecs@mappings",
-        "traces-otel@mappings",
-        "ecs-tsdb@mappings",
-        "logs-otel@mappings",
-        "otel@mappings",
-    }
diff --git a/utils/build-dists.py b/utils/build-dists.py
index ec8083103..fd1b477e0 100644
--- a/utils/build-dists.py
+++ b/utils/build-dists.py
@@ -42,7 +42,6 @@ def set_tmp_dir():
 
 
 def run(*argv, expect_exit_code=0):
-    global tmp_dir
     try:
         prev_dir = os.getcwd()
         if tmp_dir is None:
@@ -122,6 +121,7 @@ def test_dist(dist):
                 "--install-types",
                 "--non-interactive",
                 "--ignore-missing-imports",
+                "--implicit-reexport",
                 os.path.join(base_dir, "test_elasticsearch/test_types/async_types.py"),
             )
 
@@ -146,6 +146,7 @@ def test_dist(dist):
                 "--install-types",
                 "--non-interactive",
                 "--ignore-missing-imports",
+                "--implicit-reexport",
                 os.path.join(base_dir, "test_elasticsearch/test_types/sync_types.py"),
             )
         else:
@@ -157,6 +158,7 @@ def test_dist(dist):
                 "--install-types",
                 "--non-interactive",
                 "--ignore-missing-imports",
+                "--implicit-reexport",
                 os.path.join(
                     base_dir, "test_elasticsearch/test_types/aliased_types.py"
                 ),
diff --git a/utils/dsl-generator.py b/utils/dsl-generator.py
index 3841967e7..f18991dfc 100644
--- a/utils/dsl-generator.py
+++ b/utils/dsl-generator.py
@@ -17,14 +17,13 @@
 
 import json
 import re
+import subprocess
 import textwrap
 from urllib.error import HTTPError
 from urllib.request import urlopen
 
 from jinja2 import Environment, PackageLoader, select_autoescape
 
-from elasticsearch import VERSION
-
 jinja_env = Environment(
     loader=PackageLoader("utils"),
     autoescape=select_autoescape(),
@@ -38,7 +37,7 @@
 types_py = jinja_env.get_template("types.py.tpl")
 
 # map with name replacements for Elasticsearch attributes
-PROP_REPLACEMENTS = {"from": "from_"}
+PROP_REPLACEMENTS = {"from": "from_", "global": "global_"}
 
 # map with Elasticsearch type replacements
 # keys and values are in given in "{namespace}:{name}" format
@@ -115,9 +114,9 @@ def type_for_types_py(type_):
 class ElasticsearchSchema:
     """Operations related to the Elasticsearch schema."""
 
-    def __init__(self):
+    def __init__(self, version="main"):
         response = None
-        for branch in [f"{VERSION[0]}.{VERSION[1]}", "main"]:
+        for branch in [version, "main"]:
             url = f"https://raw.githubusercontent.com/elastic/elasticsearch-specification/%7Bbranch%7D/output/schema/schema.json"
             try:
                 response = urlopen(url)
@@ -201,6 +200,12 @@ def get_python_type(self, schema_type, for_response=False):
             ):
                 # QueryContainer maps to the DSL's Query class
                 return "Query", {"type": "query"}
+            elif (
+                type_name["namespace"] == "_global.search._types"
+                and type_name["name"] == "SearchRequestBody"
+            ):
+                # we currently do not provide specific typing for this one
+                return "Dict[str, Any]", None
             elif (
                 type_name["namespace"] == "_types.query_dsl"
                 and type_name["name"] == "FunctionScoreContainer"
@@ -219,7 +224,7 @@ def get_python_type(self, schema_type, for_response=False):
                 type_name["namespace"] == "_types.aggregations"
                 and type_name["name"] == "CompositeAggregationSource"
             ):
-                # QueryContainer maps to the DSL's Query class
+                # CompositeAggreagationSource maps to the DSL's Agg class
                 return "Agg[_R]", None
             else:
                 # for any other instances we get the type and recurse
@@ -300,6 +305,8 @@ def get_python_type(self, schema_type, for_response=False):
                         ]
                     )
                 )
+                if len(types) == 1:
+                    return types[0]
                 return "Union[" + ", ".join([type_ for type_, _ in types]) + "]", None
 
         elif schema_type["kind"] == "enum":
@@ -338,6 +345,12 @@ def get_python_type(self, schema_type, for_response=False):
             ]["name"].endswith("Analyzer"):
                 # not expanding analyzers at this time, maybe in the future
                 return "str, Dict[str, Any]", None
+            elif schema_type["name"]["namespace"] == "_types.aggregations":
+                if (
+                    schema_type["name"]["name"].endswith("AggregationRange")
+                    or schema_type["name"]["name"] == "DateRangeExpression"
+                ) and schema_type["name"]["name"] != "IpRangeAggregationRange":
+                    return '"wrappers.AggregationRange"', None
 
             # to handle other interfaces we generate a type of the same name
             # and add the interface to the interfaces.py module
@@ -380,9 +393,12 @@ def add_attribute(self, k, arg, for_types_py=False, for_response=False):
             param = None
         if not for_response:
             if type_ != "Any":
-                if 'Sequence["types.' in type_:
+                if (
+                    'Sequence["types.' in type_
+                    or 'Sequence["wrappers.AggregationRange' in type_
+                ):
                     type_ = add_seq_dict_type(type_)  # interfaces can be given as dicts
-                elif "types." in type_:
+                elif "types." in type_ or "wrappers.AggregationRange" in type_:
                     type_ = add_dict_type(type_)  # interfaces can be given as dicts
                 type_ = add_not_set(type_)
         if for_types_py:
@@ -999,7 +1015,8 @@ def generate_types_py(schema, filename):
 
 
 if __name__ == "__main__":
-    schema = ElasticsearchSchema()
+    v = subprocess.check_output(["git", "branch", "--show-current"]).strip().decode()
+    schema = ElasticsearchSchema(v)
     generate_field_py(schema, "elasticsearch/dsl/field.py")
     generate_query_py(schema, "elasticsearch/dsl/query.py")
     generate_aggs_py(schema, "elasticsearch/dsl/aggs.py")
diff --git a/utils/run-unasync-dsl.py b/utils/run-unasync-dsl.py
index 59c0b05bc..b74c748fa 100644
--- a/utils/run-unasync-dsl.py
+++ b/utils/run-unasync-dsl.py
@@ -121,7 +121,7 @@ def main(check=False):
                 [
                     "sed",
                     "-i.bak",
-                    "s/elasticsearch\\[async\\]/elasticsearch/",
+                    's/"elasticsearch\\[async\\]"/elasticsearch/',
                     f"{output_dir}{file}",
                 ]
             )
diff --git a/utils/templates/aggs.py.tpl b/utils/templates/aggs.py.tpl
index d4ba4f4cd..68d46e63d 100644
--- a/utils/templates/aggs.py.tpl
+++ b/utils/templates/aggs.py.tpl
@@ -38,6 +38,7 @@ from elastic_transport.client_utils import DEFAULT
 from .query import Query
 from .response.aggs import AggResponse, BucketData, FieldBucketData, TopHitsData
 from .utils import _R, AttrDict, DslBase
+from . import wrappers
 
 if TYPE_CHECKING:
     from elastic_transport.client_utils import DefaultType
diff --git a/utils/templates/field.py.tpl b/utils/templates/field.py.tpl
index 95ee2f391..43df1b5f0 100644
--- a/utils/templates/field.py.tpl
+++ b/utils/templates/field.py.tpl
@@ -119,9 +119,16 @@ class Field(DslBase):
     def __getitem__(self, subfield: str) -> "Field":
         return cast(Field, self._params.get("fields", {})[subfield])
 
-    def _serialize(self, data: Any) -> Any:
+    def _serialize(self, data: Any, skip_empty: bool) -> Any:
         return data
 
+    def _safe_serialize(self, data: Any, skip_empty: bool) -> Any:
+        try:
+            return self._serialize(data, skip_empty)
+        except TypeError:
+            # older method signature, without skip_empty
+            return self._serialize(data)  # type: ignore[call-arg]
+
     def _deserialize(self, data: Any) -> Any:
         return data
 
@@ -133,10 +140,10 @@ class Field(DslBase):
             return AttrList([])
         return self._empty()
 
-    def serialize(self, data: Any) -> Any:
+    def serialize(self, data: Any, skip_empty: bool = True) -> Any:
         if isinstance(data, (list, AttrList, tuple)):
-            return list(map(self._serialize, cast(Iterable[Any], data)))
-        return self._serialize(data)
+            return list(map(self._safe_serialize, cast(Iterable[Any], data), [skip_empty] * len(data)))
+        return self._safe_serialize(data, skip_empty)
 
     def deserialize(self, data: Any) -> Any:
         if isinstance(data, (list, AttrList, tuple)):
@@ -186,7 +193,7 @@ class RangeField(Field):
         data = {k: self._core_field.deserialize(v) for k, v in data.items()}  # type: ignore[union-attr]
         return Range(data)
 
-    def _serialize(self, data: Any) -> Optional[Dict[str, Any]]:
+    def _serialize(self, data: Any, skip_empty: bool) -> Optional[Dict[str, Any]]:
         if data is None:
             return None
         if not isinstance(data, collections.abc.Mapping):
@@ -245,7 +252,14 @@ class {{ k.name }}({{ k.parent }}):
             {% if not arg.positional %}
         if {{ arg.name }} is not DEFAULT:
                 {% if "InstrumentedField" in arg.type %}
+                    {% if "Sequence" in arg.type %}
+            if isinstance({{ arg.name }}, list):
+                kwargs["{{ arg.name }}"] = [str(field) for field in {{ arg.name }}]
+            else:
+                kwargs["{{ arg.name }}"] = str({{ arg.name }})
+                    {% else %}
             kwargs["{{ arg.name }}"] = str({{ arg.name }})
+                    {% endif %}
                 {% else %}
             kwargs["{{ arg.name }}"] = {{ arg.name }}
                 {% endif %}
@@ -311,7 +325,7 @@ class {{ k.name }}({{ k.parent }}):
         return self._wrap(data)
 
     def _serialize(
-        self, data: Optional[Union[Dict[str, Any], "InnerDoc"]]
+        self, data: Optional[Union[Dict[str, Any], "InnerDoc"]], skip_empty: bool
     ) -> Optional[Dict[str, Any]]:
         if data is None:
             return None
@@ -320,7 +334,11 @@ class {{ k.name }}({{ k.parent }}):
         if isinstance(data, collections.abc.Mapping):
             return data
 
-        return data.to_dict()
+        try:
+            return data.to_dict(skip_empty=skip_empty)
+        except TypeError:
+            # this would only happen if an AttrDict was given instead of an InnerDoc
+            return data.to_dict()
 
     def clean(self, data: Any) -> Any:
         data = super().clean(data)
@@ -367,7 +385,7 @@ class {{ k.name }}({{ k.parent }}):
         if isinstance(data, datetime):
             if self._default_timezone and data.tzinfo is None:
                 data = data.replace(tzinfo=self._default_timezone)
-            return data
+            return cast(datetime, data)
         if isinstance(data, date):
             return data
         if isinstance(data, int):
@@ -426,7 +444,7 @@ class {{ k.name }}({{ k.parent }}):
         # the ipaddress library for pypy only accepts unicode.
         return ipaddress.ip_address(unicode(data))
 
-    def _serialize(self, data: Any) -> Optional[str]:
+    def _serialize(self, data: Any, skip_empty: bool) -> Optional[str]:
         if data is None:
             return None
         return str(data)        
@@ -441,7 +459,7 @@ class {{ k.name }}({{ k.parent }}):
     def _deserialize(self, data: Any) -> bytes:
         return base64.b64decode(data)
 
-    def _serialize(self, data: Any) -> Optional[str]:
+    def _serialize(self, data: Any, skip_empty: bool) -> Optional[str]:
         if data is None:
             return None
         return base64.b64encode(data).decode()        
@@ -451,7 +469,7 @@ class {{ k.name }}({{ k.parent }}):
     def _deserialize(self, data: Any) -> "Query":
         return Q(data)  # type: ignore[no-any-return]
 
-    def _serialize(self, data: Any) -> Optional[Dict[str, Any]]:
+    def _serialize(self, data: Any, skip_empty: bool) -> Optional[Dict[str, Any]]:
         if data is None:
             return None
         return data.to_dict()  # type: ignore[no-any-return]