Bumped v7.14.1

Co-authored-by: Tomas Della Vedova <delvedor@users.noreply.github.com>

.ci/run-elasticsearch.sh

@@ -7,7 +7,7 @@
 # Export the TEST_SUITE variable, eg. 'free' or 'platinum' defaults to 'free'.
 # Export the NUMBER_OF_NODES variable to start more than 1 node
 
-# Version 1.2.0
+# Version 1.4.0
 # - Initial version of the run-elasticsearch.sh script
 # - Deleting the volume should not dependent on the container still running
 # - Fixed `ES_JAVA_OPTS` config
@@ -15,6 +15,9 @@
 # - Refactored into functions and imports
 # - Support NUMBER_OF_NODES
 # - Added 5 retries on docker pull for fixing transient network errors
+# - Added flags to make local CCR configurations work
+# - Added action.destructive_requires_name=false as the default will be true in v8
+# - Added ingest.geoip.downloader.enabled=false as it causes false positives in testing
 
 script_path=$(dirname $(realpath -s $0))
 source $script_path/functions/imports.sh
@@ -37,6 +40,8 @@ environment=($(cat <<-END
   --env node.attr.testattr=test
   --env path.repo=/tmp
   --env repositories.url.allowed_urls=http://snapshot.test*
+  --env action.destructive_requires_name=false
+  --env ingest.geoip.downloader.enabled=false
 END
 ))
 if [[ "$TEST_SUITE" == "platinum" ]]; then
@@ -50,6 +55,7 @@ if [[ "$TEST_SUITE" == "platinum" ]]; then
     --env xpack.security.http.ssl.certificate=certs/testnode.crt
     --env xpack.security.http.ssl.certificate_authorities=certs/ca.crt
     --env xpack.security.transport.ssl.enabled=true
+    --env xpack.security.transport.ssl.verification_mode=certificate
     --env xpack.security.transport.ssl.key=certs/testnode.key
     --env xpack.security.transport.ssl.certificate=certs/testnode.crt
     --env xpack.security.transport.ssl.certificate_authorities=certs/ca.crt
@@ -104,7 +110,7 @@ END
   docker run \
     --name "$node_name" \
     --network "$network_name" \
-    --env "ES_JAVA_OPTS=-Xms1g -Xmx1g" \
+    --env "ES_JAVA_OPTS=-Xms1g -Xmx1g -da:org.elasticsearch.xpack.ccr.index.engine.FollowingEngineAssertions" \
     "${environment[@]}" \
     "${volumes[@]}" \
     --publish "$http_port":9200 \

.ci/test-matrix.yml

@@ -1,6 +1,6 @@
 ---
 STACK_VERSION:
-  - 7.x-SNAPSHOT
+  - 7.14.0-SNAPSHOT
 
 NODE_JS_VERSION:
   - 16

.github/workflows/nodejs.yml

@@ -61,7 +61,7 @@ jobs:
     - name: Runs Elasticsearch
       uses: elastic/elastic-github-actions/elasticsearch@master
       with:
-        stack-version: 7.x-SNAPSHOT
+        stack-version: 7.14.0-SNAPSHOT
 
     - name: Use Node.js ${{ matrix.node-version }}
       uses: actions/setup-node@v1
@@ -93,7 +93,7 @@ jobs:
     - name: Runs Elasticsearch
       uses: elastic/elastic-github-actions/elasticsearch@master
       with:
-        stack-version: 8.0.0-SNAPSHOT
+        stack-version: 7.14.0-SNAPSHOT
 
     - name: Use Node.js 14.x
       uses: actions/setup-node@v1

README.md

@@ -54,7 +54,9 @@ of `^7.10.0`).
 
 ### Compatibility
 
-The library is compatible with all Elasticsearch versions since 5.x, and you should use the same major version of the Elasticsearch instance that you are using.
+Elastic language clients are guaranteed to be able to communicate with Elasticsearch or Elastic solutions running on the same major version and greater or equal minor version.
+
+Language clients are forward compatible; meaning that clients support communicating with greater minor versions of Elasticsearch. Elastic language clients are not guaranteed to be backwards compatible.
 
 | Elasticsearch Version | Client Version |
 | --------------------- |----------------|

api/api/ilm.js

@@ -23,8 +23,8 @@
 /* eslint no-unused-vars: 0 */
 
 const { handleError, snakeCaseKeys, normalizeArguments, kConfigurationError } = require('../utils')
-const acceptedQuerystring = ['pretty', 'human', 'error_trace', 'source', 'filter_path', 'only_managed', 'only_errors']
-const snakeCase = { errorTrace: 'error_trace', filterPath: 'filter_path', onlyManaged: 'only_managed', onlyErrors: 'only_errors' }
+const acceptedQuerystring = ['pretty', 'human', 'error_trace', 'source', 'filter_path', 'only_managed', 'only_errors', 'dry_run']
+const snakeCase = { errorTrace: 'error_trace', filterPath: 'filter_path', onlyManaged: 'only_managed', onlyErrors: 'only_errors', dryRun: 'dry_run' }
 
 function IlmApi (transport, ConfigurationError) {
   this.transport = transport
@@ -132,6 +132,27 @@ IlmApi.prototype.getStatus = function ilmGetStatusApi (params, options, callback
   return this.transport.request(request, options, callback)
 }
 
+IlmApi.prototype.migrateToDataTiers = function ilmMigrateToDataTiersApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  let { method, body, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'POST'
+  path = '/' + '_ilm' + '/' + 'migrate_to_data_tiers'
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: body || '',
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
 IlmApi.prototype.moveToStep = function ilmMoveToStepApi (params, options, callback) {
   ;[params, options, callback] = normalizeArguments(params, options, callback)
 
@@ -287,6 +308,7 @@ Object.defineProperties(IlmApi.prototype, {
   explain_lifecycle: { get () { return this.explainLifecycle } },
   get_lifecycle: { get () { return this.getLifecycle } },
   get_status: { get () { return this.getStatus } },
+  migrate_to_data_tiers: { get () { return this.migrateToDataTiers } },
   move_to_step: { get () { return this.moveToStep } },
   put_lifecycle: { get () { return this.putLifecycle } },
   remove_policy: { get () { return this.removePolicy } }

api/api/ml.js

@@ -1493,6 +1493,33 @@ MlApi.prototype.putTrainedModelAlias = function mlPutTrainedModelAliasApi (param
   return this.transport.request(request, options, callback)
 }
 
+MlApi.prototype.resetJob = function mlResetJobApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  // check required parameters
+  if (params.job_id == null && params.jobId == null) {
+    const err = new this[kConfigurationError]('Missing required parameter: job_id or jobId')
+    return handleError(err, callback)
+  }
+
+  let { method, body, jobId, job_id, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'POST'
+  path = '/' + '_ml' + '/' + 'anomaly_detectors' + '/' + encodeURIComponent(job_id || jobId) + '/' + '_reset'
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: body || '',
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
 MlApi.prototype.revertModelSnapshot = function mlRevertModelSnapshotApi (params, options, callback) {
   ;[params, options, callback] = normalizeArguments(params, options, callback)
 
@@ -1964,6 +1991,7 @@ Object.defineProperties(MlApi.prototype, {
   put_job: { get () { return this.putJob } },
   put_trained_model: { get () { return this.putTrainedModel } },
   put_trained_model_alias: { get () { return this.putTrainedModelAlias } },
+  reset_job: { get () { return this.resetJob } },
   revert_model_snapshot: { get () { return this.revertModelSnapshot } },
   set_upgrade_mode: { get () { return this.setUpgradeMode } },
   start_data_frame_analytics: { get () { return this.startDataFrameAnalytics } },

api/api/security.js

@@ -1032,6 +1032,168 @@ SecurityApi.prototype.putUser = function securityPutUserApi (params, options, ca
   return this.transport.request(request, options, callback)
 }
 
+SecurityApi.prototype.samlAuthenticate = function securitySamlAuthenticateApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  // check required parameters
+  if (params.body == null) {
+    const err = new this[kConfigurationError]('Missing required parameter: body')
+    return handleError(err, callback)
+  }
+
+  let { method, body, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'POST'
+  path = '/' + '_security' + '/' + 'saml' + '/' + 'authenticate'
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: body || '',
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
+SecurityApi.prototype.samlCompleteLogout = function securitySamlCompleteLogoutApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  // check required parameters
+  if (params.body == null) {
+    const err = new this[kConfigurationError]('Missing required parameter: body')
+    return handleError(err, callback)
+  }
+
+  let { method, body, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'POST'
+  path = '/' + '_security' + '/' + 'saml' + '/' + 'complete_logout'
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: body || '',
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
+SecurityApi.prototype.samlInvalidate = function securitySamlInvalidateApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  // check required parameters
+  if (params.body == null) {
+    const err = new this[kConfigurationError]('Missing required parameter: body')
+    return handleError(err, callback)
+  }
+
+  let { method, body, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'POST'
+  path = '/' + '_security' + '/' + 'saml' + '/' + 'invalidate'
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: body || '',
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
+SecurityApi.prototype.samlLogout = function securitySamlLogoutApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  // check required parameters
+  if (params.body == null) {
+    const err = new this[kConfigurationError]('Missing required parameter: body')
+    return handleError(err, callback)
+  }
+
+  let { method, body, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'POST'
+  path = '/' + '_security' + '/' + 'saml' + '/' + 'logout'
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: body || '',
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
+SecurityApi.prototype.samlPrepareAuthentication = function securitySamlPrepareAuthenticationApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  // check required parameters
+  if (params.body == null) {
+    const err = new this[kConfigurationError]('Missing required parameter: body')
+    return handleError(err, callback)
+  }
+
+  let { method, body, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'POST'
+  path = '/' + '_security' + '/' + 'saml' + '/' + 'prepare'
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: body || '',
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
+SecurityApi.prototype.samlServiceProviderMetadata = function securitySamlServiceProviderMetadataApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  // check required parameters
+  if (params.realm_name == null && params.realmName == null) {
+    const err = new this[kConfigurationError]('Missing required parameter: realm_name or realmName')
+    return handleError(err, callback)
+  }
+
+  let { method, body, realmName, realm_name, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'GET'
+  path = '/' + '_security' + '/' + 'saml' + '/' + 'metadata' + '/' + encodeURIComponent(realm_name || realmName)
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: null,
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
 Object.defineProperties(SecurityApi.prototype, {
   change_password: { get () { return this.changePassword } },
   clear_api_key_cache: { get () { return this.clearApiKeyCache } },
@@ -1065,7 +1227,13 @@ Object.defineProperties(SecurityApi.prototype, {
   put_privileges: { get () { return this.putPrivileges } },
   put_role: { get () { return this.putRole } },
   put_role_mapping: { get () { return this.putRoleMapping } },
-  put_user: { get () { return this.putUser } }
+  put_user: { get () { return this.putUser } },
+  saml_authenticate: { get () { return this.samlAuthenticate } },
+  saml_complete_logout: { get () { return this.samlCompleteLogout } },
+  saml_invalidate: { get () { return this.samlInvalidate } },
+  saml_logout: { get () { return this.samlLogout } },
+  saml_prepare_authentication: { get () { return this.samlPrepareAuthentication } },
+  saml_service_provider_metadata: { get () { return this.samlServiceProviderMetadata } }
 })
 
 module.exports = SecurityApi

api/api/snapshot.js

@@ -23,8 +23,8 @@
 /* eslint no-unused-vars: 0 */
 
 const { handleError, snakeCaseKeys, normalizeArguments, kConfigurationError } = require('../utils')
-const acceptedQuerystring = ['master_timeout', 'timeout', 'pretty', 'human', 'error_trace', 'source', 'filter_path', 'wait_for_completion', 'verify', 'ignore_unavailable', 'index_details', 'verbose', 'local']
-const snakeCase = { masterTimeout: 'master_timeout', errorTrace: 'error_trace', filterPath: 'filter_path', waitForCompletion: 'wait_for_completion', ignoreUnavailable: 'ignore_unavailable', indexDetails: 'index_details' }
+const acceptedQuerystring = ['master_timeout', 'timeout', 'pretty', 'human', 'error_trace', 'source', 'filter_path', 'wait_for_completion', 'verify', 'ignore_unavailable', 'index_details', 'include_repository', 'verbose', 'local', 'blob_count', 'concurrency', 'read_node_count', 'early_read_node_count', 'seed', 'rare_action_probability', 'max_blob_size', 'max_total_data_size', 'detailed', 'rarely_abort_writes']
+const snakeCase = { masterTimeout: 'master_timeout', errorTrace: 'error_trace', filterPath: 'filter_path', waitForCompletion: 'wait_for_completion', ignoreUnavailable: 'ignore_unavailable', indexDetails: 'index_details', includeRepository: 'include_repository', blobCount: 'blob_count', readNodeCount: 'read_node_count', earlyReadNodeCount: 'early_read_node_count', rareActionProbability: 'rare_action_probability', maxBlobSize: 'max_blob_size', maxTotalDataSize: 'max_total_data_size', rarelyAbortWrites: 'rarely_abort_writes' }
 
 function SnapshotApi (transport, ConfigurationError) {
   this.transport = transport
@@ -301,6 +301,33 @@ SnapshotApi.prototype.getRepository = function snapshotGetRepositoryApi (params,
   return this.transport.request(request, options, callback)
 }
 
+SnapshotApi.prototype.repositoryAnalyze = function snapshotRepositoryAnalyzeApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  // check required parameters
+  if (params.repository == null) {
+    const err = new this[kConfigurationError]('Missing required parameter: repository')
+    return handleError(err, callback)
+  }
+
+  let { method, body, repository, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'POST'
+  path = '/' + '_snapshot' + '/' + encodeURIComponent(repository) + '/' + '_analyze'
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: body || '',
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
 SnapshotApi.prototype.restore = function snapshotRestoreApi (params, options, callback) {
   ;[params, options, callback] = normalizeArguments(params, options, callback)
 
@@ -405,6 +432,7 @@ Object.defineProperties(SnapshotApi.prototype, {
   create_repository: { get () { return this.createRepository } },
   delete_repository: { get () { return this.deleteRepository } },
   get_repository: { get () { return this.getRepository } },
+  repository_analyze: { get () { return this.repositoryAnalyze } },
   verify_repository: { get () { return this.verifyRepository } }
 })
 

api/api/sql.js

@@ -23,8 +23,8 @@
 /* eslint no-unused-vars: 0 */
 
 const { handleError, snakeCaseKeys, normalizeArguments, kConfigurationError } = require('../utils')
-const acceptedQuerystring = ['pretty', 'human', 'error_trace', 'source', 'filter_path', 'format']
-const snakeCase = { errorTrace: 'error_trace', filterPath: 'filter_path' }
+const acceptedQuerystring = ['pretty', 'human', 'error_trace', 'source', 'filter_path', 'delimiter', 'format', 'keep_alive', 'wait_for_completion_timeout']
+const snakeCase = { errorTrace: 'error_trace', filterPath: 'filter_path', keepAlive: 'keep_alive', waitForCompletionTimeout: 'wait_for_completion_timeout' }
 
 function SqlApi (transport, ConfigurationError) {
   this.transport = transport
@@ -58,6 +58,87 @@ SqlApi.prototype.clearCursor = function sqlClearCursorApi (params, options, call
   return this.transport.request(request, options, callback)
 }
 
+SqlApi.prototype.deleteAsync = function sqlDeleteAsyncApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  // check required parameters
+  if (params.id == null) {
+    const err = new this[kConfigurationError]('Missing required parameter: id')
+    return handleError(err, callback)
+  }
+
+  let { method, body, id, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'DELETE'
+  path = '/' + '_sql' + '/' + 'async' + '/' + 'delete' + '/' + encodeURIComponent(id)
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: body || '',
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
+SqlApi.prototype.getAsync = function sqlGetAsyncApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  // check required parameters
+  if (params.id == null) {
+    const err = new this[kConfigurationError]('Missing required parameter: id')
+    return handleError(err, callback)
+  }
+
+  let { method, body, id, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'GET'
+  path = '/' + '_sql' + '/' + 'async' + '/' + encodeURIComponent(id)
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: null,
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
+SqlApi.prototype.getAsyncStatus = function sqlGetAsyncStatusApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  // check required parameters
+  if (params.id == null) {
+    const err = new this[kConfigurationError]('Missing required parameter: id')
+    return handleError(err, callback)
+  }
+
+  let { method, body, id, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'GET'
+  path = '/' + '_sql' + '/' + 'async' + '/' + 'status' + '/' + encodeURIComponent(id)
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: null,
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
 SqlApi.prototype.query = function sqlQueryApi (params, options, callback) {
   ;[params, options, callback] = normalizeArguments(params, options, callback)
 
@@ -113,7 +194,10 @@ SqlApi.prototype.translate = function sqlTranslateApi (params, options, callback
 }
 
 Object.defineProperties(SqlApi.prototype, {
-  clear_cursor: { get () { return this.clearCursor } }
+  clear_cursor: { get () { return this.clearCursor } },
+  delete_async: { get () { return this.deleteAsync } },
+  get_async: { get () { return this.getAsync } },
+  get_async_status: { get () { return this.getAsyncStatus } }
 })
 
 module.exports = SqlApi

api/kibana.d.ts

@@ -210,6 +210,7 @@ interface KibanaClient {
     explainLifecycle<TContext = unknown>(params: T.IlmExplainLifecycleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IlmExplainLifecycleResponse, TContext>>
     getLifecycle<TContext = unknown>(params?: T.IlmGetLifecycleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IlmGetLifecycleResponse, TContext>>
     getStatus<TContext = unknown>(params?: T.IlmGetStatusRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IlmGetStatusResponse, TContext>>
+    migrateToDataTiers<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
     moveToStep<TContext = unknown>(params: T.IlmMoveToStepRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IlmMoveToStepResponse, TContext>>
     putLifecycle<TContext = unknown>(params?: T.IlmPutLifecycleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IlmPutLifecycleResponse, TContext>>
     removePolicy<TContext = unknown>(params: T.IlmRemovePolicyRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IlmRemovePolicyResponse, TContext>>
@@ -232,11 +233,13 @@ interface KibanaClient {
     deleteDataStream<TContext = unknown>(params: T.IndicesDeleteDataStreamRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IndicesDeleteDataStreamResponse, TContext>>
     deleteIndexTemplate<TContext = unknown>(params: T.IndicesDeleteIndexTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IndicesDeleteIndexTemplateResponse, TContext>>
     deleteTemplate<TContext = unknown>(params: T.IndicesDeleteTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IndicesDeleteTemplateResponse, TContext>>
+    diskUsage<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
     exists<TContext = unknown>(params: T.IndicesExistsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IndicesExistsResponse, TContext>>
     existsAlias<TContext = unknown>(params: T.IndicesExistsAliasRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IndicesExistsAliasResponse, TContext>>
     existsIndexTemplate<TContext = unknown>(params: T.IndicesExistsIndexTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IndicesExistsIndexTemplateResponse, TContext>>
     existsTemplate<TContext = unknown>(params: T.IndicesExistsTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IndicesExistsTemplateResponse, TContext>>
     existsType<TContext = unknown>(params: T.IndicesExistsTypeRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IndicesExistsTypeResponse, TContext>>
+    fieldUsageStats<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
     flush<TContext = unknown>(params?: T.IndicesFlushRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IndicesFlushResponse, TContext>>
     flushSynced<TContext = unknown>(params?: T.IndicesFlushSyncedRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IndicesFlushSyncedResponse, TContext>>
     forcemerge<TContext = unknown>(params?: T.IndicesForcemergeRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IndicesForcemergeResponse, TContext>>
@@ -342,7 +345,7 @@ interface KibanaClient {
     info<TContext = unknown>(params?: T.MlInfoRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MlInfoResponse, TContext>>
     openJob<TContext = unknown>(params: T.MlOpenJobRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MlOpenJobResponse, TContext>>
     postCalendarEvents<TContext = unknown>(params?: T.MlPostCalendarEventsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MlPostCalendarEventsResponse, TContext>>
-    postData<TContext = unknown>(params: T.MlPostJobDataRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MlPostJobDataResponse, TContext>>
+    postData<TContext = unknown>(params: T.MlPostDataRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MlPostDataResponse, TContext>>
     previewDataFrameAnalytics<TContext = unknown>(params?: T.MlPreviewDataFrameAnalyticsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MlPreviewDataFrameAnalyticsResponse, TContext>>
     previewDatafeed<TDocument = unknown, TContext = unknown>(params?: T.MlPreviewDatafeedRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MlPreviewDatafeedResponse<TDocument>, TContext>>
     putCalendar<TContext = unknown>(params: T.MlPutCalendarRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MlPutCalendarResponse, TContext>>
@@ -353,6 +356,7 @@ interface KibanaClient {
     putJob<TContext = unknown>(params: T.MlPutJobRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MlPutJobResponse, TContext>>
     putTrainedModel<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
     putTrainedModelAlias<TContext = unknown>(params: T.MlPutTrainedModelAliasRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MlPutTrainedModelAliasResponse, TContext>>
+    resetJob<TContext = unknown>(params: T.MlResetJobRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MlResetJobResponse, TContext>>
     revertModelSnapshot<TContext = unknown>(params: T.MlRevertModelSnapshotRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MlRevertModelSnapshotResponse, TContext>>
     setUpgradeMode<TContext = unknown>(params?: T.MlSetUpgradeModeRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MlSetUpgradeModeResponse, TContext>>
     startDataFrameAnalytics<TContext = unknown>(params: T.MlStartDataFrameAnalyticsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MlStartDataFrameAnalyticsResponse, TContext>>
@@ -362,7 +366,7 @@ interface KibanaClient {
     updateDataFrameAnalytics<TContext = unknown>(params: T.MlUpdateDataFrameAnalyticsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MlUpdateDataFrameAnalyticsResponse, TContext>>
     updateDatafeed<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
     updateFilter<TContext = unknown>(params: T.MlUpdateFilterRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MlUpdateFilterResponse, TContext>>
-    updateJob<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    updateJob<TContext = unknown>(params: T.MlUpdateJobRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MlUpdateJobResponse, TContext>>
     updateModelSnapshot<TContext = unknown>(params: T.MlUpdateModelSnapshotRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MlUpdateModelSnapshotResponse, TContext>>
     upgradeJobSnapshot<TContext = unknown>(params: T.MlUpgradeJobSnapshotRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MlUpgradeJobSnapshotResponse, TContext>>
     validate<TContext = unknown>(params?: T.MlValidateJobRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MlValidateJobResponse, TContext>>
@@ -375,6 +379,8 @@ interface KibanaClient {
   msearchTemplate<TDocument = unknown, TContext = unknown>(params?: T.MsearchTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MsearchTemplateResponse<TDocument>, TContext>>
   mtermvectors<TContext = unknown>(params?: T.MtermvectorsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MtermvectorsResponse, TContext>>
   nodes: {
+    clearMeteringArchive<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    getMeteringInfo<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
     hotThreads<TContext = unknown>(params?: T.NodesHotThreadsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.NodesHotThreadsResponse, TContext>>
     info<TContext = unknown>(params?: T.NodesInfoRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.NodesInfoResponse, TContext>>
     reloadSecureSettings<TContext = unknown>(params?: T.NodesReloadSecureSettingsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.NodesReloadSecureSettingsResponse, TContext>>
@@ -446,7 +452,12 @@ interface KibanaClient {
     putRole<TContext = unknown>(params: T.SecurityPutRoleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.SecurityPutRoleResponse, TContext>>
     putRoleMapping<TContext = unknown>(params: T.SecurityPutRoleMappingRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.SecurityPutRoleMappingResponse, TContext>>
     putUser<TContext = unknown>(params: T.SecurityPutUserRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.SecurityPutUserResponse, TContext>>
+    samlAuthenticate<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
     samlCompleteLogout<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    samlInvalidate<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    samlLogout<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    samlPrepareAuthentication<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    samlServiceProviderMetadata<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
   }
   shutdown: {
     deleteNode<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
@@ -480,6 +491,9 @@ interface KibanaClient {
   }
   sql: {
     clearCursor<TContext = unknown>(params?: T.SqlClearCursorRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.SqlClearCursorResponse, TContext>>
+    deleteAsync<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    getAsync<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    getAsyncStatus<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
     query<TContext = unknown>(params?: T.SqlQueryRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.SqlQueryResponse, TContext>>
     translate<TContext = unknown>(params?: T.SqlTranslateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.SqlTranslateResponse, TContext>>
   }

api/new.d.ts

@@ -503,6 +503,10 @@ declare class Client {
     getStatus<TContext = unknown>(callback: callbackFn<T.IlmGetStatusResponse, TContext>): TransportRequestCallback
     getStatus<TContext = unknown>(params: T.IlmGetStatusRequest, callback: callbackFn<T.IlmGetStatusResponse, TContext>): TransportRequestCallback
     getStatus<TContext = unknown>(params: T.IlmGetStatusRequest, options: TransportRequestOptions, callback: callbackFn<T.IlmGetStatusResponse, TContext>): TransportRequestCallback
+    migrateToDataTiers<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    migrateToDataTiers<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    migrateToDataTiers<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    migrateToDataTiers<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
     moveToStep<TContext = unknown>(params: T.IlmMoveToStepRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IlmMoveToStepResponse, TContext>>
     moveToStep<TContext = unknown>(params: T.IlmMoveToStepRequest, callback: callbackFn<T.IlmMoveToStepResponse, TContext>): TransportRequestCallback
     moveToStep<TContext = unknown>(params: T.IlmMoveToStepRequest, options: TransportRequestOptions, callback: callbackFn<T.IlmMoveToStepResponse, TContext>): TransportRequestCallback
@@ -571,6 +575,10 @@ declare class Client {
     deleteTemplate<TContext = unknown>(params: T.IndicesDeleteTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IndicesDeleteTemplateResponse, TContext>>
     deleteTemplate<TContext = unknown>(params: T.IndicesDeleteTemplateRequest, callback: callbackFn<T.IndicesDeleteTemplateResponse, TContext>): TransportRequestCallback
     deleteTemplate<TContext = unknown>(params: T.IndicesDeleteTemplateRequest, options: TransportRequestOptions, callback: callbackFn<T.IndicesDeleteTemplateResponse, TContext>): TransportRequestCallback
+    diskUsage<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    diskUsage<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    diskUsage<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    diskUsage<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
     exists<TContext = unknown>(params: T.IndicesExistsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IndicesExistsResponse, TContext>>
     exists<TContext = unknown>(params: T.IndicesExistsRequest, callback: callbackFn<T.IndicesExistsResponse, TContext>): TransportRequestCallback
     exists<TContext = unknown>(params: T.IndicesExistsRequest, options: TransportRequestOptions, callback: callbackFn<T.IndicesExistsResponse, TContext>): TransportRequestCallback
@@ -586,6 +594,10 @@ declare class Client {
     existsType<TContext = unknown>(params: T.IndicesExistsTypeRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IndicesExistsTypeResponse, TContext>>
     existsType<TContext = unknown>(params: T.IndicesExistsTypeRequest, callback: callbackFn<T.IndicesExistsTypeResponse, TContext>): TransportRequestCallback
     existsType<TContext = unknown>(params: T.IndicesExistsTypeRequest, options: TransportRequestOptions, callback: callbackFn<T.IndicesExistsTypeResponse, TContext>): TransportRequestCallback
+    fieldUsageStats<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    fieldUsageStats<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    fieldUsageStats<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    fieldUsageStats<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
     flush<TContext = unknown>(params?: T.IndicesFlushRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IndicesFlushResponse, TContext>>
     flush<TContext = unknown>(callback: callbackFn<T.IndicesFlushResponse, TContext>): TransportRequestCallback
     flush<TContext = unknown>(params: T.IndicesFlushRequest, callback: callbackFn<T.IndicesFlushResponse, TContext>): TransportRequestCallback
@@ -938,9 +950,9 @@ declare class Client {
     postCalendarEvents<TContext = unknown>(callback: callbackFn<T.MlPostCalendarEventsResponse, TContext>): TransportRequestCallback
     postCalendarEvents<TContext = unknown>(params: T.MlPostCalendarEventsRequest, callback: callbackFn<T.MlPostCalendarEventsResponse, TContext>): TransportRequestCallback
     postCalendarEvents<TContext = unknown>(params: T.MlPostCalendarEventsRequest, options: TransportRequestOptions, callback: callbackFn<T.MlPostCalendarEventsResponse, TContext>): TransportRequestCallback
-    postData<TContext = unknown>(params: T.MlPostJobDataRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MlPostJobDataResponse, TContext>>
-    postData<TContext = unknown>(params: T.MlPostJobDataRequest, callback: callbackFn<T.MlPostJobDataResponse, TContext>): TransportRequestCallback
-    postData<TContext = unknown>(params: T.MlPostJobDataRequest, options: TransportRequestOptions, callback: callbackFn<T.MlPostJobDataResponse, TContext>): TransportRequestCallback
+    postData<TContext = unknown>(params: T.MlPostDataRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MlPostDataResponse, TContext>>
+    postData<TContext = unknown>(params: T.MlPostDataRequest, callback: callbackFn<T.MlPostDataResponse, TContext>): TransportRequestCallback
+    postData<TContext = unknown>(params: T.MlPostDataRequest, options: TransportRequestOptions, callback: callbackFn<T.MlPostDataResponse, TContext>): TransportRequestCallback
     previewDataFrameAnalytics<TContext = unknown>(params?: T.MlPreviewDataFrameAnalyticsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MlPreviewDataFrameAnalyticsResponse, TContext>>
     previewDataFrameAnalytics<TContext = unknown>(callback: callbackFn<T.MlPreviewDataFrameAnalyticsResponse, TContext>): TransportRequestCallback
     previewDataFrameAnalytics<TContext = unknown>(params: T.MlPreviewDataFrameAnalyticsRequest, callback: callbackFn<T.MlPreviewDataFrameAnalyticsResponse, TContext>): TransportRequestCallback
@@ -974,6 +986,9 @@ declare class Client {
     putTrainedModelAlias<TContext = unknown>(params: T.MlPutTrainedModelAliasRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MlPutTrainedModelAliasResponse, TContext>>
     putTrainedModelAlias<TContext = unknown>(params: T.MlPutTrainedModelAliasRequest, callback: callbackFn<T.MlPutTrainedModelAliasResponse, TContext>): TransportRequestCallback
     putTrainedModelAlias<TContext = unknown>(params: T.MlPutTrainedModelAliasRequest, options: TransportRequestOptions, callback: callbackFn<T.MlPutTrainedModelAliasResponse, TContext>): TransportRequestCallback
+    resetJob<TContext = unknown>(params: T.MlResetJobRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MlResetJobResponse, TContext>>
+    resetJob<TContext = unknown>(params: T.MlResetJobRequest, callback: callbackFn<T.MlResetJobResponse, TContext>): TransportRequestCallback
+    resetJob<TContext = unknown>(params: T.MlResetJobRequest, options: TransportRequestOptions, callback: callbackFn<T.MlResetJobResponse, TContext>): TransportRequestCallback
     revertModelSnapshot<TContext = unknown>(params: T.MlRevertModelSnapshotRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MlRevertModelSnapshotResponse, TContext>>
     revertModelSnapshot<TContext = unknown>(params: T.MlRevertModelSnapshotRequest, callback: callbackFn<T.MlRevertModelSnapshotResponse, TContext>): TransportRequestCallback
     revertModelSnapshot<TContext = unknown>(params: T.MlRevertModelSnapshotRequest, options: TransportRequestOptions, callback: callbackFn<T.MlRevertModelSnapshotResponse, TContext>): TransportRequestCallback
@@ -1003,10 +1018,9 @@ declare class Client {
     updateFilter<TContext = unknown>(params: T.MlUpdateFilterRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MlUpdateFilterResponse, TContext>>
     updateFilter<TContext = unknown>(params: T.MlUpdateFilterRequest, callback: callbackFn<T.MlUpdateFilterResponse, TContext>): TransportRequestCallback
     updateFilter<TContext = unknown>(params: T.MlUpdateFilterRequest, options: TransportRequestOptions, callback: callbackFn<T.MlUpdateFilterResponse, TContext>): TransportRequestCallback
-    updateJob<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
-    updateJob<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
-    updateJob<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
-    updateJob<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    updateJob<TContext = unknown>(params: T.MlUpdateJobRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MlUpdateJobResponse, TContext>>
+    updateJob<TContext = unknown>(params: T.MlUpdateJobRequest, callback: callbackFn<T.MlUpdateJobResponse, TContext>): TransportRequestCallback
+    updateJob<TContext = unknown>(params: T.MlUpdateJobRequest, options: TransportRequestOptions, callback: callbackFn<T.MlUpdateJobResponse, TContext>): TransportRequestCallback
     updateModelSnapshot<TContext = unknown>(params: T.MlUpdateModelSnapshotRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.MlUpdateModelSnapshotResponse, TContext>>
     updateModelSnapshot<TContext = unknown>(params: T.MlUpdateModelSnapshotRequest, callback: callbackFn<T.MlUpdateModelSnapshotResponse, TContext>): TransportRequestCallback
     updateModelSnapshot<TContext = unknown>(params: T.MlUpdateModelSnapshotRequest, options: TransportRequestOptions, callback: callbackFn<T.MlUpdateModelSnapshotResponse, TContext>): TransportRequestCallback
@@ -1041,6 +1055,14 @@ declare class Client {
   mtermvectors<TContext = unknown>(params: T.MtermvectorsRequest, callback: callbackFn<T.MtermvectorsResponse, TContext>): TransportRequestCallback
   mtermvectors<TContext = unknown>(params: T.MtermvectorsRequest, options: TransportRequestOptions, callback: callbackFn<T.MtermvectorsResponse, TContext>): TransportRequestCallback
   nodes: {
+    clearMeteringArchive<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    clearMeteringArchive<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    clearMeteringArchive<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    clearMeteringArchive<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    getMeteringInfo<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    getMeteringInfo<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    getMeteringInfo<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    getMeteringInfo<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
     hotThreads<TContext = unknown>(params?: T.NodesHotThreadsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.NodesHotThreadsResponse, TContext>>
     hotThreads<TContext = unknown>(callback: callbackFn<T.NodesHotThreadsResponse, TContext>): TransportRequestCallback
     hotThreads<TContext = unknown>(params: T.NodesHotThreadsRequest, callback: callbackFn<T.NodesHotThreadsResponse, TContext>): TransportRequestCallback
@@ -1280,10 +1302,30 @@ declare class Client {
     putUser<TContext = unknown>(params: T.SecurityPutUserRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.SecurityPutUserResponse, TContext>>
     putUser<TContext = unknown>(params: T.SecurityPutUserRequest, callback: callbackFn<T.SecurityPutUserResponse, TContext>): TransportRequestCallback
     putUser<TContext = unknown>(params: T.SecurityPutUserRequest, options: TransportRequestOptions, callback: callbackFn<T.SecurityPutUserResponse, TContext>): TransportRequestCallback
+    samlAuthenticate<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    samlAuthenticate<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    samlAuthenticate<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    samlAuthenticate<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
     samlCompleteLogout<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
     samlCompleteLogout<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
     samlCompleteLogout<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
     samlCompleteLogout<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    samlInvalidate<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    samlInvalidate<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    samlInvalidate<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    samlInvalidate<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    samlLogout<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    samlLogout<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    samlLogout<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    samlLogout<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    samlPrepareAuthentication<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    samlPrepareAuthentication<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    samlPrepareAuthentication<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    samlPrepareAuthentication<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    samlServiceProviderMetadata<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    samlServiceProviderMetadata<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    samlServiceProviderMetadata<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    samlServiceProviderMetadata<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
   }
   shutdown: {
     deleteNode<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
@@ -1380,6 +1422,18 @@ declare class Client {
     clearCursor<TContext = unknown>(callback: callbackFn<T.SqlClearCursorResponse, TContext>): TransportRequestCallback
     clearCursor<TContext = unknown>(params: T.SqlClearCursorRequest, callback: callbackFn<T.SqlClearCursorResponse, TContext>): TransportRequestCallback
     clearCursor<TContext = unknown>(params: T.SqlClearCursorRequest, options: TransportRequestOptions, callback: callbackFn<T.SqlClearCursorResponse, TContext>): TransportRequestCallback
+    deleteAsync<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    deleteAsync<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    deleteAsync<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    deleteAsync<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    getAsync<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    getAsync<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    getAsync<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    getAsync<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    getAsyncStatus<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    getAsyncStatus<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    getAsyncStatus<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    getAsyncStatus<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
     query<TContext = unknown>(params?: T.SqlQueryRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.SqlQueryResponse, TContext>>
     query<TContext = unknown>(callback: callbackFn<T.SqlQueryResponse, TContext>): TransportRequestCallback
     query<TContext = unknown>(params: T.SqlQueryRequest, callback: callbackFn<T.SqlQueryResponse, TContext>): TransportRequestCallback

api/requestParams.d.ts

@@ -897,6 +897,11 @@ export interface IlmGetLifecycle extends Generic {
 export interface IlmGetStatus extends Generic {
 }
 
+export interface IlmMigrateToDataTiers<T = RequestBody> extends Generic {
+  dry_run?: boolean;
+  body?: T;
+}
+
 export interface IlmMoveToStep<T = RequestBody> extends Generic {
   index: string;
   body?: T;
@@ -1856,6 +1861,11 @@ export interface MlPutTrainedModelAlias extends Generic {
   reassign?: boolean;
 }
 
+export interface MlResetJob extends Generic {
+  job_id: string;
+  wait_for_completion?: boolean;
+}
+
 export interface MlRevertModelSnapshot<T = RequestBody> extends Generic {
   job_id: string;
   snapshot_id: string;
@@ -2422,6 +2432,30 @@ export interface SecurityPutUser<T = RequestBody> extends Generic {
   body: T;
 }
 
+export interface SecuritySamlAuthenticate<T = RequestBody> extends Generic {
+  body: T;
+}
+
+export interface SecuritySamlCompleteLogout<T = RequestBody> extends Generic {
+  body: T;
+}
+
+export interface SecuritySamlInvalidate<T = RequestBody> extends Generic {
+  body: T;
+}
+
+export interface SecuritySamlLogout<T = RequestBody> extends Generic {
+  body: T;
+}
+
+export interface SecuritySamlPrepareAuthentication<T = RequestBody> extends Generic {
+  body: T;
+}
+
+export interface SecuritySamlServiceProviderMetadata extends Generic {
+  realm_name: string;
+}
+
 export interface ShutdownDeleteNode extends Generic {
   node_id: string;
 }
@@ -2515,6 +2549,7 @@ export interface SnapshotGet extends Generic {
   master_timeout?: string;
   ignore_unavailable?: boolean;
   index_details?: boolean;
+  include_repository?: boolean;
   verbose?: boolean;
 }
 
@@ -2524,6 +2559,21 @@ export interface SnapshotGetRepository extends Generic {
   local?: boolean;
 }
 
+export interface SnapshotRepositoryAnalyze extends Generic {
+  repository: string;
+  blob_count?: number;
+  concurrency?: number;
+  read_node_count?: number;
+  early_read_node_count?: number;
+  seed?: number;
+  rare_action_probability?: number;
+  max_blob_size?: string;
+  max_total_data_size?: string;
+  timeout?: string;
+  detailed?: boolean;
+  rarely_abort_writes?: boolean;
+}
+
 export interface SnapshotRestore<T = RequestBody> extends Generic {
   repository: string;
   snapshot: string;
@@ -2549,6 +2599,22 @@ export interface SqlClearCursor<T = RequestBody> extends Generic {
   body: T;
 }
 
+export interface SqlDeleteAsync extends Generic {
+  id: string;
+}
+
+export interface SqlGetAsync extends Generic {
+  id: string;
+  delimiter?: string;
+  format?: string;
+  keep_alive?: string;
+  wait_for_completion_timeout?: string;
+}
+
+export interface SqlGetAsyncStatus extends Generic {
+  id: string;
+}
+
 export interface SqlQuery<T = RequestBody> extends Generic {
   format?: string;
   body: T;

docs/advanced-config.asciidoc

@@ -83,4 +83,18 @@ class MySerializer extends Serializer {
 const client = new Client({
   Serializer: MySerializer
 })
-----
+----
+
+[discrete]
+==== Migrate to v8
+
+The Node.js client can be configured to emit an HTTP header
+``Accept: application/vnd.elasticsearch+json; compatible-with=7``
+which signals to Elasticsearch that the client is requesting
+``7.x`` version of request and response bodies. This allows for
+upgrading from 7.x to 8.x version of Elasticsearch without upgrading
+everything at once. Elasticsearch should be upgraded first after
+the compatibility header is configured and clients should be upgraded
+second.
+To enable to setting, configure the environment variable
+``ELASTIC_CLIENT_APIVERSIONING`` to ``true``.

docs/basic-config.asciidoc

@@ -67,6 +67,13 @@ auth: {
   apiKey: 'base64EncodedKey'
 }
 ----
+Bearer authentication, useful for https://www.elastic.co/guide/en/elasticsearch/reference/current/security-api-create-service-token.html[service account tokens]. Be aware that it does not handle automatic token refresh:
+[source,js]
+----
+auth: {
+  bearer: 'token'
+}
+----
 
 
 |`maxRetries`
@@ -248,4 +255,4 @@ const client = new Client({
 |`boolean`, `'proto'`, `'constructor'` - By the default the client will protect you against prototype poisoning attacks. Read https://web.archive.org/web/20200319091159/https://hueniverse.com/square-brackets-are-the-enemy-ff5b9fd8a3e8?gi=184a27ee2a08[this article] to learn more. If needed you can disable prototype poisoning protection entirely or one of the two checks. Read the `secure-json-parse` https://github.com/fastify/secure-json-parse[documentation] to learn more. +
 _Default:_ `false`
 
-|===
+|===

docs/connecting.asciidoc

@@ -10,6 +10,7 @@ This page contains the information you need to connect and use the Client with
 * <<client-usage, Using the client>>
 * <<client-connect-proxy, Connecting through a proxy>>
 * <<client-error-handling, Handling errors>>
+* <<product-check, Automatic product check>>
 
 [discrete]
 [[authentication]]
@@ -93,6 +94,26 @@ const client = new Client({
 })
 ----
 
+[discrete]
+[[auth-bearer]]
+==== Bearer authentication
+
+You can provide your credentials by passing the `bearer` token
+parameter via the `auth` option.
+Useful for https://www.elastic.co/guide/en/elasticsearch/reference/current/security-api-create-service-token.html[service account tokens].
+Be aware that it does not handle automatic token refresh.
+
+[source,js]
+----
+const { Client } = require('@elastic/elasticsearch')
+const client = new Client({
+  node: 'https://localhost:9200',
+  auth: {
+    bearer: 'token'
+  }
+})
+----
+
 
 [discrete]
 [[auth-basic]]
@@ -497,3 +518,15 @@ a|* `name` - `string`
 * `statusCode` - `object`, the response headers
 * `headers` - `object`, the response status code
 |===
+
+[discrete]
+[[product-check]]
+=== Automatic product check
+
+Since v7.14.0, the client performs a required product check before the first call.
+This pre-flight product check allows the client to establish the version of Elasticsearch
+that it is communicating with. The product check requires one additional HTTP request to
+be sent to the server as part of the request pipeline before the main API call is sent.
+In most cases, this will succeed during the very first API call that the client sends.
+Once the product check completes, no further product check HTTP requests are sent for 
+subsequent API calls.

docs/installation.asciidoc

@@ -17,7 +17,7 @@ To install a specific major version of the client, run the following command:
 npm install @elastic/elasticsearch@<major>
 ----
 
-To learn more about the supported major versions, please refer to the 
+To learn more about the supported major versions, please refer to the
 <<js-compatibility-matrix>>.
 
 [discrete]
@@ -37,7 +37,7 @@ to support that version for at least another minor release. If you are using the
 with a version of Node.js that will be unsupported soon, you will see a warning
 in your logs (the client will start logging the warning with two minors in advance).
 
-Unless you are *always* using a supported version of Node.js, 
+Unless you are *always* using a supported version of Node.js,
 we recommend defining the client dependency in your
 `package.json` with the `~` instead of `^`. In this way, you will lock the
 dependency on the minor release and not the major. (for example, `~7.10.0` instead
@@ -62,9 +62,12 @@ of `^7.10.0`).
 [[js-compatibility-matrix]]
 === Compatibility matrix
 
-The library is compatible with all {es} versions since 5.x. We recommend you to
-use the same major version of the client as the {es} instance that you are
-using.
+Elastic language clients are guaranteed to be able to communicate with Elasticsearch
+or Elastic solutions running on the same major version and greater or equal minor version.
+
+Language clients are forward compatible; meaning that clients support communicating
+with greater minor versions of Elasticsearch. Elastic language clients are not
+guaranteed to be backwards compatible.
 
 [%header,cols=2*]
 |===
@@ -91,4 +94,4 @@ using.
 WARNING: There is no official support for the browser environment. It exposes
 your {es} instance to everyone, which could lead to security issues. We
 recommend you to write a lightweight proxy that uses this client instead,
-you can see a proxy example https://github.com/elastic/elasticsearch-js/tree/master/docs/examples/proxy[here].
+you can see a proxy example https://github.com/elastic/elasticsearch-js/tree/master/docs/examples/proxy[here].

docs/reference.asciidoc

@@ -3648,6 +3648,27 @@ client.ilm.getStatus()
 link:{ref}/ilm-get-status.html[Documentation] +
 
 
+[discrete]
+=== ilm.migrateToDataTiers
+
+[source,ts]
+----
+client.ilm.migrateToDataTiers({
+  dry_run: boolean,
+  body: object
+})
+----
+link:{ref}/ilm-migrate-to-data-tiers.html[Documentation] +
+[cols=2*]
+|===
+|`dry_run` or `dryRun`
+|`boolean` - If set to true it will simulate the migration, providing a way to retrieve the ILM policies and indices that need to be migrated. The default is false
+
+|`body`
+|`object` - Optionally specify a legacy index template name to delete and optionally specify a node attribute name used for index shard routing (defaults to "data")
+
+|===
+
 [discrete]
 === ilm.moveToStep
 
@@ -7655,6 +7676,28 @@ link:{ref}/put-trained-models-aliases.html[Documentation] +
 
 |===
 
+[discrete]
+=== ml.resetJob
+
+[source,ts]
+----
+client.ml.resetJob({
+  job_id: string,
+  wait_for_completion: boolean
+})
+----
+link:{ref}/ml-reset-job.html[Documentation] +
+[cols=2*]
+|===
+|`job_id` or `jobId`
+|`string` - The ID of the job to reset
+
+|`wait_for_completion` or `waitForCompletion`
+|`boolean` - Should this request wait until the operation has completed before returning +
+_Default:_ `true`
+
+|===
+
 [discrete]
 === ml.revertModelSnapshot
 
@@ -8623,7 +8666,7 @@ client.renderSearchTemplate({
   body: object
 })
 ----
-link:{ref}/search-template.html#_validating_templates[Documentation] +
+link:{ref}/render-search-template-api.html[Documentation] +
 [cols=2*]
 |===
 |`id`
@@ -8725,7 +8768,7 @@ link:{ref}/rollup-put-job.html[Documentation] +
 
 [discrete]
 === rollup.rollup
-
+*Stability:* experimental
 [source,ts]
 ----
 client.rollup.rollup({
@@ -8734,7 +8777,7 @@ client.rollup.rollup({
   body: object
 })
 ----
-link:{ref}/rollup-api.html[Documentation] +
+link:{ref}/xpack-rollup.html[Documentation] +
 [cols=2*]
 |===
 |`index`
@@ -10020,6 +10063,108 @@ link:{ref}/security-api-put-user.html[Documentation] +
 
 |===
 
+[discrete]
+=== security.samlAuthenticate
+
+[source,ts]
+----
+client.security.samlAuthenticate({
+  body: object
+})
+----
+link:{ref}/security-api-saml-authenticate.html[Documentation] +
+[cols=2*]
+|===
+|`body`
+|`object` - The SAML response to authenticate
+
+|===
+
+[discrete]
+=== security.samlCompleteLogout
+
+[source,ts]
+----
+client.security.samlCompleteLogout({
+  body: object
+})
+----
+link:{ref}/security-api-saml-complete-logout.html[Documentation] +
+[cols=2*]
+|===
+|`body`
+|`object` - The logout response to verify
+
+|===
+
+[discrete]
+=== security.samlInvalidate
+
+[source,ts]
+----
+client.security.samlInvalidate({
+  body: object
+})
+----
+link:{ref}/security-api-saml-invalidate.html[Documentation] +
+[cols=2*]
+|===
+|`body`
+|`object` - The LogoutRequest message
+
+|===
+
+[discrete]
+=== security.samlLogout
+
+[source,ts]
+----
+client.security.samlLogout({
+  body: object
+})
+----
+link:{ref}/security-api-saml-logout.html[Documentation] +
+[cols=2*]
+|===
+|`body`
+|`object` - The tokens to invalidate
+
+|===
+
+[discrete]
+=== security.samlPrepareAuthentication
+
+[source,ts]
+----
+client.security.samlPrepareAuthentication({
+  body: object
+})
+----
+link:{ref}/security-api-saml-prepare-authentication.html[Documentation] +
+[cols=2*]
+|===
+|`body`
+|`object` - The realm for which to create the authentication request, identified by either its name or the ACS URL
+
+|===
+
+[discrete]
+=== security.samlServiceProviderMetadata
+
+[source,ts]
+----
+client.security.samlServiceProviderMetadata({
+  realm_name: string
+})
+----
+link:{ref}/security-api-saml-sp-metadata.html[Documentation] +
+[cols=2*]
+|===
+|`realm_name` or `realmName`
+|`string` - The name of the SAML realm to get the metadata for
+
+|===
+
 [discrete]
 === shutdown.deleteNode
 *Stability:* experimental
@@ -10382,6 +10527,7 @@ client.snapshot.get({
   master_timeout: string,
   ignore_unavailable: boolean,
   index_details: boolean,
+  include_repository: boolean,
   verbose: boolean
 })
 ----
@@ -10403,6 +10549,9 @@ link:{ref}/modules-snapshots.html[Documentation] +
 |`index_details` or `indexDetails`
 |`boolean` - Whether to include details of each index in the snapshot, if those details are available. Defaults to false.
 
+|`include_repository` or `includeRepository`
+|`boolean` - Whether to include the repository name in the snapshot info. Defaults to true.
+
 |`verbose`
 |`boolean` - Whether to show verbose snapshot info or only show the basic info found in the repository index blob
 
@@ -10433,6 +10582,67 @@ link:{ref}/modules-snapshots.html[Documentation] +
 
 |===
 
+[discrete]
+=== snapshot.repositoryAnalyze
+
+[source,ts]
+----
+client.snapshot.repositoryAnalyze({
+  repository: string,
+  blob_count: number,
+  concurrency: number,
+  read_node_count: number,
+  early_read_node_count: number,
+  seed: number,
+  rare_action_probability: number,
+  max_blob_size: string,
+  max_total_data_size: string,
+  timeout: string,
+  detailed: boolean,
+  rarely_abort_writes: boolean
+})
+----
+link:{ref}/modules-snapshots.html[Documentation] +
+[cols=2*]
+|===
+|`repository`
+|`string` - A repository name
+
+|`blob_count` or `blobCount`
+|`number` - Number of blobs to create during the test. Defaults to 100.
+
+|`concurrency`
+|`number` - Number of operations to run concurrently during the test. Defaults to 10.
+
+|`read_node_count` or `readNodeCount`
+|`number` - Number of nodes on which to read a blob after writing. Defaults to 10.
+
+|`early_read_node_count` or `earlyReadNodeCount`
+|`number` - Number of nodes on which to perform an early read on a blob, i.e. before writing has completed. Early reads are rare actions so the 'rare_action_probability' parameter is also relevant. Defaults to 2.
+
+|`seed`
+|`number` - Seed for the random number generator used to create the test workload. Defaults to a random value.
+
+|`rare_action_probability` or `rareActionProbability`
+|`number` - Probability of taking a rare action such as an early read or an overwrite. Defaults to 0.02.
+
+|`max_blob_size` or `maxBlobSize`
+|`string` - Maximum size of a blob to create during the test, e.g '1gb' or '100mb'. Defaults to '10mb'.
+
+|`max_total_data_size` or `maxTotalDataSize`
+|`string` - Maximum total size of all blobs to create during the test, e.g '1tb' or '100gb'. Defaults to '1gb'.
+
+|`timeout`
+|`string` - Explicit operation timeout. Defaults to '30s'.
+
+|`detailed`
+|`boolean` - Whether to return detailed results or a summary. Defaults to 'false' so that only the summary is returned.
+
+|`rarely_abort_writes` or `rarelyAbortWrites`
+|`boolean` - Whether to rarely abort writes before they complete. Defaults to 'true'.
+
+|===
+
 [discrete]
 === snapshot.restore
 
@@ -10537,6 +10747,75 @@ link:{ref}/sql-pagination.html[Documentation] +
 
 |===
 
+[discrete]
+=== sql.deleteAsync
+
+[source,ts]
+----
+client.sql.deleteAsync({
+  id: string
+})
+----
+link:{ref}/delete-async-sql-search-api.html[Documentation] +
+[cols=2*]
+|===
+|`id`
+|`string` - The async search ID
+
+|===
+
+[discrete]
+=== sql.getAsync
+
+[source,ts]
+----
+client.sql.getAsync({
+  id: string,
+  delimiter: string,
+  format: string,
+  keep_alive: string,
+  wait_for_completion_timeout: string
+})
+----
+link:{ref}/get-async-sql-search-api.html[Documentation] +
+[cols=2*]
+|===
+|`id`
+|`string` - The async search ID
+
+|`delimiter`
+|`string` - Separator for CSV results +
+_Default:_ `,`
+
+|`format`
+|`string` - Short version of the Accept header, e.g. json, yaml
+
+|`keep_alive` or `keepAlive`
+|`string` - Retention period for the search and its results +
+_Default:_ `5d`
+
+|`wait_for_completion_timeout` or `waitForCompletionTimeout`
+|`string` - Duration to wait for complete results
+
+|===
+
+[discrete]
+=== sql.getAsyncStatus
+
+[source,ts]
+----
+client.sql.getAsyncStatus({
+  id: string
+})
+----
+link:{ref}/get-async-sql-search-status-api.html[Documentation] +
+[cols=2*]
+|===
+|`id`
+|`string` - The async search ID
+
+|===
+
 [discrete]
 === sql.query
 

index.d.ts

@@ -43,7 +43,8 @@ import {
   CloudConnectionPool,
   ResurrectEvent,
   BasicAuth,
-  ApiKeyAuth
+  ApiKeyAuth,
+  BearerAuth
 } from './lib/pool';
 import Serializer from './lib/Serializer';
 import Helpers from './lib/Helpers';
@@ -106,7 +107,7 @@ interface ClientOptions {
   opaqueIdPrefix?: string;
   generateRequestId?: generateRequestIdFn;
   name?: string | symbol;
-  auth?: BasicAuth | ApiKeyAuth;
+  auth?: BasicAuth | ApiKeyAuth | BearerAuth;
   context?: Context;
   proxy?: string | URL;
   enableMetaHeader?: boolean;
@@ -832,6 +833,14 @@ declare class Client {
     getStatus<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
     getStatus<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IlmGetStatus, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
     getStatus<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IlmGetStatus, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    migrate_to_data_tiers<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IlmMigrateToDataTiers<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    migrate_to_data_tiers<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    migrate_to_data_tiers<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IlmMigrateToDataTiers<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    migrate_to_data_tiers<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IlmMigrateToDataTiers<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    migrateToDataTiers<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IlmMigrateToDataTiers<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    migrateToDataTiers<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    migrateToDataTiers<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IlmMigrateToDataTiers<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    migrateToDataTiers<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IlmMigrateToDataTiers<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
     move_to_step<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IlmMoveToStep<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     move_to_step<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
     move_to_step<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IlmMoveToStep<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
@@ -1760,6 +1769,14 @@ declare class Client {
     putTrainedModelAlias<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
     putTrainedModelAlias<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlPutTrainedModelAlias, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
     putTrainedModelAlias<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlPutTrainedModelAlias, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    reset_job<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlResetJob, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    reset_job<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    reset_job<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlResetJob, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    reset_job<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlResetJob, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    resetJob<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlResetJob, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    resetJob<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    resetJob<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlResetJob, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    resetJob<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlResetJob, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
     revert_model_snapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlRevertModelSnapshot<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     revert_model_snapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
     revert_model_snapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlRevertModelSnapshot<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
@@ -2408,6 +2425,54 @@ declare class Client {
     putUser<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
     putUser<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityPutUser<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
     putUser<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityPutUser<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    saml_authenticate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecuritySamlAuthenticate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    saml_authenticate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    saml_authenticate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecuritySamlAuthenticate<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    saml_authenticate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecuritySamlAuthenticate<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    samlAuthenticate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecuritySamlAuthenticate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    samlAuthenticate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    samlAuthenticate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecuritySamlAuthenticate<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    samlAuthenticate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecuritySamlAuthenticate<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    saml_complete_logout<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecuritySamlCompleteLogout<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    saml_complete_logout<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    saml_complete_logout<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecuritySamlCompleteLogout<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    saml_complete_logout<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecuritySamlCompleteLogout<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    samlCompleteLogout<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecuritySamlCompleteLogout<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    samlCompleteLogout<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    samlCompleteLogout<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecuritySamlCompleteLogout<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    samlCompleteLogout<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecuritySamlCompleteLogout<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    saml_invalidate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecuritySamlInvalidate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    saml_invalidate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    saml_invalidate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecuritySamlInvalidate<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    saml_invalidate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecuritySamlInvalidate<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    samlInvalidate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecuritySamlInvalidate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    samlInvalidate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    samlInvalidate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecuritySamlInvalidate<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    samlInvalidate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecuritySamlInvalidate<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    saml_logout<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecuritySamlLogout<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    saml_logout<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    saml_logout<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecuritySamlLogout<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    saml_logout<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecuritySamlLogout<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    samlLogout<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecuritySamlLogout<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    samlLogout<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    samlLogout<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecuritySamlLogout<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    samlLogout<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecuritySamlLogout<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    saml_prepare_authentication<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecuritySamlPrepareAuthentication<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    saml_prepare_authentication<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    saml_prepare_authentication<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecuritySamlPrepareAuthentication<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    saml_prepare_authentication<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecuritySamlPrepareAuthentication<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    samlPrepareAuthentication<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecuritySamlPrepareAuthentication<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    samlPrepareAuthentication<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    samlPrepareAuthentication<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecuritySamlPrepareAuthentication<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    samlPrepareAuthentication<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecuritySamlPrepareAuthentication<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    saml_service_provider_metadata<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecuritySamlServiceProviderMetadata, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    saml_service_provider_metadata<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    saml_service_provider_metadata<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecuritySamlServiceProviderMetadata, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    saml_service_provider_metadata<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecuritySamlServiceProviderMetadata, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    samlServiceProviderMetadata<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecuritySamlServiceProviderMetadata, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    samlServiceProviderMetadata<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    samlServiceProviderMetadata<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecuritySamlServiceProviderMetadata, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    samlServiceProviderMetadata<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecuritySamlServiceProviderMetadata, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
   shutdown: {
     delete_node<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ShutdownDeleteNode, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
@@ -2550,6 +2615,14 @@ declare class Client {
     getRepository<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
     getRepository<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotGetRepository, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
     getRepository<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotGetRepository, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    repository_analyze<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SnapshotRepositoryAnalyze, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    repository_analyze<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    repository_analyze<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotRepositoryAnalyze, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    repository_analyze<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotRepositoryAnalyze, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    repositoryAnalyze<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SnapshotRepositoryAnalyze, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    repositoryAnalyze<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    repositoryAnalyze<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotRepositoryAnalyze, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    repositoryAnalyze<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotRepositoryAnalyze, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
     restore<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SnapshotRestore<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     restore<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
     restore<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotRestore<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
@@ -2576,6 +2649,30 @@ declare class Client {
     clearCursor<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
     clearCursor<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SqlClearCursor<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
     clearCursor<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SqlClearCursor<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_async<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SqlDeleteAsync, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_async<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_async<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SqlDeleteAsync, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_async<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SqlDeleteAsync, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteAsync<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SqlDeleteAsync, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteAsync<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteAsync<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SqlDeleteAsync, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteAsync<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SqlDeleteAsync, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_async<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SqlGetAsync, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_async<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_async<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SqlGetAsync, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_async<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SqlGetAsync, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getAsync<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SqlGetAsync, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getAsync<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getAsync<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SqlGetAsync, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getAsync<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SqlGetAsync, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_async_status<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SqlGetAsyncStatus, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_async_status<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_async_status<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SqlGetAsyncStatus, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_async_status<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SqlGetAsyncStatus, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getAsyncStatus<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SqlGetAsyncStatus, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getAsyncStatus<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getAsyncStatus<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SqlGetAsyncStatus, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getAsyncStatus<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SqlGetAsyncStatus, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
     query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SqlQuery<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
     query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SqlQuery<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback

index.js

@@ -116,6 +116,10 @@ class Client extends ESAPI {
         disablePrototypePoisoningProtection: false
       }, opts)
 
+    if (process.env.ELASTIC_CLIENT_APIVERSIONING === 'true') {
+      options.headers = Object.assign({ accept: 'application/vnd.elasticsearch+json; compatible-with=7' }, options.headers)
+    }
+
     this[kInitialOptions] = options
     this[kExtensions] = []
     this.name = options.name
@@ -251,6 +255,10 @@ class Client extends ESAPI {
     }
 
     const client = new Client(options)
+    // sync product check
+    const tSymbol = Object.getOwnPropertySymbols(this.transport)
+      .filter(symbol => symbol.description === 'product check')[0]
+    client.transport[tSymbol] = this.transport[tSymbol]
     // Add parent extensions
     if (this[kExtensions].length > 0) {
       this[kExtensions].forEach(({ name, opts, fn }) => {

lib/Connection.js

@@ -331,6 +331,8 @@ function prepareHeaders (headers = {}, auth) {
       } else {
         headers.authorization = `ApiKey ${auth.apiKey}`
       }
+    } else if (auth.bearer) {
+      headers.authorization = `Bearer ${auth.bearer}`
     } else if (auth.username && auth.password) {
       headers.authorization = 'Basic ' + Buffer.from(`${auth.username}:${auth.password}`).toString('base64')
     }

lib/Helpers.d.ts

@@ -36,6 +36,7 @@ export interface ScrollSearchResponse<TDocument = unknown, TResponse = Record<st
 
 export interface BulkHelper<T> extends Promise<T> {
   abort: () => BulkHelper<T>
+  readonly stats: BulkStats
 }
 
 export interface BulkStats {
@@ -43,6 +44,7 @@ export interface BulkStats {
   failed: number
   retry: number
   successful: number
+  noop: number
   time: number
   bytes: number
   aborted: boolean

lib/Helpers.js

@@ -456,6 +456,7 @@ class Helpers {
       failed: 0,
       retry: 0,
       successful: 0,
+      noop: 0,
       time: 0,
       bytes: 0,
       aborted: false
@@ -463,6 +464,9 @@ class Helpers {
 
     const p = iterate()
     const helper = {
+      get stats () {
+        return stats
+      },
       then (onFulfilled, onRejected) {
         return p.then(onFulfilled, onRejected)
       },
@@ -692,6 +696,11 @@ class Helpers {
           if (err) return callback(err, null)
           if (body.errors === false) {
             stats.successful += body.items.length
+            for (const item of body.items) {
+              if (item.update && item.update.result === 'noop') {
+                stats.noop++
+              }
+            }
             return callback(null, [])
           }
           const retry = []

lib/Transport.d.ts

@@ -26,7 +26,8 @@ import * as errors from './errors';
 export type ApiError = errors.ConfigurationError | errors.ConnectionError |
                        errors.DeserializationError | errors.SerializationError |
                        errors.NoLivingConnectionsError | errors.ResponseError |
-                       errors.TimeoutError | errors.RequestAbortedError
+                       errors.TimeoutError | errors.RequestAbortedError |
+                       errors.ProductNotSupportedError
 
 export type Context = unknown
 

lib/Transport.js

@@ -24,12 +24,14 @@ const os = require('os')
 const { gzip, unzip, createGzip } = require('zlib')
 const buffer = require('buffer')
 const ms = require('ms')
+const { EventEmitter } = require('events')
 const {
   ConnectionError,
   RequestAbortedError,
   NoLivingConnectionsError,
   ResponseError,
-  ConfigurationError
+  ConfigurationError,
+  ProductNotSupportedError
 } = require('./errors')
 
 const noop = () => {}
@@ -38,6 +40,9 @@ const clientVersion = require('../package.json').version
 const userAgent = `elasticsearch-js/${clientVersion} (${os.platform()} ${os.release()}-${os.arch()}; Node.js ${process.version})`
 const MAX_BUFFER_LENGTH = buffer.constants.MAX_LENGTH
 const MAX_STRING_LENGTH = buffer.constants.MAX_STRING_LENGTH
+const kProductCheck = Symbol('product check')
+const kApiVersioning = Symbol('api versioning')
+const kEventEmitter = Symbol('event emitter')
 
 class Transport {
   constructor (opts) {
@@ -64,6 +69,9 @@ class Transport {
     this.generateRequestId = opts.generateRequestId || generateRequestId()
     this.name = opts.name
     this.opaqueIdPrefix = opts.opaqueIdPrefix
+    this[kProductCheck] = 0 // 0 = to be checked, 1 = checking, 2 = checked-ok, 3 checked-notok, 4 checked-nodefault
+    this[kApiVersioning] = process.env.ELASTIC_CLIENT_APIVERSIONING === 'true'
+    this[kEventEmitter] = new EventEmitter()
 
     this.nodeFilter = opts.nodeFilter || defaultNodeFilter
     if (typeof opts.nodeSelector === 'function') {
@@ -81,7 +89,11 @@ class Transport {
     this._isSniffing = false
 
     if (opts.sniffOnStart === true) {
-      this.sniff({ reason: Transport.sniffReasons.SNIFF_ON_START })
+      // timer needed otherwise it will clash
+      // with the product check testing
+      setTimeout(() => {
+        this.sniff({ reason: Transport.sniffReasons.SNIFF_ON_START })
+      }, 10)
     }
   }
 
@@ -295,7 +307,8 @@ class Transport {
       //    - the request is not a HEAD request
       //    - the payload is not an empty string
       if (result.headers['content-type'] !== undefined &&
-          result.headers['content-type'].indexOf('application/json') > -1 &&
+          (result.headers['content-type'].indexOf('application/json') > -1 ||
+          result.headers['content-type'].indexOf('application/vnd.elasticsearch+json') > -1) &&
           isHead === false &&
           payload !== ''
       ) {
@@ -347,91 +360,130 @@ class Transport {
       }
     }
 
-    this.emit('serialization', null, result)
-    const headers = Object.assign({}, this.headers, lowerCaseHeaders(options.headers))
+    const prepareRequest = () => {
+      this.emit('serialization', null, result)
+      const headers = Object.assign({}, this.headers, lowerCaseHeaders(options.headers))
 
-    if (options.opaqueId !== undefined) {
-      headers['x-opaque-id'] = this.opaqueIdPrefix !== null
-        ? this.opaqueIdPrefix + options.opaqueId
-        : options.opaqueId
-    }
-
-    // handle json body
-    if (params.body != null) {
-      if (shouldSerialize(params.body) === true) {
-        try {
-          params.body = this.serializer.serialize(params.body)
-        } catch (err) {
-          this.emit('request', err, result)
-          process.nextTick(callback, err, result)
-          return transportReturn
-        }
+      if (options.opaqueId !== undefined) {
+        headers['x-opaque-id'] = this.opaqueIdPrefix !== null
+          ? this.opaqueIdPrefix + options.opaqueId
+          : options.opaqueId
       }
 
-      if (params.body !== '') {
-        headers['content-type'] = headers['content-type'] || 'application/json'
-      }
-
-    // handle ndjson body
-    } else if (params.bulkBody != null) {
-      if (shouldSerialize(params.bulkBody) === true) {
-        try {
-          params.body = this.serializer.ndserialize(params.bulkBody)
-        } catch (err) {
-          this.emit('request', err, result)
-          process.nextTick(callback, err, result)
-          return transportReturn
-        }
-      } else {
-        params.body = params.bulkBody
-      }
-      if (params.body !== '') {
-        headers['content-type'] = headers['content-type'] || 'application/x-ndjson'
-      }
-    }
-
-    params.headers = headers
-    // serializes the querystring
-    if (options.querystring == null) {
-      params.querystring = this.serializer.qserialize(params.querystring)
-    } else {
-      params.querystring = this.serializer.qserialize(
-        Object.assign({}, params.querystring, options.querystring)
-      )
-    }
-
-    // handles request timeout
-    params.timeout = toMs(options.requestTimeout || this.requestTimeout)
-    if (options.asStream === true) params.asStream = true
-    meta.request.params = params
-    meta.request.options = options
-
-    // handle compression
-    if (params.body !== '' && params.body != null) {
-      if (isStream(params.body) === true) {
-        if (compression === 'gzip') {
-          params.headers['content-encoding'] = compression
-          params.body = params.body.pipe(createGzip())
-        }
-        makeRequest()
-      } else if (compression === 'gzip') {
-        gzip(params.body, (err, buffer) => {
-          /* istanbul ignore next */
-          if (err) {
+      // handle json body
+      if (params.body != null) {
+        if (shouldSerialize(params.body) === true) {
+          try {
+            params.body = this.serializer.serialize(params.body)
+          } catch (err) {
             this.emit('request', err, result)
-            return callback(err, result)
+            process.nextTick(callback, err, result)
+            return transportReturn
           }
-          params.headers['content-encoding'] = compression
-          params.headers['content-length'] = '' + Buffer.byteLength(buffer)
-          params.body = buffer
-          makeRequest()
-        })
+        }
+
+        if (params.body !== '') {
+          headers['content-type'] = headers['content-type'] || (this[kApiVersioning] ? 'application/vnd.elasticsearch+json; compatible-with=7' : 'application/json')
+        }
+
+      // handle ndjson body
+      } else if (params.bulkBody != null) {
+        if (shouldSerialize(params.bulkBody) === true) {
+          try {
+            params.body = this.serializer.ndserialize(params.bulkBody)
+          } catch (err) {
+            this.emit('request', err, result)
+            process.nextTick(callback, err, result)
+            return transportReturn
+          }
+        } else {
+          params.body = params.bulkBody
+        }
+        if (params.body !== '') {
+          headers['content-type'] = headers['content-type'] || (this[kApiVersioning] ? 'application/vnd.elasticsearch+x-ndjson; compatible-with=7' : 'application/x-ndjson')
+        }
+      }
+
+      params.headers = headers
+      // serializes the querystring
+      if (options.querystring == null) {
+        params.querystring = this.serializer.qserialize(params.querystring)
+      } else {
+        params.querystring = this.serializer.qserialize(
+          Object.assign({}, params.querystring, options.querystring)
+        )
+      }
+
+      // handles request timeout
+      params.timeout = toMs(options.requestTimeout || this.requestTimeout)
+      if (options.asStream === true) params.asStream = true
+      meta.request.params = params
+      meta.request.options = options
+
+      // handle compression
+      if (params.body !== '' && params.body != null) {
+        if (isStream(params.body) === true) {
+          if (compression === 'gzip') {
+            params.headers['content-encoding'] = compression
+            params.body = params.body.pipe(createGzip())
+          }
+          makeRequest()
+        } else if (compression === 'gzip') {
+          gzip(params.body, (err, buffer) => {
+            /* istanbul ignore next */
+            if (err) {
+              this.emit('request', err, result)
+              return callback(err, result)
+            }
+            params.headers['content-encoding'] = compression
+            params.headers['content-length'] = '' + Buffer.byteLength(buffer)
+            params.body = buffer
+            makeRequest()
+          })
+        } else {
+          params.headers['content-length'] = '' + Buffer.byteLength(params.body)
+          makeRequest()
+        }
       } else {
-        params.headers['content-length'] = '' + Buffer.byteLength(params.body)
         makeRequest()
       }
+    }
+
+    // still need to check the product or waiting for the check to finish
+    if (this[kProductCheck] === 0 || this[kProductCheck] === 1) {
+      // let pass info requests
+      if (params.method === 'GET' && params.path === '/') {
+        prepareRequest()
+      } else {
+        // wait for product check to finish
+        this[kEventEmitter].once('product-check', (error, status) => {
+          if (status === false) {
+            const err = error || new ProductNotSupportedError(result)
+            if (this[kProductCheck] === 4) {
+              err.message = 'The client noticed that the server is not a supported distribution of Elasticsearch'
+            }
+            this.emit('request', err, result)
+            process.nextTick(callback, err, result)
+          } else {
+            prepareRequest()
+          }
+        })
+        // the very first request triggers the product check
+        if (this[kProductCheck] === 0) {
+          this.productCheck()
+        }
+      }
+    // the product check is finished and it's not Elasticsearch
+    } else if (this[kProductCheck] === 3 || this[kProductCheck] === 4) {
+      const err = new ProductNotSupportedError(result)
+      if (this[kProductCheck] === 4) {
+        err.message = 'The client noticed that the server is not a supported distribution of Elasticsearch'
+      }
+      this.emit('request', err, result)
+      process.nextTick(callback, err, result)
+    // the product check finished and it's Elasticsearch
     } else {
-      makeRequest()
+      prepareRequest()
     }
 
     return transportReturn
@@ -491,6 +543,65 @@ class Transport {
       callback(null, hosts)
     })
   }
+
+  productCheck () {
+    debug('Start product check')
+    this[kProductCheck] = 1
+    this.request({
+      method: 'GET',
+      path: '/'
+    }, (err, result) => {
+      this[kProductCheck] = 3
+      if (err) {
+        debug('Product check failed', err)
+        if (err.statusCode === 401 || err.statusCode === 403) {
+          this[kProductCheck] = 2
+          process.emitWarning('The client is unable to verify that the server is Elasticsearch due to security privileges on the server side. Some functionality may not be compatible if the server is running an unsupported product.')
+          this[kEventEmitter].emit('product-check', null, true)
+        } else {
+          this[kProductCheck] = 0
+          this[kEventEmitter].emit('product-check', err, false)
+        }
+      } else {
+        debug('Checking elasticsearch version', result.body, result.headers)
+        if (result.body.version == null || typeof result.body.version.number !== 'string') {
+          debug('Can\'t access Elasticsearch version')
+          return this[kEventEmitter].emit('product-check', null, false)
+        }
+        const tagline = result.body.tagline
+        const version = result.body.version.number.split('.')
+        const major = Number(version[0])
+        const minor = Number(version[1])
+        if (major < 6) {
+          return this[kEventEmitter].emit('product-check', null, false)
+        } else if (major >= 6 && major < 7) {
+          if (tagline !== 'You Know, for Search') {
+            debug('Bad tagline')
+            return this[kEventEmitter].emit('product-check', null, false)
+          }
+        } else if (major === 7 && minor < 14) {
+          if (tagline !== 'You Know, for Search') {
+            debug('Bad tagline')
+            return this[kEventEmitter].emit('product-check', null, false)
+          }
+
+          if (result.body.version.build_flavor !== 'default') {
+            debug('Bad build_flavor')
+            this[kProductCheck] = 4
+            return this[kEventEmitter].emit('product-check', null, false)
+          }
+        } else {
+          if (result.headers['x-elastic-product'] !== 'Elasticsearch') {
+            debug('x-elastic-product not recognized')
+            return this[kEventEmitter].emit('product-check', null, false)
+          }
+        }
+        debug('Valid Elasticsearch distribution')
+        this[kProductCheck] = 2
+        this[kEventEmitter].emit('product-check', null, true)
+      }
+    })
+  }
 }
 
 Transport.sniffReasons = {

lib/errors.d.ts

@@ -81,3 +81,10 @@ export declare class RequestAbortedError<TResponse = Record<string, any>, TConte
   meta: ApiResponse<TResponse, TContext>;
   constructor(message: string, meta: ApiResponse);
 }
+
+export declare class ProductNotSupportedError<TResponse = Record<string, any>, TContext = Context> extends ElasticsearchClientError {
+  name: string;
+  message: string;
+  meta: ApiResponse<TResponse, TContext>;
+  constructor(meta: ApiResponse);
+}

lib/errors.js

@@ -133,6 +133,16 @@ class RequestAbortedError extends ElasticsearchClientError {
   }
 }
 
+class ProductNotSupportedError extends ElasticsearchClientError {
+  constructor (meta) {
+    super('Product Not Supported Error')
+    Error.captureStackTrace(this, ProductNotSupportedError)
+    this.name = 'ProductNotSupportedError'
+    this.message = 'The client noticed that the server is not Elasticsearch and we do not support this unknown product.'
+    this.meta = meta
+  }
+}
+
 module.exports = {
   ElasticsearchClientError,
   TimeoutError,
@@ -142,5 +152,6 @@ module.exports = {
   DeserializationError,
   ConfigurationError,
   ResponseError,
-  RequestAbortedError
+  RequestAbortedError,
+  ProductNotSupportedError
 }

lib/pool/index.d.ts

@@ -61,6 +61,10 @@ interface BasicAuth {
   password: string;
 }
 
+interface BearerAuth {
+  bearer: string
+}
+
 interface resurrectOptions {
   now?: number;
   requestId: string;
@@ -204,6 +208,7 @@ export {
   getConnectionOptions,
   ApiKeyAuth,
   BasicAuth,
+  BearerAuth,
   internals,
   resurrectOptions,
   ResurrectEvent,

package.json

@@ -11,8 +11,8 @@
     "./": "./"
   },
   "homepage": "http://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/index.html",
-  "version": "7.14.0",
-  "versionCanary": "7.14.0-canary.6",
+  "version": "7.14.1",
+  "versionCanary": "7.14.0-canary.7",
   "keywords": [
     "elasticsearch",
     "elastic",

test/acceptance/events-order.test.js

@@ -21,7 +21,7 @@
 
 const { test } = require('tap')
 const intoStream = require('into-stream')
-const { Client, Connection, events } = require('../../index')
+const { Connection, events } = require('../../index')
 const {
   TimeoutError,
   ConnectionError,
@@ -31,6 +31,7 @@ const {
   DeserializationError
 } = require('../../lib/errors')
 const {
+  Client,
   buildServer,
   connection: {
     MockConnection,

test/acceptance/observability.test.js

@@ -2,8 +2,9 @@
 
 const { test } = require('tap')
 const FakeTimers = require('@sinonjs/fake-timers')
-const { Client, Transport } = require('../../index')
+const { Transport } = require('../../index')
 const {
+  Client,
   connection: { MockConnection, MockConnectionSniff }
 } = require('../utils')
 const noop = () => {}

test/acceptance/proxy.test.js

@@ -4,8 +4,8 @@
 process.env.NODE_TLS_REJECT_UNAUTHORIZED = 0
 
 const { test } = require('tap')
-const { Client } = require('../../index')
 const {
+  Client,
   buildProxy: {
     createProxy,
     createSecureProxy,

test/acceptance/resurrect.test.js

@@ -23,8 +23,8 @@ const { test } = require('tap')
 const { URL } = require('url')
 const FakeTimers = require('@sinonjs/fake-timers')
 const workq = require('workq')
-const { buildCluster } = require('../utils')
-const { Client, events } = require('../../index')
+const { Client, buildCluster } = require('../utils')
+const { events } = require('../../index')
 
 /**
  * The aim of this test is to verify how the resurrect logic behaves

test/acceptance/sniff.test.js

@@ -23,8 +23,8 @@ const { test } = require('tap')
 const { URL } = require('url')
 const FakeTimers = require('@sinonjs/fake-timers')
 const workq = require('workq')
-const { buildCluster } = require('../utils')
-const { Client, Connection, Transport, events, errors } = require('../../index')
+const { Client, buildCluster } = require('../utils')
+const { Connection, Transport, events, errors } = require('../../index')
 
 /**
  * The aim of this test is to verify how the sniffer behaves

test/bundlers/parcel-test/package.json

@@ -2,7 +2,6 @@
   "name": "parcel-test",
   "version": "1.0.0",
   "description": "",
-  "main": "index.js",
   "scripts": {
     "start": "node index.js",
     "build": "parcel build index.js --no-source-maps"

test/integration/index.js

@@ -47,6 +47,8 @@ const freeSkips = {
   // TODO: remove this once 'arbitrary_key' is implemented
   // https://github.com/elastic/elasticsearch/pull/41492
   'indices.split/30_copy_settings.yml': ['*'],
+  'indices.stats/50_disk_usage.yml': ['Disk usage stats'],
+  'indices.stats/60_field_usage.yml': ['Field usage stats'],
   // skipping because we are booting ES with `discovery.type=single-node`
   // and this test will fail because of this configuration
   'nodes.stats/30_discovery.yml': ['*'],
@@ -55,6 +57,7 @@ const freeSkips = {
   'search.aggregation/240_max_buckets.yml': ['*']
 }
 const platinumBlackList = {
+  'analytics/histogram.yml': ['Histogram requires values in increasing order'],
   // this two test cases are broken, we should
   // return on those in the future.
   'analytics/top_metrics.yml': [

test/integration/test-runner.js

@@ -80,6 +80,18 @@ function build (opts = {}) {
 
       // remove 'x_pack_rest_user', used in some xpack test
       await client.security.deleteUser({ username: 'x_pack_rest_user' }, { ignore: [404] })
+
+      const { body: searchableSnapshotIndices } = await client.cluster.state({
+        metric: 'metadata',
+        filter_path: 'metadata.indices.*.settings.index.store.snapshot'
+      })
+      if (searchableSnapshotIndices.metadata != null && searchableSnapshotIndices.metadata.indices != null) {
+        await helper.runInParallel(
+          client, 'indices.delete',
+          Object.keys(searchableSnapshotIndices.metadata.indices).map(i => ({ index: i })),
+          { ignore: [404] }
+        )
+      }
     }
 
     // clean snapshots
@@ -164,6 +176,13 @@ function build (opts = {}) {
       )
     }
 
+    const { body: shutdownNodes } = await client.shutdown.getNode()
+    if (shutdownNodes._nodes == null && shutdownNodes.cluster_name == null) {
+      for (const node of shutdownNodes.nodes) {
+        await client.shutdown.deleteNode({ node_id: node.node_id })
+      }
+    }
+
     // wait for pending task before resolving the promise
     await sleep(100)
     while (true) {

test/unit/api-async.js

@@ -19,8 +19,8 @@
 
 'use strict'
 
-const { Client, errors } = require('../../index')
-const { buildServer } = require('../utils')
+const { errors } = require('../../index')
+const { Client, buildServer } = require('../utils')
 
 function runAsyncTest (test) {
   test('async await (search)', t => {

test/unit/api.test.js

@@ -20,8 +20,8 @@
 'use strict'
 
 const { test } = require('tap')
-const { Client, errors } = require('../../index')
-const { buildServer } = require('../utils')
+const { errors } = require('../../index')
+const { Client, buildServer } = require('../utils')
 
 test('Basic (callback)', t => {
   t.plan(2)

test/unit/child.test.js

@@ -20,8 +20,9 @@
 'use strict'
 
 const { test } = require('tap')
-const { Client, errors } = require('../../index')
+const { errors } = require('../../index')
 const {
+  Client,
   buildServer,
   connection: { MockConnection }
 } = require('../utils')

test/unit/client.test.js

@@ -23,9 +23,9 @@ const { test } = require('tap')
 const { URL } = require('url')
 const buffer = require('buffer')
 const intoStream = require('into-stream')
-const { Client, ConnectionPool, Transport, Connection, errors } = require('../../index')
+const { ConnectionPool, Transport, Connection, errors } = require('../../index')
 const { CloudConnectionPool } = require('../../lib/pool')
-const { buildServer } = require('../utils')
+const { Client, buildServer } = require('../utils')
 let clientVersion = require('../../package.json').version
 if (clientVersion.includes('-')) {
   clientVersion = clientVersion.slice(0, clientVersion.indexOf('-')) + 'p'
@@ -1421,3 +1421,80 @@ test('Disable prototype poisoning protection', t => {
     t.error(err)
   })
 })
+
+test('API compatibility header (json)', t => {
+  t.plan(4)
+
+  function handler (req, res) {
+    t.equal(req.headers.accept, 'application/vnd.elasticsearch+json; compatible-with=7')
+    t.equal(req.headers['content-type'], 'application/vnd.elasticsearch+json; compatible-with=7')
+    res.setHeader('Content-Type', 'application/vnd.elasticsearch+json; compatible-with=7')
+    res.end(JSON.stringify({ hello: 'world' }))
+  }
+
+  buildServer(handler, ({ port }, server) => {
+    process.env.ELASTIC_CLIENT_APIVERSIONING = 'true'
+    const client = new Client({
+      node: `http://localhost:${port}`
+    })
+
+    client.index({ index: 'foo', body: {} }, (err, { body }) => {
+      t.error(err)
+      t.same(body, { hello: 'world' })
+      server.stop()
+      delete process.env.ELASTIC_CLIENT_APIVERSIONING
+    })
+  })
+})
+
+test('API compatibility header (x-ndjson)', t => {
+  t.plan(4)
+
+  function handler (req, res) {
+    t.equal(req.headers.accept, 'application/vnd.elasticsearch+json; compatible-with=7')
+    t.equal(req.headers['content-type'], 'application/vnd.elasticsearch+x-ndjson; compatible-with=7')
+    res.setHeader('Content-Type', 'application/vnd.elasticsearch+json; compatible-with=7')
+    res.end(JSON.stringify({ hello: 'world' }))
+  }
+
+  buildServer(handler, ({ port }, server) => {
+    process.env.ELASTIC_CLIENT_APIVERSIONING = 'true'
+    const client = new Client({
+      node: `http://localhost:${port}`
+    })
+
+    client.bulk({ index: 'foo', body: [{}, {}] }, (err, { body }) => {
+      t.error(err)
+      t.same(body, { hello: 'world' })
+      server.stop()
+      delete process.env.ELASTIC_CLIENT_APIVERSIONING
+    })
+  })
+})
+
+test('Bearer auth', t => {
+  t.plan(3)
+
+  function handler (req, res) {
+    t.match(req.headers, {
+      authorization: 'Bearer Zm9vOmJhcg=='
+    })
+    res.setHeader('Content-Type', 'application/json;utf=8')
+    res.end(JSON.stringify({ hello: 'world' }))
+  }
+
+  buildServer(handler, ({ port }, server) => {
+    const client = new Client({
+      node: `http://localhost:${port}`,
+      auth: {
+        bearer: 'Zm9vOmJhcg=='
+      }
+    })
+
+    client.info((err, { body }) => {
+      t.error(err)
+      t.same(body, { hello: 'world' })
+      server.stop()
+    })
+  })
+})

test/unit/events.test.js

@@ -20,9 +20,10 @@
 'use strict'
 
 const { test } = require('tap')
-const { Client, events } = require('../../index')
+const { events } = require('../../index')
 const { TimeoutError } = require('../../lib/errors')
 const {
+  Client,
   connection: {
     MockConnection,
     MockConnectionTimeout

test/unit/helpers/bulk.test.js

@@ -24,8 +24,8 @@ const { join } = require('path')
 const split = require('split2')
 const FakeTimers = require('@sinonjs/fake-timers')
 const { test } = require('tap')
-const { Client, errors } = require('../../../')
-const { buildServer, connection } = require('../../utils')
+const { errors } = require('../../../')
+const { Client, buildServer, connection } = require('../../utils')
 let clientVersion = require('../../../package.json').version
 if (clientVersion.includes('-')) {
   clientVersion = clientVersion.slice(0, clientVersion.indexOf('-')) + 'p'
@@ -913,6 +913,55 @@ test('bulk update', t => {
     })
   })
 
+  t.test('Should track the number of noop results', async t => {
+    let count = 0
+    const MockConnection = connection.buildMockConnection({
+      onRequest (params) {
+        t.strictEqual(params.path, '/_bulk')
+        t.match(params.headers, { 'content-type': 'application/x-ndjson' })
+        const [action, payload] = params.body.split('\n')
+        t.deepEqual(JSON.parse(action), { update: { _index: 'test', _id: count } })
+        t.deepEqual(JSON.parse(payload), { doc: dataset[count++], doc_as_upsert: true })
+        return { body: { errors: false, items: [{ update: { result: 'noop' } }] } }
+      }
+    })
+
+    const client = new Client({
+      node: 'http://localhost:9200',
+      Connection: MockConnection
+    })
+    let id = 0
+    const result = await client.helpers.bulk({
+      datasource: dataset.slice(),
+      flushBytes: 1,
+      concurrency: 1,
+      onDocument (doc) {
+        return [{
+          update: {
+            _index: 'test',
+            _id: id++
+          }
+        }, {
+          doc_as_upsert: true
+        }]
+      },
+      onDrop (doc) {
+        t.fail('This should never be called')
+      }
+    })
+
+    t.type(result.time, 'number')
+    t.type(result.bytes, 'number')
+    t.match(result, {
+      total: 3,
+      successful: 3,
+      noop: 3,
+      retry: 0,
+      failed: 0,
+      aborted: false
+    })
+  })
+
   t.end()
 })
 
@@ -1263,5 +1312,52 @@ test('Flush interval', t => {
     })
   })
 
+  t.test('Operation stats', async t => {
+    let count = 0
+    const MockConnection = connection.buildMockConnection({
+      onRequest (params) {
+        t.strictEqual(params.path, '/_bulk')
+        t.match(params.headers, {
+          'content-type': 'application/x-ndjson',
+          'x-elastic-client-meta': `es=${clientVersion},js=${nodeVersion},t=${clientVersion},hc=${nodeVersion},h=bp`
+        })
+        const [action, payload] = params.body.split('\n')
+        t.deepEqual(JSON.parse(action), { index: { _index: 'test' } })
+        t.deepEqual(JSON.parse(payload), dataset[count++])
+        return { body: { errors: false, items: [{}] } }
+      }
+    })
+
+    const client = new Client({
+      node: 'http://localhost:9200',
+      Connection: MockConnection
+    })
+    const b = client.helpers.bulk({
+      datasource: dataset.slice(),
+      flushBytes: 1,
+      concurrency: 1,
+      onDocument (doc) {
+        return {
+          index: { _index: 'test' }
+        }
+      },
+      onDrop (doc) {
+        t.fail('This should never be called')
+      }
+    })
+    const result = await b
+
+    t.type(result.time, 'number')
+    t.type(result.bytes, 'number')
+    t.match(result, b.stats)
+    t.match(result, {
+      total: 3,
+      successful: 3,
+      retry: 0,
+      failed: 0,
+      aborted: false
+    })
+  })
+
   t.end()
 })

test/unit/helpers/msearch.test.js

@@ -20,8 +20,8 @@
 'use strict'
 
 const { test } = require('tap')
-const { Client, errors } = require('../../../')
-const { connection } = require('../../utils')
+const { errors } = require('../../../')
+const { Client, connection } = require('../../utils')
 const FakeTimers = require('@sinonjs/fake-timers')
 
 test('Basic', async t => {

test/unit/helpers/scroll.test.js

@@ -20,8 +20,8 @@
 'use strict'
 
 const { test } = require('tap')
-const { Client, errors } = require('../../../')
-const { connection } = require('../../utils')
+const { errors } = require('../../../')
+const { Client, connection } = require('../../utils')
 let clientVersion = require('../../../package.json').version
 if (clientVersion.includes('-')) {
   clientVersion = clientVersion.slice(0, clientVersion.indexOf('-')) + 'p'

test/unit/helpers/search.test.js

@@ -20,8 +20,7 @@
 'use strict'
 
 const { test } = require('tap')
-const { Client } = require('../../../')
-const { connection } = require('../../utils')
+const { Client, connection } = require('../../utils')
 
 test('Search should have an additional documents property', async t => {
   const MockConnection = connection.buildMockConnection({

test/unit/transport.test.js

@@ -27,6 +27,7 @@ const os = require('os')
 const intoStream = require('into-stream')
 const {
   buildServer,
+  skipProductCheck,
   connection: { MockConnection, MockConnectionTimeout, MockConnectionError }
 } = require('../utils')
 const {
@@ -65,6 +66,7 @@ test('Basic', t => {
       sniffInterval: false,
       sniffOnStart: false
     })
+    skipProductCheck(transport)
 
     transport.request({
       method: 'GET',
@@ -92,6 +94,7 @@ test('Basic (promises support)', t => {
     sniffInterval: false,
     sniffOnStart: false
   })
+  skipProductCheck(transport)
 
   transport
     .request({
@@ -119,6 +122,7 @@ test('Basic - failing (promises support)', t => {
     sniffInterval: false,
     sniffOnStart: false
   })
+  skipProductCheck(transport)
 
   transport
     .request({
@@ -145,6 +149,7 @@ test('Basic (options + promises support)', t => {
     sniffInterval: false,
     sniffOnStart: false
   })
+  skipProductCheck(transport)
 
   transport
     .request({
@@ -190,6 +195,7 @@ test('Send POST', t => {
       sniffInterval: false,
       sniffOnStart: false
     })
+    skipProductCheck(transport)
 
     transport.request({
       method: 'POST',
@@ -246,6 +252,7 @@ test('Send POST (ndjson)', t => {
       sniffInterval: false,
       sniffOnStart: false
     })
+    skipProductCheck(transport)
 
     transport.request({
       method: 'POST',
@@ -289,6 +296,7 @@ test('Send stream', t => {
       sniffInterval: false,
       sniffOnStart: false
     })
+    skipProductCheck(transport)
 
     transport.request({
       method: 'POST',
@@ -332,6 +340,7 @@ test('Send stream (bulkBody)', t => {
       sniffInterval: false,
       sniffOnStart: false
     })
+    skipProductCheck(transport)
 
     transport.request({
       method: 'POST',
@@ -365,6 +374,7 @@ test('Not JSON payload from server', t => {
       sniffInterval: false,
       sniffOnStart: false
     })
+    skipProductCheck(transport)
 
     transport.request({
       method: 'GET',
@@ -396,6 +406,7 @@ test('NoLivingConnectionsError (null connection)', t => {
       return null
     }
   })
+  skipProductCheck(transport)
 
   transport.request({
     method: 'GET',
@@ -424,6 +435,7 @@ test('NoLivingConnectionsError (undefined connection)', t => {
       return undefined
     }
   })
+  skipProductCheck(transport)
 
   transport.request({
     method: 'GET',
@@ -447,6 +459,7 @@ test('SerializationError', t => {
     sniffInterval: false,
     sniffOnStart: false
   })
+  skipProductCheck(transport)
 
   const body = { hello: 'world' }
   body.o = body
@@ -473,6 +486,7 @@ test('SerializationError (bulk)', t => {
     sniffInterval: false,
     sniffOnStart: false
   })
+  skipProductCheck(transport)
 
   const bulkBody = { hello: 'world' }
   bulkBody.o = bulkBody
@@ -505,6 +519,7 @@ test('DeserializationError', t => {
       sniffInterval: false,
       sniffOnStart: false
     })
+    skipProductCheck(transport)
 
     transport.request({
       method: 'GET',
@@ -541,6 +556,7 @@ test('TimeoutError (should call markDead on the failing connection)', t => {
     sniffInterval: false,
     sniffOnStart: false
   })
+  skipProductCheck(transport)
 
   transport.request({
     method: 'GET',
@@ -575,6 +591,7 @@ test('ConnectionError (should call markDead on the failing connection)', t => {
     sniffInterval: false,
     sniffOnStart: false
   })
+  skipProductCheck(transport)
 
   transport.request({
     method: 'GET',
@@ -620,6 +637,7 @@ test('Retry mechanism', t => {
       sniffInterval: false,
       sniffOnStart: false
     })
+    skipProductCheck(transport)
 
     transport.request({
       method: 'GET',
@@ -664,6 +682,7 @@ test('Should not retry if the body is a stream', t => {
       sniffInterval: false,
       sniffOnStart: false
     })
+    skipProductCheck(transport)
 
     transport.request({
       method: 'POST',
@@ -709,6 +728,7 @@ test('Should not retry if the bulkBody is a stream', t => {
       sniffInterval: false,
       sniffOnStart: false
     })
+    skipProductCheck(transport)
 
     transport.request({
       method: 'POST',
@@ -754,6 +774,7 @@ test('No retry', t => {
       sniffInterval: false,
       sniffOnStart: false
     })
+    skipProductCheck(transport)
 
     transport.request({
       method: 'POST',
@@ -805,6 +826,7 @@ test('Custom retry mechanism', t => {
       sniffInterval: false,
       sniffOnStart: false
     })
+    skipProductCheck(transport)
 
     transport.request({
       method: 'GET',
@@ -852,6 +874,7 @@ test('Should not retry on 429', t => {
       sniffInterval: false,
       sniffOnStart: false
     })
+    skipProductCheck(transport)
 
     transport.request({
       method: 'GET',
@@ -889,6 +912,7 @@ test('Should call markAlive with a successful response', t => {
     sniffInterval: false,
     sniffOnStart: false
   })
+  skipProductCheck(transport)
 
   transport.request({
     method: 'GET',
@@ -926,6 +950,7 @@ test('Should call resurrect on every request', t => {
     sniffOnStart: false,
     name: 'elasticsearch-js'
   })
+  skipProductCheck(transport)
 
   transport.request({
     method: 'GET',
@@ -954,6 +979,7 @@ test('Should return a request aborter utility', t => {
     sniffInterval: false,
     sniffOnStart: false
   })
+  skipProductCheck(transport)
 
   const request = transport.request({
     method: 'GET',
@@ -1002,6 +1028,7 @@ test('Retry mechanism and abort', t => {
       sniffInterval: false,
       sniffOnStart: false
     })
+    skipProductCheck(transport)
 
     const request = transport.request({
       method: 'GET',
@@ -1031,6 +1058,7 @@ test('Abort a request with the promise API', t => {
     sniffInterval: false,
     sniffOnStart: false
   })
+  skipProductCheck(transport)
 
   const request = transport.request({
     method: 'GET',
@@ -1070,6 +1098,7 @@ test('ResponseError', t => {
       sniffInterval: false,
       sniffOnStart: false
     })
+    skipProductCheck(transport)
 
     transport.request({
       method: 'GET',
@@ -1105,6 +1134,7 @@ test('Override requestTimeout', t => {
       sniffInterval: false,
       sniffOnStart: false
     })
+    skipProductCheck(transport)
 
     transport.request({
       method: 'GET',
@@ -1167,6 +1197,7 @@ test('sniff', t => {
       sniffOnConnectionFault: true,
       sniffEndpoint: '/sniff'
     })
+    skipProductCheck(transport)
 
     transport.request({
       method: 'GET',
@@ -1200,6 +1231,7 @@ test('sniff', t => {
       sniffInterval: 1,
       sniffEndpoint: '/sniff'
     })
+    skipProductCheck(transport)
 
     const params = { method: 'GET', path: '/' }
     clock.tick(100)
@@ -1233,6 +1265,7 @@ test('sniff', t => {
       sniffInterval: false,
       sniffEndpoint: '/sniff'
     })
+    skipProductCheck(transport)
 
     transport.sniff((err, hosts) => {
       t.ok(err instanceof ConnectionError)
@@ -1269,6 +1302,7 @@ test(`Should mark as dead connections where the statusCode is 502/3/4
         sniffInterval: false,
         sniffOnStart: false
       })
+      skipProductCheck(transport)
 
       transport.request({
         method: 'GET',
@@ -1323,6 +1357,7 @@ test('Should retry the request if the statusCode is 502/3/4', t => {
           sniffInterval: false,
           sniffOnStart: false
         })
+        skipProductCheck(transport)
 
         transport.request({
           method: 'GET',
@@ -1354,6 +1389,7 @@ test('Ignore status code', t => {
     sniffInterval: false,
     sniffOnStart: false
   })
+  skipProductCheck(transport)
 
   transport.request({
     method: 'GET',
@@ -1403,6 +1439,7 @@ test('Should serialize the querystring', t => {
       sniffInterval: false,
       sniffOnStart: false
     })
+    skipProductCheck(transport)
 
     transport.request({
       method: 'GET',
@@ -1446,6 +1483,7 @@ test('timeout option', t => {
           sniffInterval: false,
           sniffOnStart: false
         })
+        skipProductCheck(transport)
 
         transport.request({
           method: 'GET',
@@ -1476,6 +1514,7 @@ test('timeout option', t => {
           sniffInterval: false,
           sniffOnStart: false
         })
+        skipProductCheck(transport)
 
         transport.request({
           method: 'GET',
@@ -1512,6 +1551,7 @@ test('timeout option', t => {
           sniffInterval: false,
           sniffOnStart: false
         })
+        skipProductCheck(transport)
 
         transport.request({
           method: 'GET',
@@ -1542,6 +1582,7 @@ test('timeout option', t => {
           sniffInterval: false,
           sniffOnStart: false
         })
+        skipProductCheck(transport)
 
         transport.request({
           method: 'GET',
@@ -1576,6 +1617,7 @@ test('Should cast to boolean HEAD request', t => {
       sniffInterval: false,
       sniffOnStart: false
     })
+    skipProductCheck(transport)
 
     transport.request({
       method: 'HEAD',
@@ -1601,6 +1643,7 @@ test('Should cast to boolean HEAD request', t => {
       sniffInterval: false,
       sniffOnStart: false
     })
+    skipProductCheck(transport)
 
     transport.request({
       method: 'HEAD',
@@ -1627,6 +1670,7 @@ test('Should cast to boolean HEAD request', t => {
       sniffInterval: false,
       sniffOnStart: false
     })
+    skipProductCheck(transport)
 
     transport.request({
       method: 'HEAD',
@@ -1652,6 +1696,7 @@ test('Should cast to boolean HEAD request', t => {
       sniffInterval: false,
       sniffOnStart: false
     })
+    skipProductCheck(transport)
 
     transport.request({
       method: 'HEAD',
@@ -1694,6 +1739,7 @@ test('Suggest compression', t => {
       sniffOnStart: false,
       suggestCompression: true
     })
+    skipProductCheck(transport)
 
     transport.request({
       method: 'GET',
@@ -1734,6 +1780,7 @@ test('Broken compression', t => {
       sniffOnStart: false,
       suggestCompression: true
     })
+    skipProductCheck(transport)
 
     transport.request({
       method: 'GET',
@@ -1769,6 +1816,7 @@ test('Warning header', t => {
         sniffInterval: false,
         sniffOnStart: false
       })
+      skipProductCheck(transport)
 
       transport.request({
         method: 'GET',
@@ -1806,6 +1854,7 @@ test('Warning header', t => {
         sniffInterval: false,
         sniffOnStart: false
       })
+      skipProductCheck(transport)
 
       transport.request({
         method: 'GET',
@@ -1840,6 +1889,7 @@ test('Warning header', t => {
         sniffInterval: false,
         sniffOnStart: false
       })
+      skipProductCheck(transport)
 
       transport.request({
         method: 'GET',
@@ -1875,6 +1925,7 @@ test('asStream set to true', t => {
       sniffInterval: false,
       sniffOnStart: false
     })
+    skipProductCheck(transport)
 
     transport.request({
       method: 'GET',
@@ -1933,6 +1984,7 @@ test('Compress request', t => {
         sniffInterval: false,
         sniffOnStart: false
       })
+      skipProductCheck(transport)
 
       transport.request({
         method: 'POST',
@@ -1981,6 +2033,7 @@ test('Compress request', t => {
         sniffOnStart: false,
         compression: 'gzip'
       })
+      skipProductCheck(transport)
 
       transport.request({
         method: 'POST',
@@ -2026,6 +2079,7 @@ test('Compress request', t => {
         sniffInterval: false,
         sniffOnStart: false
       })
+      skipProductCheck(transport)
 
       transport.request({
         method: 'POST',
@@ -2085,6 +2139,7 @@ test('Compress request', t => {
         sniffInterval: false,
         sniffOnStart: false
       })
+      skipProductCheck(transport)
 
       transport.request({
         method: 'DELETE',
@@ -2151,6 +2206,7 @@ test('Compress request', t => {
         sniffInterval: false,
         sniffOnStart: false
       })
+      skipProductCheck(transport)
 
       transport.request({
         method: 'POST',
@@ -2195,6 +2251,7 @@ test('Headers configuration', t => {
           'x-foo': 'bar'
         }
       })
+      skipProductCheck(transport)
 
       transport.request({
         method: 'GET',
@@ -2234,6 +2291,7 @@ test('Headers configuration', t => {
           'x-foo': 'bar'
         }
       })
+      skipProductCheck(transport)
 
       transport.request({
         method: 'GET',
@@ -2272,6 +2330,7 @@ test('Headers configuration', t => {
           'x-foo': 'bar'
         }
       })
+      skipProductCheck(transport)
 
       transport.request({
         method: 'GET',
@@ -2312,6 +2371,7 @@ test('nodeFilter and nodeSelector', t => {
       return conns[0]
     }
   })
+  skipProductCheck(transport)
 
   transport.request({
     method: 'GET',
@@ -2345,6 +2405,7 @@ test('Should accept custom querystring in the optons object', t => {
         sniffInterval: false,
         sniffOnStart: false
       })
+      skipProductCheck(transport)
 
       transport.request({
         method: 'GET',
@@ -2381,6 +2442,7 @@ test('Should accept custom querystring in the optons object', t => {
         sniffInterval: false,
         sniffOnStart: false
       })
+      skipProductCheck(transport)
 
       transport.request({
         method: 'GET',
@@ -2425,6 +2487,7 @@ test('Should add an User-Agent header', t => {
       sniffInterval: false,
       sniffOnStart: false
     })
+    skipProductCheck(transport)
 
     transport.request({
       method: 'GET',
@@ -2459,6 +2522,7 @@ test('Should pass request params and options to generateRequestId', t => {
       return 'id'
     }
   })
+  skipProductCheck(transport)
 
   transport.request(params, options, t.error)
 })
@@ -2484,6 +2548,7 @@ test('Secure json parsing', t => {
         sniffInterval: false,
         sniffOnStart: false
       })
+      skipProductCheck(transport)
 
       transport.request({
         method: 'GET',
@@ -2516,6 +2581,7 @@ test('Secure json parsing', t => {
         sniffInterval: false,
         sniffOnStart: false
       })
+      skipProductCheck(transport)
 
       transport.request({
         method: 'GET',
@@ -2574,6 +2640,7 @@ test('The callback with a sync error should be called in the next tick - json',
     sniffInterval: false,
     sniffOnStart: false
   })
+  skipProductCheck(transport)
 
   const body = { a: true }
   body.o = body
@@ -2605,6 +2672,7 @@ test('The callback with a sync error should be called in the next tick - ndjson'
     sniffInterval: false,
     sniffOnStart: false
   })
+  skipProductCheck(transport)
 
   const field = { a: true }
   field.o = field

test/utils/MockConnection.js

@@ -133,7 +133,7 @@ function buildMockConnection (opts) {
 
   class MockConnection extends Connection {
     request (params, callback) {
-      let { body, statusCode } = opts.onRequest(params)
+      let { body, statusCode, headers } = opts.onRequest(params)
       if (typeof body !== 'string') {
         body = JSON.stringify(body)
       }
@@ -144,7 +144,8 @@ function buildMockConnection (opts) {
         'content-type': 'application/json;utf=8',
         date: new Date().toISOString(),
         connection: 'keep-alive',
-        'content-length': Buffer.byteLength(body)
+        'content-length': Buffer.byteLength(body),
+        ...headers
       }
       process.nextTick(() => {
         if (!aborted) {

test/utils/index.js

@@ -25,6 +25,7 @@ const buildServer = require('./buildServer')
 const buildCluster = require('./buildCluster')
 const buildProxy = require('./buildProxy')
 const connection = require('./MockConnection')
+const { Client } = require('../../')
 
 async function waitCluster (client, waitForStatus = 'green', timeout = '50s', times = 0) {
   if (!client) {
@@ -41,10 +42,25 @@ async function waitCluster (client, waitForStatus = 'green', timeout = '50s', ti
   }
 }
 
+function skipProductCheck (client) {
+  const tSymbol = Object.getOwnPropertySymbols(client.transport || client)
+    .filter(symbol => symbol.description === 'product check')[0]
+  ;(client.transport || client)[tSymbol] = 2
+}
+
+class NoProductCheckClient extends Client {
+  constructor (opts) {
+    super(opts)
+    skipProductCheck(this)
+  }
+}
+
 module.exports = {
   buildServer,
   buildCluster,
   buildProxy,
   connection,
-  waitCluster
+  waitCluster,
+  skipProductCheck,
+  Client: NoProductCheckClient
 }