Switch 8.6 clients to only get patch updates to transport (#2210)

* Switch 8.6 clients to only get patch updates to transport

* Fix escaping on asciidocs

.buildkite/Dockerfile

@@ -1,16 +0,0 @@
-ARG NODE_VERSION=${NODE_VERSION:-18}
-FROM node:$NODE_VERSION
-
-# Install required tools
-RUN apt-get clean -y && \
-    apt-get -qy update && \
-    apt-get -y install zip && \
-    apt-get clean && \
-    rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
-
-WORKDIR /usr/src/app
-
-COPY package.json .
-RUN npm install --production=false
-
-COPY . .

.buildkite/certs/testnode.crt

@@ -1,21 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIDYjCCAkqgAwIBAgIVAIClHav09e9XGWJrnshywAjUHTnXMA0GCSqGSIb3DQEB
-CwUAMDQxMjAwBgNVBAMTKUVsYXN0aWMgQ2VydGlmaWNhdGUgVG9vbCBBdXRvZ2Vu
-ZXJhdGVkIENBMB4XDTIzMDMyODE3MDIzOVoXDTI2MDMyNzE3MDIzOVowEzERMA8G
-A1UEAxMIaW5zdGFuY2UwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCV
-+t5/g6u2r3awCtzqp17KG0hRxzkVoJoF8DYzVh+Rv9ymxQW0C/U8dQihAjkZHaIA
-n49lSyNLkwWtmqQgPcimV4d6XuTYx2ahDixXYtjmoOSwH5dRtovKPCNKDPkUj9Vq
-NwMW0uB1VxniMKI4DnYFqBgHL9kQKhQqvas6Gx0X6ptGRCLYCtVxeFcau6nnkZJt
-urb+HNV5waOh0uTmsqnnslK3NjCQ/f030vPKxM5fOqOU5ajUHpZFJ6ZFmS32074H
-l+mZoRT/GtbnVtIg+CJXsWThF3/L4iBImv+rkY9MKX5fyMLJgmIJG68S90IQGR8c
-Z2lZYzC0J7zjMsYlODbDAgMBAAGjgYswgYgwHQYDVR0OBBYEFIDIcECn3AVHc3jk
-MpQ4r7Kc3WCsMB8GA1UdIwQYMBaAFJYCWKn16g+acbing4Vl45QGUBs0MDsGA1Ud
-EQQ0MDKCCWxvY2FsaG9zdIIIaW5zdGFuY2WHBH8AAAGHEAAAAAAAAAAAAAAAAAAA
-AAGCA2VzMTAJBgNVHRMEAjAAMA0GCSqGSIb3DQEBCwUAA4IBAQBtX3RQ5ATpfORM
-lrnhaUPGOWkjnb3p3BrdAWUaWoh136QhaXqxKiALQQhTtTerkXOcuquy9MmAyYvS
-9fDdGvLCAO8pPCXjnzonCHerCLGdS7f/eqvSFWCdy7LPHzTAFYfVWVvbZed+83TL
-bDY63AMwIexj34vJEStMapuFwWx05fstE8qZWIbYCL87sF5H/MRhzlz3ScAhQ1N7
-tODH7zvLzSxFGGEzCIKZ0iPFKbd3Y0wE6SptDSKhOqlnC8kkNeI2GjWsqVfHKsoF
-pDFmri7IfOucuvalXJ6xiHPr9RDbuxEXs0u8mteT5nFQo7EaEGdHpg1pNGbfBOzP
-lmj/dRS9
------END CERTIFICATE-----

.buildkite/certs/testnode.key

@@ -1,27 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIEowIBAAKCAQEAlfref4Ortq92sArc6qdeyhtIUcc5FaCaBfA2M1Yfkb/cpsUF
-tAv1PHUIoQI5GR2iAJ+PZUsjS5MFrZqkID3IpleHel7k2MdmoQ4sV2LY5qDksB+X
-UbaLyjwjSgz5FI/VajcDFtLgdVcZ4jCiOA52BagYBy/ZECoUKr2rOhsdF+qbRkQi
-2ArVcXhXGrup55GSbbq2/hzVecGjodLk5rKp57JStzYwkP39N9LzysTOXzqjlOWo
-1B6WRSemRZkt9tO+B5fpmaEU/xrW51bSIPgiV7Fk4Rd/y+IgSJr/q5GPTCl+X8jC
-yYJiCRuvEvdCEBkfHGdpWWMwtCe84zLGJTg2wwIDAQABAoIBAAEP7HYNNnDWdYMD
-+WAtYM12X/W5s/wUP94juaBI4u4iZH2EZodlixEdZUCTXgq43WsDUhxX05s7cE+p
-H5DuSCHtoo2WHvGKAposwRDm2f3YVWQ2Xyb2ahNt69LYHHWrO+XQ60YYTa3r8Gn3
-7dFR3I016/jyn5DeEVaglvS1dfj2UG4ybR4KkMfcKd94X0rKvz3wzAhHIh+hwMtv
-sVk7V4vSnKf2mJXwIVECTolnEJEkCjWjjymgUJYKT8yN7JnAsHRcvMa6kWwIGrLp
-oQCEaJwYM6ynCRS989pLt3vA2iu5VkYhiHXJ9Ds/5b5yzhzmj+ymzKbFKrrUUrmn
-+2Jp1K0CgYEAw8BchALsD/+JuoXjinA14MH7PZjIsXyhtPk+c4pk42iMNyg1J8XF
-Y/ITepLYsl2bZqQI1jOJdDqsTwIsva9r749lsmkYI3VOxhi7+qBK0sThR66C87lX
-iU2QpnZ9NloC6ort4a3MEvZ/gRQcXdBrNlNoza2p7PHAVDTnsdSrNKUCgYEAxCQV
-uo85oZyfnMufn/gcI9IeYOgiB0tO3a8cAFX2wQW1y935t6Z13ApUQc4EnCOH7ZBc
-td5kT+xGdRWnfPZ38FM1dd5MBdGE69s3q8pJDUExSgNLqaF6/5bD32qui66L3ugu
-eMjxrzqJsc2uQTPCs18SGsyRmf54DpY8HglOmUcCgYAGRDgx+a347SNJl1OrcOAo
-q80RMbzrAaRjmL8JD9se9I/YjC73cPtasbsx51WMkDaTWJj30nqJ//7YIKeyAtWf
-u6Vzyq19JRo6eTw7T7pVePwFQW7rwnks6hDBY3WqscL6IyxuVxP7X2zBgxVNY4ir
-Gox2WSLhdPPFPlRUewxoCQKBgAJvqE1u5fpZ5ame5dao0ECppXLyrymEB/C88g4X
-Az+WgJGNqkJbsO8QuccvdeMylcefmWcw4fIULzPZFwF4VjkH74wNPMh9t7buPBzI
-IGwnuSMAM3ph5RMzni8yNgTKIDaej6U0abwRcBBjS5zHtc1giusGS3CsNnWH7Cs7
-VlyVAoGBAK+prq9t9x3tC3NfCZH8/Wfs/X0T1qm11RiL5+tOhmbguWAqSSBy8OjX
-Yh8AOXrFuMGldcaTXxMeiKvI2cyybnls1MFsPoeV/fSMJbex7whdeJeTi66NOSKr
-oftUHvkHS0Vv/LicMEOufFGslb4T9aPJ7oyhoSlz9CfAutDWk/q/
------END RSA PRIVATE KEY-----

.buildkite/pipeline.yml

@@ -1,31 +0,0 @@
----
-steps:
-  - label: ":elasticsearch: :javascript: ES JavaScript ({{ matrix.nodejs }}) Test Suite: {{ matrix.suite }}"
-    agents:
-      provider: "gcp"
-    env:
-      NODE_VERSION: "{{ matrix.nodejs }}"
-      TEST_SUITE: "{{ matrix.suite }}"
-      STACK_VERSION: 8.12.0-SNAPSHOT
-    matrix:
-      setup:
-        suite:
-          - "free"
-          - "platinum"
-        nodejs:
-          - "18"
-          - "20"
-    command: ./.buildkite/run-tests.sh
-    artifact_paths: "./junit-output/junit-*.xml"
-  - wait: ~
-    continue_on_failure: true
-  - label: ":junit: Test results"
-    agents:
-      provider: "gcp"
-      image: family/core-ubuntu-2204
-    plugins:
-      - junit-annotate#v2.4.1:
-          artifacts: "junit-output/junit-*.xml"
-          job-uuid-file-pattern: 'junit-(.*).xml'
-          fail-build-on-error: true
-          failure-format: file

.buildkite/pull-requests.json

@@ -1,20 +0,0 @@
-{
-  "jobs": [
-    {
-      "enabled": true,
-      "pipeline_slug": "elasticsearch-js-integration-tests",
-      "allowed_repo_permissions": ["admin", "write"],
-      "build_on_commit": true,
-      "skip_ci_on_only_changed": [
-        "\\.md$",
-        "\\.asciidoc$",
-        "^docs\\/",
-        "^\\.ci\\/",
-        "^scripts\\/",
-        "^catalog-info\\.yaml$",
-        "^test\\/unit\\/",
-        "^\\.github\\/"
-      ]
-    }
-  ]
-}

.buildkite/run-client.sh

@@ -1,31 +0,0 @@
-#!/usr/bin/env bash
-#
-# Once called Elasticsearch should be up and running
-#
-script_path=$(dirname "$(realpath -s "$0")")
-set -euo pipefail
-repo=$(pwd)
-
-export NODE_VERSION=${NODE_VERSION:-18}
-
-echo "--- :javascript: Building Docker image"
-docker build \
-       --file "$script_path/Dockerfile" \
-       --tag elastic/elasticsearch-js \
-       --build-arg NODE_VERSION="$NODE_VERSION" \
-       .
-
-echo "--- :javascript: Running $TEST_SUITE tests"
-mkdir -p "$repo/junit-output"
-docker run \
-       --network="${network_name}" \
-       --env "TEST_ES_SERVER=${elasticsearch_url}" \
-       --env "ELASTIC_PASSWORD=${elastic_password}" \
-       --env "TEST_SUITE=${TEST_SUITE}" \
-       --env "ELASTIC_USER=elastic" \
-       --env "BUILDKITE=true" \
-       --volume "$repo/junit-output:/junit-output" \
-       --name elasticsearch-js \
-       --rm \
-       elastic/elasticsearch-js \
-       bash -c "npm run test:integration; [ -f ./$TEST_SUITE-report-junit.xml ] && mv ./$TEST_SUITE-report-junit.xml /junit-output/junit-$BUILDKITE_JOB_ID.xml || echo 'No JUnit artifact found'"

.buildkite/run-tests.sh

@@ -1,16 +0,0 @@
-#!/usr/bin/env bash
-#
-# Script to run Elasticsearch container and Elasticsearch client integration tests on Buildkite
-#
-# Version 0.1
-#
-script_path=$(dirname "$(realpath -s "$0")")
-source "$script_path/functions/imports.sh"
-
-set -euo pipefail
-
-echo "--- :elasticsearch: Starting Elasticsearch"
-DETACH=true bash "$script_path/run-elasticsearch.sh"
-
-echo "+++ :javascript: Run Client"
-bash "$script_path/run-client.sh"

.ci/Dockerfile

@@ -1,30 +1,15 @@
-ARG NODE_JS_VERSION=${NODE_JS_VERSION:-18}
+ARG NODE_JS_VERSION=16
 FROM node:${NODE_JS_VERSION}
 
-ARG BUILDER_UID=1000
-ARG BUILDER_GID=1000
-ENV BUILDER_USER elastic
-ENV BUILDER_GROUP elastic
+# Create app directory
+WORKDIR /usr/src/app
 
-# install zip util
-RUN apt-get clean -y && \
-    apt-get update -y && \
-    apt-get install -y zip
+RUN apt-get clean -y
+RUN apt-get update -y
+RUN apt-get install -y zip
 
-# Set user permissions and directory
-RUN (id -g ${BUILDER_GID} || groupadd --system -g ${BUILDER_GID} ${BUILDER_GROUP}) \
-    && (id -u ${BUILDER_UID} || useradd --system --shell /bin/bash -u ${BUILDER_UID} -g ${BUILDER_GID} -m elastic) \
-    && mkdir -p /usr/src/elasticsearch-js \
-    && chown -R ${BUILDER_UID}:${BUILDER_GID} /usr/src/
+# Install app dependencies
+COPY package*.json ./
+RUN npm install
 
-WORKDIR /usr/src/elasticsearch-js
-
-# run remainder of commands as non-root user
-USER ${BUILDER_UID}:${BUILDER_GID}
-
-# install dependencies
-COPY package.json .
-RUN npm install --production=false
-
-# copy project files
 COPY . .

.ci/certs/testnode.crt

@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDIzCCAgugAwIBAgIVAMTO6uVx9dLox2t0lY4IcBKZXb5WMA0GCSqGSIb3DQEB
+CwUAMDQxMjAwBgNVBAMTKUVsYXN0aWMgQ2VydGlmaWNhdGUgVG9vbCBBdXRvZ2Vu
+ZXJhdGVkIENBMB4XDTIwMDIyNjA1NTA1OVoXDTIzMDIyNTA1NTA1OVowEzERMA8G
+A1UEAxMIaW5zdGFuY2UwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDK
+YLTOikVENiN/qYupOsoXd7VYYnryyfCC/dK4FC2aozkbqjFzBdvPGAasoc4yEiH5
+CGeXMgJuOjk1maqetmdIsw00j4oHJviYsnGXzxxS5swhD7spcW4Uk4V4tAUzrbfT
+vW/2WW/yYCLe5phVb2chz0jL+WYb4bBmdfs/t6RtP9RqsplYAmVp3gZ6lt2YNtvE
+k9gz0TVk3DuO1TquIClfRYUjuywS6xDSvxJ8Jl91EfDWM8QU+9F+YAtiv74xl2U3
+P0wwMqNvMxf9/3ak3lTQGsgO4L6cwbKpVLMMzxSVunZz/sgl19xy3qHHz1Qr2MjJ
+/2c2J7vahUL4NPRkjJClAgMBAAGjTTBLMB0GA1UdDgQWBBS2Wn8E2VZv4oenY+pR
+O8G3zfQXhzAfBgNVHSMEGDAWgBSWAlip9eoPmnG4p4OFZeOUBlAbNDAJBgNVHRME
+AjAAMA0GCSqGSIb3DQEBCwUAA4IBAQAvwPvCiJJ6v9jYcyvYY8I3gP0oCwrylpRL
+n91UlgRSHUmuAObyOoVN5518gSV/bTU2SDrstcLkLFxHvnfpoGJoxsQEHuGxwDRI
+nhYNd62EKLerehNM/F9ILKmvTh8f6QPCzjUuExTXv+63l2Sr6dBS7FHsGs6UKUYO
+llM/y9wMZ1LCuZuBg9RhtgpFXRSgDM9Z7Begu0d/BPX9od/qAeZg9Arz4rwUiCN4
+IJOMEBEPi5q1tgeS0Fb1Grpqd0Uz5tZKtEHNKzLG+zSMmkneL62Nk2HsmEFZKwzg
+u2pU42UaUE596G6o78s1aLn9ICcElPHTjiuZNSiyuu9IzvFDjGQw
+-----END CERTIFICATE-----

.ci/certs/testnode.key

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEogIBAAKCAQEAymC0zopFRDYjf6mLqTrKF3e1WGJ68snwgv3SuBQtmqM5G6ox
+cwXbzxgGrKHOMhIh+QhnlzICbjo5NZmqnrZnSLMNNI+KByb4mLJxl88cUubMIQ+7
+KXFuFJOFeLQFM623071v9llv8mAi3uaYVW9nIc9Iy/lmG+GwZnX7P7ekbT/UarKZ
+WAJlad4GepbdmDbbxJPYM9E1ZNw7jtU6riApX0WFI7ssEusQ0r8SfCZfdRHw1jPE
+FPvRfmALYr++MZdlNz9MMDKjbzMX/f92pN5U0BrIDuC+nMGyqVSzDM8Ulbp2c/7I
+Jdfcct6hx89UK9jIyf9nNie72oVC+DT0ZIyQpQIDAQABAoIBADAh7f7NjgnaInlD
+ds8KB3SraPsbeQhzlPtiqRJU4j/MIFH/GYG03AGWQkget67a9y+GmzSvlTpoKKEh
+6h2TXl9BDpv4o6ht0WRn1HJ5tM/Wyqf2WNpTew3zxCPgFPikkXsPrChYPzLTQJfp
+GkP/mfTFmxfAOlPZSp4j41zVLYs53eDkAegFPVfKSr1XNNJ3QODLPcIBfxBYsiC9
+oU+jRW8xYuj31cEl5k5UqrChJ1rm3mt6cguqXKbISuoSvi13gXI6DccqhuLAU+Kr
+ib2XYrRP+pWocZo/pM9WUVoNGtFxfY88sAQtvG6gDKo2AURtFyq84Ow0h9mdixV/
+gRIDPcECgYEA5nEqE3OKuG9WuUFGXvjtn4C0F6JjflYWh7AbX51S4F6LKrW6/XHL
+Rg4BtF+XReT7OQ6llsV8kZeUxsUckkgDLzSaA8lysNDV5KkhAWHfRqH//QKFbqZi
+JL9t3x63Qt81US8s2hQk3khPYTRM8ZB3xHiXvZYSGC/0x/DxfEO3QJECgYEA4NK5
+sxtrat8sFz6SK9nWEKimPjDVzxJ0hxdX4tRq/JdOO5RncawVqt6TNP9gTuxfBvhW
+MhJYEsQj8iUoL1dxo9d1eP8HEANNV0iX5OBvJNmgBp+2OyRSyr+PA55+wAxYuAE7
+QKaitOjW57fpArNRt2hQyiSzTuqUFRWTWJHCWNUCgYAEurPTXF6vdFGCUc2g61jt
+GhYYGhQSpq+lrz6Qksj9o9MVWE9zHh++21C7o+6V16I0RJGva3QoBMVf4vG4KtQt
+5tV2WG8LI+4P2Ey+G4UajP6U8bVNVQrUmD0oBBhcvfn5JY+1Fg6/pRpD82/U0VMz
+7AmpMWhDqNBMPiymkTk0kQKBgCuWb05cSI0ly4SOKwS5bRk5uVFhYnKNH255hh6C
+FGP4acB/WzbcqC7CjEPAJ0nl5d6SExQOHmk1AcsWjR3wlCWxxiK5PwNJwJrlhh1n
+reS1FKN0H36D4lFQpkeLWQOe4Sx7gKNeKzlr0w6Fx3Uwku0+Gju2tdTdAey8jB6l
+08opAoGAEe1AuR/OFp2xw6V8TH9UHkkpGxy+OrXI6PX6tgk29PgB+uiMu4RwbjVz
+1di1KKq2XecAilVbnyqY+edADxYGbSnci9x5wQRIebfMi3VXKtV8NQBv2as6qwtW
+JDcQUWotOHjpdvmfJWWkcBhbAKrgX8ukww00ZI/lC3/rmkGnBBg=
+-----END RSA PRIVATE KEY-----

.ci/docker/Dockerfile

@@ -0,0 +1,7 @@
+ARG NODE_JS_VERSION=10
+FROM node:${NODE_JS_VERSION}-alpine
+
+RUN apk --no-cache add git
+
+# Create app directory
+WORKDIR /usr/src/app

.ci/jobs/defaults.yml

@@ -0,0 +1,81 @@
+---
+
+##### GLOBAL METADATA
+
+- meta:
+    cluster: clients-ci
+
+##### JOB DEFAULTS
+
+- job:
+    project-type: matrix
+    logrotate:
+      daysToKeep: 30
+      numToKeep: 100
+    parameters:
+    - string:
+        name: branch_specifier
+        default: refs/heads/main
+        description: the Git branch specifier to build (<branchName>, <tagName>,
+          <commitId>, etc.)
+    properties:
+    - github:
+        url: https://github.com/elastic/elasticsearch-js/
+    - inject:
+        properties-content: HOME=$JENKINS_HOME
+    concurrent: true
+    node: flyweight
+    scm:
+    - git:
+        name: origin
+        credentials-id: f6c7695a-671e-4f4f-a331-acdce44ff9ba
+        reference-repo: /var/lib/jenkins/.git-references/elasticsearch-js.git
+        branches:
+        - ${branch_specifier}
+        url: https://github.com/elastic/elasticsearch-js.git
+        basedir: ''
+        wipe-workspace: 'True'
+    triggers:
+    - github
+    vault:
+      # vault read auth/approle/role/clients-ci/role-id
+      role_id: ddbd0d44-0e51-105b-177a-c8fdfd445126
+    axes:
+    - axis:
+        type: slave
+        name: label
+        values:
+        - linux
+    - axis:
+        type: yaml
+        filename: .ci/test-matrix.yml
+        name: STACK_VERSION
+    - axis:
+        type: yaml
+        filename: .ci/test-matrix.yml
+        name: NODE_JS_VERSION
+    - axis:
+        type: yaml
+        filename: .ci/test-matrix.yml
+        name: TEST_SUITE
+    yaml-strategy:
+      exclude-key: exclude
+      filename: .ci/test-matrix.yml
+    wrappers:
+      - ansicolor
+      - timeout:
+          type: absolute
+          timeout: 120
+          fail: true
+      - timestamps
+      - workspace-cleanup
+    builders:
+      - shell: |-
+          #!/usr/local/bin/runbld
+          .ci/run-tests
+    publishers:
+      - email:
+          recipients: build-lang-clients@elastic.co
+      - junit:
+          results: "**/*-junit.xml"
+          allow-empty-results: true

.ci/jobs/elastic+elasticsearch-js+7.17.yml

@@ -0,0 +1,15 @@
+---
+- job:
+    name: elastic+elasticsearch-js+7.17
+    display-name: 'elastic / elasticsearch-js # 7.17'
+    description: Testing the elasticsearch-js 7.17 branch.
+    junit_results: "*-junit.xml"
+    parameters:
+    - string:
+        name: branch_specifier
+        default: refs/heads/7.17
+        description: the Git branch specifier to build (<branchName>, <tagName>,
+          <commitId>, etc.)
+    triggers:
+    - github
+    - timed: 'H */12 * * *'

.ci/jobs/elastic+elasticsearch-js+8.1.yml

@@ -0,0 +1,15 @@
+---
+- job:
+    name: elastic+elasticsearch-js+8.1
+    display-name: 'elastic / elasticsearch-js # 8.1'
+    description: Testing the elasticsearch-js 8.1 branch.
+    junit_results: "*-junit.xml"
+    parameters:
+    - string:
+        name: branch_specifier
+        default: refs/heads/8.1
+        description: the Git branch specifier to build (<branchName>, <tagName>,
+          <commitId>, etc.)
+    triggers:
+    - github
+    - timed: 'H */12 * * *'

.ci/jobs/elastic+elasticsearch-js+8.2.yml

@@ -0,0 +1,15 @@
+---
+- job:
+    name: elastic+elasticsearch-js+8.2
+    display-name: 'elastic / elasticsearch-js # 8.2'
+    description: Testing the elasticsearch-js 8.2 branch.
+    junit_results: "*-junit.xml"
+    parameters:
+    - string:
+        name: branch_specifier
+        default: refs/heads/8.2
+        description: the Git branch specifier to build (<branchName>, <tagName>,
+          <commitId>, etc.)
+    triggers:
+    - github
+    - timed: 'H */12 * * *'

.ci/jobs/elastic+elasticsearch-js+main.yml

@@ -0,0 +1,15 @@
+---
+- job:
+    name: elastic+elasticsearch-js+main
+    display-name: 'elastic / elasticsearch-js # main'
+    description: Testing the elasticsearch-js main branch.
+    junit_results: "*-junit.xml"
+    parameters:
+    - string:
+        name: branch_specifier
+        default: refs/heads/main
+        description: the Git branch specifier to build (<branchName>, <tagName>,
+          <commitId>, etc.)
+    triggers:
+    - github
+    - timed: 'H */12 * * *'

.ci/jobs/elastic+elasticsearch-js+pull-request.yml

@@ -0,0 +1,19 @@
+---
+- job:
+    name: elastic+elasticsearch-js+pull-request
+    display-name: 'elastic / elasticsearch-js # pull-request'
+    description: Testing of elasticsearch-js pull requests.
+    junit_results: "*-junit.xml"
+    scm:
+    - git:
+        branches:
+        - ${ghprbActualCommit}
+        refspec: +refs/pull/*:refs/remotes/origin/pr/*
+    triggers:
+    - github-pull-request:
+        org-list:
+        - elastic
+        allow-whitelist-orgs-as-admins: true
+        github-hooks: true
+        status-context: clients-ci
+        cancel-builds-on-update: true

.ci/make.mjs

@@ -28,11 +28,6 @@ import assert from 'assert'
 import { join } from 'desm'
 import semver from 'semver'
 
-// xz/globals loads minimist-parsed args as a global `argv`, but it
-// interprets args like '8.10' as numbers and shortens them to '8.1'.
-// so we have to import and configure minimist ourselves.
-import minimist from 'minimist'
-const argv = minimist(process.argv.slice(2), { string: ['_', 'task'] })
 assert(typeof argv.task === 'string', 'Missing task parameter')
 
 switch (argv.task) {
@@ -91,33 +86,31 @@ async function bump (args) {
     'utf8'
   )
 
-  const pipeline = await readFile(join(import.meta.url, '..', '.buildkite', 'pipeline.yml'), 'utf8')
+  const testMatrix = await readFile(join(import.meta.url, 'test-matrix.yml'), 'utf8')
   await writeFile(
-    join(import.meta.url, '..', '.buildkite', 'pipeline.yml'),
-    pipeline.replace(/STACK_VERSION: [0-9]+[0-9\.]*[0-9](?:\-SNAPSHOT)?/, `STACK_VERSION: ${cleanVersion}-SNAPSHOT`),
+    join(import.meta.url, 'test-matrix.yml'),
+    testMatrix.replace(/STACK_VERSION:\s+\- "[0-9]+[0-9\.]*[0-9](?:\-SNAPSHOT)?"/, `STACK_VERSION:\n  - "${cleanVersion}-SNAPSHOT"`), // eslint-disable-line
     'utf8'
   )
 }
 
 // this command can only be executed locally for now
 async function codegen (args) {
-  assert(args.length === 1, 'Codegen task expects one parameter')
-  const version = args[0].toString()
-
+  assert(args.length === 1, 'Bump task expects one parameter')
   const clientGeneratorPath = join(import.meta.url, '..', '..', 'elastic-client-generator-js')
+  const [version] = args
+
   const isGeneratorCloned = await $`[[ -d ${clientGeneratorPath} ]]`.exitCode === 0
   assert(isGeneratorCloned, 'You must clone the elastic-client-generator-js first')
 
   await $`npm install --prefix ${clientGeneratorPath}`
-
-  // generate elasticsearch client. this command will take a while!
+  // this command will take a while!
   if (version === 'main') {
     await $`npm run elasticsearch --prefix ${clientGeneratorPath} -- --version main`
   } else {
     await $`npm run elasticsearch --prefix ${clientGeneratorPath} -- --version ${version.split('.').slice(0, 2).join('.')}`
   }
-  // clean up fixable linter issues
-  await $`npm run fix --prefix ${clientGeneratorPath}`
+  await $`npm run lint --prefix ${clientGeneratorPath}`
 
   await $`rm -rf ${join(import.meta.url, '..', 'src', 'api')}`
   await $`mkdir ${join(import.meta.url, '..', 'src', 'api')}`

.ci/make.sh

@@ -1,7 +1,9 @@
 #!/usr/bin/env bash
+
 # ------------------------------------------------------- #
 #
-# Build entry script for elasticsearch-js
+# Skeleton for common build entry script for all elastic
+# clients. Needs to be adapted to individual client usage.
 #
 # Must be called: ./.ci/make.sh <target> <params>
 #
@@ -9,21 +11,22 @@
 #
 # Targets:
 # ---------------------------
-# assemble   <VERSION> : build client artifacts 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
+# 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
 #
 # ------------------------------------------------------- #
 
 # ------------------------------------------------------- #
 # Bootstrap
 # ------------------------------------------------------- #
+
 script_path=$(dirname "$(realpath -s "$0")")
 repo=$(realpath "$script_path/../")
+generator=$(realpath "$script_path/../../elastic-client-generator-js")
 
 # shellcheck disable=SC1090
 CMD=$1
@@ -31,20 +34,24 @@ TASK=$1
 TASK_ARGS=()
 VERSION=$2
 STACK_VERSION=$VERSION
+NODE_JS_VERSION=16
+WORKFLOW=${WORKFLOW-staging}
 set -euo pipefail
 
 product="elastic/elasticsearch-js"
 output_folder=".ci/output"
-codegen_folder=".ci/output"
 OUTPUT_DIR="$repo/${output_folder}"
-NODE_JS_VERSION=18
-WORKFLOW=${WORKFLOW-staging}
+REPO_BINDING="${OUTPUT_DIR}:/sln/${output_folder}"
 mkdir -p "$OUTPUT_DIR"
 
 echo -e "\033[34;1mINFO:\033[0m PRODUCT ${product}\033[0m"
 echo -e "\033[34;1mINFO:\033[0m VERSION ${STACK_VERSION}\033[0m"
 echo -e "\033[34;1mINFO:\033[0m OUTPUT_DIR ${OUTPUT_DIR}\033[0m"
 
+# ------------------------------------------------------- #
+# Parse Command
+# ------------------------------------------------------- #
+
 case $CMD in
     clean)
         echo -e "\033[36;1mTARGET: clean workspace $output_folder\033[0m"
@@ -57,29 +64,18 @@ case $CMD in
             echo -e "\033[31;1mTARGET: assemble -> missing version parameter\033[0m"
             exit 1
         fi
-        echo -e "\033[36;1mTARGET: assemble artifact $VERSION\033[0m"
+        echo -e "\033[36;1mTARGET: assemble artefact $VERSION\033[0m"
         TASK=release
         TASK_ARGS=("$VERSION" "$output_folder")
         ;;
     codegen)
-        if [ -v "$VERSION" ] || [[ -z "$VERSION" ]]; then
-            # fall back to branch name or `main` if no VERSION is set
-            branch_name=$(git rev-parse --abbrev-ref HEAD)
-            if [[ "$branch_name" =~ ^[0-9]+\.[0-9]+ ]]; then
-              echo -e "\033[36;1mTARGET: codegen -> No VERSION argument found, using branch name: \`$branch_name\`\033[0m"
-              VERSION="$branch_name"
-            else
-              echo -e "\033[36;1mTARGET: codegen -> No VERSION argument found, using \`main\`\033[0m"
-              VERSION="main"
-            fi
+        if [ -v $VERSION ]; then
+            echo -e "\033[31;1mTARGET: codegen -> missing version parameter\033[0m"
+            exit 1
         fi
-        if [ "$VERSION" = 'main' ]; then
-          echo -e "\033[36;1mTARGET: codegen API $VERSION\033[0m"
-        else
-          echo -e "\033[36;1mTARGET: codegen API v$VERSION\033[0m"
-        fi
-
+        echo -e "\033[36;1mTARGET: codegen API v$VERSION\033[0m"
         TASK=codegen
+        # VERSION is BRANCH here for now
         TASK_ARGS=("$VERSION")
         ;;
     docsgen)
@@ -89,11 +85,13 @@ case $CMD in
         fi
         echo -e "\033[36;1mTARGET: generate docs for $VERSION\033[0m"
         TASK=codegen
+        # VERSION is BRANCH here for now
         TASK_ARGS=("$VERSION" "$codegen_folder")
         ;;
     examplesgen)
         echo -e "\033[36;1mTARGET: generate examples\033[0m"
         TASK=codegen
+        # VERSION is BRANCH here for now
         TASK_ARGS=("$VERSION" "$codegen_folder")
         ;;
     bump)
@@ -103,23 +101,11 @@ case $CMD in
         fi
         echo -e "\033[36;1mTARGET: bump to version $VERSION\033[0m"
         TASK=bump
+        # 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 "\n'$CMD' is not supported right now\n"
-        echo -e "\nUsage:"
-        echo -e "\t $0 release \$VERSION\n"
-        echo -e "\t $0 bump \$VERSION"
-        echo -e "\t $0 codegen \$VERSION"
+        echo -e "\nUsage:\n\t $CMD is not supported right now\n"
         exit 1
 esac
 
@@ -132,10 +118,10 @@ echo -e "\033[34;1mINFO: building $product container\033[0m"
 
 docker build \
   --file .ci/Dockerfile \
-  --tag "$product" \
-  --build-arg NODE_JS_VERSION="$NODE_JS_VERSION" \
-  --build-arg "BUILDER_UID=$(id -u)" \
-  --build-arg "BUILDER_GID=$(id -g)" \
+  --tag ${product} \
+  --build-arg NODE_JS_VERSION=${NODE_JS_VERSION} \
+  --build-arg USER_ID="$(id -u)" \
+  --build-arg GROUP_ID="$(id -g)" \
   .
 
 # ------------------------------------------------------- #
@@ -144,35 +130,15 @@ docker build \
 
 echo -e "\033[34;1mINFO: running $product container\033[0m"
 
-if [[ -z "${BUILDKITE+x}" ]] && [[ -z "${CI+x}" ]] && [[ -z "${GITHUB_ACTIONS+x}" ]]; then
-  echo -e "\033[34;1mINFO: Running in local mode"
-  docker run \
-    -u "$(id -u):$(id -g)" \
-    --volume "$repo:/usr/src/elasticsearch-js" \
-    --volume /usr/src/elasticsearch-js/node_modules \
-    --volume "$(realpath $repo/../elastic-client-generator-js):/usr/src/elastic-client-generator-js" \
-    --env "WORKFLOW=$WORKFLOW" \
-    --name make-elasticsearch-js \
-    --rm \
-    $product \
-    /bin/bash -c "mkdir -p /usr/src/elastic-client-generator-js/output && \
-      node .ci/make.mjs --task $TASK ${TASK_ARGS[*]}"
-else
-  echo -e "\033[34;1mINFO: Running in CI mode"
-  docker run \
-    --volume "$repo:/usr/src/elasticsearch-js" \
-    --volume /usr/src/elasticsearch-js/node_modules \
-    -u "$(id -u):$(id -g)" \
-    --env "WORKFLOW=$WORKFLOW" \
-    --name make-elasticsearch-js \
-    --rm \
-    $product \
-    /bin/bash -c "cd /usr/src && \
-      git clone https://$CLIENTS_GITHUB_TOKEN@github.com/elastic/elastic-client-generator-js.git && \
-      mkdir -p /usr/src/elastic-client-generator-js/output && \
-      cd /usr/src/elasticsearch-js && \
-      node .ci/make.mjs --task $TASK ${TASK_ARGS[*]}"
-fi
+docker run \
+  --volume $repo:/usr/src/app \
+  --volume $generator:/usr/src/elastic-client-generator-js \
+  --volume /usr/src/app/node_modules \
+  --env "WORKFLOW=${WORKFLOW}" \
+  --name make-elasticsearch-js \
+  --rm \
+  $product \
+  node .ci/make.mjs --task $TASK ${TASK_ARGS[*]}
 
 # ------------------------------------------------------- #
 # Post Command tasks & checks

.ci/packer_cache.sh

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+
+source /usr/local/bin/bash_standard_lib.sh
+
+DOCKER_IMAGES="node:17-alpine
+node:16-alpine
+node:14-alpine
+"
+
+for di in ${DOCKER_IMAGES}
+do
+(retry 2 docker pull "${di}") || echo "Error pulling ${di} Docker image, we continue"
+done
+

.ci/run-elasticsearch.sh

@@ -26,18 +26,12 @@ script_path=$(dirname $(realpath -s $0))
 source $script_path/functions/imports.sh
 set -euo pipefail
 
-echo -e "\033[34;1mINFO:\033[0m Take down node if called twice with the same arguments (DETACH=true) or on separate terminals \033[0m"
+echo -e "\033[34;1mINFO:\033[0m Take down node if called twice with the same arguments (DETACH=true) or on seperate terminals \033[0m"
 cleanup_node $es_node_name
 
 master_node_name=${es_node_name}
 cluster_name=${moniker}${suffix}
 
-# Set vm.max_map_count kernel setting to 262144
-if [ "$(sysctl vm.max_map_count)" != 'vm.max_map_count = 262144' ]; then
-  echo "vm.max_map_count may be too low. resetting."
-  sudo sysctl -w vm.max_map_count=262144
-fi
-
 declare -a volumes
 environment=($(cat <<-END
   --env ELASTIC_PASSWORD=$elastic_password
@@ -79,7 +73,6 @@ END
 ))
 else
   environment+=($(cat <<-END
-    --env node.roles=data,data_cold,data_content,data_frozen,data_hot,data_warm,ingest,master,ml,remote_cluster_client,transform
     --env xpack.security.enabled=false
     --env xpack.security.http.ssl.enabled=false
 END
@@ -91,13 +84,6 @@ if [[ "$TEST_SUITE" == "platinum" ]]; then
   cert_validation_flags="--insecure --cacert /usr/share/elasticsearch/config/certs/ca.crt --resolve ${es_node_name}:443:127.0.0.1"
 fi
 
-echo "--- :elasticsearch: Environment setup"
-echo "TEST_SUITE: $TEST_SUITE"
-echo "Elasticsearch URL: $elasticsearch_url"
-echo "Elasticsearch External URL: $external_elasticsearch_url"
-
-
-echo "--- :elasticsearch: Running container"
 # Pull the container, retry on failures up to 5 times with
 # short delays between each attempt. Fixes most transient network errors.
 docker_pull_attempts=0
@@ -152,4 +138,6 @@ END
   if wait_for_container "$es_node_name" "$network_name"; then
     echo -e "\033[32;1mSUCCESS:\033[0m Running on: $node_url\033[0m"
   fi
+
 done
+

.ci/run-repository.sh

@@ -0,0 +1,43 @@
+#!/usr/bin/env bash
+# parameters are available to this script
+
+# STACK_VERSION -- version e.g Major.Minor.Patch(-Prelease)
+# TEST_SUITE -- which test suite to run: free or platinum
+# ELASTICSEARCH_URL -- The url at which elasticsearch is reachable, a default is composed based on STACK_VERSION and TEST_SUITE
+# NODE_JS_VERSION -- node js version (defined in test-matrix.yml, a default is hardcoded here)
+script_path=$(dirname $(realpath -s $0))
+source $script_path/functions/imports.sh
+set -euo pipefail
+
+NODE_JS_VERSION=${NODE_JS_VERSION-16}
+ELASTICSEARCH_URL=${ELASTICSEARCH_URL-"$elasticsearch_url"}
+elasticsearch_container=${elasticsearch_container-}
+
+echo -e "\033[34;1mINFO:\033[0m VERSION ${STACK_VERSION}\033[0m"
+echo -e "\033[34;1mINFO:\033[0m TEST_SUITE ${TEST_SUITE}\033[0m"
+echo -e "\033[34;1mINFO:\033[0m URL ${ELASTICSEARCH_URL}\033[0m"
+echo -e "\033[34;1mINFO:\033[0m CONTAINER ${elasticsearch_container}\033[0m"
+echo -e "\033[34;1mINFO:\033[0m NODE_JS_VERSION ${NODE_JS_VERSION}\033[0m"
+
+echo -e "\033[1m>>>>> Build docker container >>>>>>>>>>>>>>>>>>>>>>>>>>>>>\033[0m"
+
+docker build \
+  --file .ci/Dockerfile \
+  --tag elastic/elasticsearch-js \
+  --build-arg NODE_JS_VERSION=${NODE_JS_VERSION} \
+  .
+
+echo -e "\033[1m>>>>> NPM run test:integration >>>>>>>>>>>>>>>>>>>>>>>>>>>>>\033[0m"
+
+repo=$(realpath $(dirname $(realpath -s $0))/../)
+
+docker run \
+  --network=${network_name} \
+  --env "TEST_ES_SERVER=${ELASTICSEARCH_URL}" \
+  --env "TEST_SUITE=${TEST_SUITE}" \
+  --volume $repo:/usr/src/app \
+  --volume /usr/src/app/node_modules \
+  --name elasticsearch-js \
+  --rm \
+  elastic/elasticsearch-js \
+  npm run test:integration

.ci/run-tests

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+#
+# Version 1.1
+# - Moved to .ci folder and seperated out `run-repository.sh`
+# - Add `$RUNSCRIPTS` env var for running Elasticsearch dependent products
+script_path=$(dirname $(realpath -s $0))
+source $script_path/functions/imports.sh
+set -euo pipefail
+
+echo -e "\033[1m>>>>> Start [$STACK_VERSION container] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>\033[0m"
+DETACH=true bash .ci/run-elasticsearch.sh
+
+if [[ -n "$RUNSCRIPTS" ]]; then
+  for RUNSCRIPT in ${RUNSCRIPTS//,/ } ; do
+    echo -e "\033[1m>>>>> Running run-$RUNSCRIPT.sh >>>>>>>>>>>>>>>>>>>>>>>>>>>>>\033[0m"
+    CONTAINER_NAME=${RUNSCRIPT} \
+      DETACH=true \
+      bash .ci/run-${RUNSCRIPT}.sh
+  done
+fi
+
+echo -e "\033[1m>>>>> Repository specific tests >>>>>>>>>>>>>>>>>>>>>>>>>>>>>\033[0m"
+bash .ci/run-repository.sh

.ci/test-matrix.yml

@@ -0,0 +1,14 @@
+---
+STACK_VERSION:
+  - "8.6.0-SNAPSHOT"
+
+NODE_JS_VERSION:
+  - 18
+  - 16
+  - 14
+
+TEST_SUITE:
+  - free
+  - platinum
+
+exclude: ~

.dockerignore

@@ -3,5 +3,3 @@ npm-debug.log
 test/benchmarks
 elasticsearch
 .git
-lib
-junit-output

.github/workflows/backport.yml

@@ -1,27 +1,16 @@
----
 name: Backport
 on:
-  pull_request_target:
+  pull_request:
     types:
       - closed
       - labeled
 
 jobs:
   backport:
-    name: Backport
     runs-on: ubuntu-latest
-    # Only react to merged PRs for security reasons.
-    # See https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#pull_request_target.
-    if: >
-      github.event.pull_request.merged
-      && (
-        github.event.action == 'closed'
-        || (
-          github.event.action == 'labeled'
-          && contains(github.event.label.name, 'backport')
-        )
-      )
+    name: Backport
     steps:
-      - uses: tibdex/backport@9565281eda0731b1d20c4025c43339fb0a23812e  # v2.0.4
+      - name: Backport
+        uses: tibdex/backport@v1
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/nodejs.yml

@@ -1,64 +1,174 @@
----
 name: Node CI
 
-on:
-  pull_request: {}
+on: [push, pull_request]
 
 jobs:
-  paths-filter:
-    name: Detect files changed
-    runs-on: ubuntu-latest
-    outputs:
-      src-only: '${{ steps.changes.outputs.src-only }}'
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dorny/paths-filter/@v2.11.1
-        id: changes
-        with:
-          filters: |
-            src-only:
-              - '!(**/*.{md,asciidoc,txt}|*.{md,asciidoc,txt}|{docs,.ci,.buildkite,scripts}/**/*|catalog-info.yaml)'
-              - '.github/workflows/**'
-
   test:
     name: Test
     runs-on: ${{ matrix.os }}
-    needs: paths-filter
-    # only run if code relevant to unit tests was changed
-    if: needs.paths-filter.outputs.src-only == 'true'
 
     strategy:
-      fail-fast: false
       matrix:
-        node-version: [18.x, 20.x]
+        node-version: [14.x, 16.x, 18.x]
         os: [ubuntu-latest, windows-latest, macOS-latest]
 
     steps:
-      - uses: actions/checkout@v4
+    - uses: actions/checkout@v2
 
-      - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v3
-        with:
-          node-version: ${{ matrix.node-version }}
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
 
-      # workaround for failing tests on Node.js 14.x
-      # see https://github.com/actions/setup-node/issues/411
-      - name: Force install specific npm version
-        run: |
-          npm install --global npm@8.3.1
-          npm install --global npm@9.7.1
+    - name: Install
+      run: |
+        npm install
 
-      - name: Install
-        run: |
-          npm install
+    - name: Lint
+      run: |
+        npm run lint
 
-      - name: Lint
-        run: |
-          npm run lint
+    - name: Unit test
+      run: |
+        npm run test:unit
 
-      - name: Unit test
-        run: |
-          npm run test:unit
+    # - name: Acceptance test
+    #   run: |
+    #     npm run test:acceptance
+
+  # helpers-integration-test:
+  #   name: Helpers integration test
+  #   runs-on: ubuntu-latest
+
+  #   strategy:
+  #     matrix:
+  #       node-version: [12.x, 14.x, 16.x]
+
+  #   steps:
+  #   - uses: actions/checkout@v2
+
+  #   - name: Configure sysctl limits
+  #     run: |
+  #       sudo swapoff -a
+  #       sudo sysctl -w vm.swappiness=1
+  #       sudo sysctl -w fs.file-max=262144
+  #       sudo sysctl -w vm.max_map_count=262144
+
+  #   - name: Runs Elasticsearch
+  #     uses: elastic/elastic-github-actions/elasticsearch@master
+  #     with:
+  #       stack-version: 8.0.0-SNAPSHOT
+
+  #   - name: Use Node.js ${{ matrix.node-version }}
+  #     uses: actions/setup-node@v1
+  #     with:
+  #       node-version: ${{ matrix.node-version }}
+
+  #   - name: Install
+  #     run: |
+  #       npm install
+
+  #   - name: Integration test
+  #     run: |
+  #       npm run test:integration:helpers
+
+  # bundler-support:
+  #   name: Bundler support
+  #   runs-on: ubuntu-latest
+
+  #   steps:
+  #   - uses: actions/checkout@v2
+
+  #   - name: Configure sysctl limits
+  #     run: |
+  #       sudo swapoff -a
+  #       sudo sysctl -w vm.swappiness=1
+  #       sudo sysctl -w fs.file-max=262144
+  #       sudo sysctl -w vm.max_map_count=262144
+
+  #   - name: Runs Elasticsearch
+  #     uses: elastic/elastic-github-actions/elasticsearch@master
+  #     with:
+  #       stack-version: 8.0.0-SNAPSHOT
+
+  #   - name: Use Node.js 14.x
+  #     uses: actions/setup-node@v1
+  #     with:
+  #       node-version: 14.x
+
+  #   - name: Install
+  #     run: |
+  #       npm install
+  #       npm install --prefix test/bundlers/parcel-test
+  #       npm install --prefix test/bundlers/rollup-test
+  #       npm install --prefix test/bundlers/webpack-test
+
+  #   - name: Build
+  #     run: |
+  #       npm run build --prefix test/bundlers/parcel-test
+  #       npm run build --prefix test/bundlers/rollup-test
+  #       npm run build --prefix test/bundlers/webpack-test
+
+  #   - name: Run bundle
+  #     run: |
+  #       npm start --prefix test/bundlers/parcel-test
+  #       npm start --prefix test/bundlers/rollup-test
+  #       npm start --prefix test/bundlers/webpack-test
+
+  # mock-support:
+  #   name: Mock support
+  #   runs-on: ubuntu-latest
+
+  #   steps:
+  #   - uses: actions/checkout@v2
+
+  #   - name: Use Node.js 14.x
+  #     uses: actions/setup-node@v1
+  #     with:
+  #       node-version: 14.x
+
+  #   - name: Install
+  #     run: |
+  #       npm install
+  #       npm install --prefix test/mock
+
+  #   - name: Run test
+  #     run: |
+  #       npm test --prefix test/mock
+
+  # code-coverage:
+  #   name: Code coverage
+  #   runs-on: ubuntu-latest
+
+  #   strategy:
+  #     matrix:
+  #       node-version: [14.x]
+
+  #   steps:
+  #   - uses: actions/checkout@v2
+
+  #   - name: Use Node.js ${{ matrix.node-version }}
+  #     uses: actions/setup-node@v1
+  #     with:
+  #       node-version: ${{ matrix.node-version }}
+
+  #   - name: Install
+  #     run: |
+  #       npm install
+
+  #   - name: Code coverage report
+  #     run: |
+  #       npm run test:coverage-report
+
+  #   - name: Upload coverage to Codecov
+  #     uses: codecov/codecov-action@v1
+  #     with:
+  #       file: ./coverage.lcov
+  #       fail_ci_if_error: true
+
+  #   - name: Code coverage 100%
+  #     run: |
+  #       npm run test:coverage-100
 
   license:
     name: License check
@@ -66,20 +176,20 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [20.x]
+        node-version: [16.x]
 
     steps:
-      - uses: actions/checkout@v3
+    - uses: actions/checkout@v2
 
-      - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v3
-        with:
-          node-version: ${{ matrix.node-version }}
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
 
-      - name: Install
-        run: |
-          npm install
+    - name: Install
+      run: |
+        npm install
 
-      - name: License checker
-        run: |
-          npm run license-checker
+    - name: License checker
+      run: |
+        npm run license-checker

.github/workflows/stale.yml

@@ -1,21 +0,0 @@
----
-name: 'Close stale issues and PRs'
-on:
-  schedule:
-    - cron: '30 1 * * *'
-
-jobs:
-  stale:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/stale@v8
-        with:
-          stale-issue-label: stale
-          stale-pr-label: stale
-          days-before-stale: 90
-          days-before-close: 14
-          exempt-issue-labels: 'good first issue'
-          close-issue-label: closed-stale
-          close-pr-label: closed-stale
-          stale-issue-message: 'This issue is stale because it has been open 90 days with no activity. Remove the `stale` label, or leave a comment, or this will be closed in 14 days.'
-          stale-pr-message: 'This pull request is stale because it has been open 90 days with no activity. Remove the `stale` label, or leave a comment, or this will be closed in 14 days.'

.npmignore

@@ -66,7 +66,6 @@ scripts
 # ci configuration
 .ci
 .travis.yml
-.buildkite
 certs
 .github
 CODE_OF_CONDUCT.md

CONTRIBUTING.md

@@ -8,7 +8,7 @@ improving the documentation,
 submitting bug reports and feature requests or writing code.
 
 ## Repository structure
-The `main` branch is considered unstable, and it's compatible with Elasticsearch main. Unless you are patching an issue, new features should always be sent to the `main` branch, in case of a bugfix, it depends if the bug affects all the release lines.<br/>
+The `master` branch is considered unstable, and it's compatible with Elasticsearch master. Unless you are patching an issue, new features should always be sent to the `master` branch, in case of a bugfix, it depends if the bug affects all the release lines.<br/>
 There is a branch for every supported release line, such as `7.x` or `6.x`. We release bugfixes as soon as possible, while minor and major releases are published at the same time of the Elastic Stack.
 
 Usually for every release line there will be a *published* version and a *next* version. Eg: the `7.x` branch contains the version published on npm, and bugfixes should be sent there, while `7.2` *(assuming that 7.1.x is released)* contains the next version, and new features should be sent there.
@@ -31,7 +31,7 @@ Once your changes are ready to submit for review:
 1. Test your changes
 
     Run the test suite to make sure that nothing is broken.
-    Usually running `npm test` is enough; our CI will take care of running the integration tests. If you want to run the integration tests yourself, see [the *Testing* section](#testing) below.
+    Usually run `npm test` is enough, our CI will take care of running the integration test. If you want to run the integration test yourself, see the *Testing* section below.
 
 2. Submit a pull request
 
@@ -58,50 +58,36 @@ Once your changes are ready to submit for review:
 
 ### Code generation
 
-The entire content of the `src/api/` directory is automatically generated from [the Elasticsearch specification](https://github.com/elastic/elasticsearch-specification), as is the `docs/reference.asciidoc` file.
-This code generation is done using a separate repository that is not currently available to the public.
-
-If you find discrepancies between this client's API code and what you see when actually interacting with an Elasticsearch API, you can open a pull request here to fix it.
-For API fixes, it's likely a change will need to be made to the specification as well, to ensure your fix is not undone by the code generation process.
-We will do our best to make sure this is addressed when reviewing and merging your changes.
-
-PRs to improve the specification are also welcome!
-It is implemented in TypeScript, so JavaScript devs should be able to understand it fairly easily.
-Spec fixes are particularly helpful, as they will be reflected in ALL official Elasticsearch clients, not just this one.
+The entire content of the API folder is generated as well as the `docs/reference.asciidoc` file.<br/>
+If you want to run the code generation you should run the following command:
+```sh
+node scripts/generate --tag <tag name>
+# or
+node scripts/generate --branch <branch name>
+```
+Then you should copy the content of `api/generated.d.ts` into the `index.d.ts` file *(automate this step would be a nice pr!)*.
 
 ### Testing
-
-There are a few different test scripts.
-Usually during development you only need to run `npm test`, but if you want you can run just a part of the suite:
+There are different test scripts, usually during development you only need to run `npm test`, but if you want you can run just a part of the suite, following you will find all the testing scripts and what they do.
 
 | Script | Description |
 |---|---|
 | `npm run test:unit` | Runs the content of the `test/unit` folder. |
-| `npm run test:coverage-100` | Runs unit tests enforcing 100% coverage. |
-| `npm run test:coverage-report` | Runs unit tests and generates an `lcov` coverage report. |
-| `npm run test:coverage-ui` | Runs unit tests and generates an HTML coverage report. |
-| `npm run test:integration` | Runs the integration test runner.<br/>**Note: requires a living instance of Elasticsearch.** |
-| `npm run lint` | Run the [linter](https://github.com/standard/ts-standard). |
-| `npm run lint:fix` | Fixes linter errors. |
-| `npm run license-checker` | Checks that all dependencies have acceptable open source licenses. |
-
-| `npm test` | Runs `lint` and `test:unit`. |
+| `npm run test:behavior` | Runs the content of the `test/behavior` folder. |
+| `npm run test:types` | Runs the content of the `test/types` folder. |
+| `npm run test:unit -- --cov --coverage-report=html` | Runs the content of the `test/unit` folder and calculates the code coverage. |
+| `npm run test:integration` | Runs the integration test runner.<br/>*Note: it requires a living instance of Elasticsearch.* |
+| `npm run lint` | Run the [linter](https://standardjs.com/). |
+| `npm run lint:fix` | Fixes the lint errors. |
+| `npm test` | Runs lint, unit, behavior, and types test. |
 
 #### Integration test
+The integration test are generated on the fly by the runner you will find inside `test/integration`, once you execute it, it will clone the Elasticsearch repository and checkout the correct version to grab the [OSS yaml files](https://github.com/elastic/elasticsearch/tree/master/rest-api-spec/src/main/resources/rest-api-spec/test) and the [Elastic licensed yaml files](https://github.com/elastic/elasticsearch/tree/master/x-pack/plugin/src/test/resources/rest-api-spec/test) that will be used for generating the test.
 
-The integration tests are generated on the fly by the runner you will find inside `test/integration`.
-Once you execute it, it will fetch the [YAML REST test files](https://github.com/elastic/elasticsearch/tree/main/rest-api-spec/src/yamlRestTest/resources/rest-api-spec/test) from our artifacts API.
-These are used to generate the integration tests.
-
-Usually this step is executed by CI since it takes some time, but you can easily run this yourself!
-Just follow this steps:
-1. Boot a fresh Elasticsearch instance, which can be done in a Docker container by running `STACK_VERSION=8.10.0 DETACH=true .buildkite/run-elasticsearch.sh`, where `STACK_VERSION` and `DETACH` environment variables can be adjusted to your needs. A `TEST_SUITE` env var can also be set to `free` or `platinum`, and defaults to `free`.
-1. Run `npm run test:integration` to run the whole suite, or `npm run test:integration -- --bail` to stop after the first failure.
-1. Grab a coffee, it will take some time. ;)
-
-This suite is very large, and not all tests will pass.
-This is fine.
-This suite is mostly used to identify notable changes in success/fail rate over time as we make changes to the client.
+Usually this step is executed by CI since it takes some time, but you can easily run this yourself! Just follow this steps:
+1. Boot an Elasticsearch instance, you can do that by running `./scripts/es-docker.sh` or `./scripts/es-docker-platinum.sh`, the first one will work only with the OSS APIs, while the second will work also with the Elastic licensed APIs;
+1. If you are running the OSS test, you should use `npm run test:integration`, otherwise use `TEST_ES_SERVER=https://elastic:changeme@localhost:9200 npm run test:integration`. You can also pass a `-b` parameter if you want the test to bail out at the first failure: `npm run test:integration -- -b`;
+1. Grab a coffee, it will take some time ;)
 
 ### Releasing
 

Makefile

@@ -1,11 +0,0 @@
-.PHONY: integration-setup
-integration-setup: integration-cleanup
-	DETACH=true .ci/run-elasticsearch.sh
-
-.PHONY: integration-cleanup
-integration-cleanup:
-	docker container rm --force --volumes instance || true
-
-.PHONY: integration
-integration: integration-setup
-	npm run test:integration

README.md

@@ -2,38 +2,27 @@
 
 # Elasticsearch Node.js client
 
-[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](http://standardjs.com/)  [![Build Status](https://badge.buildkite.com/15e4246eb268ea78f6e10aa90bce38c1abb0a4489e79f5a0ac.svg)](https://buildkite.com/elastic/elasticsearch-javascript-client-integration-tests/builds?branch=main)  [![Node CI](https://github.com/elastic/elasticsearch-js/actions/workflows/nodejs.yml/badge.svg)](https://github.com/elastic/elasticsearch-js/actions/workflows/nodejs.yml)  [![codecov](https://codecov.io/gh/elastic/elasticsearch-js/branch/master/graph/badge.svg)](https://codecov.io/gh/elastic/elasticsearch-js)  [![NPM downloads](https://img.shields.io/npm/dm/@elastic/elasticsearch.svg?style=flat)](https://www.npmjs.com/package/@elastic/elasticsearch)
-
-**[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**.
+[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](http://standardjs.com/)  [![Build Status](https://clients-ci.elastic.co/buildStatus/icon?job=elastic%2Belasticsearch-js%2Bmain)](https://clients-ci.elastic.co/view/JavaScript/job/elastic+elasticsearch-js+main/)  [![Node CI](https://github.com/elastic/elasticsearch-js/actions/workflows/nodejs.yml/badge.svg)](https://github.com/elastic/elasticsearch-js/actions/workflows/nodejs.yml)  [![codecov](https://codecov.io/gh/elastic/elasticsearch-js/branch/master/graph/badge.svg)](https://codecov.io/gh/elastic/elasticsearch-js)  [![NPM downloads](https://img.shields.io/npm/dm/@elastic/elasticsearch.svg?style=flat)](https://www.npmjs.com/package/@elastic/elasticsearch)
 
 The official Node.js client for Elasticsearch.
 
-## Installation
+## Features
+- One-to-one mapping with REST API.
+- Generalized, pluggable architecture.
+- Configurable, automatic discovery of cluster nodes.
+- Persistent, Keep-Alive connections.
+- Load balancing across all available nodes.
+- Child client support.
+- TypeScript support out of the box.
 
-Refer to the [Installation section](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/getting-started-js.html#_installation)
-of the getting started documentation.
-
-## Connecting
-
-Refer to the [Connecting section](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/getting-started-js.html#_connecting)
-of the getting started documentation.
-
-## Usage
-
-* [Creating an index](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/getting-started-js.html#_creating_an_index)
-* [Indexing a document](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/getting-started-js.html#_indexing_documents)
-* [Getting documents](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/getting-started-js.html#_getting_documents)
-* [Searching documents](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/getting-started-js.html#_searching_documents)
-* [Updating documents](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/getting-started-js.html#_updating_documents)
-* [Deleting documents](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/getting-started-js.html#_deleting_documents)
-* [Deleting an index](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/getting-started-js.html#_deleting_an_index)
+## Install
+```
+npm install @elastic/elasticsearch
+```
 
 ### Node.js support
 
-NOTE: The minimum supported version of Node.js is `v18`.
+NOTE: The minimum supported version of Node.js is `v14`.
 
 The client versioning follows the Elastic Stack versioning, this means that
 major, minor, and patch releases are done following a precise schedule that
@@ -58,7 +47,6 @@ of `^7.10.0`).
 | `10.x`          | `April 2021`     | `7.12` (mid 2021)      |
 | `12.x`          | `April 2022`     | `8.2` (early 2022)     |
 | `14.x`          | `April 2023`     | `8.8` (early 2023)     |
-| `16.x`          | `September 2023` | `8.11` (late 2023)     |
 
 ### Compatibility
 
@@ -79,51 +67,98 @@ npm install @elastic/elasticsearch@<major>
 
 #### Browser
 
-> [!WARNING]
-> There is no official support for the browser environment. It exposes your Elasticsearch instance to everyone, which could lead to security issues.
+WARNING: There is no official support for the browser environment. It exposes your Elasticsearch instance to everyone, which could lead to security issues.
 We recommend that you write a lightweight proxy that uses this client instead, you can see a proxy example [here](./docs/examples/proxy).
 
 ## Documentation
 
-* [Introduction](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/introduction.html)
-* [Usage](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/client-connecting.html#client-usage)
-* [Client configuration](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/client-configuration.html)
-* [API reference](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/api-reference.html)
-* [Authentication](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/client-connecting.html#authentication)
-* [Observability](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/observability.html)
-* [Creating a child client](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/child.html)
-* [Client helpers](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/client-helpers.html)
-* [Typescript support](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/typescript.html)
-* [Testing](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/client-testing.html)
-* [Examples](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/examples.html)
+- [Introduction](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/introduction.html)
+- [Usage](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/client-connecting.html#client-usage)
+- [Client configuration](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/client-configuration.html)
+- [API reference](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/api-reference.html)
+- [Authentication](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/client-connecting.html#authentication)
+- [Observability](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/observability.html)
+- [Creating a child client](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/child.html)
+- [Client helpers](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/client-helpers.html)
+- [Typescript support](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/typescript.html)
+- [Testing](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/client-testing.html)
+- [Examples](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/examples.html)
+
+## Quick start
+
+```js
+'use strict'
+
+const { Client } = require('@elastic/elasticsearch')
+const client = new Client({
+  cloud: { id: '<cloud-id>' },
+  auth: { apiKey: 'base64EncodedKey' }
+})
+
+async function run () {
+  // Let's start by indexing some data
+  await client.index({
+    index: 'game-of-thrones',
+    document: {
+      character: 'Ned Stark',
+      quote: 'Winter is coming.'
+    }
+  })
+
+  await client.index({
+    index: 'game-of-thrones',
+    document: {
+      character: 'Daenerys Targaryen',
+      quote: 'I am the blood of the dragon.'
+    }
+  })
+
+  await client.index({
+    index: 'game-of-thrones',
+    document: {
+      character: 'Tyrion Lannister',
+      quote: 'A mind needs books like a sword needs a whetstone.'
+    }
+  })
+
+  // here we are forcing an index refresh, otherwise we will not
+  // get any result in the consequent search
+  await client.indices.refresh({ index: 'game-of-thrones' })
+
+  // Let's search!
+  const result= await client.search({
+    index: 'game-of-thrones',
+    query: {
+      match: { quote: 'winter' }
+    }
+  })
+
+  console.log(result.hits.hits)
+}
+
+run().catch(console.log)
+```
 
 ## Install multiple versions
 If you are using multiple versions of Elasticsearch, you need to use multiple versions of the client. In the past, install multiple versions of the same package was not possible, but with `npm v6.9`, you can do that via aliasing.
 
 The command you must run to install different version of the client is:
-
 ```sh
 npm install <alias>@npm:@elastic/elasticsearch@<version>
 ```
-
-So for example if you need to install `7.x` and `6.x`, you will run:
-
+So for example if you need to install `7.x` and `6.x`, you will run
 ```sh
 npm install es6@npm:@elastic/elasticsearch@6
 npm install es7@npm:@elastic/elasticsearch@7
 ```
-
 And your `package.json` will look like the following:
-
 ```json
 "dependencies": {
   "es6": "npm:@elastic/elasticsearch@^6.7.0",
   "es7": "npm:@elastic/elasticsearch@^7.0.0"
 }
 ```
-
 You will require the packages from your code by using the alias you have defined.
-
 ```js
 const { Client: Client6 } = require('es6')
 const { Client: Client7 } = require('es7')
@@ -141,10 +176,7 @@ client6.info().then(console.log, console.log)
 client7.info().then(console.log, console.log)
 ```
 
-Finally, if you want to install the client for the next version of Elasticsearch
-*(the one that lives in Elasticsearch’s main branch)*, you can use the following
-command:
-
+Finally, if you want to install the client for the next version of Elasticsearch *(the one that lives in Elasticsearch’s main branch)*, you can use the following command:
 ```sh
 npm install esmain@github:elastic/elasticsearch-js
 ```

catalog-info.yaml

@@ -1,50 +0,0 @@
----
-# yaml-language-server: $schema=https://json.schemastore.org/catalog-info.json
-apiVersion: backstage.io/v1alpha1
-kind: Component
-metadata:
-  name: elasticsearch-js
-spec:
-  type: library
-  owner: group:clients-team
-  lifecycle: production
-
----
-# yaml-language-server: $schema=https://gist.githubusercontent.com/elasticmachine/988b80dae436cafea07d9a4a460a011d/raw/e57ee3bed7a6f73077a3f55a38e76e40ec87a7cf/rre.schema.json
-apiVersion: backstage.io/v1alpha1
-kind: Resource
-metadata:
-  name: elasticsearch-js-integration-tests
-  description: elasticsearch-js - integration tests
-spec:
-  type: buildkite-pipeline
-  owner: group:clients-team
-  system: buildkite
-  implementation:
-    apiVersion: buildkite.elastic.dev/v1
-    kind: Pipeline
-    metadata:
-      name: elasticsearch-js - integration tests
-    spec:
-      repository: elastic/elasticsearch-js
-      pipeline_file: .buildkite/pipeline.yml
-      teams:
-        clients-team:
-          access_level: MANAGE_BUILD_AND_READ
-        everyone:
-          access_level: READ_ONLY
-      provider_settings:
-        build_pull_requests: false
-        build_branches: false
-      cancel_intermediate_builds: true
-      cancel_intermediate_builds_branch_filter: '!main'
-      schedules:
-        main_semi_daily:
-          branch: 'main'
-          cronline: '0 */12 * * *'
-        8_12_semi_daily:
-          branch: '8.12'
-          cronline: '0 */12 * * *'
-        8_11_daily:
-          branch: '8.11'
-          cronline: '@daily'

docs/advanced-config.asciidoc

@@ -91,95 +91,6 @@ const client = new Client({
 })
 ----
 
-[discrete]
-[[redaction]]
-==== Redaction of potentially sensitive data
-
-When the client raises an `Error` that originated at the HTTP layer, like a `ConnectionError` or `TimeoutError`, a `meta` object is often attached to the error object that includes metadata useful for debugging, like request and response information. Because this can include potentially sensitive data, like authentication secrets in an `Authorization` header, the client takes measures to redact common sources of sensitive data when this metadata is attached and serialized.
-
-If your configuration requires extra headers or other configurations that may include sensitive data, you may want to adjust these settings to account for that.
-
-By default, the `redaction` option is set to `{ type: 'replace' }`, which recursively searches for sensitive key names, case insensitive, and replaces their values with the string `[redacted]`.
-
-[source,js]
-----
-const { Client } = require('@elastic/elasticsearch')
-
-const client = new Client({
-  cloud: { id: '<cloud-id>' },
-  auth: { apiKey: 'base64EncodedKey' },
-})
-
-try {
-  await client.indices.create({ index: 'my_index' })
-} catch (err) {
-  console.log(err.meta.meta.request.options.headers.authorization) // prints "[redacted]"
-}
-----
-
-If you would like to redact additional properties, you can include additional key names to search and replace:
-
-[source,js]
-----
-const { Client } = require('@elastic/elasticsearch')
-
-const client = new Client({
-  cloud: { id: '<cloud-id>' },
-  auth: { apiKey: 'base64EncodedKey' },
-  headers: { 'X-My-Secret-Password': 'shhh it's a secret!' },
-  redaction: {
-    type: "replace",
-    additionalKeys: ["x-my-secret-password"]
-  }
-})
-
-try {
-  await client.indices.create({ index: 'my_index' })
-} catch (err) {
-  console.log(err.meta.meta.request.options.headers['X-My-Secret-Password']) // prints "[redacted]"
-}
-----
-
-Alternatively, if you know you're not going to use the metadata at all, setting the redaction type to `remove` will remove all optional sources of potentially sensitive data entirely, or replacing them with `null` for required properties.
-
-[source,js]
-----
-const { Client } = require('@elastic/elasticsearch')
-
-const client = new Client({
-  cloud: { id: '<cloud-id>' },
-  auth: { apiKey: 'base64EncodedKey' },
-  redaction: { type: "remove" }
-})
-
-try {
-  await client.indices.create({ index: 'my_index' })
-} catch (err) {
-  console.log(err.meta.meta.request.options.headers) // undefined
-}
-----
-
-Finally, if you prefer to turn off redaction altogether, perhaps while debugging on a local developer environment, you can set the redaction type to `off`. This will revert the client to pre-8.11.0 behavior, where basic redaction is only performed during common serialization methods like `console.log` and `JSON.stringify`.
-
-WARNING: Setting `redaction.type` to `off` is not recommended in production environments.
-
-[source,js]
-----
-const { Client } = require('@elastic/elasticsearch')
-
-const client = new Client({
-  cloud: { id: '<cloud-id>' },
-  auth: { apiKey: 'base64EncodedKey' },
-  redaction: { type: "off" }
-})
-
-try {
-  await client.indices.create({ index: 'my_index' })
-} catch (err) {
-  console.log(err.meta.meta.request.options.headers.authorization) // the actual header value will be logged
-}
-----
-
 [discrete]
 ==== Migrate to v8
 

docs/basic-config.asciidoc

@@ -11,7 +11,7 @@ const { Client } = require('@elastic/elasticsearch')
 
 const client = new Client({
   cloud: { id: '<cloud-id>' },
-  auth: { apiKey: 'base64EncodedKey' },
+  auth: { apiKey: 'base64EncodedKey' }
   maxRetries: 5,
   requestTimeout: 60000,
   sniffOnStart: true
@@ -267,4 +267,4 @@ _Default:_ `null`
 |`number` - When configured, it verifies that the compressed response size is lower than the configured number, if it's higher it will abort the request. It cannot be higher than buffer.constants.MAX_LENTGH +
 _Default:_ `null`
 
-|===
+|===

docs/changelog.asciidoc

@@ -2,159 +2,11 @@
 == Release notes
 
 [discrete]
-=== 8.12.2
+=== 8.6.1
 
 [discrete]
-==== Fixes
-
-[discrete]
-===== Upgrade transport to 8.4.1 https://github.com/elastic/elasticsearch-js/pull/2137[#2137]
-
-Upgrades `@elastic/transport` to 8.4.1 to resolve https://github.com/elastic/elastic-transport-js/pull/83[a bug] where arrays in error diagnostics were unintentionally transformed into objects.
-
-[discrete]
-=== 8.12.1
-
-[discrete]
-==== Fixes
-
-[discrete]
-===== Fix hang in bulk helper semaphore https://github.com/elastic/elasticsearch-js/pull/2027[#2027]
-
-The failing state could be reached when a server's response times are slower than flushInterval.
-
-[discrete]
-=== 8.12.0
-
-[discrete]
-=== Features
-
-[discrete]
-===== Support for Elasticsearch `v8.12.0`
-
-You can find all the API changes
-https://www.elastic.co/guide/en/elasticsearch/reference/8.12/release-notes-8.12.0.html[here].
-
-[discrete]
-=== 8.11.0
-
-[discrete]
-=== Features
-
-[discrete]
-===== Support for Elasticsearch `v8.11.0`
-
-You can find all the API changes
-https://www.elastic.co/guide/en/elasticsearch/reference/8.11/release-notes-8.11.0.html[here].
-
-[discrete]
-===== Enhanced support for redacting potentially sensitive data https://github.com/elastic/elasticsearch-js/pull/2095[#2095]
-
-`@elastic/transport` https://github.com/elastic/elastic-transport-js/releases/tag/v8.4.0[version 8.4.0] introduces enhanced measures for ensuring that request metadata attached to some `Error` objects is redacted. This functionality is primarily to address custom logging solutions that don't use common serialization methods like `JSON.stringify`, `console.log`, or `util.inspect`, which were already accounted for.
-
-See <<redaction>> for more information.
-
-[discrete]
-=== 8.10.0
-
-[discrete]
-=== Features
-
-[discrete]
-===== Support for Elasticsearch `v8.10.0`
-
-You can find all the API changes
-https://www.elastic.co/guide/en/elasticsearch/reference/8.10/release-notes-8.10.0.html[here].
-
-[discrete]
-=== 8.9.1
-
-[discrete]
-==== Fixes
-
-[discrete]
-===== Upgrade Transport https://github.com/elastic/elasticsearch-js/pull/1968[#1968]
-
-Upgrades `@elastic/transport` to the latest patch release to fix https://github.com/elastic/elastic-transport-js/pull/69[a bug] that could cause the process to exit when handling malformed `HEAD` requests.
-
-[discrete]
-=== 8.9.0
-
-[discrete]
-==== Features
-
-[discrete]
-===== Support for Elasticsearch `v8.9.0`
-
-You can find all the API changes
-https://www.elastic.co/guide/en/elasticsearch/reference/8.9/release-notes-8.9.0.html[here].
-
-[discrete]
-===== Allow document to be overwritten in `onDocument` iteratee of bulk helper https://github.com/elastic/elasticsearch-js/pull/1732[#1732]
-
-In the https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/client-helpers.html#bulk-helper[bulk helper], documents could not be modified before being sent to Elasticsearch. It is now possible to https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/client-helpers.html#_modifying_a_document_before_operation[modify a document] before sending it.
-
-[discrete]
-==== Fixes
-
-[discrete]
-===== Updated `user-agent` header https://github.com/elastic/elasticsearch-js/pull/1954[#1954]
-
-The `user-agent` header the client used to connect to Elasticsearch was using a non-standard format that has been improved.
-
-[discrete]
-=== 8.8.1
-
-[discrete]
-==== Features
-
-[discrete]
-===== Support for Elasticsearch `v8.8.1`
-
-You can find all the API changes
-https://www.elastic.co/guide/en/elasticsearch/reference/8.8/release-notes-8.8.1.html[here].
-
-[discrete]
-==== Fixes
-
-[discrete]
-===== Fix index drift bug in bulk helper https://github.com/elastic/elasticsearch-js/pull/1759[#1759]
-
-Fixes a bug in the bulk helper that would cause `onDrop` to send back the wrong JSON document or error on a nonexistent document when an error occurred on a bulk HTTP request that contained a `delete` action.
-
-[discrete]
-===== Fix a memory leak caused by an outdated version of Undici https://github.com/elastic/elasticsearch-js/pull/1902[#1902]
-
-Undici 5.5.1, used by https://github.com/elastic/elastic-transport-js[elastic-transport-js], could create a memory leak when a high volume of requests created too many HTTP `abort` listeners. Upgrading Undici to 5.22.1 removed the memory leak.
-
-[discrete]
-=== 8.8.0
-
-[discrete]
-==== Features
-
-[discrete]
-===== Support for Elasticsearch `v8.8.0`
-
-You can find all the API changes
-https://www.elastic.co/guide/en/elasticsearch/reference/8.8/release-notes-8.8.0.html[here].
-
-[discrete]
-==== Fixes
-
-[discrete]
-===== Fix type declarations for legacy types with a body key https://github.com/elastic/elasticsearch-js/pull/1784[#1784]
-
-Prior releases contained a bug where type declarations for legacy types that include a `body` key were not actually importing the type that includes the `body` key.
-
-[discrete]
-=== 8.7.0
-
-[discrete]
-===== Support for Elasticsearch `v8.7.0`
-
-You can find all the API changes
-https://www.elastic.co/guide/en/elasticsearch/reference/8.7/release-notes-8.7.0.html[here].
+===== Bump @elastic/transport to `~8.3.1`
+Switching from `^8.3.1` to `~8.3.1` ensures 8.6 client users are not required to update to Node.js v18+, which is a new requirement set by `@elastic/transport` v8.5.0. See https://github.com/elastic/elastic-transport-js/issues/91[elastic/elastic-transport-js#91] for details.
 
 [discrete]
 === 8.6.0
@@ -395,9 +247,6 @@ The client API leaks HTTP-related notions in many places, and removing them woul
 
 This could be a rather big breaking change, so a double solution could be used during the 8.x lifecycle. (accepting body keys without them being wrapped in the body as well as the current solution).
 
-To convert code from 7.x, you need to remove the `body` parameter in all the endpoints request.
-For instance, this is an example for the `search` endpoint:
-
 [source,js]
 ----
 // from
@@ -436,12 +285,6 @@ If you weren't extending the internals of the client, this won't be a breaking c
 The client API leaks HTTP-related notions in many places, and removing them would definitely improve the DX.
 The client will expose a new request-specific option to still get the full response details.
 
-The new behaviour returns the `body` value directly as response.
-If you want to have the 7.x response format, you need to add `meta : true` in the request.
-This will return all the HTTP meta information, including the `body`.
-
-For instance, this is an example for the `search` endpoint:
-
 [source,js]
 ----
 // from

docs/connecting.asciidoc

@@ -11,8 +11,6 @@ This page contains the information you need to connect and use the Client with
 * <<client-faas-env, Using the Client in a Function-as-a-Service Environment>>
 * <<client-connect-proxy, Connecting through a proxy>>
 * <<client-error-handling, Handling errors>>
-* <<keep-alive, Keep-alive connections>>
-* <<close-connections, Closing a client's connections>>
 * <<product-check, Automatic product check>>
 
 [[authentication]]
@@ -541,17 +539,11 @@ If you need to pass through an http(s) proxy for connecting to {es}, the client
 out of the box offers a handy configuration for helping you with it. Under the 
 hood, it uses the https://github.com/delvedor/hpagent[`hpagent`] module.
 
-IMPORTANT: In versions 8.0+ of the client, the default `Connection` type is set to `UndiciConnection`, which does not support proxy configurations.
-To use a proxy, you will need to use the `HttpConnection` class from `@elastic/transport` instead.
-
 [source,js]
 ----
-import { HttpConnection } from '@elastic/transport'
-
 const client = new Client({
   node: 'http://localhost:9200',
-  proxy: 'http://localhost:8080',
-  Connection: HttpConnection,
+  proxy: 'http://localhost:8080'
 })
 ----
 
@@ -561,12 +553,11 @@ Basic authentication is supported as well:
 ----
 const client = new Client({
   node: 'http://localhost:9200',
-  proxy: 'http:user:pwd@//localhost:8080',
-  Connection: HttpConnection,
+  proxy: 'http:user:pwd@//localhost:8080'
 })
 ----
 
-If you are connecting through a non-http(s) proxy, such as a `socks5` or `pac`,
+If you are connecting through a not http(s) proxy, such as a `socks5` or `pac`,
 you can use the `agent` option to configure it.
 
 [source,js]
@@ -576,8 +567,7 @@ const client = new Client({
   node: 'http://localhost:9200',
   agent () {
     return new SocksProxyAgent('socks://127.0.0.1:1080')
-  },
-  Connection: HttpConnection,
+  }
 })
 ----
 
@@ -661,51 +651,6 @@ a|* `name` - `string`
 * `headers` - `object`, the response status code
 |===
 
-[[keep-alive]]
-[discrete]
-=== Keep-alive connections
-
-By default, the client uses persistent, keep-alive connections to reduce the overhead of creating a new HTTP connection for each Elasticsearch request.
-If you are using the default `UndiciConnection` connection class, it maintains a pool of 256 connections with a keep-alive of 10 minutes.
-If you are using the legacy `HttpConnection` connection class, it maintains a pool of 256 connections with a keep-alive of 1 minute.
-
-If you need to disable keep-alive connections, you can override the HTTP agent with your preferred https://nodejs.org/api/http.html#http_new_agent_options[HTTP agent options]:
-
-[source,js]
-----
-const client = new Client({
-  node: 'http://localhost:9200',
-  // the function takes as parameter the option
-  // object passed to the Connection constructor
-  agent: (opts) => new CustomAgent()
-})
-----
-
-Or you can disable the HTTP agent entirely:
-
-[source,js]
-----
-const client = new Client({
-  node: 'http://localhost:9200',
-  // Disable agent and keep-alive
-  agent: false
-})
-----
-
-[discrete]
-[[close-connections]]
-=== Closing a client's connections
-
-If you would like to close all open connections being managed by an instance of the client, use the `close()` function:
-
-[source,js]
-----
-const client = new Client({
-  node: 'http://localhost:9200'
-});
-client.close();
-----
-
 [discrete]
 [[product-check]]
 === Automatic product check

docs/doc_examples/36b86b97feedcf5632824eefc251d6ed.asciidoc

@@ -1,12 +0,0 @@
-[source,js]
-----
-const response = await client.search({
-  index: 'books',
-  query: {
-    match: {
-      name: 'brave'
-    }
-  }
-})
-console.log(response)
-----

docs/doc_examples/8575c966b004fb124c7afd6bb5827b50.asciidoc

@@ -1,13 +0,0 @@
-[source,js]
-----
-const response = await client.index({
-  index: 'books',
-  document: {
-    name: 'Snow Crash',
-    author: 'Neal Stephenson',
-    release_date: '1992-06-01',
-    page_count: 470,
-  }
-})
-console.log(response)
-----

docs/doc_examples/bcc75fc01b45e482638c65b8fbdf09fa.asciidoc

@@ -1,7 +0,0 @@
-[source,js]
-----
-const response = await client.search({
-  index: 'books'
-})
-console.log(response)
-----

docs/doc_examples/d04f0c8c44e8b4fb55f2e7d9d05977e7.asciidoc

@@ -1,43 +0,0 @@
-[source,js]
-----
-const response = await client.bulk({
-  operations: [
-    { index: { _index: 'books' } },
-    {
-      name: 'Revelation Space',
-      author: 'Alastair Reynolds',
-      release_date: '2000-03-15',
-      page_count: 585,
-    },
-    { index: { _index: 'books' } },
-    {
-      name: '1984',
-      author: 'George Orwell',
-      release_date: '1985-06-01',
-      page_count: 328,
-    },
-    { index: { _index: 'books' } },
-    {
-      name: 'Fahrenheit 451',
-      author: 'Ray Bradbury',
-      release_date: '1953-10-15',
-      page_count: 227,
-    },
-    { index: { _index: 'books' } },
-    {
-      name: 'Brave New World',
-      author: 'Aldous Huxley',
-      release_date: '1932-06-01',
-      page_count: 268,
-    },
-    { index: { _index: 'books' } },
-    {
-      name: 'The Handmaids Tale',
-      author: 'Margaret Atwood',
-      release_date: '1985-06-01',
-      page_count: 311,
-    }
-  ]
-})
-console.log(response)
-----

docs/examples/proxy/package.json

@@ -8,7 +8,7 @@
     "test": "standard"
   },
   "keywords": [],
-  "author": "Elastic Client Library Maintainers",
+  "author": "Tomas Della Vedova",
   "license": "Apache-2.0",
   "dependencies": {
     "@elastic/elasticsearch": "^8.0.0"

docs/examples/scroll.asciidoc

@@ -103,7 +103,7 @@ async function run () {
     // get the next response if there are more quotes to fetch
     responseQueue.push(
       await client.scroll({
-        scroll_id: body._scroll_id,
+        scrollId: body._scroll_id,
         scroll: '30s'
       })
     )
@@ -146,7 +146,7 @@ async function * scrollSearch (params) {
     }
 
     response = await client.scroll({
-      scroll_id: response._scroll_id,
+      scrollId: response._scroll_id,
       scroll: params.scroll
     })
   }

docs/getting-started.asciidoc

@@ -1,170 +0,0 @@
-[[getting-started-js]]
-== Getting started
-
-This page guides you through the installation process of the Node.js client,
-shows you how to instantiate the client, and how to perform basic Elasticsearch 
-operations with it.
-
-[discrete]
-=== Requirements
-
-* https://nodejs.org/[Node.js] version 14.x or newer
-* https://docs.npmjs.com/downloading-and-installing-node-js-and-npm[`npm`], usually bundled with Node.js
-
-[discrete]
-=== Installation 
-
-To install the latest version of the client, run the following command:
-
-[source,shell]
---------------------------
-npm install @elastic/elasticsearch
---------------------------
-
-Refer to the <<installation>> page to learn more.
-
-
-[discrete]
-=== Connecting
-
-You can connect to the Elastic Cloud using an API key and the Elasticsearch 
-endpoint. 
-
-[source,js]
-----
-const { Client } = require('@elastic/elasticsearch')
-const client = new Client({
-  node: 'https://...', // Elasticsearch endpoint
-  auth: {
-    apiKey: { // API key ID and secret
-      id: 'foo',
-      api_key: 'bar',
-    }
-  }
-})
-----
-
-Your Elasticsearch endpoint can be found on the **My deployment** page of your 
-deployment:
-
-image::images/es-endpoint.jpg[alt="Finding Elasticsearch endpoint",align="center"]
-
-You can generate an API key on the **Management** page under Security.
-
-image::images/create-api-key.png[alt="Create API key",align="center"]
-
-For other connection options, refer to the <<client-connecting>> section.
-
-
-[discrete]
-=== Operations
-
-Time to use Elasticsearch! This section walks you through the basic, and most 
-important, operations of Elasticsearch.
-
-
-[discrete]
-==== Creating an index
-
-This is how you create the `my_index` index:
-
-[source,js]
-----
-await client.indices.create({ index: 'my_index' })
-----
-
-
-[discrete]
-==== Indexing documents
-
-This is a simple way of indexing a document:
-
-[source,js]
-----
-await client.index({
-  index: 'my_index',
-  id: 'my_document_id',
-  document: {
-    foo: 'foo',
-    bar: 'bar',
-  },
-})
-----
-
-
-[discrete]
-==== Getting documents
-
-You can get documents by using the following code:
-
-[source,js]
-----
-await client.get({
-  index: 'my_index',
-  id: 'my_document_id',
-})
-----
-
-
-[discrete]
-==== Searching documents
-
-This is how you can create a single match query with the client: 
-
-[source,js]
-----
-await client.search({
-  query: {
-    match: {
-      foo: 'foo'
-    }
-  }
-})
-----
-
-
-[discrete]
-==== Updating documents
-
-This is how you can update a document, for example to add a new field:
-
-[source,js]
-----
-await client.update({
-  index: 'my_index',
-  id: 'my_document_id',
-  doc: {
-    foo: 'bar',
-    new_field: 'new value'
-  }
-})
-----
-
-
-[discrete]
-==== Deleting documents
-
-[source,js]
-----
-await client.delete({
-  index: 'my_index',
-  id: 'my_document_id',
-})
-----
-
-
-[discrete]
-==== Deleting an index
-
-[source,js]
-----
-await client.indices.delete({ index: 'my_index' })
-----
-
-
-[discrete]
-== Further reading
-
-* Use <<client-helpers>> for a more comfortable experience with the APIs.
-* For an elaborate example of how to ingest data into Elastic Cloud, 
-refer to {cloud}/ec-getting-started-node-js.html[this page].

docs/helpers.asciidoc

@@ -281,7 +281,7 @@ helper uses those options in conjunction with the Bulk API call.
 [source,js]
 ----
 const result = await client.helpers.bulk({
-  datasource: [...],
+  datasource: [...]
   onDocument (doc) {
     return {
       index: { _index: 'my-index' }
@@ -326,33 +326,6 @@ const result = await client.helpers.bulk({
 console.log(result)
 ----
 
-[discrete]
-==== Modifying a document before operation
-
-~Added~ ~in~ ~`v8.8.2`~
-
-If you need to modify documents in your datasource before it is sent to Elasticsearch, you can return an array in the `onDocument` function rather than an operation object. The first item in the array must be the operation object, and the second item must be the document or partial document object as you'd like it to be sent to Elasticsearch.
-
-[source,js]
-----
-const { Client } = require('@elastic/elasticsearch')
-
-const client = new Client({
-  cloud: { id: '<cloud-id>' },
-  auth: { apiKey: 'base64EncodedKey' }
-})
-const result = await client.helpers.bulk({
-  datasource: [...],
-  onDocument (doc) {
-    return [
-      { index: { _index: 'my-index' } },
-      { ...doc, favorite_color: 'mauve' },
-    ]
-  }
-})
-
-console.log(result)
-----
 
 [discrete]
 [[multi-search-helper]]
@@ -601,4 +574,4 @@ const scrollSearch = client.helpers.scrollDocuments({
 for await (const doc of scrollSearch) {
   console.log(doc)
 }
-----
+----

docs/index-custom-title-page.html

@@ -1,185 +0,0 @@
-<style>
-    * {
-      box-sizing: border-box;
-    }
-
-    .card {
-      cursor: pointer;
-      padding: 16px;
-      text-align: left;
-      color: #000;
-    }
-
-    .card:hover {
-      box-shadow: 0 4px 8px 0 rgba(0, 0, 0, 0.2);
-      padding: 16px;
-      text-align: left;
-    }
-
-    #guide a.no-text-decoration:hover {
-      text-decoration: none!important;
-    }
-
-    .icon {
-      width: 24px;
-      height: 24px;
-      background-position: bottom;
-      background-size: contain;
-      background-repeat: no-repeat;
-    }
-
-    .ul-col-1 {
-      columns: 1;
-      -webkit-columns: 1;
-      -moz-columns: 1;
-    }
-
-    @media (min-width:769px) {
-      .ul-col-md-2 {
-        columns: 2;
-        -webkit-columns: 2;
-        -moz-columns: 2;
-      }
-    }
-
-    #guide h3.gtk {
-    margin-top: 16px;
-  }
-
-  .mb-4, .my-4 {
-    margin-bottom: 0!important;
-  }
-  </style>
-
-  <div class="legalnotice"></div>
-
-  <div class="row my-4">
-    <div class="col-md-6 col-12">
-      <p></p>
-      <p>
-        <h2>Documentation</h2>
-      </p>
-      <p>
-        The official Node.js client provides one-to-one mapping with Elasticsearch REST APIs.
-      </p>
-      <p>
-        <a href="https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/getting-started-js.html">
-          <button class="btn btn-primary">Get started</button>
-        </a>
-      </p>
-    </div>
-    <div class="col-md-6 col-12">
-      <img class="w-100" src="https://images.contentstack.io/v3/assets/bltefdd0b53724fa2ce/blt3826dd36882ab258/641c4e9d542f593a7e8ba656/js-es-lp-hero.png" />
-    </div>
-  </div>
-
-  <h3 class="gtk">Get to know the JavaScript client</h3>
-
-  <div class="my-5">
-    <div class="d-flex align-items-center mb-3">
-      <h4 class="mt-3">
-        <span class="inline-block float-left icon mr-2" style="background-image: url('https://images.contentstack.io/v3/assets/bltefdd0b53724fa2ce/bltfd59779217093221/641ae0c8db18f61d68e9c377/64x64_Color_icon-connected-circles64-color.png');"></span>
-        Connecting
-      </h4>
-    </div>
-    <ul class="ul-col-md-2 ul-col-1">
-      <li>
-        <a href="introduction.html">Introduction to the client</a>
-      </li>
-      <li>
-        <a href="installation.html">Installing the client</a>
-      </li>
-      <li>
-        <a href="client-connecting.html">Connecting to Elasticsearch</a>
-      </li>
-      <li>
-        <a href="client-configuration.html">Configuration options</a>
-      </li>
-    </ul>
-  </div>
-
-  <div class="my-5">
-    <div class="d-flex align-items-center mb-3">
-      <h4 class="mt-3">
-        <span class="inline-block float-left icon mr-2" style="background-image: url('https://images.contentstack.io/v3/assets/bltefdd0b53724fa2ce/bltca09fd8c807816ce/641ae17733e7f95594918557/icon-monitor-cog-64-color.png');"></span>
-        Using the JS client
-      </h4>
-    </div>
-    <ul class="ul-col-md-2 ul-col-1">
-      <li>
-        <a href="bulk_examples.html">Bulk indexing</a>
-      </li>
-      <li>
-        <a href="get_examples.html">Getting documents</a>
-      </li>
-      <li>
-        <a href="search_examples.html">Searching</a>
-      </li>
-      <li>
-        <a href="examples.html">More examples</a>
-      </li>
-    </ul>
-  </div>
-
-  <div class="my-5">
-    <div class="d-flex align-items-center mb-3">
-      <h4 class="mt-3">
-        <span class="inline-block float-left icon mr-2" style="background-image: url('https://images.contentstack.io/v3/assets/bltefdd0b53724fa2ce/blteacd058910f155d8/636925a6e0ff7c532db636d7/64x64_Color_icon-dev-tools-64-color.png');"></span>
-        API and developer docs
-      </h4>
-    </div>
-    <ul class="ul-col-md-2 ul-col-1">
-      <li>
-        <a href="api-reference.html">API reference</a>
-      </li>
-      <li>
-        <a href="client-helpers.html">Client helpers</a>
-      </li>
-      <li>
-        <a href="integrations.html">Integrations</a>
-      </li>
-      <li>
-        <a href="changelog-client.html">Release notes</a>
-      </li>
-    </ul>
-  </div>
-
-  <h3 class="explore">Explore by use case</h3>
-
-  <div class="row my-4">
-    <div class="col-md-4 col-12 mb-2">
-      <a class="no-text-decoration" href="https://www.elastic.co/guide/en/enterprise-search/current/start.html">
-        <div class="card h-100">
-          <h4 class="mt-3">
-            <span class="inline-block float-left icon mr-2" style="background-image: url('https://images.contentstack.io/v3/assets/bltefdd0b53724fa2ce/blt11200907c1c033aa/634d9da119d8652169cf9b2b/enterprise-search-logo-color-32px.png');"></span>
-            Search my data
-          </h4>
-          <p>Create search experiences for your content, wherever it lives.</p>
-        </div>
-      </a>
-    </div>
-    <div class="col-md-4 col-12 mb-2">
-      <a class="no-text-decoration" href="https://www.elastic.co/guide/en/starting-with-the-elasticsearch-platform-and-its-solutions/current/getting-started-observability.html">
-        <div class="card h-100">
-          <h4 class="mt-3">
-            <span class="inline-block float-left icon mr-2" style="background-image: url('https://images.contentstack.io/v3/assets/bltefdd0b53724fa2ce/bltaa08b370a00bbecc/634d9da14e565f1cdce27f7c/observability-logo-color-32px.png');"></span>
-            Observe my data
-          </h4>
-          <p>Follow our guides to monitor logs, metrics, and traces.</p>
-        </div>
-      </a>
-    </div>
-    <div class="col-md-4 col-12 mb-2">
-      <a class="no-text-decoration" href="https://www.elastic.co/guide/en/security/current/es-overview.html">
-        <div class="card h-100">
-          <h4 class="mt-3">
-            <span class="inline-block float-left icon mr-2" style="background-image: url('https://images.contentstack.io/v3/assets/bltefdd0b53724fa2ce/blt5e0e0ad9a13e6b8c/634d9da18473831f96bbdf1e/security-logo-color-32px.png');"></span>
-            Protect my environment
-          </h4>
-          <p>Learn how to defend against threats across your environment.</p>
-        </div>
-      </a>
-    </div>
-  </div>
-
-  <p class="my-4"><a href="https://www.elastic.co/guide/index.html">View all Elastic docs</a></p>

docs/index.asciidoc

@@ -4,7 +4,6 @@ include::{asciidoc-dir}/../../shared/versions/stack/{source_branch}.asciidoc[]
 include::{asciidoc-dir}/../../shared/attributes.asciidoc[]
 
 include::introduction.asciidoc[]
-include::getting-started.asciidoc[]
 include::changelog.asciidoc[]
 include::installation.asciidoc[]
 include::connecting.asciidoc[]

docs/installation.asciidoc

@@ -24,7 +24,7 @@ To learn more about the supported major versions, please refer to the
 [[nodejs-support]]
 === Node.js support
 
-NOTE: The minimum supported version of Node.js is `v18`.
+NOTE: The minimum supported version of Node.js is `v14`.
 
 The client versioning follows the {stack} versioning, this means that
 major, minor, and patch releases are done following a precise schedule that
@@ -64,10 +64,6 @@ of `^7.10.0`).
 |`14.x`
 |April 2023
 |`8.8` (early 2023)
-
-|`16.x`
-|September 2023
-|`8.11` (late 2023)
 |===
 
 [discrete]

docs/introduction.asciidoc

@@ -17,6 +17,66 @@ about the features of the client.
 * TypeScript support out of the box.
 
 
+[discrete]
+=== Quick start
+
+[source,js]
+----
+'use strict'
+
+const { Client } = require('@elastic/elasticsearch')
+const client = new Client({
+  cloud: { id: '<cloud-id>' },
+  auth: { apiKey: 'base64EncodedKey' }
+})
+
+async function run () {
+  // Let's start by indexing some data
+  await client.index({
+    index: 'game-of-thrones',
+    document: {
+      character: 'Ned Stark',
+      quote: 'Winter is coming.'
+    }
+  })
+
+  await client.index({
+    index: 'game-of-thrones',
+    document: {
+      character: 'Daenerys Targaryen',
+      quote: 'I am the blood of the dragon.'
+    }
+  })
+
+  await client.index({
+    index: 'game-of-thrones',
+    document: {
+      character: 'Tyrion Lannister',
+      quote: 'A mind needs books like a sword needs a whetstone.'
+    }
+  })
+
+  // here we are forcing an index refresh, otherwise we will not
+  // get any result in the consequent search
+  await client.indices.refresh({ index: 'game-of-thrones' })
+
+  // Let's search!
+  const result= await client.search({
+    index: 'game-of-thrones',
+    query: {
+      match: { quote: 'winter' }
+    }
+  })
+
+  console.log(result.hits.hits)
+}
+
+run().catch(console.log)
+----
+
+TIP: For an elaborate example of how to ingest data into Elastic Cloud, 
+refer to {cloud}/ec-getting-started-node-js.html[this page].
+
 [discrete]
 ==== Install multiple versions
 

docs/typescript.asciidoc

@@ -6,7 +6,6 @@ of type definitions of Elasticsearch's API surface.
 
 The types are not 100% complete yet. Some APIs are missing (the newest ones, e.g. EQL),
 and others may contain some errors, but we are continuously pushing fixes & improvements.
-Contribute type fixes and improvements to https://github.com/elastic/elasticsearch-specification[elasticsearch-specification github repository].
 
 NOTE: The client is developed against the https://www.npmjs.com/package/typescript?activeTab=versions[latest]
 version of TypeScript. Furthermore, unless you have set `skipLibCheck` to `true`,

index.d.ts

@@ -22,6 +22,6 @@ import SniffingTransport from './lib/sniffingTransport'
 
 export * from '@elastic/transport'
 export * as estypes from './lib/api/types'
-export * as estypesWithBody from './lib/api/typesWithBodyKey'
+export * as estypesWithBody from './lib/api/types'
 export { Client, SniffingTransport }
 export type { ClientOptions, NodeOptions } from './lib/client'

package.json

@@ -1,17 +1,17 @@
 {
   "name": "@elastic/elasticsearch",
-  "version": "8.12.2",
-  "versionCanary": "8.12.2-canary.0",
+  "version": "8.6.1",
+  "versionCanary": "8.6.1-canary.0",
   "description": "The official Elasticsearch client for Node.js",
   "main": "index.js",
   "types": "index.d.ts",
-  "type": "commonjs",
   "scripts": {
-    "test": "npm run build && npm run lint && tap test/unit/{*,**/*}.test.ts",
+    "test": "npm run build && npm run lint && tap test/{unit,acceptance}/{*,**/*}.test.ts",
     "test:unit": "npm run build && tap test/unit/{*,**/*}.test.ts",
-    "test:coverage-100": "npm run build && tap test/unit/{*,**/*}.test.ts --coverage --100",
-    "test:coverage-report": "npm run build && tap test/unit/{*,**/*}.test.ts --coverage && nyc report --reporter=text-lcov > coverage.lcov",
-    "test:coverage-ui": "npm run build && tap test/unit/{*,**/*}.test.ts --coverage --coverage-report=html",
+    "test:acceptance": "npm run build && tap test/acceptance/*.test.ts",
+    "test:coverage-100": "npm run build && tap test/{unit,acceptance}/{*,**/*}.test.ts --coverage --100",
+    "test:coverage-report": "npm run build && tap test/{unit,acceptance}/{*,**/*}.test.ts --coverage && nyc report --reporter=text-lcov > coverage.lcov",
+    "test:coverage-ui": "npm run build && tap test/{unit,acceptance}/{*,**/*}.test.ts --coverage --coverage-report=html",
     "test:integration": "tsc && node test/integration/index.js",
     "lint": "ts-standard src",
     "lint:fix": "ts-standard --fix src",
@@ -31,12 +31,10 @@
     "client",
     "index"
   ],
-  "contributors": [
-    {
-      "name": "Elastic Client Library Maintainers",
-      "company": "Elastic BV"
-    }
-  ],
+  "author": {
+    "name": "Tomas Della Vedova",
+    "company": "Elastic BV"
+  },
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -47,7 +45,7 @@
   },
   "homepage": "http://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/index.html",
   "engines": {
-    "node": ">=18"
+    "node": ">=14"
   },
   "devDependencies": {
     "@sinonjs/fake-timers": "github:sinonjs/fake-timers#0bfffc1",
@@ -58,9 +56,9 @@
     "@types/split2": "^3.2.1",
     "@types/stoppable": "^1.1.1",
     "@types/tap": "^15.0.7",
-    "chai": "^4.3.7",
     "cross-zip": "^4.0.0",
     "desm": "^1.2.0",
+    "fast-deep-equal": "^3.1.3",
     "into-stream": "^7.0.0",
     "js-yaml": "^4.1.0",
     "license-checker": "^25.0.1",
@@ -80,10 +78,10 @@
     "typescript": "^4.6.4",
     "workq": "^3.0.0",
     "xmlbuilder2": "^3.0.2",
-    "zx": "^7.2.2"
+    "zx": "^6.1.0"
   },
   "dependencies": {
-    "@elastic/transport": "^8.4.1",
+    "@elastic/transport": "~8.3.1",
     "tslib": "^2.4.0"
   },
   "tap": {

scripts/release-canary.js

@@ -22,25 +22,11 @@ const { join } = require('path')
 const minimist = require('minimist')
 const chalk = require('chalk')
 
-const helpMessage = `usage: node scripts/release-canary.js [options]
-
-    --otp <code> One-time password (required)
-    --reset      Reset the canary version to 1
-    --dry-run    Run everything but don't actually publish
-    -h, --help   Show this help message`
-
 async function release (opts) {
-  if (opts.help) {
-    console.log(helpMessage)
-    process.exit(0)
-  }
-
   assert(process.cwd() !== __dirname, 'You should run the script from the top level directory of the repository')
-  if (!opts['dry-run']) {
-    assert(typeof opts.otp === 'string', 'Missing OTP')
-  }
-
+  assert(typeof opts.otp === 'string', 'Missing OTP')
   const packageJson = JSON.parse(await readFile(join(__dirname, '..', 'package.json'), 'utf8'))
+
   const originalName = packageJson.name
   const originalVersion = packageJson.version
   const currentCanaryVersion = packageJson.versionCanary
@@ -66,7 +52,6 @@ async function release (opts) {
   const diff = execSync('git diff').toString().split('\n').map(colorDiff).join('\n')
   console.log(diff)
   const answer = await confirm()
-
   // release on npm with provided otp
   if (answer) {
     execSync(`npm publish --otp ${opts.otp} ${opts['dry-run'] ? '--dry-run' : ''}`, { stdio: 'inherit' })
@@ -88,8 +73,8 @@ async function release (opts) {
   )
 }
 
-function confirm () {
-  return new Promise((resolve) => {
+function confirm (question) {
+  return new Promise((resolve, reject) => {
     const rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout
@@ -125,18 +110,12 @@ release(
     boolean: [
       // Reset the canary version to '1'
       'reset',
-
-      // run all the steps but don't publish
-      'dry-run',
-
-      // help text
-      'help',
-    ],
-    alias: { help: 'h' },
+      // run all the steps but publish
+      'dry-run'
+    ]
   })
 )
   .catch(err => {
     console.log(err)
-    console.log('\n' + helpMessage)
     process.exit(1)
   })

scripts/utils/generateApis.js

@@ -228,11 +228,11 @@ function generateSingleApi (version, spec, common) {
 
     ${genUrlValidation(paths, api)}
 
-    let { ${genQueryDenylist(false)}, ...querystring } = params
+    let { ${genQueryBlacklist(false)}, ...querystring } = params
     querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
 
     let path = ''
-    ${buildPath()}
+    ${buildPath(api)}
 
     // build request object
     const request = {
@@ -254,7 +254,7 @@ function generateSingleApi (version, spec, common) {
     documentation: generateDocumentation(spec[api], api)
   }
 
-  function genRequiredChecks () {
+  function genRequiredChecks (param) {
     const code = required
       .map(_genRequiredCheck)
       .concat(_noBody())
@@ -316,20 +316,20 @@ function generateSingleApi (version, spec, common) {
     }, {})
   }
 
-  function genQueryDenylist (addQuotes = true) {
+  function genQueryBlacklist (addQuotes = true) {
     const toCamelCase = str => {
       return str[0] === '_'
         ? '_' + str.slice(1).replace(/_([a-z])/g, k => k[1].toUpperCase())
         : str.replace(/_([a-z])/g, k => k[1].toUpperCase())
     }
 
-    const denylist = ['method', 'body']
+    const blacklist = ['method', 'body']
     parts.forEach(p => {
       const camelStr = toCamelCase(p)
-      if (camelStr !== p) denylist.push(`${camelStr}`)
-      denylist.push(`${p}`)
+      if (camelStr !== p) blacklist.push(`${camelStr}`)
+      blacklist.push(`${p}`)
     })
-    return addQuotes ? denylist.map(q => `'${q}'`) : denylist
+    return addQuotes ? blacklist.map(q => `'${q}'`) : blacklist
   }
 
   function buildPath () {

src/api/api/async_search.ts

@@ -43,10 +43,6 @@ export default class AsyncSearch {
     this.transport = transport
   }
 
-  /**
-    * Deletes an async search by ID. If the search is still running, the search request will be cancelled. Otherwise, the saved search results are deleted.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/async-search.html | Elasticsearch API documentation}
-    */
   async delete (this: That, params: T.AsyncSearchDeleteRequest | TB.AsyncSearchDeleteRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.AsyncSearchDeleteResponse>
   async delete (this: That, params: T.AsyncSearchDeleteRequest | TB.AsyncSearchDeleteRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.AsyncSearchDeleteResponse, unknown>>
   async delete (this: That, params: T.AsyncSearchDeleteRequest | TB.AsyncSearchDeleteRequest, options?: TransportRequestOptions): Promise<T.AsyncSearchDeleteResponse>
@@ -69,10 +65,6 @@ export default class AsyncSearch {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Retrieves the results of a previously submitted async search request given its ID.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/async-search.html | Elasticsearch API documentation}
-    */
   async get<TDocument = unknown, TAggregations = Record<T.AggregateName, T.AggregationsAggregate>> (this: That, params: T.AsyncSearchGetRequest | TB.AsyncSearchGetRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.AsyncSearchGetResponse<TDocument, TAggregations>>
   async get<TDocument = unknown, TAggregations = Record<T.AggregateName, T.AggregationsAggregate>> (this: That, params: T.AsyncSearchGetRequest | TB.AsyncSearchGetRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.AsyncSearchGetResponse<TDocument, TAggregations>, unknown>>
   async get<TDocument = unknown, TAggregations = Record<T.AggregateName, T.AggregationsAggregate>> (this: That, params: T.AsyncSearchGetRequest | TB.AsyncSearchGetRequest, options?: TransportRequestOptions): Promise<T.AsyncSearchGetResponse<TDocument, TAggregations>>
@@ -95,10 +87,6 @@ export default class AsyncSearch {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Retrieves the status of a previously submitted async search request given its ID.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/async-search.html | Elasticsearch API documentation}
-    */
   async status (this: That, params: T.AsyncSearchStatusRequest | TB.AsyncSearchStatusRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.AsyncSearchStatusResponse>
   async status (this: That, params: T.AsyncSearchStatusRequest | TB.AsyncSearchStatusRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.AsyncSearchStatusResponse, unknown>>
   async status (this: That, params: T.AsyncSearchStatusRequest | TB.AsyncSearchStatusRequest, options?: TransportRequestOptions): Promise<T.AsyncSearchStatusResponse>
@@ -121,10 +109,6 @@ export default class AsyncSearch {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Executes a search request asynchronously.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/async-search.html | Elasticsearch API documentation}
-    */
   async submit<TDocument = unknown, TAggregations = Record<T.AggregateName, T.AggregationsAggregate>> (this: That, params?: T.AsyncSearchSubmitRequest | TB.AsyncSearchSubmitRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.AsyncSearchSubmitResponse<TDocument, TAggregations>>
   async submit<TDocument = unknown, TAggregations = Record<T.AggregateName, T.AggregationsAggregate>> (this: That, params?: T.AsyncSearchSubmitRequest | TB.AsyncSearchSubmitRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.AsyncSearchSubmitResponse<TDocument, TAggregations>, unknown>>
   async submit<TDocument = unknown, TAggregations = Record<T.AggregateName, T.AggregationsAggregate>> (this: That, params?: T.AsyncSearchSubmitRequest | TB.AsyncSearchSubmitRequest, options?: TransportRequestOptions): Promise<T.AsyncSearchSubmitResponse<TDocument, TAggregations>>

src/api/api/autoscaling.ts

@@ -43,10 +43,6 @@ export default class Autoscaling {
     this.transport = transport
   }
 
-  /**
-    * Deletes an autoscaling policy. Designed for indirect use by ECE/ESS and ECK. Direct use is not supported.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/autoscaling-delete-autoscaling-policy.html | Elasticsearch API documentation}
-    */
   async deleteAutoscalingPolicy (this: That, params: T.AutoscalingDeleteAutoscalingPolicyRequest | TB.AutoscalingDeleteAutoscalingPolicyRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.AutoscalingDeleteAutoscalingPolicyResponse>
   async deleteAutoscalingPolicy (this: That, params: T.AutoscalingDeleteAutoscalingPolicyRequest | TB.AutoscalingDeleteAutoscalingPolicyRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.AutoscalingDeleteAutoscalingPolicyResponse, unknown>>
   async deleteAutoscalingPolicy (this: That, params: T.AutoscalingDeleteAutoscalingPolicyRequest | TB.AutoscalingDeleteAutoscalingPolicyRequest, options?: TransportRequestOptions): Promise<T.AutoscalingDeleteAutoscalingPolicyResponse>
@@ -69,10 +65,6 @@ export default class Autoscaling {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Gets the current autoscaling capacity based on the configured autoscaling policy. Designed for indirect use by ECE/ESS and ECK. Direct use is not supported.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/autoscaling-get-autoscaling-capacity.html | Elasticsearch API documentation}
-    */
   async getAutoscalingCapacity (this: That, params?: T.AutoscalingGetAutoscalingCapacityRequest | TB.AutoscalingGetAutoscalingCapacityRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.AutoscalingGetAutoscalingCapacityResponse>
   async getAutoscalingCapacity (this: That, params?: T.AutoscalingGetAutoscalingCapacityRequest | TB.AutoscalingGetAutoscalingCapacityRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.AutoscalingGetAutoscalingCapacityResponse, unknown>>
   async getAutoscalingCapacity (this: That, params?: T.AutoscalingGetAutoscalingCapacityRequest | TB.AutoscalingGetAutoscalingCapacityRequest, options?: TransportRequestOptions): Promise<T.AutoscalingGetAutoscalingCapacityResponse>
@@ -96,10 +88,6 @@ export default class Autoscaling {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Retrieves an autoscaling policy. Designed for indirect use by ECE/ESS and ECK. Direct use is not supported.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/autoscaling-get-autoscaling-capacity.html | Elasticsearch API documentation}
-    */
   async getAutoscalingPolicy (this: That, params: T.AutoscalingGetAutoscalingPolicyRequest | TB.AutoscalingGetAutoscalingPolicyRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.AutoscalingGetAutoscalingPolicyResponse>
   async getAutoscalingPolicy (this: That, params: T.AutoscalingGetAutoscalingPolicyRequest | TB.AutoscalingGetAutoscalingPolicyRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.AutoscalingGetAutoscalingPolicyResponse, unknown>>
   async getAutoscalingPolicy (this: That, params: T.AutoscalingGetAutoscalingPolicyRequest | TB.AutoscalingGetAutoscalingPolicyRequest, options?: TransportRequestOptions): Promise<T.AutoscalingGetAutoscalingPolicyResponse>
@@ -122,10 +110,6 @@ export default class Autoscaling {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Creates a new autoscaling policy. Designed for indirect use by ECE/ESS and ECK. Direct use is not supported.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/autoscaling-put-autoscaling-policy.html | Elasticsearch API documentation}
-    */
   async putAutoscalingPolicy (this: That, params: T.AutoscalingPutAutoscalingPolicyRequest | TB.AutoscalingPutAutoscalingPolicyRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.AutoscalingPutAutoscalingPolicyResponse>
   async putAutoscalingPolicy (this: That, params: T.AutoscalingPutAutoscalingPolicyRequest | TB.AutoscalingPutAutoscalingPolicyRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.AutoscalingPutAutoscalingPolicyResponse, unknown>>
   async putAutoscalingPolicy (this: That, params: T.AutoscalingPutAutoscalingPolicyRequest | TB.AutoscalingPutAutoscalingPolicyRequest, options?: TransportRequestOptions): Promise<T.AutoscalingPutAutoscalingPolicyResponse>

src/api/api/bulk.ts

@@ -37,10 +37,6 @@ import * as T from '../types'
 import * as TB from '../typesWithBodyKey'
 interface That { transport: Transport }
 
-/**
-  * Allows to perform multiple index/update/delete operations in a single request.
-  * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/docs-bulk.html | Elasticsearch API documentation}
-  */
 export default async function BulkApi<TDocument = unknown, TPartialDocument = unknown> (this: That, params: T.BulkRequest<TDocument, TPartialDocument> | TB.BulkRequest<TDocument, TPartialDocument>, options?: TransportRequestOptionsWithOutMeta): Promise<T.BulkResponse>
 export default async function BulkApi<TDocument = unknown, TPartialDocument = unknown> (this: That, params: T.BulkRequest<TDocument, TPartialDocument> | TB.BulkRequest<TDocument, TPartialDocument>, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.BulkResponse, unknown>>
 export default async function BulkApi<TDocument = unknown, TPartialDocument = unknown> (this: That, params: T.BulkRequest<TDocument, TPartialDocument> | TB.BulkRequest<TDocument, TPartialDocument>, options?: TransportRequestOptions): Promise<T.BulkResponse>

src/api/api/cat.ts

@@ -43,10 +43,6 @@ export default class Cat {
     this.transport = transport
   }
 
-  /**
-    * Shows information about currently configured aliases to indices including filter and routing infos.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cat-alias.html | Elasticsearch API documentation}
-    */
   async aliases (this: That, params?: T.CatAliasesRequest | TB.CatAliasesRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatAliasesResponse>
   async aliases (this: That, params?: T.CatAliasesRequest | TB.CatAliasesRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatAliasesResponse, unknown>>
   async aliases (this: That, params?: T.CatAliasesRequest | TB.CatAliasesRequest, options?: TransportRequestOptions): Promise<T.CatAliasesResponse>
@@ -77,10 +73,6 @@ export default class Cat {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Provides a snapshot of how many shards are allocated to each data node and how much disk space they are using.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cat-allocation.html | Elasticsearch API documentation}
-    */
   async allocation (this: That, params?: T.CatAllocationRequest | TB.CatAllocationRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatAllocationResponse>
   async allocation (this: That, params?: T.CatAllocationRequest | TB.CatAllocationRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatAllocationResponse, unknown>>
   async allocation (this: That, params?: T.CatAllocationRequest | TB.CatAllocationRequest, options?: TransportRequestOptions): Promise<T.CatAllocationResponse>
@@ -111,10 +103,6 @@ export default class Cat {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns information about existing component_templates templates.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cat-component-templates.html | Elasticsearch API documentation}
-    */
   async componentTemplates (this: That, params?: T.CatComponentTemplatesRequest | TB.CatComponentTemplatesRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatComponentTemplatesResponse>
   async componentTemplates (this: That, params?: T.CatComponentTemplatesRequest | TB.CatComponentTemplatesRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatComponentTemplatesResponse, unknown>>
   async componentTemplates (this: That, params?: T.CatComponentTemplatesRequest | TB.CatComponentTemplatesRequest, options?: TransportRequestOptions): Promise<T.CatComponentTemplatesResponse>
@@ -145,10 +133,6 @@ export default class Cat {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Provides quick access to the document count of the entire cluster, or individual indices.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cat-count.html | Elasticsearch API documentation}
-    */
   async count (this: That, params?: T.CatCountRequest | TB.CatCountRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatCountResponse>
   async count (this: That, params?: T.CatCountRequest | TB.CatCountRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatCountResponse, unknown>>
   async count (this: That, params?: T.CatCountRequest | TB.CatCountRequest, options?: TransportRequestOptions): Promise<T.CatCountResponse>
@@ -179,10 +163,6 @@ export default class Cat {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Shows how much heap memory is currently being used by fielddata on every data node in the cluster.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cat-fielddata.html | Elasticsearch API documentation}
-    */
   async fielddata (this: That, params?: T.CatFielddataRequest | TB.CatFielddataRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatFielddataResponse>
   async fielddata (this: That, params?: T.CatFielddataRequest | TB.CatFielddataRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatFielddataResponse, unknown>>
   async fielddata (this: That, params?: T.CatFielddataRequest | TB.CatFielddataRequest, options?: TransportRequestOptions): Promise<T.CatFielddataResponse>
@@ -213,10 +193,6 @@ export default class Cat {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns a concise representation of the cluster health.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cat-health.html | Elasticsearch API documentation}
-    */
   async health (this: That, params?: T.CatHealthRequest | TB.CatHealthRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatHealthResponse>
   async health (this: That, params?: T.CatHealthRequest | TB.CatHealthRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatHealthResponse, unknown>>
   async health (this: That, params?: T.CatHealthRequest | TB.CatHealthRequest, options?: TransportRequestOptions): Promise<T.CatHealthResponse>
@@ -240,10 +216,6 @@ export default class Cat {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns help for the Cat APIs.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cat.html | Elasticsearch API documentation}
-    */
   async help (this: That, params?: T.CatHelpRequest | TB.CatHelpRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatHelpResponse>
   async help (this: That, params?: T.CatHelpRequest | TB.CatHelpRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatHelpResponse, unknown>>
   async help (this: That, params?: T.CatHelpRequest | TB.CatHelpRequest, options?: TransportRequestOptions): Promise<T.CatHelpResponse>
@@ -267,10 +239,6 @@ export default class Cat {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns information about indices: number of primaries and replicas, document counts, disk size, ...
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cat-indices.html | Elasticsearch API documentation}
-    */
   async indices (this: That, params?: T.CatIndicesRequest | TB.CatIndicesRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatIndicesResponse>
   async indices (this: That, params?: T.CatIndicesRequest | TB.CatIndicesRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatIndicesResponse, unknown>>
   async indices (this: That, params?: T.CatIndicesRequest | TB.CatIndicesRequest, options?: TransportRequestOptions): Promise<T.CatIndicesResponse>
@@ -301,10 +269,6 @@ export default class Cat {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns information about the master node.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cat-master.html | Elasticsearch API documentation}
-    */
   async master (this: That, params?: T.CatMasterRequest | TB.CatMasterRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatMasterResponse>
   async master (this: That, params?: T.CatMasterRequest | TB.CatMasterRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatMasterResponse, unknown>>
   async master (this: That, params?: T.CatMasterRequest | TB.CatMasterRequest, options?: TransportRequestOptions): Promise<T.CatMasterResponse>
@@ -328,10 +292,6 @@ export default class Cat {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Gets configuration and usage information about data frame analytics jobs.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cat-dfanalytics.html | Elasticsearch API documentation}
-    */
   async mlDataFrameAnalytics (this: That, params?: T.CatMlDataFrameAnalyticsRequest | TB.CatMlDataFrameAnalyticsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatMlDataFrameAnalyticsResponse>
   async mlDataFrameAnalytics (this: That, params?: T.CatMlDataFrameAnalyticsRequest | TB.CatMlDataFrameAnalyticsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatMlDataFrameAnalyticsResponse, unknown>>
   async mlDataFrameAnalytics (this: That, params?: T.CatMlDataFrameAnalyticsRequest | TB.CatMlDataFrameAnalyticsRequest, options?: TransportRequestOptions): Promise<T.CatMlDataFrameAnalyticsResponse>
@@ -362,10 +322,6 @@ export default class Cat {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Gets configuration and usage information about datafeeds.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cat-datafeeds.html | Elasticsearch API documentation}
-    */
   async mlDatafeeds (this: That, params?: T.CatMlDatafeedsRequest | TB.CatMlDatafeedsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatMlDatafeedsResponse>
   async mlDatafeeds (this: That, params?: T.CatMlDatafeedsRequest | TB.CatMlDatafeedsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatMlDatafeedsResponse, unknown>>
   async mlDatafeeds (this: That, params?: T.CatMlDatafeedsRequest | TB.CatMlDatafeedsRequest, options?: TransportRequestOptions): Promise<T.CatMlDatafeedsResponse>
@@ -396,10 +352,6 @@ export default class Cat {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Gets configuration and usage information about anomaly detection jobs.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cat-anomaly-detectors.html | Elasticsearch API documentation}
-    */
   async mlJobs (this: That, params?: T.CatMlJobsRequest | TB.CatMlJobsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatMlJobsResponse>
   async mlJobs (this: That, params?: T.CatMlJobsRequest | TB.CatMlJobsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatMlJobsResponse, unknown>>
   async mlJobs (this: That, params?: T.CatMlJobsRequest | TB.CatMlJobsRequest, options?: TransportRequestOptions): Promise<T.CatMlJobsResponse>
@@ -430,10 +382,6 @@ export default class Cat {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Gets configuration and usage information about inference trained models.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cat-trained-model.html | Elasticsearch API documentation}
-    */
   async mlTrainedModels (this: That, params?: T.CatMlTrainedModelsRequest | TB.CatMlTrainedModelsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatMlTrainedModelsResponse>
   async mlTrainedModels (this: That, params?: T.CatMlTrainedModelsRequest | TB.CatMlTrainedModelsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatMlTrainedModelsResponse, unknown>>
   async mlTrainedModels (this: That, params?: T.CatMlTrainedModelsRequest | TB.CatMlTrainedModelsRequest, options?: TransportRequestOptions): Promise<T.CatMlTrainedModelsResponse>
@@ -464,10 +412,6 @@ export default class Cat {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns information about custom node attributes.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cat-nodeattrs.html | Elasticsearch API documentation}
-    */
   async nodeattrs (this: That, params?: T.CatNodeattrsRequest | TB.CatNodeattrsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatNodeattrsResponse>
   async nodeattrs (this: That, params?: T.CatNodeattrsRequest | TB.CatNodeattrsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatNodeattrsResponse, unknown>>
   async nodeattrs (this: That, params?: T.CatNodeattrsRequest | TB.CatNodeattrsRequest, options?: TransportRequestOptions): Promise<T.CatNodeattrsResponse>
@@ -491,10 +435,6 @@ export default class Cat {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns basic statistics about performance of cluster nodes.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cat-nodes.html | Elasticsearch API documentation}
-    */
   async nodes (this: That, params?: T.CatNodesRequest | TB.CatNodesRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatNodesResponse>
   async nodes (this: That, params?: T.CatNodesRequest | TB.CatNodesRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatNodesResponse, unknown>>
   async nodes (this: That, params?: T.CatNodesRequest | TB.CatNodesRequest, options?: TransportRequestOptions): Promise<T.CatNodesResponse>
@@ -518,10 +458,6 @@ export default class Cat {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns a concise representation of the cluster pending tasks.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cat-pending-tasks.html | Elasticsearch API documentation}
-    */
   async pendingTasks (this: That, params?: T.CatPendingTasksRequest | TB.CatPendingTasksRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatPendingTasksResponse>
   async pendingTasks (this: That, params?: T.CatPendingTasksRequest | TB.CatPendingTasksRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatPendingTasksResponse, unknown>>
   async pendingTasks (this: That, params?: T.CatPendingTasksRequest | TB.CatPendingTasksRequest, options?: TransportRequestOptions): Promise<T.CatPendingTasksResponse>
@@ -545,10 +481,6 @@ export default class Cat {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns information about installed plugins across nodes node.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cat-plugins.html | Elasticsearch API documentation}
-    */
   async plugins (this: That, params?: T.CatPluginsRequest | TB.CatPluginsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatPluginsResponse>
   async plugins (this: That, params?: T.CatPluginsRequest | TB.CatPluginsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatPluginsResponse, unknown>>
   async plugins (this: That, params?: T.CatPluginsRequest | TB.CatPluginsRequest, options?: TransportRequestOptions): Promise<T.CatPluginsResponse>
@@ -572,10 +504,6 @@ export default class Cat {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns information about index shard recoveries, both on-going completed.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cat-recovery.html | Elasticsearch API documentation}
-    */
   async recovery (this: That, params?: T.CatRecoveryRequest | TB.CatRecoveryRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatRecoveryResponse>
   async recovery (this: That, params?: T.CatRecoveryRequest | TB.CatRecoveryRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatRecoveryResponse, unknown>>
   async recovery (this: That, params?: T.CatRecoveryRequest | TB.CatRecoveryRequest, options?: TransportRequestOptions): Promise<T.CatRecoveryResponse>
@@ -606,10 +534,6 @@ export default class Cat {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns information about snapshot repositories registered in the cluster.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cat-repositories.html | Elasticsearch API documentation}
-    */
   async repositories (this: That, params?: T.CatRepositoriesRequest | TB.CatRepositoriesRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatRepositoriesResponse>
   async repositories (this: That, params?: T.CatRepositoriesRequest | TB.CatRepositoriesRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatRepositoriesResponse, unknown>>
   async repositories (this: That, params?: T.CatRepositoriesRequest | TB.CatRepositoriesRequest, options?: TransportRequestOptions): Promise<T.CatRepositoriesResponse>
@@ -633,10 +557,6 @@ export default class Cat {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Provides low-level information about the segments in the shards of an index.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cat-segments.html | Elasticsearch API documentation}
-    */
   async segments (this: That, params?: T.CatSegmentsRequest | TB.CatSegmentsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatSegmentsResponse>
   async segments (this: That, params?: T.CatSegmentsRequest | TB.CatSegmentsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatSegmentsResponse, unknown>>
   async segments (this: That, params?: T.CatSegmentsRequest | TB.CatSegmentsRequest, options?: TransportRequestOptions): Promise<T.CatSegmentsResponse>
@@ -667,10 +587,6 @@ export default class Cat {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Provides a detailed view of shard allocation on nodes.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cat-shards.html | Elasticsearch API documentation}
-    */
   async shards (this: That, params?: T.CatShardsRequest | TB.CatShardsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatShardsResponse>
   async shards (this: That, params?: T.CatShardsRequest | TB.CatShardsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatShardsResponse, unknown>>
   async shards (this: That, params?: T.CatShardsRequest | TB.CatShardsRequest, options?: TransportRequestOptions): Promise<T.CatShardsResponse>
@@ -701,10 +617,6 @@ export default class Cat {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns all snapshots in a specific repository.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cat-snapshots.html | Elasticsearch API documentation}
-    */
   async snapshots (this: That, params?: T.CatSnapshotsRequest | TB.CatSnapshotsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatSnapshotsResponse>
   async snapshots (this: That, params?: T.CatSnapshotsRequest | TB.CatSnapshotsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatSnapshotsResponse, unknown>>
   async snapshots (this: That, params?: T.CatSnapshotsRequest | TB.CatSnapshotsRequest, options?: TransportRequestOptions): Promise<T.CatSnapshotsResponse>
@@ -735,10 +647,6 @@ export default class Cat {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns information about the tasks currently executing on one or more nodes in the cluster.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/tasks.html | Elasticsearch API documentation}
-    */
   async tasks (this: That, params?: T.CatTasksRequest | TB.CatTasksRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatTasksResponse>
   async tasks (this: That, params?: T.CatTasksRequest | TB.CatTasksRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatTasksResponse, unknown>>
   async tasks (this: That, params?: T.CatTasksRequest | TB.CatTasksRequest, options?: TransportRequestOptions): Promise<T.CatTasksResponse>
@@ -762,10 +670,6 @@ export default class Cat {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns information about existing templates.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cat-templates.html | Elasticsearch API documentation}
-    */
   async templates (this: That, params?: T.CatTemplatesRequest | TB.CatTemplatesRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatTemplatesResponse>
   async templates (this: That, params?: T.CatTemplatesRequest | TB.CatTemplatesRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatTemplatesResponse, unknown>>
   async templates (this: That, params?: T.CatTemplatesRequest | TB.CatTemplatesRequest, options?: TransportRequestOptions): Promise<T.CatTemplatesResponse>
@@ -796,10 +700,6 @@ export default class Cat {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns cluster-wide thread pool statistics per node. By default the active, queue and rejected statistics are returned for all thread pools.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cat-thread-pool.html | Elasticsearch API documentation}
-    */
   async threadPool (this: That, params?: T.CatThreadPoolRequest | TB.CatThreadPoolRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatThreadPoolResponse>
   async threadPool (this: That, params?: T.CatThreadPoolRequest | TB.CatThreadPoolRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatThreadPoolResponse, unknown>>
   async threadPool (this: That, params?: T.CatThreadPoolRequest | TB.CatThreadPoolRequest, options?: TransportRequestOptions): Promise<T.CatThreadPoolResponse>
@@ -830,10 +730,6 @@ export default class Cat {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Gets configuration and usage information about transforms.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cat-transforms.html | Elasticsearch API documentation}
-    */
   async transforms (this: That, params?: T.CatTransformsRequest | TB.CatTransformsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatTransformsResponse>
   async transforms (this: That, params?: T.CatTransformsRequest | TB.CatTransformsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatTransformsResponse, unknown>>
   async transforms (this: That, params?: T.CatTransformsRequest | TB.CatTransformsRequest, options?: TransportRequestOptions): Promise<T.CatTransformsResponse>

src/api/api/ccr.ts

@@ -43,10 +43,6 @@ export default class Ccr {
     this.transport = transport
   }
 
-  /**
-    * Deletes auto-follow patterns.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/ccr-delete-auto-follow-pattern.html | Elasticsearch API documentation}
-    */
   async deleteAutoFollowPattern (this: That, params: T.CcrDeleteAutoFollowPatternRequest | TB.CcrDeleteAutoFollowPatternRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CcrDeleteAutoFollowPatternResponse>
   async deleteAutoFollowPattern (this: That, params: T.CcrDeleteAutoFollowPatternRequest | TB.CcrDeleteAutoFollowPatternRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CcrDeleteAutoFollowPatternResponse, unknown>>
   async deleteAutoFollowPattern (this: That, params: T.CcrDeleteAutoFollowPatternRequest | TB.CcrDeleteAutoFollowPatternRequest, options?: TransportRequestOptions): Promise<T.CcrDeleteAutoFollowPatternResponse>
@@ -69,10 +65,6 @@ export default class Ccr {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Creates a new follower index configured to follow the referenced leader index.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/ccr-put-follow.html | Elasticsearch API documentation}
-    */
   async follow (this: That, params: T.CcrFollowRequest | TB.CcrFollowRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CcrFollowResponse>
   async follow (this: That, params: T.CcrFollowRequest | TB.CcrFollowRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CcrFollowResponse, unknown>>
   async follow (this: That, params: T.CcrFollowRequest | TB.CcrFollowRequest, options?: TransportRequestOptions): Promise<T.CcrFollowResponse>
@@ -107,10 +99,6 @@ export default class Ccr {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Retrieves information about all follower indices, including parameters and status for each follower index
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/ccr-get-follow-info.html | Elasticsearch API documentation}
-    */
   async followInfo (this: That, params: T.CcrFollowInfoRequest | TB.CcrFollowInfoRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CcrFollowInfoResponse>
   async followInfo (this: That, params: T.CcrFollowInfoRequest | TB.CcrFollowInfoRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CcrFollowInfoResponse, unknown>>
   async followInfo (this: That, params: T.CcrFollowInfoRequest | TB.CcrFollowInfoRequest, options?: TransportRequestOptions): Promise<T.CcrFollowInfoResponse>
@@ -133,10 +121,6 @@ export default class Ccr {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Retrieves follower stats. return shard-level stats about the following tasks associated with each shard for the specified indices.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/ccr-get-follow-stats.html | Elasticsearch API documentation}
-    */
   async followStats (this: That, params: T.CcrFollowStatsRequest | TB.CcrFollowStatsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CcrFollowStatsResponse>
   async followStats (this: That, params: T.CcrFollowStatsRequest | TB.CcrFollowStatsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CcrFollowStatsResponse, unknown>>
   async followStats (this: That, params: T.CcrFollowStatsRequest | TB.CcrFollowStatsRequest, options?: TransportRequestOptions): Promise<T.CcrFollowStatsResponse>
@@ -159,10 +143,6 @@ export default class Ccr {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Removes the follower retention leases from the leader.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/ccr-post-forget-follower.html | Elasticsearch API documentation}
-    */
   async forgetFollower (this: That, params: T.CcrForgetFollowerRequest | TB.CcrForgetFollowerRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CcrForgetFollowerResponse>
   async forgetFollower (this: That, params: T.CcrForgetFollowerRequest | TB.CcrForgetFollowerRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CcrForgetFollowerResponse, unknown>>
   async forgetFollower (this: That, params: T.CcrForgetFollowerRequest | TB.CcrForgetFollowerRequest, options?: TransportRequestOptions): Promise<T.CcrForgetFollowerResponse>
@@ -197,10 +177,6 @@ export default class Ccr {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Gets configured auto-follow patterns. Returns the specified auto-follow pattern collection.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/ccr-get-auto-follow-pattern.html | Elasticsearch API documentation}
-    */
   async getAutoFollowPattern (this: That, params?: T.CcrGetAutoFollowPatternRequest | TB.CcrGetAutoFollowPatternRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CcrGetAutoFollowPatternResponse>
   async getAutoFollowPattern (this: That, params?: T.CcrGetAutoFollowPatternRequest | TB.CcrGetAutoFollowPatternRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CcrGetAutoFollowPatternResponse, unknown>>
   async getAutoFollowPattern (this: That, params?: T.CcrGetAutoFollowPatternRequest | TB.CcrGetAutoFollowPatternRequest, options?: TransportRequestOptions): Promise<T.CcrGetAutoFollowPatternResponse>
@@ -231,10 +207,6 @@ export default class Ccr {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Pauses an auto-follow pattern
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/ccr-pause-auto-follow-pattern.html | Elasticsearch API documentation}
-    */
   async pauseAutoFollowPattern (this: That, params: T.CcrPauseAutoFollowPatternRequest | TB.CcrPauseAutoFollowPatternRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CcrPauseAutoFollowPatternResponse>
   async pauseAutoFollowPattern (this: That, params: T.CcrPauseAutoFollowPatternRequest | TB.CcrPauseAutoFollowPatternRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CcrPauseAutoFollowPatternResponse, unknown>>
   async pauseAutoFollowPattern (this: That, params: T.CcrPauseAutoFollowPatternRequest | TB.CcrPauseAutoFollowPatternRequest, options?: TransportRequestOptions): Promise<T.CcrPauseAutoFollowPatternResponse>
@@ -257,10 +229,6 @@ export default class Ccr {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Pauses a follower index. The follower index will not fetch any additional operations from the leader index.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/ccr-post-pause-follow.html | Elasticsearch API documentation}
-    */
   async pauseFollow (this: That, params: T.CcrPauseFollowRequest | TB.CcrPauseFollowRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CcrPauseFollowResponse>
   async pauseFollow (this: That, params: T.CcrPauseFollowRequest | TB.CcrPauseFollowRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CcrPauseFollowResponse, unknown>>
   async pauseFollow (this: That, params: T.CcrPauseFollowRequest | TB.CcrPauseFollowRequest, options?: TransportRequestOptions): Promise<T.CcrPauseFollowResponse>
@@ -283,10 +251,6 @@ export default class Ccr {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Creates a new named collection of auto-follow patterns against a specified remote cluster. Newly created indices on the remote cluster matching any of the specified patterns will be automatically configured as follower indices.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/ccr-put-auto-follow-pattern.html | Elasticsearch API documentation}
-    */
   async putAutoFollowPattern (this: That, params: T.CcrPutAutoFollowPatternRequest | TB.CcrPutAutoFollowPatternRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CcrPutAutoFollowPatternResponse>
   async putAutoFollowPattern (this: That, params: T.CcrPutAutoFollowPatternRequest | TB.CcrPutAutoFollowPatternRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CcrPutAutoFollowPatternResponse, unknown>>
   async putAutoFollowPattern (this: That, params: T.CcrPutAutoFollowPatternRequest | TB.CcrPutAutoFollowPatternRequest, options?: TransportRequestOptions): Promise<T.CcrPutAutoFollowPatternResponse>
@@ -321,10 +285,6 @@ export default class Ccr {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Resumes an auto-follow pattern that has been paused
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/ccr-resume-auto-follow-pattern.html | Elasticsearch API documentation}
-    */
   async resumeAutoFollowPattern (this: That, params: T.CcrResumeAutoFollowPatternRequest | TB.CcrResumeAutoFollowPatternRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CcrResumeAutoFollowPatternResponse>
   async resumeAutoFollowPattern (this: That, params: T.CcrResumeAutoFollowPatternRequest | TB.CcrResumeAutoFollowPatternRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CcrResumeAutoFollowPatternResponse, unknown>>
   async resumeAutoFollowPattern (this: That, params: T.CcrResumeAutoFollowPatternRequest | TB.CcrResumeAutoFollowPatternRequest, options?: TransportRequestOptions): Promise<T.CcrResumeAutoFollowPatternResponse>
@@ -347,10 +307,6 @@ export default class Ccr {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Resumes a follower index that has been paused
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/ccr-post-resume-follow.html | Elasticsearch API documentation}
-    */
   async resumeFollow (this: That, params: T.CcrResumeFollowRequest | TB.CcrResumeFollowRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CcrResumeFollowResponse>
   async resumeFollow (this: That, params: T.CcrResumeFollowRequest | TB.CcrResumeFollowRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CcrResumeFollowResponse, unknown>>
   async resumeFollow (this: That, params: T.CcrResumeFollowRequest | TB.CcrResumeFollowRequest, options?: TransportRequestOptions): Promise<T.CcrResumeFollowResponse>
@@ -385,10 +341,6 @@ export default class Ccr {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Gets all stats related to cross-cluster replication.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/ccr-get-stats.html | Elasticsearch API documentation}
-    */
   async stats (this: That, params?: T.CcrStatsRequest | TB.CcrStatsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CcrStatsResponse>
   async stats (this: That, params?: T.CcrStatsRequest | TB.CcrStatsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CcrStatsResponse, unknown>>
   async stats (this: That, params?: T.CcrStatsRequest | TB.CcrStatsRequest, options?: TransportRequestOptions): Promise<T.CcrStatsResponse>
@@ -412,10 +364,6 @@ export default class Ccr {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Stops the following task associated with a follower index and removes index metadata and settings associated with cross-cluster replication.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/ccr-post-unfollow.html | Elasticsearch API documentation}
-    */
   async unfollow (this: That, params: T.CcrUnfollowRequest | TB.CcrUnfollowRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CcrUnfollowResponse>
   async unfollow (this: That, params: T.CcrUnfollowRequest | TB.CcrUnfollowRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CcrUnfollowResponse, unknown>>
   async unfollow (this: That, params: T.CcrUnfollowRequest | TB.CcrUnfollowRequest, options?: TransportRequestOptions): Promise<T.CcrUnfollowResponse>

src/api/api/clear_scroll.ts

@@ -37,10 +37,6 @@ import * as T from '../types'
 import * as TB from '../typesWithBodyKey'
 interface That { transport: Transport }
 
-/**
-  * Explicitly clears the search context for a scroll.
-  * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/clear-scroll-api.html | Elasticsearch API documentation}
-  */
 export default async function ClearScrollApi (this: That, params?: T.ClearScrollRequest | TB.ClearScrollRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.ClearScrollResponse>
 export default async function ClearScrollApi (this: That, params?: T.ClearScrollRequest | TB.ClearScrollRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.ClearScrollResponse, unknown>>
 export default async function ClearScrollApi (this: That, params?: T.ClearScrollRequest | TB.ClearScrollRequest, options?: TransportRequestOptions): Promise<T.ClearScrollResponse>

src/api/api/close_point_in_time.ts

@@ -37,10 +37,6 @@ import * as T from '../types'
 import * as TB from '../typesWithBodyKey'
 interface That { transport: Transport }
 
-/**
-  * Close a point in time
-  * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/point-in-time-api.html | Elasticsearch API documentation}
-  */
 export default async function ClosePointInTimeApi (this: That, params: T.ClosePointInTimeRequest | TB.ClosePointInTimeRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.ClosePointInTimeResponse>
 export default async function ClosePointInTimeApi (this: That, params: T.ClosePointInTimeRequest | TB.ClosePointInTimeRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.ClosePointInTimeResponse, unknown>>
 export default async function ClosePointInTimeApi (this: That, params: T.ClosePointInTimeRequest | TB.ClosePointInTimeRequest, options?: TransportRequestOptions): Promise<T.ClosePointInTimeResponse>

src/api/api/cluster.ts

@@ -43,10 +43,6 @@ export default class Cluster {
     this.transport = transport
   }
 
-  /**
-    * Provides explanations for shard allocations in the cluster.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cluster-allocation-explain.html | Elasticsearch API documentation}
-    */
   async allocationExplain (this: That, params?: T.ClusterAllocationExplainRequest | TB.ClusterAllocationExplainRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.ClusterAllocationExplainResponse>
   async allocationExplain (this: That, params?: T.ClusterAllocationExplainRequest | TB.ClusterAllocationExplainRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.ClusterAllocationExplainResponse, unknown>>
   async allocationExplain (this: That, params?: T.ClusterAllocationExplainRequest | TB.ClusterAllocationExplainRequest, options?: TransportRequestOptions): Promise<T.ClusterAllocationExplainResponse>
@@ -82,10 +78,6 @@ export default class Cluster {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Deletes a component template
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-component-template.html | Elasticsearch API documentation}
-    */
   async deleteComponentTemplate (this: That, params: T.ClusterDeleteComponentTemplateRequest | TB.ClusterDeleteComponentTemplateRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.ClusterDeleteComponentTemplateResponse>
   async deleteComponentTemplate (this: That, params: T.ClusterDeleteComponentTemplateRequest | TB.ClusterDeleteComponentTemplateRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.ClusterDeleteComponentTemplateResponse, unknown>>
   async deleteComponentTemplate (this: That, params: T.ClusterDeleteComponentTemplateRequest | TB.ClusterDeleteComponentTemplateRequest, options?: TransportRequestOptions): Promise<T.ClusterDeleteComponentTemplateResponse>
@@ -108,10 +100,6 @@ export default class Cluster {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Clears cluster voting config exclusions.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/voting-config-exclusions.html | Elasticsearch API documentation}
-    */
   async deleteVotingConfigExclusions (this: That, params?: T.ClusterDeleteVotingConfigExclusionsRequest | TB.ClusterDeleteVotingConfigExclusionsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.ClusterDeleteVotingConfigExclusionsResponse>
   async deleteVotingConfigExclusions (this: That, params?: T.ClusterDeleteVotingConfigExclusionsRequest | TB.ClusterDeleteVotingConfigExclusionsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.ClusterDeleteVotingConfigExclusionsResponse, unknown>>
   async deleteVotingConfigExclusions (this: That, params?: T.ClusterDeleteVotingConfigExclusionsRequest | TB.ClusterDeleteVotingConfigExclusionsRequest, options?: TransportRequestOptions): Promise<T.ClusterDeleteVotingConfigExclusionsResponse>
@@ -135,10 +123,6 @@ export default class Cluster {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns information about whether a particular component template exist
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-component-template.html | Elasticsearch API documentation}
-    */
   async existsComponentTemplate (this: That, params: T.ClusterExistsComponentTemplateRequest | TB.ClusterExistsComponentTemplateRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.ClusterExistsComponentTemplateResponse>
   async existsComponentTemplate (this: That, params: T.ClusterExistsComponentTemplateRequest | TB.ClusterExistsComponentTemplateRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.ClusterExistsComponentTemplateResponse, unknown>>
   async existsComponentTemplate (this: That, params: T.ClusterExistsComponentTemplateRequest | TB.ClusterExistsComponentTemplateRequest, options?: TransportRequestOptions): Promise<T.ClusterExistsComponentTemplateResponse>
@@ -161,10 +145,6 @@ export default class Cluster {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns one or more component templates
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-component-template.html | Elasticsearch API documentation}
-    */
   async getComponentTemplate (this: That, params?: T.ClusterGetComponentTemplateRequest | TB.ClusterGetComponentTemplateRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.ClusterGetComponentTemplateResponse>
   async getComponentTemplate (this: That, params?: T.ClusterGetComponentTemplateRequest | TB.ClusterGetComponentTemplateRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.ClusterGetComponentTemplateResponse, unknown>>
   async getComponentTemplate (this: That, params?: T.ClusterGetComponentTemplateRequest | TB.ClusterGetComponentTemplateRequest, options?: TransportRequestOptions): Promise<T.ClusterGetComponentTemplateResponse>
@@ -195,10 +175,6 @@ export default class Cluster {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns cluster settings.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cluster-get-settings.html | Elasticsearch API documentation}
-    */
   async getSettings (this: That, params?: T.ClusterGetSettingsRequest | TB.ClusterGetSettingsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.ClusterGetSettingsResponse>
   async getSettings (this: That, params?: T.ClusterGetSettingsRequest | TB.ClusterGetSettingsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.ClusterGetSettingsResponse, unknown>>
   async getSettings (this: That, params?: T.ClusterGetSettingsRequest | TB.ClusterGetSettingsRequest, options?: TransportRequestOptions): Promise<T.ClusterGetSettingsResponse>
@@ -222,10 +198,6 @@ export default class Cluster {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns basic information about the health of the cluster.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cluster-health.html | Elasticsearch API documentation}
-    */
   async health (this: That, params?: T.ClusterHealthRequest | TB.ClusterHealthRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.ClusterHealthResponse>
   async health (this: That, params?: T.ClusterHealthRequest | TB.ClusterHealthRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.ClusterHealthResponse, unknown>>
   async health (this: That, params?: T.ClusterHealthRequest | TB.ClusterHealthRequest, options?: TransportRequestOptions): Promise<T.ClusterHealthResponse>
@@ -256,36 +228,6 @@ export default class Cluster {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns different information about the cluster.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cluster-info.html | Elasticsearch API documentation}
-    */
-  async info (this: That, params: T.ClusterInfoRequest | TB.ClusterInfoRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.ClusterInfoResponse>
-  async info (this: That, params: T.ClusterInfoRequest | TB.ClusterInfoRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.ClusterInfoResponse, unknown>>
-  async info (this: That, params: T.ClusterInfoRequest | TB.ClusterInfoRequest, options?: TransportRequestOptions): Promise<T.ClusterInfoResponse>
-  async info (this: That, params: T.ClusterInfoRequest | TB.ClusterInfoRequest, options?: TransportRequestOptions): Promise<any> {
-    const acceptedPath: string[] = ['target']
-    const querystring: Record<string, any> = {}
-    const body = undefined
-
-    for (const key in params) {
-      if (acceptedPath.includes(key)) {
-        continue
-      } else if (key !== 'body') {
-        // @ts-expect-error
-        querystring[key] = params[key]
-      }
-    }
-
-    const method = 'GET'
-    const path = `/_info/${encodeURIComponent(params.target.toString())}`
-    return await this.transport.request({ path, method, querystring, body }, options)
-  }
-
-  /**
-    * Returns a list of any cluster-level changes (e.g. create index, update mapping, allocate or fail shard) which have not yet been executed.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cluster-pending.html | Elasticsearch API documentation}
-    */
   async pendingTasks (this: That, params?: T.ClusterPendingTasksRequest | TB.ClusterPendingTasksRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.ClusterPendingTasksResponse>
   async pendingTasks (this: That, params?: T.ClusterPendingTasksRequest | TB.ClusterPendingTasksRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.ClusterPendingTasksResponse, unknown>>
   async pendingTasks (this: That, params?: T.ClusterPendingTasksRequest | TB.ClusterPendingTasksRequest, options?: TransportRequestOptions): Promise<T.ClusterPendingTasksResponse>
@@ -309,10 +251,6 @@ export default class Cluster {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Updates the cluster voting config exclusions by node ids or node names.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/voting-config-exclusions.html | Elasticsearch API documentation}
-    */
   async postVotingConfigExclusions (this: That, params?: T.ClusterPostVotingConfigExclusionsRequest | TB.ClusterPostVotingConfigExclusionsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.ClusterPostVotingConfigExclusionsResponse>
   async postVotingConfigExclusions (this: That, params?: T.ClusterPostVotingConfigExclusionsRequest | TB.ClusterPostVotingConfigExclusionsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.ClusterPostVotingConfigExclusionsResponse, unknown>>
   async postVotingConfigExclusions (this: That, params?: T.ClusterPostVotingConfigExclusionsRequest | TB.ClusterPostVotingConfigExclusionsRequest, options?: TransportRequestOptions): Promise<T.ClusterPostVotingConfigExclusionsResponse>
@@ -336,16 +274,12 @@ export default class Cluster {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Creates or updates a component template
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-component-template.html | Elasticsearch API documentation}
-    */
   async putComponentTemplate (this: That, params: T.ClusterPutComponentTemplateRequest | TB.ClusterPutComponentTemplateRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.ClusterPutComponentTemplateResponse>
   async putComponentTemplate (this: That, params: T.ClusterPutComponentTemplateRequest | TB.ClusterPutComponentTemplateRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.ClusterPutComponentTemplateResponse, unknown>>
   async putComponentTemplate (this: That, params: T.ClusterPutComponentTemplateRequest | TB.ClusterPutComponentTemplateRequest, options?: TransportRequestOptions): Promise<T.ClusterPutComponentTemplateResponse>
   async putComponentTemplate (this: That, params: T.ClusterPutComponentTemplateRequest | TB.ClusterPutComponentTemplateRequest, options?: TransportRequestOptions): Promise<any> {
     const acceptedPath: string[] = ['name']
-    const acceptedBody: string[] = ['allow_auto_create', 'template', 'version', '_meta']
+    const acceptedBody: string[] = ['template', 'aliases', 'mappings', 'settings', 'version', '_meta']
     const querystring: Record<string, any> = {}
     // @ts-expect-error
     const userBody: any = params?.body
@@ -374,10 +308,6 @@ export default class Cluster {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Updates the cluster settings.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cluster-update-settings.html | Elasticsearch API documentation}
-    */
   async putSettings (this: That, params?: T.ClusterPutSettingsRequest | TB.ClusterPutSettingsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.ClusterPutSettingsResponse>
   async putSettings (this: That, params?: T.ClusterPutSettingsRequest | TB.ClusterPutSettingsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.ClusterPutSettingsResponse, unknown>>
   async putSettings (this: That, params?: T.ClusterPutSettingsRequest | TB.ClusterPutSettingsRequest, options?: TransportRequestOptions): Promise<T.ClusterPutSettingsResponse>
@@ -413,10 +343,6 @@ export default class Cluster {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns the information about configured remote clusters.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cluster-remote-info.html | Elasticsearch API documentation}
-    */
   async remoteInfo (this: That, params?: T.ClusterRemoteInfoRequest | TB.ClusterRemoteInfoRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.ClusterRemoteInfoResponse>
   async remoteInfo (this: That, params?: T.ClusterRemoteInfoRequest | TB.ClusterRemoteInfoRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.ClusterRemoteInfoResponse, unknown>>
   async remoteInfo (this: That, params?: T.ClusterRemoteInfoRequest | TB.ClusterRemoteInfoRequest, options?: TransportRequestOptions): Promise<T.ClusterRemoteInfoResponse>
@@ -440,10 +366,6 @@ export default class Cluster {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Allows to manually change the allocation of individual shards in the cluster.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cluster-reroute.html | Elasticsearch API documentation}
-    */
   async reroute (this: That, params?: T.ClusterRerouteRequest | TB.ClusterRerouteRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.ClusterRerouteResponse>
   async reroute (this: That, params?: T.ClusterRerouteRequest | TB.ClusterRerouteRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.ClusterRerouteResponse, unknown>>
   async reroute (this: That, params?: T.ClusterRerouteRequest | TB.ClusterRerouteRequest, options?: TransportRequestOptions): Promise<T.ClusterRerouteResponse>
@@ -479,10 +401,6 @@ export default class Cluster {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns a comprehensive information about the state of the cluster.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cluster-state.html | Elasticsearch API documentation}
-    */
   async state (this: That, params?: T.ClusterStateRequest | TB.ClusterStateRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.ClusterStateResponse>
   async state (this: That, params?: T.ClusterStateRequest | TB.ClusterStateRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.ClusterStateResponse, unknown>>
   async state (this: That, params?: T.ClusterStateRequest | TB.ClusterStateRequest, options?: TransportRequestOptions): Promise<T.ClusterStateResponse>
@@ -516,10 +434,6 @@ export default class Cluster {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns high-level overview of cluster statistics.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/cluster-stats.html | Elasticsearch API documentation}
-    */
   async stats (this: That, params?: T.ClusterStatsRequest | TB.ClusterStatsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.ClusterStatsResponse>
   async stats (this: That, params?: T.ClusterStatsRequest | TB.ClusterStatsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.ClusterStatsResponse, unknown>>
   async stats (this: That, params?: T.ClusterStatsRequest | TB.ClusterStatsRequest, options?: TransportRequestOptions): Promise<T.ClusterStatsResponse>

src/api/api/count.ts

@@ -37,10 +37,6 @@ import * as T from '../types'
 import * as TB from '../typesWithBodyKey'
 interface That { transport: Transport }
 
-/**
-  * Returns number of documents matching a query.
-  * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/search-count.html | Elasticsearch API documentation}
-  */
 export default async function CountApi (this: That, params?: T.CountRequest | TB.CountRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CountResponse>
 export default async function CountApi (this: That, params?: T.CountRequest | TB.CountRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CountResponse, unknown>>
 export default async function CountApi (this: That, params?: T.CountRequest | TB.CountRequest, options?: TransportRequestOptions): Promise<T.CountResponse>

src/api/api/create.ts

@@ -37,10 +37,6 @@ import * as T from '../types'
 import * as TB from '../typesWithBodyKey'
 interface That { transport: Transport }
 
-/**
-  * Creates a new document in the index. Returns a 409 response when a document with a same ID already exists in the index.
-  * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/docs-index_.html | Elasticsearch API documentation}
-  */
 export default async function CreateApi<TDocument = unknown> (this: That, params: T.CreateRequest<TDocument> | TB.CreateRequest<TDocument>, options?: TransportRequestOptionsWithOutMeta): Promise<T.CreateResponse>
 export default async function CreateApi<TDocument = unknown> (this: That, params: T.CreateRequest<TDocument> | TB.CreateRequest<TDocument>, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CreateResponse, unknown>>
 export default async function CreateApi<TDocument = unknown> (this: That, params: T.CreateRequest<TDocument> | TB.CreateRequest<TDocument>, options?: TransportRequestOptions): Promise<T.CreateResponse>

src/api/api/dangling_indices.ts

@@ -43,10 +43,6 @@ export default class DanglingIndices {
     this.transport = transport
   }
 
-  /**
-    * Deletes the specified dangling index
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/modules-gateway-dangling-indices.html | Elasticsearch API documentation}
-    */
   async deleteDanglingIndex (this: That, params: T.DanglingIndicesDeleteDanglingIndexRequest | TB.DanglingIndicesDeleteDanglingIndexRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.DanglingIndicesDeleteDanglingIndexResponse>
   async deleteDanglingIndex (this: That, params: T.DanglingIndicesDeleteDanglingIndexRequest | TB.DanglingIndicesDeleteDanglingIndexRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.DanglingIndicesDeleteDanglingIndexResponse, unknown>>
   async deleteDanglingIndex (this: That, params: T.DanglingIndicesDeleteDanglingIndexRequest | TB.DanglingIndicesDeleteDanglingIndexRequest, options?: TransportRequestOptions): Promise<T.DanglingIndicesDeleteDanglingIndexResponse>
@@ -69,10 +65,6 @@ export default class DanglingIndices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Imports the specified dangling index
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/modules-gateway-dangling-indices.html | Elasticsearch API documentation}
-    */
   async importDanglingIndex (this: That, params: T.DanglingIndicesImportDanglingIndexRequest | TB.DanglingIndicesImportDanglingIndexRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.DanglingIndicesImportDanglingIndexResponse>
   async importDanglingIndex (this: That, params: T.DanglingIndicesImportDanglingIndexRequest | TB.DanglingIndicesImportDanglingIndexRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.DanglingIndicesImportDanglingIndexResponse, unknown>>
   async importDanglingIndex (this: That, params: T.DanglingIndicesImportDanglingIndexRequest | TB.DanglingIndicesImportDanglingIndexRequest, options?: TransportRequestOptions): Promise<T.DanglingIndicesImportDanglingIndexResponse>
@@ -95,10 +87,6 @@ export default class DanglingIndices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns all dangling indices.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/modules-gateway-dangling-indices.html | Elasticsearch API documentation}
-    */
   async listDanglingIndices (this: That, params?: T.DanglingIndicesListDanglingIndicesRequest | TB.DanglingIndicesListDanglingIndicesRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.DanglingIndicesListDanglingIndicesResponse>
   async listDanglingIndices (this: That, params?: T.DanglingIndicesListDanglingIndicesRequest | TB.DanglingIndicesListDanglingIndicesRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.DanglingIndicesListDanglingIndicesResponse, unknown>>
   async listDanglingIndices (this: That, params?: T.DanglingIndicesListDanglingIndicesRequest | TB.DanglingIndicesListDanglingIndicesRequest, options?: TransportRequestOptions): Promise<T.DanglingIndicesListDanglingIndicesResponse>

src/api/api/delete.ts

@@ -37,10 +37,6 @@ import * as T from '../types'
 import * as TB from '../typesWithBodyKey'
 interface That { transport: Transport }
 
-/**
-  * Removes a document from the index.
-  * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/docs-delete.html | Elasticsearch API documentation}
-  */
 export default async function DeleteApi (this: That, params: T.DeleteRequest | TB.DeleteRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.DeleteResponse>
 export default async function DeleteApi (this: That, params: T.DeleteRequest | TB.DeleteRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.DeleteResponse, unknown>>
 export default async function DeleteApi (this: That, params: T.DeleteRequest | TB.DeleteRequest, options?: TransportRequestOptions): Promise<T.DeleteResponse>

src/api/api/delete_by_query.ts

@@ -37,10 +37,6 @@ import * as T from '../types'
 import * as TB from '../typesWithBodyKey'
 interface That { transport: Transport }
 
-/**
-  * Deletes documents matching the provided query.
-  * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/docs-delete-by-query.html | Elasticsearch API documentation}
-  */
 export default async function DeleteByQueryApi (this: That, params: T.DeleteByQueryRequest | TB.DeleteByQueryRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.DeleteByQueryResponse>
 export default async function DeleteByQueryApi (this: That, params: T.DeleteByQueryRequest | TB.DeleteByQueryRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.DeleteByQueryResponse, unknown>>
 export default async function DeleteByQueryApi (this: That, params: T.DeleteByQueryRequest | TB.DeleteByQueryRequest, options?: TransportRequestOptions): Promise<T.DeleteByQueryResponse>

src/api/api/delete_by_query_rethrottle.ts

@@ -37,10 +37,6 @@ import * as T from '../types'
 import * as TB from '../typesWithBodyKey'
 interface That { transport: Transport }
 
-/**
-  * Changes the number of requests per second for a particular Delete By Query operation.
-  * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/docs-delete-by-query.html | Elasticsearch API documentation}
-  */
 export default async function DeleteByQueryRethrottleApi (this: That, params: T.DeleteByQueryRethrottleRequest | TB.DeleteByQueryRethrottleRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.DeleteByQueryRethrottleResponse>
 export default async function DeleteByQueryRethrottleApi (this: That, params: T.DeleteByQueryRethrottleRequest | TB.DeleteByQueryRethrottleRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.DeleteByQueryRethrottleResponse, unknown>>
 export default async function DeleteByQueryRethrottleApi (this: That, params: T.DeleteByQueryRethrottleRequest | TB.DeleteByQueryRethrottleRequest, options?: TransportRequestOptions): Promise<T.DeleteByQueryRethrottleResponse>

src/api/api/delete_script.ts

@@ -37,10 +37,6 @@ import * as T from '../types'
 import * as TB from '../typesWithBodyKey'
 interface That { transport: Transport }
 
-/**
-  * Deletes a script.
-  * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/modules-scripting.html | Elasticsearch API documentation}
-  */
 export default async function DeleteScriptApi (this: That, params: T.DeleteScriptRequest | TB.DeleteScriptRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.DeleteScriptResponse>
 export default async function DeleteScriptApi (this: That, params: T.DeleteScriptRequest | TB.DeleteScriptRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.DeleteScriptResponse, unknown>>
 export default async function DeleteScriptApi (this: That, params: T.DeleteScriptRequest | TB.DeleteScriptRequest, options?: TransportRequestOptions): Promise<T.DeleteScriptResponse>

src/api/api/enrich.ts

@@ -43,10 +43,6 @@ export default class Enrich {
     this.transport = transport
   }
 
-  /**
-    * Deletes an existing enrich policy and its enrich index.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/delete-enrich-policy-api.html | Elasticsearch API documentation}
-    */
   async deletePolicy (this: That, params: T.EnrichDeletePolicyRequest | TB.EnrichDeletePolicyRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.EnrichDeletePolicyResponse>
   async deletePolicy (this: That, params: T.EnrichDeletePolicyRequest | TB.EnrichDeletePolicyRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.EnrichDeletePolicyResponse, unknown>>
   async deletePolicy (this: That, params: T.EnrichDeletePolicyRequest | TB.EnrichDeletePolicyRequest, options?: TransportRequestOptions): Promise<T.EnrichDeletePolicyResponse>
@@ -69,10 +65,6 @@ export default class Enrich {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Creates the enrich index for an existing enrich policy.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/execute-enrich-policy-api.html | Elasticsearch API documentation}
-    */
   async executePolicy (this: That, params: T.EnrichExecutePolicyRequest | TB.EnrichExecutePolicyRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.EnrichExecutePolicyResponse>
   async executePolicy (this: That, params: T.EnrichExecutePolicyRequest | TB.EnrichExecutePolicyRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.EnrichExecutePolicyResponse, unknown>>
   async executePolicy (this: That, params: T.EnrichExecutePolicyRequest | TB.EnrichExecutePolicyRequest, options?: TransportRequestOptions): Promise<T.EnrichExecutePolicyResponse>
@@ -95,10 +87,6 @@ export default class Enrich {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Gets information about an enrich policy.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/get-enrich-policy-api.html | Elasticsearch API documentation}
-    */
   async getPolicy (this: That, params?: T.EnrichGetPolicyRequest | TB.EnrichGetPolicyRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.EnrichGetPolicyResponse>
   async getPolicy (this: That, params?: T.EnrichGetPolicyRequest | TB.EnrichGetPolicyRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.EnrichGetPolicyResponse, unknown>>
   async getPolicy (this: That, params?: T.EnrichGetPolicyRequest | TB.EnrichGetPolicyRequest, options?: TransportRequestOptions): Promise<T.EnrichGetPolicyResponse>
@@ -129,10 +117,6 @@ export default class Enrich {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Creates a new enrich policy.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/put-enrich-policy-api.html | Elasticsearch API documentation}
-    */
   async putPolicy (this: That, params: T.EnrichPutPolicyRequest | TB.EnrichPutPolicyRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.EnrichPutPolicyResponse>
   async putPolicy (this: That, params: T.EnrichPutPolicyRequest | TB.EnrichPutPolicyRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.EnrichPutPolicyResponse, unknown>>
   async putPolicy (this: That, params: T.EnrichPutPolicyRequest | TB.EnrichPutPolicyRequest, options?: TransportRequestOptions): Promise<T.EnrichPutPolicyResponse>
@@ -167,10 +151,6 @@ export default class Enrich {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Gets enrich coordinator statistics and information about enrich policies that are currently executing.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/enrich-stats-api.html | Elasticsearch API documentation}
-    */
   async stats (this: That, params?: T.EnrichStatsRequest | TB.EnrichStatsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.EnrichStatsResponse>
   async stats (this: That, params?: T.EnrichStatsRequest | TB.EnrichStatsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.EnrichStatsResponse, unknown>>
   async stats (this: That, params?: T.EnrichStatsRequest | TB.EnrichStatsRequest, options?: TransportRequestOptions): Promise<T.EnrichStatsResponse>

src/api/api/eql.ts

@@ -43,10 +43,6 @@ export default class Eql {
     this.transport = transport
   }
 
-  /**
-    * Deletes an async EQL search by ID. If the search is still running, the search request will be cancelled. Otherwise, the saved search results are deleted.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/eql-search-api.html | Elasticsearch API documentation}
-    */
   async delete (this: That, params: T.EqlDeleteRequest | TB.EqlDeleteRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.EqlDeleteResponse>
   async delete (this: That, params: T.EqlDeleteRequest | TB.EqlDeleteRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.EqlDeleteResponse, unknown>>
   async delete (this: That, params: T.EqlDeleteRequest | TB.EqlDeleteRequest, options?: TransportRequestOptions): Promise<T.EqlDeleteResponse>
@@ -69,10 +65,6 @@ export default class Eql {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns async results from previously executed Event Query Language (EQL) search
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/get-async-eql-search-api.html | Elasticsearch API documentation}
-    */
   async get<TEvent = unknown> (this: That, params: T.EqlGetRequest | TB.EqlGetRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.EqlGetResponse<TEvent>>
   async get<TEvent = unknown> (this: That, params: T.EqlGetRequest | TB.EqlGetRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.EqlGetResponse<TEvent>, unknown>>
   async get<TEvent = unknown> (this: That, params: T.EqlGetRequest | TB.EqlGetRequest, options?: TransportRequestOptions): Promise<T.EqlGetResponse<TEvent>>
@@ -95,10 +87,6 @@ export default class Eql {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns the status of a previously submitted async or stored Event Query Language (EQL) search
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/get-async-eql-status-api.html | Elasticsearch API documentation}
-    */
   async getStatus (this: That, params: T.EqlGetStatusRequest | TB.EqlGetStatusRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.EqlGetStatusResponse>
   async getStatus (this: That, params: T.EqlGetStatusRequest | TB.EqlGetStatusRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.EqlGetStatusResponse, unknown>>
   async getStatus (this: That, params: T.EqlGetStatusRequest | TB.EqlGetStatusRequest, options?: TransportRequestOptions): Promise<T.EqlGetStatusResponse>
@@ -121,10 +109,6 @@ export default class Eql {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns results matching a query expressed in Event Query Language (EQL)
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/eql-search-api.html | Elasticsearch API documentation}
-    */
   async search<TEvent = unknown> (this: That, params: T.EqlSearchRequest | TB.EqlSearchRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.EqlSearchResponse<TEvent>>
   async search<TEvent = unknown> (this: That, params: T.EqlSearchRequest | TB.EqlSearchRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.EqlSearchResponse<TEvent>, unknown>>
   async search<TEvent = unknown> (this: That, params: T.EqlSearchRequest | TB.EqlSearchRequest, options?: TransportRequestOptions): Promise<T.EqlSearchResponse<TEvent>>

src/api/api/esql.ts

@@ -1,83 +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.
- */
-
-/* eslint-disable import/export */
-/* eslint-disable @typescript-eslint/no-misused-new */
-/* eslint-disable @typescript-eslint/no-extraneous-class */
-/* eslint-disable @typescript-eslint/no-unused-vars */
-
-// This file was automatically generated by elastic/elastic-client-generator-js
-// DO NOT MODIFY IT BY HAND. Instead, modify the source open api file,
-// and elastic/elastic-client-generator-js to regenerate this file again.
-
-import {
-  Transport,
-  TransportRequestOptions,
-  TransportRequestOptionsWithMeta,
-  TransportRequestOptionsWithOutMeta,
-  TransportResult
-} from '@elastic/transport'
-import * as T from '../types'
-import * as TB from '../typesWithBodyKey'
-interface That { transport: Transport }
-
-export default class Esql {
-  transport: Transport
-  constructor (transport: Transport) {
-    this.transport = transport
-  }
-
-  /**
-    * Executes an ESQL request
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/esql-rest.html | Elasticsearch API documentation}
-    */
-  async query (this: That, params: T.EsqlQueryRequest | TB.EsqlQueryRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.EsqlQueryResponse>
-  async query (this: That, params: T.EsqlQueryRequest | TB.EsqlQueryRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.EsqlQueryResponse, unknown>>
-  async query (this: That, params: T.EsqlQueryRequest | TB.EsqlQueryRequest, options?: TransportRequestOptions): Promise<T.EsqlQueryResponse>
-  async query (this: That, params: T.EsqlQueryRequest | TB.EsqlQueryRequest, options?: TransportRequestOptions): Promise<any> {
-    const acceptedPath: string[] = []
-    const acceptedBody: string[] = ['columnar', 'filter', 'locale', 'params', 'query']
-    const querystring: Record<string, any> = {}
-    // @ts-expect-error
-    const userBody: any = params?.body
-    let body: Record<string, any> | string
-    if (typeof userBody === 'string') {
-      body = userBody
-    } else {
-      body = userBody != null ? { ...userBody } : undefined
-    }
-
-    for (const key in params) {
-      if (acceptedBody.includes(key)) {
-        body = body ?? {}
-        // @ts-expect-error
-        body[key] = params[key]
-      } else if (acceptedPath.includes(key)) {
-        continue
-      } else if (key !== 'body') {
-        // @ts-expect-error
-        querystring[key] = params[key]
-      }
-    }
-
-    const method = 'POST'
-    const path = '/_query'
-    return await this.transport.request({ path, method, querystring, body }, options)
-  }
-}

src/api/api/exists.ts

@@ -37,10 +37,6 @@ import * as T from '../types'
 import * as TB from '../typesWithBodyKey'
 interface That { transport: Transport }
 
-/**
-  * Returns information about whether a document exists in an index.
-  * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/docs-get.html | Elasticsearch API documentation}
-  */
 export default async function ExistsApi (this: That, params: T.ExistsRequest | TB.ExistsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.ExistsResponse>
 export default async function ExistsApi (this: That, params: T.ExistsRequest | TB.ExistsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.ExistsResponse, unknown>>
 export default async function ExistsApi (this: That, params: T.ExistsRequest | TB.ExistsRequest, options?: TransportRequestOptions): Promise<T.ExistsResponse>

src/api/api/exists_source.ts

@@ -37,10 +37,6 @@ import * as T from '../types'
 import * as TB from '../typesWithBodyKey'
 interface That { transport: Transport }
 
-/**
-  * Returns information about whether a document source exists in an index.
-  * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/docs-get.html | Elasticsearch API documentation}
-  */
 export default async function ExistsSourceApi (this: That, params: T.ExistsSourceRequest | TB.ExistsSourceRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.ExistsSourceResponse>
 export default async function ExistsSourceApi (this: That, params: T.ExistsSourceRequest | TB.ExistsSourceRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.ExistsSourceResponse, unknown>>
 export default async function ExistsSourceApi (this: That, params: T.ExistsSourceRequest | TB.ExistsSourceRequest, options?: TransportRequestOptions): Promise<T.ExistsSourceResponse>

src/api/api/explain.ts

@@ -37,10 +37,6 @@ import * as T from '../types'
 import * as TB from '../typesWithBodyKey'
 interface That { transport: Transport }
 
-/**
-  * Returns information about why a specific matches (or doesn't match) a query.
-  * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/search-explain.html | Elasticsearch API documentation}
-  */
 export default async function ExplainApi<TDocument = unknown> (this: That, params: T.ExplainRequest | TB.ExplainRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.ExplainResponse<TDocument>>
 export default async function ExplainApi<TDocument = unknown> (this: That, params: T.ExplainRequest | TB.ExplainRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.ExplainResponse<TDocument>, unknown>>
 export default async function ExplainApi<TDocument = unknown> (this: That, params: T.ExplainRequest | TB.ExplainRequest, options?: TransportRequestOptions): Promise<T.ExplainResponse<TDocument>>

src/api/api/features.ts

@@ -43,10 +43,6 @@ export default class Features {
     this.transport = transport
   }
 
-  /**
-    * Gets a list of features which can be included in snapshots using the feature_states field when creating a snapshot
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/get-features-api.html | Elasticsearch API documentation}
-    */
   async getFeatures (this: That, params?: T.FeaturesGetFeaturesRequest | TB.FeaturesGetFeaturesRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.FeaturesGetFeaturesResponse>
   async getFeatures (this: That, params?: T.FeaturesGetFeaturesRequest | TB.FeaturesGetFeaturesRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.FeaturesGetFeaturesResponse, unknown>>
   async getFeatures (this: That, params?: T.FeaturesGetFeaturesRequest | TB.FeaturesGetFeaturesRequest, options?: TransportRequestOptions): Promise<T.FeaturesGetFeaturesResponse>
@@ -70,10 +66,6 @@ export default class Features {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Resets the internal state of features, usually by deleting system indices
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/modules-snapshots.html | Elasticsearch API documentation}
-    */
   async resetFeatures (this: That, params?: T.FeaturesResetFeaturesRequest | TB.FeaturesResetFeaturesRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.FeaturesResetFeaturesResponse>
   async resetFeatures (this: That, params?: T.FeaturesResetFeaturesRequest | TB.FeaturesResetFeaturesRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.FeaturesResetFeaturesResponse, unknown>>
   async resetFeatures (this: That, params?: T.FeaturesResetFeaturesRequest | TB.FeaturesResetFeaturesRequest, options?: TransportRequestOptions): Promise<T.FeaturesResetFeaturesResponse>

src/api/api/field_caps.ts

@@ -37,16 +37,12 @@ import * as T from '../types'
 import * as TB from '../typesWithBodyKey'
 interface That { transport: Transport }
 
-/**
-  * Returns the information about the capabilities of fields among multiple indices.
-  * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/search-field-caps.html | Elasticsearch API documentation}
-  */
-export default async function FieldCapsApi (this: That, params?: T.FieldCapsRequest | TB.FieldCapsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.FieldCapsResponse>
-export default async function FieldCapsApi (this: That, params?: T.FieldCapsRequest | TB.FieldCapsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.FieldCapsResponse, unknown>>
-export default async function FieldCapsApi (this: That, params?: T.FieldCapsRequest | TB.FieldCapsRequest, options?: TransportRequestOptions): Promise<T.FieldCapsResponse>
-export default async function FieldCapsApi (this: That, params?: T.FieldCapsRequest | TB.FieldCapsRequest, options?: TransportRequestOptions): Promise<any> {
+export default async function FieldCapsApi (this: That, params: T.FieldCapsRequest | TB.FieldCapsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.FieldCapsResponse>
+export default async function FieldCapsApi (this: That, params: T.FieldCapsRequest | TB.FieldCapsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.FieldCapsResponse, unknown>>
+export default async function FieldCapsApi (this: That, params: T.FieldCapsRequest | TB.FieldCapsRequest, options?: TransportRequestOptions): Promise<T.FieldCapsResponse>
+export default async function FieldCapsApi (this: That, params: T.FieldCapsRequest | TB.FieldCapsRequest, options?: TransportRequestOptions): Promise<any> {
   const acceptedPath: string[] = ['index']
-  const acceptedBody: string[] = ['fields', 'index_filter', 'runtime_mappings']
+  const acceptedBody: string[] = ['index_filter', 'runtime_mappings']
   const querystring: Record<string, any> = {}
   // @ts-expect-error
   const userBody: any = params?.body
@@ -57,7 +53,6 @@ export default async function FieldCapsApi (this: That, params?: T.FieldCapsRequ
     body = userBody != null ? { ...userBody } : undefined
   }
 
-  params = params ?? {}
   for (const key in params) {
     if (acceptedBody.includes(key)) {
       body = body ?? {}

src/api/api/fleet.ts

@@ -43,60 +43,6 @@ export default class Fleet {
     this.transport = transport
   }
 
-  /**
-    * Deletes a secret stored by Fleet.
-    */
-  async deleteSecret (this: That, params?: T.TODO | TB.TODO, options?: TransportRequestOptionsWithOutMeta): Promise<T.TODO>
-  async deleteSecret (this: That, params?: T.TODO | TB.TODO, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.TODO, unknown>>
-  async deleteSecret (this: That, params?: T.TODO | TB.TODO, options?: TransportRequestOptions): Promise<T.TODO>
-  async deleteSecret (this: That, params?: T.TODO | TB.TODO, options?: TransportRequestOptions): Promise<any> {
-    const acceptedPath: string[] = ['id']
-    const querystring: Record<string, any> = {}
-    const body = undefined
-
-    params = params ?? {}
-    for (const key in params) {
-      if (acceptedPath.includes(key)) {
-        continue
-      } else if (key !== 'body') {
-        querystring[key] = params[key]
-      }
-    }
-
-    const method = 'DELETE'
-    const path = `/_fleet/secret/${encodeURIComponent(params.id.toString())}`
-    return await this.transport.request({ path, method, querystring, body }, options)
-  }
-
-  /**
-    * Retrieves a secret stored by Fleet.
-    */
-  async getSecret (this: That, params?: T.TODO | TB.TODO, options?: TransportRequestOptionsWithOutMeta): Promise<T.TODO>
-  async getSecret (this: That, params?: T.TODO | TB.TODO, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.TODO, unknown>>
-  async getSecret (this: That, params?: T.TODO | TB.TODO, options?: TransportRequestOptions): Promise<T.TODO>
-  async getSecret (this: That, params?: T.TODO | TB.TODO, options?: TransportRequestOptions): Promise<any> {
-    const acceptedPath: string[] = ['id']
-    const querystring: Record<string, any> = {}
-    const body = undefined
-
-    params = params ?? {}
-    for (const key in params) {
-      if (acceptedPath.includes(key)) {
-        continue
-      } else if (key !== 'body') {
-        querystring[key] = params[key]
-      }
-    }
-
-    const method = 'GET'
-    const path = `/_fleet/secret/${encodeURIComponent(params.id.toString())}`
-    return await this.transport.request({ path, method, querystring, body }, options)
-  }
-
-  /**
-    * Returns the current global checkpoints for an index. This API is design for internal use by the fleet server project.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/get-global-checkpoints.html | Elasticsearch API documentation}
-    */
   async globalCheckpoints (this: That, params: T.FleetGlobalCheckpointsRequest | TB.FleetGlobalCheckpointsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.FleetGlobalCheckpointsResponse>
   async globalCheckpoints (this: That, params: T.FleetGlobalCheckpointsRequest | TB.FleetGlobalCheckpointsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.FleetGlobalCheckpointsResponse, unknown>>
   async globalCheckpoints (this: That, params: T.FleetGlobalCheckpointsRequest | TB.FleetGlobalCheckpointsRequest, options?: TransportRequestOptions): Promise<T.FleetGlobalCheckpointsResponse>
@@ -119,9 +65,6 @@ export default class Fleet {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Multi Search API where the search will only be executed after specified checkpoints are available due to a refresh. This API is designed for internal use by the fleet server project.
-    */
   async msearch<TDocument = unknown> (this: That, params: T.FleetMsearchRequest | TB.FleetMsearchRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.FleetMsearchResponse<TDocument>>
   async msearch<TDocument = unknown> (this: That, params: T.FleetMsearchRequest | TB.FleetMsearchRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.FleetMsearchResponse<TDocument>, unknown>>
   async msearch<TDocument = unknown> (this: That, params: T.FleetMsearchRequest | TB.FleetMsearchRequest, options?: TransportRequestOptions): Promise<T.FleetMsearchResponse<TDocument>>
@@ -156,34 +99,6 @@ export default class Fleet {
     return await this.transport.request({ path, method, querystring, bulkBody: body }, options)
   }
 
-  /**
-    * Creates a secret stored by Fleet.
-    */
-  async postSecret (this: That, params?: T.TODO | TB.TODO, options?: TransportRequestOptionsWithOutMeta): Promise<T.TODO>
-  async postSecret (this: That, params?: T.TODO | TB.TODO, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.TODO, unknown>>
-  async postSecret (this: That, params?: T.TODO | TB.TODO, options?: TransportRequestOptions): Promise<T.TODO>
-  async postSecret (this: That, params?: T.TODO | TB.TODO, options?: TransportRequestOptions): Promise<any> {
-    const acceptedPath: string[] = []
-    const querystring: Record<string, any> = {}
-    const body = undefined
-
-    params = params ?? {}
-    for (const key in params) {
-      if (acceptedPath.includes(key)) {
-        continue
-      } else if (key !== 'body') {
-        querystring[key] = params[key]
-      }
-    }
-
-    const method = 'POST'
-    const path = '/_fleet/secret'
-    return await this.transport.request({ path, method, querystring, body }, options)
-  }
-
-  /**
-    * Search API where the search will only be executed after specified checkpoints are available due to a refresh. This API is designed for internal use by the fleet server project.
-    */
   async search<TDocument = unknown> (this: That, params: T.FleetSearchRequest | TB.FleetSearchRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.FleetSearchResponse<TDocument>>
   async search<TDocument = unknown> (this: That, params: T.FleetSearchRequest | TB.FleetSearchRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.FleetSearchResponse<TDocument>, unknown>>
   async search<TDocument = unknown> (this: That, params: T.FleetSearchRequest | TB.FleetSearchRequest, options?: TransportRequestOptions): Promise<T.FleetSearchResponse<TDocument>>

src/api/api/get.ts

@@ -37,10 +37,6 @@ import * as T from '../types'
 import * as TB from '../typesWithBodyKey'
 interface That { transport: Transport }
 
-/**
-  * Returns a document.
-  * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/docs-get.html | Elasticsearch API documentation}
-  */
 export default async function GetApi<TDocument = unknown> (this: That, params: T.GetRequest | TB.GetRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.GetResponse<TDocument>>
 export default async function GetApi<TDocument = unknown> (this: That, params: T.GetRequest | TB.GetRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.GetResponse<TDocument>, unknown>>
 export default async function GetApi<TDocument = unknown> (this: That, params: T.GetRequest | TB.GetRequest, options?: TransportRequestOptions): Promise<T.GetResponse<TDocument>>

src/api/api/get_script.ts

@@ -37,10 +37,6 @@ import * as T from '../types'
 import * as TB from '../typesWithBodyKey'
 interface That { transport: Transport }
 
-/**
-  * Returns a script.
-  * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/modules-scripting.html | Elasticsearch API documentation}
-  */
 export default async function GetScriptApi (this: That, params: T.GetScriptRequest | TB.GetScriptRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.GetScriptResponse>
 export default async function GetScriptApi (this: That, params: T.GetScriptRequest | TB.GetScriptRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.GetScriptResponse, unknown>>
 export default async function GetScriptApi (this: That, params: T.GetScriptRequest | TB.GetScriptRequest, options?: TransportRequestOptions): Promise<T.GetScriptResponse>

src/api/api/get_script_context.ts

@@ -37,10 +37,6 @@ import * as T from '../types'
 import * as TB from '../typesWithBodyKey'
 interface That { transport: Transport }
 
-/**
-  * Returns all script contexts.
-  * @see {@link https://www.elastic.co/guide/en/elasticsearch/painless/8.12/painless-contexts.html | Elasticsearch API documentation}
-  */
 export default async function GetScriptContextApi (this: That, params?: T.GetScriptContextRequest | TB.GetScriptContextRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.GetScriptContextResponse>
 export default async function GetScriptContextApi (this: That, params?: T.GetScriptContextRequest | TB.GetScriptContextRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.GetScriptContextResponse, unknown>>
 export default async function GetScriptContextApi (this: That, params?: T.GetScriptContextRequest | TB.GetScriptContextRequest, options?: TransportRequestOptions): Promise<T.GetScriptContextResponse>

src/api/api/get_script_languages.ts

@@ -37,10 +37,6 @@ import * as T from '../types'
 import * as TB from '../typesWithBodyKey'
 interface That { transport: Transport }
 
-/**
-  * Returns available script types, languages and contexts
-  * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/modules-scripting.html | Elasticsearch API documentation}
-  */
 export default async function GetScriptLanguagesApi (this: That, params?: T.GetScriptLanguagesRequest | TB.GetScriptLanguagesRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.GetScriptLanguagesResponse>
 export default async function GetScriptLanguagesApi (this: That, params?: T.GetScriptLanguagesRequest | TB.GetScriptLanguagesRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.GetScriptLanguagesResponse, unknown>>
 export default async function GetScriptLanguagesApi (this: That, params?: T.GetScriptLanguagesRequest | TB.GetScriptLanguagesRequest, options?: TransportRequestOptions): Promise<T.GetScriptLanguagesResponse>

src/api/api/get_source.ts

@@ -37,10 +37,6 @@ import * as T from '../types'
 import * as TB from '../typesWithBodyKey'
 interface That { transport: Transport }
 
-/**
-  * Returns the source of a document.
-  * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/docs-get.html | Elasticsearch API documentation}
-  */
 export default async function GetSourceApi<TDocument = unknown> (this: That, params: T.GetSourceRequest | TB.GetSourceRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.GetSourceResponse<TDocument>>
 export default async function GetSourceApi<TDocument = unknown> (this: That, params: T.GetSourceRequest | TB.GetSourceRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.GetSourceResponse<TDocument>, unknown>>
 export default async function GetSourceApi<TDocument = unknown> (this: That, params: T.GetSourceRequest | TB.GetSourceRequest, options?: TransportRequestOptions): Promise<T.GetSourceResponse<TDocument>>

src/api/api/graph.ts

@@ -43,10 +43,6 @@ export default class Graph {
     this.transport = transport
   }
 
-  /**
-    * Explore extracted and summarized information about the documents and terms in an index.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/graph-explore-api.html | Elasticsearch API documentation}
-    */
   async explore (this: That, params: T.GraphExploreRequest | TB.GraphExploreRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.GraphExploreResponse>
   async explore (this: That, params: T.GraphExploreRequest | TB.GraphExploreRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.GraphExploreResponse, unknown>>
   async explore (this: That, params: T.GraphExploreRequest | TB.GraphExploreRequest, options?: TransportRequestOptions): Promise<T.GraphExploreResponse>

src/api/api/health_report.ts

@@ -1,72 +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.
- */
-
-/* eslint-disable import/export */
-/* eslint-disable @typescript-eslint/no-misused-new */
-/* eslint-disable @typescript-eslint/no-extraneous-class */
-/* eslint-disable @typescript-eslint/no-unused-vars */
-
-// This file was automatically generated by elastic/elastic-client-generator-js
-// DO NOT MODIFY IT BY HAND. Instead, modify the source open api file,
-// and elastic/elastic-client-generator-js to regenerate this file again.
-
-import {
-  Transport,
-  TransportRequestOptions,
-  TransportRequestOptionsWithMeta,
-  TransportRequestOptionsWithOutMeta,
-  TransportResult
-} from '@elastic/transport'
-import * as T from '../types'
-import * as TB from '../typesWithBodyKey'
-interface That { transport: Transport }
-
-/**
-  * Returns the health of the cluster.
-  * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/health-api.html | Elasticsearch API documentation}
-  */
-export default async function HealthReportApi (this: That, params?: T.HealthReportRequest | TB.HealthReportRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.HealthReportResponse>
-export default async function HealthReportApi (this: That, params?: T.HealthReportRequest | TB.HealthReportRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.HealthReportResponse, unknown>>
-export default async function HealthReportApi (this: That, params?: T.HealthReportRequest | TB.HealthReportRequest, options?: TransportRequestOptions): Promise<T.HealthReportResponse>
-export default async function HealthReportApi (this: That, params?: T.HealthReportRequest | TB.HealthReportRequest, options?: TransportRequestOptions): Promise<any> {
-  const acceptedPath: string[] = ['feature']
-  const querystring: Record<string, any> = {}
-  const body = undefined
-
-  params = params ?? {}
-  for (const key in params) {
-    if (acceptedPath.includes(key)) {
-      continue
-    } else if (key !== 'body') {
-      // @ts-expect-error
-      querystring[key] = params[key]
-    }
-  }
-
-  let method = ''
-  let path = ''
-  if (params.feature != null) {
-    method = 'GET'
-    path = `/_health_report/${encodeURIComponent(params.feature.toString())}`
-  } else {
-    method = 'GET'
-    path = '/_health_report'
-  }
-  return await this.transport.request({ path, method, querystring, body }, options)
-}

src/api/api/ilm.ts

@@ -43,10 +43,6 @@ export default class Ilm {
     this.transport = transport
   }
 
-  /**
-    * Deletes the specified lifecycle policy definition. A currently used policy cannot be deleted.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/ilm-delete-lifecycle.html | Elasticsearch API documentation}
-    */
   async deleteLifecycle (this: That, params: T.IlmDeleteLifecycleRequest | TB.IlmDeleteLifecycleRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IlmDeleteLifecycleResponse>
   async deleteLifecycle (this: That, params: T.IlmDeleteLifecycleRequest | TB.IlmDeleteLifecycleRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IlmDeleteLifecycleResponse, unknown>>
   async deleteLifecycle (this: That, params: T.IlmDeleteLifecycleRequest | TB.IlmDeleteLifecycleRequest, options?: TransportRequestOptions): Promise<T.IlmDeleteLifecycleResponse>
@@ -69,10 +65,6 @@ export default class Ilm {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Retrieves information about the index's current lifecycle state, such as the currently executing phase, action, and step.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/ilm-explain-lifecycle.html | Elasticsearch API documentation}
-    */
   async explainLifecycle (this: That, params: T.IlmExplainLifecycleRequest | TB.IlmExplainLifecycleRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IlmExplainLifecycleResponse>
   async explainLifecycle (this: That, params: T.IlmExplainLifecycleRequest | TB.IlmExplainLifecycleRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IlmExplainLifecycleResponse, unknown>>
   async explainLifecycle (this: That, params: T.IlmExplainLifecycleRequest | TB.IlmExplainLifecycleRequest, options?: TransportRequestOptions): Promise<T.IlmExplainLifecycleResponse>
@@ -95,10 +87,6 @@ export default class Ilm {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns the specified policy definition. Includes the policy version and last modified date.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/ilm-get-lifecycle.html | Elasticsearch API documentation}
-    */
   async getLifecycle (this: That, params?: T.IlmGetLifecycleRequest | TB.IlmGetLifecycleRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IlmGetLifecycleResponse>
   async getLifecycle (this: That, params?: T.IlmGetLifecycleRequest | TB.IlmGetLifecycleRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IlmGetLifecycleResponse, unknown>>
   async getLifecycle (this: That, params?: T.IlmGetLifecycleRequest | TB.IlmGetLifecycleRequest, options?: TransportRequestOptions): Promise<T.IlmGetLifecycleResponse>
@@ -129,10 +117,6 @@ export default class Ilm {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Retrieves the current index lifecycle management (ILM) status.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/ilm-get-status.html | Elasticsearch API documentation}
-    */
   async getStatus (this: That, params?: T.IlmGetStatusRequest | TB.IlmGetStatusRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IlmGetStatusResponse>
   async getStatus (this: That, params?: T.IlmGetStatusRequest | TB.IlmGetStatusRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IlmGetStatusResponse, unknown>>
   async getStatus (this: That, params?: T.IlmGetStatusRequest | TB.IlmGetStatusRequest, options?: TransportRequestOptions): Promise<T.IlmGetStatusResponse>
@@ -156,10 +140,6 @@ export default class Ilm {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Migrates the indices and ILM policies away from custom node attribute allocation routing to data tiers routing
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/ilm-migrate-to-data-tiers.html | Elasticsearch API documentation}
-    */
   async migrateToDataTiers (this: That, params?: T.IlmMigrateToDataTiersRequest | TB.IlmMigrateToDataTiersRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IlmMigrateToDataTiersResponse>
   async migrateToDataTiers (this: That, params?: T.IlmMigrateToDataTiersRequest | TB.IlmMigrateToDataTiersRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IlmMigrateToDataTiersResponse, unknown>>
   async migrateToDataTiers (this: That, params?: T.IlmMigrateToDataTiersRequest | TB.IlmMigrateToDataTiersRequest, options?: TransportRequestOptions): Promise<T.IlmMigrateToDataTiersResponse>
@@ -195,10 +175,6 @@ export default class Ilm {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Manually moves an index into the specified step and executes that step.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/ilm-move-to-step.html | Elasticsearch API documentation}
-    */
   async moveToStep (this: That, params: T.IlmMoveToStepRequest | TB.IlmMoveToStepRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IlmMoveToStepResponse>
   async moveToStep (this: That, params: T.IlmMoveToStepRequest | TB.IlmMoveToStepRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IlmMoveToStepResponse, unknown>>
   async moveToStep (this: That, params: T.IlmMoveToStepRequest | TB.IlmMoveToStepRequest, options?: TransportRequestOptions): Promise<T.IlmMoveToStepResponse>
@@ -233,10 +209,6 @@ export default class Ilm {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Creates a lifecycle policy
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/ilm-put-lifecycle.html | Elasticsearch API documentation}
-    */
   async putLifecycle (this: That, params: T.IlmPutLifecycleRequest | TB.IlmPutLifecycleRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IlmPutLifecycleResponse>
   async putLifecycle (this: That, params: T.IlmPutLifecycleRequest | TB.IlmPutLifecycleRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IlmPutLifecycleResponse, unknown>>
   async putLifecycle (this: That, params: T.IlmPutLifecycleRequest | TB.IlmPutLifecycleRequest, options?: TransportRequestOptions): Promise<T.IlmPutLifecycleResponse>
@@ -271,10 +243,6 @@ export default class Ilm {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Removes the assigned lifecycle policy and stops managing the specified index
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/ilm-remove-policy.html | Elasticsearch API documentation}
-    */
   async removePolicy (this: That, params: T.IlmRemovePolicyRequest | TB.IlmRemovePolicyRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IlmRemovePolicyResponse>
   async removePolicy (this: That, params: T.IlmRemovePolicyRequest | TB.IlmRemovePolicyRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IlmRemovePolicyResponse, unknown>>
   async removePolicy (this: That, params: T.IlmRemovePolicyRequest | TB.IlmRemovePolicyRequest, options?: TransportRequestOptions): Promise<T.IlmRemovePolicyResponse>
@@ -297,10 +265,6 @@ export default class Ilm {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Retries executing the policy for an index that is in the ERROR step.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/ilm-retry-policy.html | Elasticsearch API documentation}
-    */
   async retry (this: That, params: T.IlmRetryRequest | TB.IlmRetryRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IlmRetryResponse>
   async retry (this: That, params: T.IlmRetryRequest | TB.IlmRetryRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IlmRetryResponse, unknown>>
   async retry (this: That, params: T.IlmRetryRequest | TB.IlmRetryRequest, options?: TransportRequestOptions): Promise<T.IlmRetryResponse>
@@ -323,10 +287,6 @@ export default class Ilm {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Start the index lifecycle management (ILM) plugin.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/ilm-start.html | Elasticsearch API documentation}
-    */
   async start (this: That, params?: T.IlmStartRequest | TB.IlmStartRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IlmStartResponse>
   async start (this: That, params?: T.IlmStartRequest | TB.IlmStartRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IlmStartResponse, unknown>>
   async start (this: That, params?: T.IlmStartRequest | TB.IlmStartRequest, options?: TransportRequestOptions): Promise<T.IlmStartResponse>
@@ -350,10 +310,6 @@ export default class Ilm {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Halts all lifecycle management operations and stops the index lifecycle management (ILM) plugin
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/ilm-stop.html | Elasticsearch API documentation}
-    */
   async stop (this: That, params?: T.IlmStopRequest | TB.IlmStopRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IlmStopResponse>
   async stop (this: That, params?: T.IlmStopRequest | TB.IlmStopRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IlmStopResponse, unknown>>
   async stop (this: That, params?: T.IlmStopRequest | TB.IlmStopRequest, options?: TransportRequestOptions): Promise<T.IlmStopResponse>

src/api/api/index.ts

@@ -37,10 +37,6 @@ import * as T from '../types'
 import * as TB from '../typesWithBodyKey'
 interface That { transport: Transport }
 
-/**
-  * Creates or updates a document in an index.
-  * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/docs-index_.html | Elasticsearch API documentation}
-  */
 export default async function IndexApi<TDocument = unknown> (this: That, params: T.IndexRequest<TDocument> | TB.IndexRequest<TDocument>, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndexResponse>
 export default async function IndexApi<TDocument = unknown> (this: That, params: T.IndexRequest<TDocument> | TB.IndexRequest<TDocument>, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndexResponse, unknown>>
 export default async function IndexApi<TDocument = unknown> (this: That, params: T.IndexRequest<TDocument> | TB.IndexRequest<TDocument>, options?: TransportRequestOptions): Promise<T.IndexResponse>

src/api/api/indices.ts

@@ -43,10 +43,6 @@ export default class Indices {
     this.transport = transport
   }
 
-  /**
-    * Adds a block to an index.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/index-modules-blocks.html | Elasticsearch API documentation}
-    */
   async addBlock (this: That, params: T.IndicesAddBlockRequest | TB.IndicesAddBlockRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesAddBlockResponse>
   async addBlock (this: That, params: T.IndicesAddBlockRequest | TB.IndicesAddBlockRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesAddBlockResponse, unknown>>
   async addBlock (this: That, params: T.IndicesAddBlockRequest | TB.IndicesAddBlockRequest, options?: TransportRequestOptions): Promise<T.IndicesAddBlockResponse>
@@ -69,10 +65,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Performs the analysis process on a text and return the tokens breakdown of the text.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-analyze.html | Elasticsearch API documentation}
-    */
   async analyze (this: That, params?: T.IndicesAnalyzeRequest | TB.IndicesAnalyzeRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesAnalyzeResponse>
   async analyze (this: That, params?: T.IndicesAnalyzeRequest | TB.IndicesAnalyzeRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesAnalyzeResponse, unknown>>
   async analyze (this: That, params?: T.IndicesAnalyzeRequest | TB.IndicesAnalyzeRequest, options?: TransportRequestOptions): Promise<T.IndicesAnalyzeResponse>
@@ -115,10 +107,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Clears all or specific caches for one or more indices.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-clearcache.html | Elasticsearch API documentation}
-    */
   async clearCache (this: That, params?: T.IndicesClearCacheRequest | TB.IndicesClearCacheRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesClearCacheResponse>
   async clearCache (this: That, params?: T.IndicesClearCacheRequest | TB.IndicesClearCacheRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesClearCacheResponse, unknown>>
   async clearCache (this: That, params?: T.IndicesClearCacheRequest | TB.IndicesClearCacheRequest, options?: TransportRequestOptions): Promise<T.IndicesClearCacheResponse>
@@ -149,10 +137,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Clones an index
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-clone-index.html | Elasticsearch API documentation}
-    */
   async clone (this: That, params: T.IndicesCloneRequest | TB.IndicesCloneRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesCloneResponse>
   async clone (this: That, params: T.IndicesCloneRequest | TB.IndicesCloneRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesCloneResponse, unknown>>
   async clone (this: That, params: T.IndicesCloneRequest | TB.IndicesCloneRequest, options?: TransportRequestOptions): Promise<T.IndicesCloneResponse>
@@ -187,10 +171,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Closes an index.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-close.html | Elasticsearch API documentation}
-    */
   async close (this: That, params: T.IndicesCloseRequest | TB.IndicesCloseRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesCloseResponse>
   async close (this: That, params: T.IndicesCloseRequest | TB.IndicesCloseRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesCloseResponse, unknown>>
   async close (this: That, params: T.IndicesCloseRequest | TB.IndicesCloseRequest, options?: TransportRequestOptions): Promise<T.IndicesCloseResponse>
@@ -213,10 +193,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Creates an index with optional settings and mappings.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-create-index.html | Elasticsearch API documentation}
-    */
   async create (this: That, params: T.IndicesCreateRequest | TB.IndicesCreateRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesCreateResponse>
   async create (this: That, params: T.IndicesCreateRequest | TB.IndicesCreateRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesCreateResponse, unknown>>
   async create (this: That, params: T.IndicesCreateRequest | TB.IndicesCreateRequest, options?: TransportRequestOptions): Promise<T.IndicesCreateResponse>
@@ -251,10 +227,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Creates a data stream
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/data-streams.html | Elasticsearch API documentation}
-    */
   async createDataStream (this: That, params: T.IndicesCreateDataStreamRequest | TB.IndicesCreateDataStreamRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesCreateDataStreamResponse>
   async createDataStream (this: That, params: T.IndicesCreateDataStreamRequest | TB.IndicesCreateDataStreamRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesCreateDataStreamResponse, unknown>>
   async createDataStream (this: That, params: T.IndicesCreateDataStreamRequest | TB.IndicesCreateDataStreamRequest, options?: TransportRequestOptions): Promise<T.IndicesCreateDataStreamResponse>
@@ -277,10 +249,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Provides statistics on operations happening in a data stream.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/data-streams.html | Elasticsearch API documentation}
-    */
   async dataStreamsStats (this: That, params?: T.IndicesDataStreamsStatsRequest | TB.IndicesDataStreamsStatsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesDataStreamsStatsResponse>
   async dataStreamsStats (this: That, params?: T.IndicesDataStreamsStatsRequest | TB.IndicesDataStreamsStatsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesDataStreamsStatsResponse, unknown>>
   async dataStreamsStats (this: That, params?: T.IndicesDataStreamsStatsRequest | TB.IndicesDataStreamsStatsRequest, options?: TransportRequestOptions): Promise<T.IndicesDataStreamsStatsResponse>
@@ -311,10 +279,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Deletes an index.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-delete-index.html | Elasticsearch API documentation}
-    */
   async delete (this: That, params: T.IndicesDeleteRequest | TB.IndicesDeleteRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesDeleteResponse>
   async delete (this: That, params: T.IndicesDeleteRequest | TB.IndicesDeleteRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesDeleteResponse, unknown>>
   async delete (this: That, params: T.IndicesDeleteRequest | TB.IndicesDeleteRequest, options?: TransportRequestOptions): Promise<T.IndicesDeleteResponse>
@@ -337,10 +301,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Deletes an alias.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-aliases.html | Elasticsearch API documentation}
-    */
   async deleteAlias (this: That, params: T.IndicesDeleteAliasRequest | TB.IndicesDeleteAliasRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesDeleteAliasResponse>
   async deleteAlias (this: That, params: T.IndicesDeleteAliasRequest | TB.IndicesDeleteAliasRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesDeleteAliasResponse, unknown>>
   async deleteAlias (this: That, params: T.IndicesDeleteAliasRequest | TB.IndicesDeleteAliasRequest, options?: TransportRequestOptions): Promise<T.IndicesDeleteAliasResponse>
@@ -370,36 +330,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Deletes the data stream lifecycle of the selected data streams.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/data-streams-delete-lifecycle.html | Elasticsearch API documentation}
-    */
-  async deleteDataLifecycle (this: That, params: T.IndicesDeleteDataLifecycleRequest | TB.IndicesDeleteDataLifecycleRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesDeleteDataLifecycleResponse>
-  async deleteDataLifecycle (this: That, params: T.IndicesDeleteDataLifecycleRequest | TB.IndicesDeleteDataLifecycleRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesDeleteDataLifecycleResponse, unknown>>
-  async deleteDataLifecycle (this: That, params: T.IndicesDeleteDataLifecycleRequest | TB.IndicesDeleteDataLifecycleRequest, options?: TransportRequestOptions): Promise<T.IndicesDeleteDataLifecycleResponse>
-  async deleteDataLifecycle (this: That, params: T.IndicesDeleteDataLifecycleRequest | TB.IndicesDeleteDataLifecycleRequest, options?: TransportRequestOptions): Promise<any> {
-    const acceptedPath: string[] = ['name']
-    const querystring: Record<string, any> = {}
-    const body = undefined
-
-    for (const key in params) {
-      if (acceptedPath.includes(key)) {
-        continue
-      } else if (key !== 'body') {
-        // @ts-expect-error
-        querystring[key] = params[key]
-      }
-    }
-
-    const method = 'DELETE'
-    const path = `/_data_stream/${encodeURIComponent(params.name.toString())}/_lifecycle`
-    return await this.transport.request({ path, method, querystring, body }, options)
-  }
-
-  /**
-    * Deletes a data stream.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/data-streams.html | Elasticsearch API documentation}
-    */
   async deleteDataStream (this: That, params: T.IndicesDeleteDataStreamRequest | TB.IndicesDeleteDataStreamRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesDeleteDataStreamResponse>
   async deleteDataStream (this: That, params: T.IndicesDeleteDataStreamRequest | TB.IndicesDeleteDataStreamRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesDeleteDataStreamResponse, unknown>>
   async deleteDataStream (this: That, params: T.IndicesDeleteDataStreamRequest | TB.IndicesDeleteDataStreamRequest, options?: TransportRequestOptions): Promise<T.IndicesDeleteDataStreamResponse>
@@ -422,10 +352,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Deletes an index template.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-delete-template.html | Elasticsearch API documentation}
-    */
   async deleteIndexTemplate (this: That, params: T.IndicesDeleteIndexTemplateRequest | TB.IndicesDeleteIndexTemplateRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesDeleteIndexTemplateResponse>
   async deleteIndexTemplate (this: That, params: T.IndicesDeleteIndexTemplateRequest | TB.IndicesDeleteIndexTemplateRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesDeleteIndexTemplateResponse, unknown>>
   async deleteIndexTemplate (this: That, params: T.IndicesDeleteIndexTemplateRequest | TB.IndicesDeleteIndexTemplateRequest, options?: TransportRequestOptions): Promise<T.IndicesDeleteIndexTemplateResponse>
@@ -448,10 +374,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Deletes an index template.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-delete-template-v1.html | Elasticsearch API documentation}
-    */
   async deleteTemplate (this: That, params: T.IndicesDeleteTemplateRequest | TB.IndicesDeleteTemplateRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesDeleteTemplateResponse>
   async deleteTemplate (this: That, params: T.IndicesDeleteTemplateRequest | TB.IndicesDeleteTemplateRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesDeleteTemplateResponse, unknown>>
   async deleteTemplate (this: That, params: T.IndicesDeleteTemplateRequest | TB.IndicesDeleteTemplateRequest, options?: TransportRequestOptions): Promise<T.IndicesDeleteTemplateResponse>
@@ -474,10 +396,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Analyzes the disk usage of each field of an index or data stream
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-disk-usage.html | Elasticsearch API documentation}
-    */
   async diskUsage (this: That, params: T.IndicesDiskUsageRequest | TB.IndicesDiskUsageRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesDiskUsageResponse>
   async diskUsage (this: That, params: T.IndicesDiskUsageRequest | TB.IndicesDiskUsageRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesDiskUsageResponse, unknown>>
   async diskUsage (this: That, params: T.IndicesDiskUsageRequest | TB.IndicesDiskUsageRequest, options?: TransportRequestOptions): Promise<T.IndicesDiskUsageResponse>
@@ -500,10 +418,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Downsample an index
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-downsample-data-stream.html | Elasticsearch API documentation}
-    */
   async downsample (this: That, params: T.IndicesDownsampleRequest | TB.IndicesDownsampleRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesDownsampleResponse>
   async downsample (this: That, params: T.IndicesDownsampleRequest | TB.IndicesDownsampleRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesDownsampleResponse, unknown>>
   async downsample (this: That, params: T.IndicesDownsampleRequest | TB.IndicesDownsampleRequest, options?: TransportRequestOptions): Promise<T.IndicesDownsampleResponse>
@@ -531,10 +445,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns information about whether a particular index exists.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-exists.html | Elasticsearch API documentation}
-    */
   async exists (this: That, params: T.IndicesExistsRequest | TB.IndicesExistsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesExistsResponse>
   async exists (this: That, params: T.IndicesExistsRequest | TB.IndicesExistsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesExistsResponse, unknown>>
   async exists (this: That, params: T.IndicesExistsRequest | TB.IndicesExistsRequest, options?: TransportRequestOptions): Promise<T.IndicesExistsResponse>
@@ -557,10 +467,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns information about whether a particular alias exists.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-aliases.html | Elasticsearch API documentation}
-    */
   async existsAlias (this: That, params: T.IndicesExistsAliasRequest | TB.IndicesExistsAliasRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesExistsAliasResponse>
   async existsAlias (this: That, params: T.IndicesExistsAliasRequest | TB.IndicesExistsAliasRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesExistsAliasResponse, unknown>>
   async existsAlias (this: That, params: T.IndicesExistsAliasRequest | TB.IndicesExistsAliasRequest, options?: TransportRequestOptions): Promise<T.IndicesExistsAliasResponse>
@@ -590,10 +496,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns information about whether a particular index template exists.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/index-templates.html | Elasticsearch API documentation}
-    */
   async existsIndexTemplate (this: That, params: T.IndicesExistsIndexTemplateRequest | TB.IndicesExistsIndexTemplateRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesExistsIndexTemplateResponse>
   async existsIndexTemplate (this: That, params: T.IndicesExistsIndexTemplateRequest | TB.IndicesExistsIndexTemplateRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesExistsIndexTemplateResponse, unknown>>
   async existsIndexTemplate (this: That, params: T.IndicesExistsIndexTemplateRequest | TB.IndicesExistsIndexTemplateRequest, options?: TransportRequestOptions): Promise<T.IndicesExistsIndexTemplateResponse>
@@ -616,10 +518,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns information about whether a particular index template exists.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-template-exists-v1.html | Elasticsearch API documentation}
-    */
   async existsTemplate (this: That, params: T.IndicesExistsTemplateRequest | TB.IndicesExistsTemplateRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesExistsTemplateResponse>
   async existsTemplate (this: That, params: T.IndicesExistsTemplateRequest | TB.IndicesExistsTemplateRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesExistsTemplateResponse, unknown>>
   async existsTemplate (this: That, params: T.IndicesExistsTemplateRequest | TB.IndicesExistsTemplateRequest, options?: TransportRequestOptions): Promise<T.IndicesExistsTemplateResponse>
@@ -642,36 +540,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Retrieves information about the index's current data stream lifecycle, such as any potential encountered error, time since creation etc.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/data-streams-explain-lifecycle.html | Elasticsearch API documentation}
-    */
-  async explainDataLifecycle (this: That, params: T.IndicesExplainDataLifecycleRequest | TB.IndicesExplainDataLifecycleRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesExplainDataLifecycleResponse>
-  async explainDataLifecycle (this: That, params: T.IndicesExplainDataLifecycleRequest | TB.IndicesExplainDataLifecycleRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesExplainDataLifecycleResponse, unknown>>
-  async explainDataLifecycle (this: That, params: T.IndicesExplainDataLifecycleRequest | TB.IndicesExplainDataLifecycleRequest, options?: TransportRequestOptions): Promise<T.IndicesExplainDataLifecycleResponse>
-  async explainDataLifecycle (this: That, params: T.IndicesExplainDataLifecycleRequest | TB.IndicesExplainDataLifecycleRequest, options?: TransportRequestOptions): Promise<any> {
-    const acceptedPath: string[] = ['index']
-    const querystring: Record<string, any> = {}
-    const body = undefined
-
-    for (const key in params) {
-      if (acceptedPath.includes(key)) {
-        continue
-      } else if (key !== 'body') {
-        // @ts-expect-error
-        querystring[key] = params[key]
-      }
-    }
-
-    const method = 'GET'
-    const path = `/${encodeURIComponent(params.index.toString())}/_lifecycle/explain`
-    return await this.transport.request({ path, method, querystring, body }, options)
-  }
-
-  /**
-    * Returns the field usage stats for each field of an index
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/field-usage-stats.html | Elasticsearch API documentation}
-    */
   async fieldUsageStats (this: That, params: T.IndicesFieldUsageStatsRequest | TB.IndicesFieldUsageStatsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesFieldUsageStatsResponse>
   async fieldUsageStats (this: That, params: T.IndicesFieldUsageStatsRequest | TB.IndicesFieldUsageStatsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesFieldUsageStatsResponse, unknown>>
   async fieldUsageStats (this: That, params: T.IndicesFieldUsageStatsRequest | TB.IndicesFieldUsageStatsRequest, options?: TransportRequestOptions): Promise<T.IndicesFieldUsageStatsResponse>
@@ -694,10 +562,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Performs the flush operation on one or more indices.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-flush.html | Elasticsearch API documentation}
-    */
   async flush (this: That, params?: T.IndicesFlushRequest | TB.IndicesFlushRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesFlushResponse>
   async flush (this: That, params?: T.IndicesFlushRequest | TB.IndicesFlushRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesFlushResponse, unknown>>
   async flush (this: That, params?: T.IndicesFlushRequest | TB.IndicesFlushRequest, options?: TransportRequestOptions): Promise<T.IndicesFlushResponse>
@@ -728,10 +592,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Performs the force merge operation on one or more indices.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-forcemerge.html | Elasticsearch API documentation}
-    */
   async forcemerge (this: That, params?: T.IndicesForcemergeRequest | TB.IndicesForcemergeRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesForcemergeResponse>
   async forcemerge (this: That, params?: T.IndicesForcemergeRequest | TB.IndicesForcemergeRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesForcemergeResponse, unknown>>
   async forcemerge (this: That, params?: T.IndicesForcemergeRequest | TB.IndicesForcemergeRequest, options?: TransportRequestOptions): Promise<T.IndicesForcemergeResponse>
@@ -762,10 +622,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns information about one or more indices.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-get-index.html | Elasticsearch API documentation}
-    */
   async get (this: That, params: T.IndicesGetRequest | TB.IndicesGetRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesGetResponse>
   async get (this: That, params: T.IndicesGetRequest | TB.IndicesGetRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesGetResponse, unknown>>
   async get (this: That, params: T.IndicesGetRequest | TB.IndicesGetRequest, options?: TransportRequestOptions): Promise<T.IndicesGetResponse>
@@ -788,10 +644,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns an alias.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-aliases.html | Elasticsearch API documentation}
-    */
   async getAlias (this: That, params?: T.IndicesGetAliasRequest | TB.IndicesGetAliasRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesGetAliasResponse>
   async getAlias (this: That, params?: T.IndicesGetAliasRequest | TB.IndicesGetAliasRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesGetAliasResponse, unknown>>
   async getAlias (this: That, params?: T.IndicesGetAliasRequest | TB.IndicesGetAliasRequest, options?: TransportRequestOptions): Promise<T.IndicesGetAliasResponse>
@@ -828,36 +680,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns the data stream lifecycle of the selected data streams.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/data-streams-get-lifecycle.html | Elasticsearch API documentation}
-    */
-  async getDataLifecycle (this: That, params: T.IndicesGetDataLifecycleRequest | TB.IndicesGetDataLifecycleRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesGetDataLifecycleResponse>
-  async getDataLifecycle (this: That, params: T.IndicesGetDataLifecycleRequest | TB.IndicesGetDataLifecycleRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesGetDataLifecycleResponse, unknown>>
-  async getDataLifecycle (this: That, params: T.IndicesGetDataLifecycleRequest | TB.IndicesGetDataLifecycleRequest, options?: TransportRequestOptions): Promise<T.IndicesGetDataLifecycleResponse>
-  async getDataLifecycle (this: That, params: T.IndicesGetDataLifecycleRequest | TB.IndicesGetDataLifecycleRequest, options?: TransportRequestOptions): Promise<any> {
-    const acceptedPath: string[] = ['name']
-    const querystring: Record<string, any> = {}
-    const body = undefined
-
-    for (const key in params) {
-      if (acceptedPath.includes(key)) {
-        continue
-      } else if (key !== 'body') {
-        // @ts-expect-error
-        querystring[key] = params[key]
-      }
-    }
-
-    const method = 'GET'
-    const path = `/_data_stream/${encodeURIComponent(params.name.toString())}/_lifecycle`
-    return await this.transport.request({ path, method, querystring, body }, options)
-  }
-
-  /**
-    * Returns data streams.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/data-streams.html | Elasticsearch API documentation}
-    */
   async getDataStream (this: That, params?: T.IndicesGetDataStreamRequest | TB.IndicesGetDataStreamRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesGetDataStreamResponse>
   async getDataStream (this: That, params?: T.IndicesGetDataStreamRequest | TB.IndicesGetDataStreamRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesGetDataStreamResponse, unknown>>
   async getDataStream (this: That, params?: T.IndicesGetDataStreamRequest | TB.IndicesGetDataStreamRequest, options?: TransportRequestOptions): Promise<T.IndicesGetDataStreamResponse>
@@ -888,10 +710,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns mapping for one or more fields.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-get-field-mapping.html | Elasticsearch API documentation}
-    */
   async getFieldMapping (this: That, params: T.IndicesGetFieldMappingRequest | TB.IndicesGetFieldMappingRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesGetFieldMappingResponse>
   async getFieldMapping (this: That, params: T.IndicesGetFieldMappingRequest | TB.IndicesGetFieldMappingRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesGetFieldMappingResponse, unknown>>
   async getFieldMapping (this: That, params: T.IndicesGetFieldMappingRequest | TB.IndicesGetFieldMappingRequest, options?: TransportRequestOptions): Promise<T.IndicesGetFieldMappingResponse>
@@ -921,10 +739,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns an index template.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-get-template.html | Elasticsearch API documentation}
-    */
   async getIndexTemplate (this: That, params?: T.IndicesGetIndexTemplateRequest | TB.IndicesGetIndexTemplateRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesGetIndexTemplateResponse>
   async getIndexTemplate (this: That, params?: T.IndicesGetIndexTemplateRequest | TB.IndicesGetIndexTemplateRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesGetIndexTemplateResponse, unknown>>
   async getIndexTemplate (this: That, params?: T.IndicesGetIndexTemplateRequest | TB.IndicesGetIndexTemplateRequest, options?: TransportRequestOptions): Promise<T.IndicesGetIndexTemplateResponse>
@@ -955,10 +769,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns mappings for one or more indices.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-get-mapping.html | Elasticsearch API documentation}
-    */
   async getMapping (this: That, params?: T.IndicesGetMappingRequest | TB.IndicesGetMappingRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesGetMappingResponse>
   async getMapping (this: That, params?: T.IndicesGetMappingRequest | TB.IndicesGetMappingRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesGetMappingResponse, unknown>>
   async getMapping (this: That, params?: T.IndicesGetMappingRequest | TB.IndicesGetMappingRequest, options?: TransportRequestOptions): Promise<T.IndicesGetMappingResponse>
@@ -989,10 +799,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns settings for one or more indices.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-get-settings.html | Elasticsearch API documentation}
-    */
   async getSettings (this: That, params?: T.IndicesGetSettingsRequest | TB.IndicesGetSettingsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesGetSettingsResponse>
   async getSettings (this: That, params?: T.IndicesGetSettingsRequest | TB.IndicesGetSettingsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesGetSettingsResponse, unknown>>
   async getSettings (this: That, params?: T.IndicesGetSettingsRequest | TB.IndicesGetSettingsRequest, options?: TransportRequestOptions): Promise<T.IndicesGetSettingsResponse>
@@ -1029,10 +835,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns an index template.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-get-template-v1.html | Elasticsearch API documentation}
-    */
   async getTemplate (this: That, params?: T.IndicesGetTemplateRequest | TB.IndicesGetTemplateRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesGetTemplateResponse>
   async getTemplate (this: That, params?: T.IndicesGetTemplateRequest | TB.IndicesGetTemplateRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesGetTemplateResponse, unknown>>
   async getTemplate (this: That, params?: T.IndicesGetTemplateRequest | TB.IndicesGetTemplateRequest, options?: TransportRequestOptions): Promise<T.IndicesGetTemplateResponse>
@@ -1063,10 +865,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Migrates an alias to a data stream
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/data-streams.html | Elasticsearch API documentation}
-    */
   async migrateToDataStream (this: That, params: T.IndicesMigrateToDataStreamRequest | TB.IndicesMigrateToDataStreamRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesMigrateToDataStreamResponse>
   async migrateToDataStream (this: That, params: T.IndicesMigrateToDataStreamRequest | TB.IndicesMigrateToDataStreamRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesMigrateToDataStreamResponse, unknown>>
   async migrateToDataStream (this: That, params: T.IndicesMigrateToDataStreamRequest | TB.IndicesMigrateToDataStreamRequest, options?: TransportRequestOptions): Promise<T.IndicesMigrateToDataStreamResponse>
@@ -1089,10 +887,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Modifies a data stream
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/data-streams.html | Elasticsearch API documentation}
-    */
   async modifyDataStream (this: That, params: T.IndicesModifyDataStreamRequest | TB.IndicesModifyDataStreamRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesModifyDataStreamResponse>
   async modifyDataStream (this: That, params: T.IndicesModifyDataStreamRequest | TB.IndicesModifyDataStreamRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesModifyDataStreamResponse, unknown>>
   async modifyDataStream (this: That, params: T.IndicesModifyDataStreamRequest | TB.IndicesModifyDataStreamRequest, options?: TransportRequestOptions): Promise<T.IndicesModifyDataStreamResponse>
@@ -1127,10 +921,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Opens an index.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-open-close.html | Elasticsearch API documentation}
-    */
   async open (this: That, params: T.IndicesOpenRequest | TB.IndicesOpenRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesOpenResponse>
   async open (this: That, params: T.IndicesOpenRequest | TB.IndicesOpenRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesOpenResponse, unknown>>
   async open (this: That, params: T.IndicesOpenRequest | TB.IndicesOpenRequest, options?: TransportRequestOptions): Promise<T.IndicesOpenResponse>
@@ -1153,10 +943,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Promotes a data stream from a replicated data stream managed by CCR to a regular data stream
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/data-streams.html | Elasticsearch API documentation}
-    */
   async promoteDataStream (this: That, params: T.IndicesPromoteDataStreamRequest | TB.IndicesPromoteDataStreamRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesPromoteDataStreamResponse>
   async promoteDataStream (this: That, params: T.IndicesPromoteDataStreamRequest | TB.IndicesPromoteDataStreamRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesPromoteDataStreamResponse, unknown>>
   async promoteDataStream (this: That, params: T.IndicesPromoteDataStreamRequest | TB.IndicesPromoteDataStreamRequest, options?: TransportRequestOptions): Promise<T.IndicesPromoteDataStreamResponse>
@@ -1179,10 +965,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Creates or updates an alias.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-aliases.html | Elasticsearch API documentation}
-    */
   async putAlias (this: That, params: T.IndicesPutAliasRequest | TB.IndicesPutAliasRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesPutAliasResponse>
   async putAlias (this: That, params: T.IndicesPutAliasRequest | TB.IndicesPutAliasRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesPutAliasResponse, unknown>>
   async putAlias (this: That, params: T.IndicesPutAliasRequest | TB.IndicesPutAliasRequest, options?: TransportRequestOptions): Promise<T.IndicesPutAliasResponse>
@@ -1224,48 +1006,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Updates the data stream lifecycle of the selected data streams.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/data-streams-put-lifecycle.html | Elasticsearch API documentation}
-    */
-  async putDataLifecycle (this: That, params: T.IndicesPutDataLifecycleRequest | TB.IndicesPutDataLifecycleRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesPutDataLifecycleResponse>
-  async putDataLifecycle (this: That, params: T.IndicesPutDataLifecycleRequest | TB.IndicesPutDataLifecycleRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesPutDataLifecycleResponse, unknown>>
-  async putDataLifecycle (this: That, params: T.IndicesPutDataLifecycleRequest | TB.IndicesPutDataLifecycleRequest, options?: TransportRequestOptions): Promise<T.IndicesPutDataLifecycleResponse>
-  async putDataLifecycle (this: That, params: T.IndicesPutDataLifecycleRequest | TB.IndicesPutDataLifecycleRequest, options?: TransportRequestOptions): Promise<any> {
-    const acceptedPath: string[] = ['name']
-    const acceptedBody: string[] = ['data_retention', 'downsampling']
-    const querystring: Record<string, any> = {}
-    // @ts-expect-error
-    const userBody: any = params?.body
-    let body: Record<string, any> | string
-    if (typeof userBody === 'string') {
-      body = userBody
-    } else {
-      body = userBody != null ? { ...userBody } : undefined
-    }
-
-    for (const key in params) {
-      if (acceptedBody.includes(key)) {
-        body = body ?? {}
-        // @ts-expect-error
-        body[key] = params[key]
-      } else if (acceptedPath.includes(key)) {
-        continue
-      } else if (key !== 'body') {
-        // @ts-expect-error
-        querystring[key] = params[key]
-      }
-    }
-
-    const method = 'PUT'
-    const path = `/_data_stream/${encodeURIComponent(params.name.toString())}/_lifecycle`
-    return await this.transport.request({ path, method, querystring, body }, options)
-  }
-
-  /**
-    * Creates or updates an index template.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-put-template.html | Elasticsearch API documentation}
-    */
   async putIndexTemplate (this: That, params: T.IndicesPutIndexTemplateRequest | TB.IndicesPutIndexTemplateRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesPutIndexTemplateResponse>
   async putIndexTemplate (this: That, params: T.IndicesPutIndexTemplateRequest | TB.IndicesPutIndexTemplateRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesPutIndexTemplateResponse, unknown>>
   async putIndexTemplate (this: That, params: T.IndicesPutIndexTemplateRequest | TB.IndicesPutIndexTemplateRequest, options?: TransportRequestOptions): Promise<T.IndicesPutIndexTemplateResponse>
@@ -1300,10 +1040,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Updates the index mappings.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-put-mapping.html | Elasticsearch API documentation}
-    */
   async putMapping (this: That, params: T.IndicesPutMappingRequest | TB.IndicesPutMappingRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesPutMappingResponse>
   async putMapping (this: That, params: T.IndicesPutMappingRequest | TB.IndicesPutMappingRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesPutMappingResponse, unknown>>
   async putMapping (this: That, params: T.IndicesPutMappingRequest | TB.IndicesPutMappingRequest, options?: TransportRequestOptions): Promise<T.IndicesPutMappingResponse>
@@ -1338,10 +1074,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Updates the index settings.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-update-settings.html | Elasticsearch API documentation}
-    */
   async putSettings (this: That, params: T.IndicesPutSettingsRequest | TB.IndicesPutSettingsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesPutSettingsResponse>
   async putSettings (this: That, params: T.IndicesPutSettingsRequest | TB.IndicesPutSettingsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesPutSettingsResponse, unknown>>
   async putSettings (this: That, params: T.IndicesPutSettingsRequest | TB.IndicesPutSettingsRequest, options?: TransportRequestOptions): Promise<T.IndicesPutSettingsResponse>
@@ -1376,10 +1108,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Creates or updates an index template.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-templates-v1.html | Elasticsearch API documentation}
-    */
   async putTemplate (this: That, params: T.IndicesPutTemplateRequest | TB.IndicesPutTemplateRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesPutTemplateResponse>
   async putTemplate (this: That, params: T.IndicesPutTemplateRequest | TB.IndicesPutTemplateRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesPutTemplateResponse, unknown>>
   async putTemplate (this: That, params: T.IndicesPutTemplateRequest | TB.IndicesPutTemplateRequest, options?: TransportRequestOptions): Promise<T.IndicesPutTemplateResponse>
@@ -1414,10 +1142,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns information about ongoing index shard recoveries.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-recovery.html | Elasticsearch API documentation}
-    */
   async recovery (this: That, params?: T.IndicesRecoveryRequest | TB.IndicesRecoveryRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesRecoveryResponse>
   async recovery (this: That, params?: T.IndicesRecoveryRequest | TB.IndicesRecoveryRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesRecoveryResponse, unknown>>
   async recovery (this: That, params?: T.IndicesRecoveryRequest | TB.IndicesRecoveryRequest, options?: TransportRequestOptions): Promise<T.IndicesRecoveryResponse>
@@ -1448,10 +1172,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Performs the refresh operation in one or more indices.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-refresh.html | Elasticsearch API documentation}
-    */
   async refresh (this: That, params?: T.IndicesRefreshRequest | TB.IndicesRefreshRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesRefreshResponse>
   async refresh (this: That, params?: T.IndicesRefreshRequest | TB.IndicesRefreshRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesRefreshResponse, unknown>>
   async refresh (this: That, params?: T.IndicesRefreshRequest | TB.IndicesRefreshRequest, options?: TransportRequestOptions): Promise<T.IndicesRefreshResponse>
@@ -1482,10 +1202,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Reloads an index's search analyzers and their resources.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-reload-analyzers.html | Elasticsearch API documentation}
-    */
   async reloadSearchAnalyzers (this: That, params: T.IndicesReloadSearchAnalyzersRequest | TB.IndicesReloadSearchAnalyzersRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesReloadSearchAnalyzersResponse>
   async reloadSearchAnalyzers (this: That, params: T.IndicesReloadSearchAnalyzersRequest | TB.IndicesReloadSearchAnalyzersRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesReloadSearchAnalyzersResponse, unknown>>
   async reloadSearchAnalyzers (this: That, params: T.IndicesReloadSearchAnalyzersRequest | TB.IndicesReloadSearchAnalyzersRequest, options?: TransportRequestOptions): Promise<T.IndicesReloadSearchAnalyzersResponse>
@@ -1508,10 +1224,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Returns information about any matching indices, aliases, and data streams
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-resolve-index-api.html | Elasticsearch API documentation}
-    */
   async resolveIndex (this: That, params: T.IndicesResolveIndexRequest | TB.IndicesResolveIndexRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesResolveIndexResponse>
   async resolveIndex (this: That, params: T.IndicesResolveIndexRequest | TB.IndicesResolveIndexRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesResolveIndexResponse, unknown>>
   async resolveIndex (this: That, params: T.IndicesResolveIndexRequest | TB.IndicesResolveIndexRequest, options?: TransportRequestOptions): Promise<T.IndicesResolveIndexResponse>
@@ -1534,10 +1246,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Updates an alias to point to a new index when the existing index is considered to be too large or too old.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-rollover-index.html | Elasticsearch API documentation}
-    */
   async rollover (this: That, params: T.IndicesRolloverRequest | TB.IndicesRolloverRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesRolloverResponse>
   async rollover (this: That, params: T.IndicesRolloverRequest | TB.IndicesRolloverRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesRolloverResponse, unknown>>
   async rollover (this: That, params: T.IndicesRolloverRequest | TB.IndicesRolloverRequest, options?: TransportRequestOptions): Promise<T.IndicesRolloverResponse>
@@ -1579,10 +1287,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Provides low-level information about segments in a Lucene index.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-segments.html | Elasticsearch API documentation}
-    */
   async segments (this: That, params?: T.IndicesSegmentsRequest | TB.IndicesSegmentsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesSegmentsResponse>
   async segments (this: That, params?: T.IndicesSegmentsRequest | TB.IndicesSegmentsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesSegmentsResponse, unknown>>
   async segments (this: That, params?: T.IndicesSegmentsRequest | TB.IndicesSegmentsRequest, options?: TransportRequestOptions): Promise<T.IndicesSegmentsResponse>
@@ -1613,10 +1317,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Provides store information for shard copies of indices.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-shards-stores.html | Elasticsearch API documentation}
-    */
   async shardStores (this: That, params?: T.IndicesShardStoresRequest | TB.IndicesShardStoresRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesShardStoresResponse>
   async shardStores (this: That, params?: T.IndicesShardStoresRequest | TB.IndicesShardStoresRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesShardStoresResponse, unknown>>
   async shardStores (this: That, params?: T.IndicesShardStoresRequest | TB.IndicesShardStoresRequest, options?: TransportRequestOptions): Promise<T.IndicesShardStoresResponse>
@@ -1647,10 +1347,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Allow to shrink an existing index into a new index with fewer primary shards.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-shrink-index.html | Elasticsearch API documentation}
-    */
   async shrink (this: That, params: T.IndicesShrinkRequest | TB.IndicesShrinkRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesShrinkResponse>
   async shrink (this: That, params: T.IndicesShrinkRequest | TB.IndicesShrinkRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesShrinkResponse, unknown>>
   async shrink (this: That, params: T.IndicesShrinkRequest | TB.IndicesShrinkRequest, options?: TransportRequestOptions): Promise<T.IndicesShrinkResponse>
@@ -1685,10 +1381,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Simulate matching the given index name against the index templates in the system
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-simulate-index.html | Elasticsearch API documentation}
-    */
   async simulateIndexTemplate (this: That, params: T.IndicesSimulateIndexTemplateRequest | TB.IndicesSimulateIndexTemplateRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesSimulateIndexTemplateResponse>
   async simulateIndexTemplate (this: That, params: T.IndicesSimulateIndexTemplateRequest | TB.IndicesSimulateIndexTemplateRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesSimulateIndexTemplateResponse, unknown>>
   async simulateIndexTemplate (this: That, params: T.IndicesSimulateIndexTemplateRequest | TB.IndicesSimulateIndexTemplateRequest, options?: TransportRequestOptions): Promise<T.IndicesSimulateIndexTemplateResponse>
@@ -1723,10 +1415,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Simulate resolving the given template name or body
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-simulate-template.html | Elasticsearch API documentation}
-    */
   async simulateTemplate (this: That, params: T.IndicesSimulateTemplateRequest | TB.IndicesSimulateTemplateRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesSimulateTemplateResponse>
   async simulateTemplate (this: That, params: T.IndicesSimulateTemplateRequest | TB.IndicesSimulateTemplateRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesSimulateTemplateResponse, unknown>>
   async simulateTemplate (this: That, params: T.IndicesSimulateTemplateRequest | TB.IndicesSimulateTemplateRequest, options?: TransportRequestOptions): Promise<T.IndicesSimulateTemplateResponse>
@@ -1761,10 +1449,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Allows you to split an existing index into a new index with more primary shards.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-split-index.html | Elasticsearch API documentation}
-    */
   async split (this: That, params: T.IndicesSplitRequest | TB.IndicesSplitRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesSplitResponse>
   async split (this: That, params: T.IndicesSplitRequest | TB.IndicesSplitRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesSplitResponse, unknown>>
   async split (this: That, params: T.IndicesSplitRequest | TB.IndicesSplitRequest, options?: TransportRequestOptions): Promise<T.IndicesSplitResponse>
@@ -1799,10 +1483,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Provides statistics on operations happening in an index.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-stats.html | Elasticsearch API documentation}
-    */
   async stats (this: That, params?: T.IndicesStatsRequest | TB.IndicesStatsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesStatsResponse>
   async stats (this: That, params?: T.IndicesStatsRequest | TB.IndicesStatsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesStatsResponse, unknown>>
   async stats (this: That, params?: T.IndicesStatsRequest | TB.IndicesStatsRequest, options?: TransportRequestOptions): Promise<T.IndicesStatsResponse>
@@ -1839,10 +1519,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Unfreezes an index. When a frozen index is unfrozen, the index goes through the normal recovery process and becomes writeable again.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/unfreeze-index-api.html | Elasticsearch API documentation}
-    */
   async unfreeze (this: That, params: T.IndicesUnfreezeRequest | TB.IndicesUnfreezeRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesUnfreezeResponse>
   async unfreeze (this: That, params: T.IndicesUnfreezeRequest | TB.IndicesUnfreezeRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesUnfreezeResponse, unknown>>
   async unfreeze (this: That, params: T.IndicesUnfreezeRequest | TB.IndicesUnfreezeRequest, options?: TransportRequestOptions): Promise<T.IndicesUnfreezeResponse>
@@ -1865,10 +1541,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Updates index aliases.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/indices-aliases.html | Elasticsearch API documentation}
-    */
   async updateAliases (this: That, params?: T.IndicesUpdateAliasesRequest | TB.IndicesUpdateAliasesRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesUpdateAliasesResponse>
   async updateAliases (this: That, params?: T.IndicesUpdateAliasesRequest | TB.IndicesUpdateAliasesRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesUpdateAliasesResponse, unknown>>
   async updateAliases (this: That, params?: T.IndicesUpdateAliasesRequest | TB.IndicesUpdateAliasesRequest, options?: TransportRequestOptions): Promise<T.IndicesUpdateAliasesResponse>
@@ -1904,10 +1576,6 @@ export default class Indices {
     return await this.transport.request({ path, method, querystring, body }, options)
   }
 
-  /**
-    * Allows a user to validate a potentially expensive query without executing it.
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/search-validate.html | Elasticsearch API documentation}
-    */
   async validateQuery (this: That, params?: T.IndicesValidateQueryRequest | TB.IndicesValidateQueryRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.IndicesValidateQueryResponse>
   async validateQuery (this: That, params?: T.IndicesValidateQueryRequest | TB.IndicesValidateQueryRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.IndicesValidateQueryResponse, unknown>>
   async validateQuery (this: That, params?: T.IndicesValidateQueryRequest | TB.IndicesValidateQueryRequest, options?: TransportRequestOptions): Promise<T.IndicesValidateQueryResponse>

src/api/api/inference.ts

@@ -1,166 +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.
- */
-
-/* eslint-disable import/export */
-/* eslint-disable @typescript-eslint/no-misused-new */
-/* eslint-disable @typescript-eslint/no-extraneous-class */
-/* eslint-disable @typescript-eslint/no-unused-vars */
-
-// This file was automatically generated by elastic/elastic-client-generator-js
-// DO NOT MODIFY IT BY HAND. Instead, modify the source open api file,
-// and elastic/elastic-client-generator-js to regenerate this file again.
-
-import {
-  Transport,
-  TransportRequestOptions,
-  TransportRequestOptionsWithMeta,
-  TransportRequestOptionsWithOutMeta,
-  TransportResult
-} from '@elastic/transport'
-import * as T from '../types'
-import * as TB from '../typesWithBodyKey'
-interface That { transport: Transport }
-
-export default class Inference {
-  transport: Transport
-  constructor (transport: Transport) {
-    this.transport = transport
-  }
-
-  /**
-    * Delete model in the Inference API
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/delete-inference-api.html | Elasticsearch API documentation}
-    */
-  async deleteModel (this: That, params: T.InferenceDeleteModelRequest | TB.InferenceDeleteModelRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.InferenceDeleteModelResponse>
-  async deleteModel (this: That, params: T.InferenceDeleteModelRequest | TB.InferenceDeleteModelRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.InferenceDeleteModelResponse, unknown>>
-  async deleteModel (this: That, params: T.InferenceDeleteModelRequest | TB.InferenceDeleteModelRequest, options?: TransportRequestOptions): Promise<T.InferenceDeleteModelResponse>
-  async deleteModel (this: That, params: T.InferenceDeleteModelRequest | TB.InferenceDeleteModelRequest, options?: TransportRequestOptions): Promise<any> {
-    const acceptedPath: string[] = ['task_type', 'model_id']
-    const querystring: Record<string, any> = {}
-    const body = undefined
-
-    for (const key in params) {
-      if (acceptedPath.includes(key)) {
-        continue
-      } else if (key !== 'body') {
-        // @ts-expect-error
-        querystring[key] = params[key]
-      }
-    }
-
-    const method = 'DELETE'
-    const path = `/_inference/${encodeURIComponent(params.task_type.toString())}/${encodeURIComponent(params.model_id.toString())}`
-    return await this.transport.request({ path, method, querystring, body }, options)
-  }
-
-  /**
-    * Get a model in the Inference API
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/get-inference-api.html | Elasticsearch API documentation}
-    */
-  async getModel (this: That, params: T.InferenceGetModelRequest | TB.InferenceGetModelRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.InferenceGetModelResponse>
-  async getModel (this: That, params: T.InferenceGetModelRequest | TB.InferenceGetModelRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.InferenceGetModelResponse, unknown>>
-  async getModel (this: That, params: T.InferenceGetModelRequest | TB.InferenceGetModelRequest, options?: TransportRequestOptions): Promise<T.InferenceGetModelResponse>
-  async getModel (this: That, params: T.InferenceGetModelRequest | TB.InferenceGetModelRequest, options?: TransportRequestOptions): Promise<any> {
-    const acceptedPath: string[] = ['task_type', 'model_id']
-    const querystring: Record<string, any> = {}
-    const body = undefined
-
-    for (const key in params) {
-      if (acceptedPath.includes(key)) {
-        continue
-      } else if (key !== 'body') {
-        // @ts-expect-error
-        querystring[key] = params[key]
-      }
-    }
-
-    const method = 'GET'
-    const path = `/_inference/${encodeURIComponent(params.task_type.toString())}/${encodeURIComponent(params.model_id.toString())}`
-    return await this.transport.request({ path, method, querystring, body }, options)
-  }
-
-  /**
-    * Perform inference on a model
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/post-inference-api.html | Elasticsearch API documentation}
-    */
-  async inference (this: That, params: T.InferenceInferenceRequest | TB.InferenceInferenceRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.InferenceInferenceResponse>
-  async inference (this: That, params: T.InferenceInferenceRequest | TB.InferenceInferenceRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.InferenceInferenceResponse, unknown>>
-  async inference (this: That, params: T.InferenceInferenceRequest | TB.InferenceInferenceRequest, options?: TransportRequestOptions): Promise<T.InferenceInferenceResponse>
-  async inference (this: That, params: T.InferenceInferenceRequest | TB.InferenceInferenceRequest, options?: TransportRequestOptions): Promise<any> {
-    const acceptedPath: string[] = ['task_type', 'model_id']
-    const acceptedBody: string[] = ['input', 'task_settings']
-    const querystring: Record<string, any> = {}
-    // @ts-expect-error
-    const userBody: any = params?.body
-    let body: Record<string, any> | string
-    if (typeof userBody === 'string') {
-      body = userBody
-    } else {
-      body = userBody != null ? { ...userBody } : undefined
-    }
-
-    for (const key in params) {
-      if (acceptedBody.includes(key)) {
-        body = body ?? {}
-        // @ts-expect-error
-        body[key] = params[key]
-      } else if (acceptedPath.includes(key)) {
-        continue
-      } else if (key !== 'body') {
-        // @ts-expect-error
-        querystring[key] = params[key]
-      }
-    }
-
-    const method = 'POST'
-    const path = `/_inference/${encodeURIComponent(params.task_type.toString())}/${encodeURIComponent(params.model_id.toString())}`
-    return await this.transport.request({ path, method, querystring, body }, options)
-  }
-
-  /**
-    * Configure a model for use in the Inference API
-    * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/put-inference-api.html | Elasticsearch API documentation}
-    */
-  async putModel (this: That, params: T.InferencePutModelRequest | TB.InferencePutModelRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.InferencePutModelResponse>
-  async putModel (this: That, params: T.InferencePutModelRequest | TB.InferencePutModelRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.InferencePutModelResponse, unknown>>
-  async putModel (this: That, params: T.InferencePutModelRequest | TB.InferencePutModelRequest, options?: TransportRequestOptions): Promise<T.InferencePutModelResponse>
-  async putModel (this: That, params: T.InferencePutModelRequest | TB.InferencePutModelRequest, options?: TransportRequestOptions): Promise<any> {
-    const acceptedPath: string[] = ['task_type', 'model_id']
-    const acceptedBody: string[] = ['model_config']
-    const querystring: Record<string, any> = {}
-    // @ts-expect-error
-    let body: any = params.body ?? undefined
-
-    for (const key in params) {
-      if (acceptedBody.includes(key)) {
-        // @ts-expect-error
-        body = params[key]
-      } else if (acceptedPath.includes(key)) {
-        continue
-      } else if (key !== 'body') {
-        // @ts-expect-error
-        querystring[key] = params[key]
-      }
-    }
-
-    const method = 'PUT'
-    const path = `/_inference/${encodeURIComponent(params.task_type.toString())}/${encodeURIComponent(params.model_id.toString())}`
-    return await this.transport.request({ path, method, querystring, body }, options)
-  }
-}

src/api/api/info.ts

@@ -37,10 +37,6 @@ import * as T from '../types'
 import * as TB from '../typesWithBodyKey'
 interface That { transport: Transport }
 
-/**
-  * Returns basic information about the cluster.
-  * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.12/index.html | Elasticsearch API documentation}
-  */
 export default async function InfoApi (this: That, params?: T.InfoRequest | TB.InfoRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.InfoResponse>
 export default async function InfoApi (this: That, params?: T.InfoRequest | TB.InfoRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.InfoResponse, unknown>>
 export default async function InfoApi (this: That, params?: T.InfoRequest | TB.InfoRequest, options?: TransportRequestOptions): Promise<T.InfoResponse>