Bumped v5.6.22

* Safe json parsing

* Updated test

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

.ci/Dockerfile

@@ -1,13 +1,9 @@
-ARG NODE_JS_VERSION=16
+ARG NODE_JS_VERSION=10
 FROM node:${NODE_JS_VERSION}
 
 # Create app directory
 WORKDIR /usr/src/app
 
-RUN apt-get clean -y
-RUN apt-get update -y
-RUN apt-get install -y zip
-
 # Install app dependencies
 COPY package*.json ./
 RUN npm install

.ci/Jenkinsfile

@@ -0,0 +1,185 @@
+#!/usr/bin/env groovy
+
+@Library('apm@current') _
+
+def NODE_JS_VERSIONS = [8,10,12]
+def nodeJsVersion = NODE_JS_VERSIONS[randomNumber(min: 0, max:2)]
+
+pipeline {
+  agent {
+    label 'docker && immutable'
+  }
+
+  environment {
+    REPO = 'elasticsearch-js'
+    BASE_DIR = "src/github.com/elastic/${env.REPO}"
+    NODE_JS_DEFAULT_VERSION = "${nodeJsVersion}"
+    NODE_JS_VERSIONS = "${NODE_JS_VERSIONS.join(',')}"
+    HOME = "${env.WORKSPACE}"
+    npm_config_cache = 'npm-cache'
+  }
+
+  options {
+    timeout(time: 1, unit: 'HOURS')
+    buildDiscarder(logRotator(numToKeepStr: '20', artifactNumToKeepStr: '20', daysToKeepStr: '30'))
+    timestamps()
+    ansiColor('xterm')
+    disableResume()
+    durabilityHint('PERFORMANCE_OPTIMIZED')
+  }
+
+  triggers {
+    issueCommentTrigger('(?i).*(?:jenkins\\W+)?run\\W+(?:the\\W+)?tests(?:\\W+please)?.*')
+    // env.CHANGE_ID as a value in case of a commit or a pr, which means
+    // that we will have a daily cron job only for branches that don't have an active pr
+    cron(env.CHANGE_ID ? '' : '@daily')
+  }
+
+  stages {
+    stage('Checkout') {
+      options { skipDefaultCheckout() }
+      steps {
+        deleteDir()
+        gitCheckout(basedir: "${BASE_DIR}", githubNotifyFirstTimeContributor: false)
+        stash allowEmpty: true, name: 'source', useDefaultExcludes: false
+      }
+    }
+
+    stage('Install dependencies') {
+      options { skipDefaultCheckout() }
+      steps {
+        deleteDir()
+        unstash 'source'
+        script {
+          buildDockerImage(image: "node:${env.NODE_JS_DEFAULT_VERSION}-alpine").inside(){
+            dir("${BASE_DIR}"){
+              sh(label: 'System info', script: 'node --version; npm --version')
+              sh(label: 'Install dependencies', script: 'npm install')
+            }
+          }
+        }
+        stash allowEmpty: true, name: 'source-dependencies', useDefaultExcludes: false
+      }
+    }
+
+    stage('License check') {
+      options { skipDefaultCheckout() }
+      steps {
+        withGithubNotify(context: 'License check') {
+          deleteDir()
+          unstash 'source-dependencies'
+          script {
+            buildDockerImage(image: "node:${env.NODE_JS_DEFAULT_VERSION}-alpine").inside(){
+              dir("${BASE_DIR}"){
+                sh(label: 'Check production dependencies licenses', script: 'npm run license-checker')
+              }
+            }
+          }
+        }
+      }
+    }
+
+    stage('Linter') {
+      options { skipDefaultCheckout() }
+      steps {
+        withGithubNotify(context: 'Linter') {
+          deleteDir()
+          unstash 'source-dependencies'
+          script {
+            buildDockerImage(image: "node:${env.NODE_JS_DEFAULT_VERSION}-alpine").inside(){
+              dir("${BASE_DIR}"){
+                sh(label: 'Lint code with standardjs', script: 'npm run lint')
+              }
+            }
+          }
+        }
+      }
+    }
+
+    stage('Unit test') {
+      failFast true
+      options { skipDefaultCheckout() }
+      steps {
+        withGithubNotify(context: 'Unit test') {
+          script {
+            def versions = env.NODE_JS_VERSIONS.split(',')
+            def parallelTasks = [:]
+            versions.each{ version ->
+              parallelTasks["Node.js v${version}"] = buildUnitTest(version: version)
+            }
+            parallel(parallelTasks)
+          }
+        }
+      }
+    }
+
+    stage('Integration test') {
+      options { skipDefaultCheckout() }
+      environment {
+        TEST_ES_SERVER = 'http://elasticsearch:9200'
+      }
+      steps {
+        withGithubNotify(context: 'Integration test OSS') {
+          deleteDir()
+          unstash 'source-dependencies'
+          dir("${BASE_DIR}"){
+            // Sometimes the docker registry fails and has random timeouts
+            // this block will retry a doker image 3 times before to fail.
+            retry(3) {
+              sleep randomNumber(min: 5, max: 10)
+              sh(label: 'Start Elasticsearch', script: './scripts/es-docker.sh --detach')
+            }
+          }
+          script {
+            buildDockerImage(fromDockerfile: true).inside('--network=elastic'){
+              dir("${BASE_DIR}"){
+                sh(label: 'Integration test', script: 'npm run test:integration | tee test-integration.tap')
+                sh(label: 'Generating test reporting', script: './node_modules/.bin/tap-mocha-reporter xunit < test-integration.tap > junit-integration.xml')
+              }
+            }
+          }
+          sh(label: 'Stop Elasticsearch', script: 'docker kill $(docker ps -q)')
+          junit(allowEmptyResults: true, keepLongStdio: true, testResults: "${BASE_DIR}/**/junit-*.xml")
+        }
+      }
+    }
+  }
+}
+
+// Sometimes the docker registry fails and has random timeouts
+// this function will retry a doker image 3 times before to fail.
+def buildDockerImage(args) {
+  def image
+  retry(3) {
+    sleep randomNumber(min: 5, max: 10)
+    if (args.fromDockerfile == true) {
+      image = docker.build('nodejs-image', "--build-arg NODE_JS_VERSION=${env.NODE_JS_DEFAULT_VERSION} ${BASE_DIR}/.ci/docker")
+    } else {
+      image = docker.image(args.image)
+      // make sure we have the latest available from Docker Hub
+      image.pull()
+    }
+  }
+  return image
+}
+
+def buildUnitTest(args) {
+  return {
+    node('docker && immutable') {
+      deleteDir()
+      unstash 'source'
+      script {
+        buildDockerImage(image: "node:${args.version}-alpine").inside(){
+          dir("${BASE_DIR}"){
+            sh(label: 'Install dependencies', script: 'npm install')
+            sh(label: 'Run unit test', script: 'npm run test:unit | tee test-unit.tap')
+            sh(label: 'Run behavior test', script: 'npm run test:behavior | tee test-behavior.tap')
+            sh(label: 'Run types test', script: 'npm run test:types')
+            sh(label: 'Generating test reporting', script: './node_modules/.bin/tap-mocha-reporter xunit < test-unit.tap > junit-unit.xml; ./node_modules/.bin/tap-mocha-reporter xunit < test-behavior.tap > junit-behavior.xml')
+          }
+        }
+      }
+      junit(allowEmptyResults: true, keepLongStdio: true, testResults: "${BASE_DIR}/**/junit-*.xml")
+    }
+  }
+}

.ci/docker-compose.yml

@@ -0,0 +1,41 @@
+version: '3.2'
+services:
+  client-oss:
+    image: docker.elastic.co/clients/elasticsearch-js:${NODE_JS_VERSION:-10}
+    build:
+      context: ..
+      dockerfile: .ci/Dockerfile
+      args:
+          NODE_JS_VERSION: ${NODE_JS_VERSION:-10}
+          CODECOV_TOKEN: ${CODECOV_TOKEN}
+    environment:
+      - "TEST_ES_SERVER=http://elasticsearch-oss:9200"
+    volumes:
+      - ..:/usr/src/app
+      # This will mount the node_modules directory
+      # to the host machine using the buildtime directory.
+      - /usr/src/app/node_modules
+      - esvol:/tmp
+    networks:
+      - esnet-oss
+    depends_on:
+      - elasticsearch-oss
+
+  elasticsearch-oss:
+    image: docker.elastic.co/elasticsearch/elasticsearch:${ELASTICSEARCH_VERSION:-5.6.15}
+    volumes:
+      - esvol:/tmp
+    networks:
+      - esnet-oss
+    environment:
+      - path.repo=/tmp
+      - "repositories.url.allowed_urls=http://snapshot.*"
+      - node.attr.testattr=test
+      - bootstrap.memory_lock=false
+      - "xpack.security.enabled=false"
+      - "discovery.type=single-node"
+      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
+networks:
+  esnet-oss:
+volumes:
+  esvol:

.ci/functions/imports.sh

@@ -18,7 +18,7 @@ require_stack_version
 if [[ -z $es_node_name ]]; then
   # only set these once
   set -euo pipefail
-  export TEST_SUITE=${TEST_SUITE-free}
+  export TEST_SUITE=${TEST_SUITE-oss}
   export RUNSCRIPTS=${RUNSCRIPTS-}
   export DETACH=${DETACH-false}
   export CLEANUP=${CLEANUP-false}
@@ -26,11 +26,11 @@ if [[ -z $es_node_name ]]; then
   export es_node_name=instance
   export elastic_password=changeme
   export elasticsearch_image=elasticsearch
-  export elasticsearch_scheme="https"
-  if [[ $TEST_SUITE != "platinum" ]]; then
-    export elasticsearch_scheme="http"
+  export elasticsearch_url=https://elastic:${elastic_password}@${es_node_name}:9200
+  if [[ $TEST_SUITE != "xpack" ]]; then
+    export elasticsearch_image=elasticsearch-${TEST_SUITE}
+    export elasticsearch_url=http://${es_node_name}:9200
   fi
-  export elasticsearch_url=${elasticsearch_scheme}://elastic:${elastic_password}@${es_node_name}:9200
   export external_elasticsearch_url=${elasticsearch_url/$es_node_name/localhost}
   export elasticsearch_container="${elasticsearch_image}:${STACK_VERSION}"
 

.ci/jobs/defaults.yml

@@ -1,4 +1,4 @@
----
+
 
 ##### GLOBAL METADATA
 
@@ -12,12 +12,6 @@
     logrotate:
       daysToKeep: 30
       numToKeep: 100
-    parameters:
-    - string:
-        name: branch_specifier
-        default: refs/heads/main
-        description: the Git branch specifier to build (<branchName>, <tagName>,
-          <commitId>, etc.)
     properties:
     - github:
         url: https://github.com/elastic/elasticsearch-js/
@@ -33,7 +27,6 @@
         branches:
         - ${branch_specifier}
         url: https://github.com/elastic/elasticsearch-js.git
-        basedir: ''
         wipe-workspace: 'True'
     triggers:
     - github
@@ -62,20 +55,20 @@
       exclude-key: exclude
       filename: .ci/test-matrix.yml
     wrappers:
-      - ansicolor
-      - timeout:
-          type: absolute
-          timeout: 120
-          fail: true
-      - timestamps
-      - workspace-cleanup
+    - ansicolor
+    - timeout:
+        type: absolute
+        timeout: 120
+        fail: true
+    - timestamps
+    - workspace-cleanup
     builders:
-      - shell: |-
-          #!/usr/local/bin/runbld
-          .ci/run-tests
+    - shell: |-
+        #!/usr/local/bin/runbld
+        .ci/run-tests
     publishers:
-      - email:
-          recipients: build-lang-clients@elastic.co
-      - junit:
-          results: "**/*-junit.xml"
-          allow-empty-results: true
+    - email:
+        recipients: infra-root+build@elastic.co
+    # - junit:
+    #     results: "*-junit.xml"
+    #     allow-empty-results: true

.ci/jobs/elastic+elasticsearch-js+5.x.yml

@@ -0,0 +1,14 @@
+---
+- job:
+    name: elastic+elasticsearch-js+5.x
+    display-name: 'elastic / elasticsearch-js # 5.x'
+    description: Testing the elasticsearch-js 5.x branch.
+    parameters:
+    - string:
+        name: branch_specifier
+        default: refs/heads/5.x
+        description: the Git branch specifier to build (<branchName>, <tagName>,
+          <commitId>, etc.)
+    triggers:
+    - github
+    - timed: '@weekly'

.ci/jobs/elastic+elasticsearch-js+6.x.yml

@@ -0,0 +1,14 @@
+---
+- job:
+    name: elastic+elasticsearch-js+6.x
+    display-name: 'elastic / elasticsearch-js # 6.x'
+    description: Testing the elasticsearch-js 6.x branch.
+    parameters:
+    - string:
+        name: branch_specifier
+        default: refs/heads/6.x
+        description: the Git branch specifier to build (<branchName>, <tagName>,
+          <commitId>, etc.)
+    triggers:
+    - github
+    - timed: '@weekly'

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

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

.ci/jobs/elastic+elasticsearch-js+7.x.yml

@@ -0,0 +1,14 @@
+---
+- job:
+    name: elastic+elasticsearch-js+7.x
+    display-name: 'elastic / elasticsearch-js # 7.x'
+    description: Testing the elasticsearch-js 7.x branch.
+    parameters:
+    - string:
+        name: branch_specifier
+        default: refs/heads/7.x
+        description: the Git branch specifier to build (<branchName>, <tagName>,
+          <commitId>, etc.)
+    triggers:
+    - github
+    - timed: '@weekly'

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

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

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

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

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

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

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

@@ -0,0 +1,14 @@
+---
+- job:
+    name: elastic+elasticsearch-js+master
+    display-name: 'elastic / elasticsearch-js # master'
+    description: Testing the elasticsearch-js master branch.
+    parameters:
+    - string:
+        name: branch_specifier
+        default: refs/heads/master
+        description: the Git branch specifier to build (<branchName>, <tagName>,
+          <commitId>, etc.)
+    triggers:
+    - github
+    - timed: '@daily'

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

@@ -3,7 +3,6 @@
     name: elastic+elasticsearch-js+pull-request
     display-name: 'elastic / elasticsearch-js # pull-request'
     description: Testing of elasticsearch-js pull requests.
-    junit_results: "*-junit.xml"
     scm:
     - git:
         branches:
@@ -17,3 +16,4 @@
         github-hooks: true
         status-context: clients-ci
         cancel-builds-on-update: true
+    publishers: []

.ci/make.mjs

@@ -1,125 +0,0 @@
-/*
- * Licensed to Elasticsearch B.V. under one or more contributor
- * license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright
- * ownership. Elasticsearch B.V. licenses this file to you under
- * the Apache License, Version 2.0 (the "License"); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-/* global $ argv */
-
-'use strict'
-
-import 'zx/globals'
-
-import { readFile, writeFile } from 'fs/promises'
-import assert from 'assert'
-import { join } from 'desm'
-import semver from 'semver'
-
-assert(typeof argv.task === 'string', 'Missing task parameter')
-
-switch (argv.task) {
-  case 'release':
-    release(argv._).catch(onError)
-    break
-  case 'bump':
-    bump(argv._).catch(onError)
-    break
-  case 'codegen':
-    codegen(argv._).catch(onError)
-    break
-  default:
-    console.log(`Unknown task: ${argv.task}`)
-    process.exit(1)
-}
-
-async function release (args) {
-  assert(args.length === 2, 'Release task expects two parameters')
-  let [version, outputFolder] = args
-
-  if (process.env.WORKFLOW === 'snapshot' && !version.endsWith('SNAPSHOT')) {
-    version = `${version}-SNAPSHOT`
-  }
-
-  await bump([version])
-
-  const packageJson = JSON.parse(await readFile(
-    join(import.meta.url, '..', 'package.json'),
-    'utf8'
-  ))
-
-  await $`npm run build`
-  await $`npm pack`
-  await $`zip elasticsearch-js-${version}.zip elastic-elasticsearch-${packageJson.version}.tgz`
-  await $`rm elastic-elasticsearch-${packageJson.version}.tgz`
-  await $`mv ${join(import.meta.url, '..', `elasticsearch-js-${version}.zip`)} ${join(import.meta.url, '..', outputFolder, `elasticsearch-js-${version}.zip`)}`
-}
-
-async function bump (args) {
-  assert(args.length === 1, 'Bump task expects one parameter')
-  const [version] = args
-  const packageJson = JSON.parse(await readFile(
-    join(import.meta.url, '..', 'package.json'),
-    'utf8'
-  ))
-
-  const cleanVersion = semver.clean(version.includes('SNAPSHOT') ? version.split('-')[0] : version)
-  assert(semver.valid(cleanVersion))
-  packageJson.version = cleanVersion
-  packageJson.versionCanary = `${cleanVersion}-canary.0`
-
-  await writeFile(
-    join(import.meta.url, '..', 'package.json'),
-    JSON.stringify(packageJson, null, 2),
-    'utf8'
-  )
-
-  const testMatrix = await readFile(join(import.meta.url, 'test-matrix.yml'), 'utf8')
-  await writeFile(
-    join(import.meta.url, 'test-matrix.yml'),
-    testMatrix.replace(/STACK_VERSION:\s+\- "[0-9]+[0-9\.]*[0-9](?:\-SNAPSHOT)?"/, `STACK_VERSION:\n  - "${cleanVersion}-SNAPSHOT"`), // eslint-disable-line
-    'utf8'
-  )
-}
-
-// this command can only be executed locally for now
-async function codegen (args) {
-  assert(args.length === 1, 'Bump task expects one parameter')
-  const clientGeneratorPath = join(import.meta.url, '..', '..', 'elastic-client-generator-js')
-  const [version] = args
-
-  const isGeneratorCloned = await $`[[ -d ${clientGeneratorPath} ]]`.exitCode === 0
-  assert(isGeneratorCloned, 'You must clone the elastic-client-generator-js first')
-
-  await $`npm install --prefix ${clientGeneratorPath}`
-  // this command will take a while!
-  if (version === 'main') {
-    await $`npm run elasticsearch --prefix ${clientGeneratorPath} -- --version main`
-  } else {
-    await $`npm run elasticsearch --prefix ${clientGeneratorPath} -- --version ${version.split('.').slice(0, 2).join('.')}`
-  }
-  await $`npm run lint --prefix ${clientGeneratorPath}`
-
-  await $`rm -rf ${join(import.meta.url, '..', 'src', 'api')}`
-  await $`mkdir ${join(import.meta.url, '..', 'src', 'api')}`
-  await $`cp -R ${join(import.meta.url, '..', '..', 'elastic-client-generator-js', 'output')}/* ${join(import.meta.url, '..', 'src', 'api')}`
-  await $`mv ${join(import.meta.url, '..', 'src', 'api', 'reference.asciidoc')} ${join(import.meta.url, '..', 'docs', 'reference.asciidoc')}`
-  await $`npm run build`
-}
-
-function onError (err) {
-  console.log(err)
-  process.exit(1)
-}

.ci/make.sh

@@ -1,180 +0,0 @@
-#!/usr/bin/env bash
-
-# ------------------------------------------------------- #
-#
-# Skeleton for common build entry script for all elastic
-# clients. Needs to be adapted to individual client usage.
-#
-# Must be called: ./.ci/make.sh <target> <params>
-#
-# Version: 1.1.0
-#
-# Targets:
-# ---------------------------
-# assemble <VERSION> : build client artefacts with version
-# bump     <VERSION> : bump client internals to version
-# codegen  <VERSION> : generate endpoints
-# docsgen  <VERSION> : generate documentation
-# examplegen         : generate the doc examples
-# clean              : clean workspace
-#
-# ------------------------------------------------------- #
-
-# ------------------------------------------------------- #
-# Bootstrap
-# ------------------------------------------------------- #
-
-script_path=$(dirname "$(realpath -s "$0")")
-repo=$(realpath "$script_path/../")
-generator=$(realpath "$script_path/../../elastic-client-generator-js")
-
-# shellcheck disable=SC1090
-CMD=$1
-TASK=$1
-TASK_ARGS=()
-VERSION=$2
-STACK_VERSION=$VERSION
-NODE_JS_VERSION=16
-WORKFLOW=${WORKFLOW-staging}
-set -euo pipefail
-
-product="elastic/elasticsearch-js"
-output_folder=".ci/output"
-OUTPUT_DIR="$repo/${output_folder}"
-REPO_BINDING="${OUTPUT_DIR}:/sln/${output_folder}"
-mkdir -p "$OUTPUT_DIR"
-
-echo -e "\033[34;1mINFO:\033[0m PRODUCT ${product}\033[0m"
-echo -e "\033[34;1mINFO:\033[0m VERSION ${STACK_VERSION}\033[0m"
-echo -e "\033[34;1mINFO:\033[0m OUTPUT_DIR ${OUTPUT_DIR}\033[0m"
-
-# ------------------------------------------------------- #
-# Parse Command
-# ------------------------------------------------------- #
-
-case $CMD in
-    clean)
-        echo -e "\033[36;1mTARGET: clean workspace $output_folder\033[0m"
-        rm -rf "$output_folder"
-        echo -e "\033[32;1mdone.\033[0m"
-        exit 0
-        ;;
-    assemble)
-        if [ -v $VERSION ]; then
-            echo -e "\033[31;1mTARGET: assemble -> missing version parameter\033[0m"
-            exit 1
-        fi
-        echo -e "\033[36;1mTARGET: assemble artefact $VERSION\033[0m"
-        TASK=release
-        TASK_ARGS=("$VERSION" "$output_folder")
-        ;;
-    codegen)
-        if [ -v $VERSION ]; then
-            echo -e "\033[31;1mTARGET: codegen -> missing version parameter\033[0m"
-            exit 1
-        fi
-        echo -e "\033[36;1mTARGET: codegen API v$VERSION\033[0m"
-        TASK=codegen
-        # VERSION is BRANCH here for now
-        TASK_ARGS=("$VERSION")
-        ;;
-    docsgen)
-        if [ -v $VERSION ]; then
-            echo -e "\033[31;1mTARGET: docsgen -> missing version parameter\033[0m"
-            exit 1
-        fi
-        echo -e "\033[36;1mTARGET: generate docs for $VERSION\033[0m"
-        TASK=codegen
-        # VERSION is BRANCH here for now
-        TASK_ARGS=("$VERSION" "$codegen_folder")
-        ;;
-    examplesgen)
-        echo -e "\033[36;1mTARGET: generate examples\033[0m"
-        TASK=codegen
-        # VERSION is BRANCH here for now
-        TASK_ARGS=("$VERSION" "$codegen_folder")
-        ;;
-    bump)
-        if [ -v $VERSION ]; then
-            echo -e "\033[31;1mTARGET: bump -> missing version parameter\033[0m"
-            exit 1
-        fi
-        echo -e "\033[36;1mTARGET: bump to version $VERSION\033[0m"
-        TASK=bump
-        # VERSION is BRANCH here for now
-        TASK_ARGS=("$VERSION")
-        ;;
-    *)
-        echo -e "\nUsage:\n\t $CMD is not supported right now\n"
-        exit 1
-esac
-
-
-# ------------------------------------------------------- #
-# Build Container
-# ------------------------------------------------------- #
-
-echo -e "\033[34;1mINFO: building $product container\033[0m"
-
-docker build \
-  --file .ci/Dockerfile \
-  --tag ${product} \
-  --build-arg NODE_JS_VERSION=${NODE_JS_VERSION} \
-  --build-arg USER_ID="$(id -u)" \
-  --build-arg GROUP_ID="$(id -g)" \
-  .
-
-# ------------------------------------------------------- #
-# Run the Container
-# ------------------------------------------------------- #
-
-echo -e "\033[34;1mINFO: running $product container\033[0m"
-
-docker run \
-  --volume $repo:/usr/src/app \
-  --volume $generator:/usr/src/elastic-client-generator-js \
-  --volume /usr/src/app/node_modules \
-  --env "WORKFLOW=${WORKFLOW}" \
-  --name make-elasticsearch-js \
-  --rm \
-  $product \
-  node .ci/make.mjs --task $TASK ${TASK_ARGS[*]}
-
-# ------------------------------------------------------- #
-# Post Command tasks & checks
-# ------------------------------------------------------- #
-
-if [[ "$CMD" == "assemble" ]]; then
-	if compgen -G ".ci/output/*" > /dev/null; then
-		echo -e "\033[32;1mTARGET: successfully assembled client v$VERSION\033[0m"
-	else
-		echo -e "\033[31;1mTARGET: assemble failed, empty workspace!\033[0m"
-		exit 1
-	fi
-fi
-
-if [[ "$CMD" == "bump" ]]; then
-  if [ -n "$(git status --porcelain)" ]; then 
-		echo -e "\033[32;1mTARGET: successfully bumped client v$VERSION\033[0m"
-  else 
-		echo -e "\033[31;1mTARGET: failed bumped client v$VERSION\033[0m"
-    exit 1
-  fi
-fi
-
-if [[ "$CMD" == "codegen" ]]; then
-  if [ -n "$(git status --porcelain)" ]; then 
-		echo -e "\033[32;1mTARGET: successfully generated client v$VERSION\033[0m"
-  else 
-		echo -e "\033[31;1mTARGET: failed generating client v$VERSION\033[0m"
-    exit 1
-  fi
-fi
-
-if [[ "$CMD" == "docsgen" ]]; then
-    echo "TODO"
-fi
-
-if [[ "$CMD" == "examplesgen" ]]; then
-    echo "TODO"
-fi

.ci/packer_cache.sh

@@ -2,9 +2,9 @@
 
 source /usr/local/bin/bash_standard_lib.sh
 
-DOCKER_IMAGES="node:17-alpine
-node:16-alpine
-node:14-alpine
+DOCKER_IMAGES="node:12-alpine
+node:10-alpine
+node:8-alpine
 "
 
 for di in ${DOCKER_IMAGES}

.ci/run-elasticsearch.sh

@@ -1,143 +0,0 @@
-#!/usr/bin/env bash
-#
-# Launch one or more Elasticsearch nodes via the Docker image,
-# to form a cluster suitable for running the REST API tests.
-#
-# Export the STACK_VERSION variable, eg. '8.0.0-SNAPSHOT'.
-# 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.6.1
-# - Initial version of the run-elasticsearch.sh script
-# - Deleting the volume should not dependent on the container still running
-# - Fixed `ES_JAVA_OPTS` config
-# - Moved to STACK_VERSION and TEST_VERSION
-# - 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
-# - Moved ELASTIC_PASSWORD and xpack.security.enabled to the base arguments for "Security On by default"
-# - Use https only when TEST_SUITE is "platinum", when "free" use http
-# - Set xpack.security.enabled=false for "free" and xpack.security.enabled=true for "platinum"
-
-script_path=$(dirname $(realpath -s $0))
-source $script_path/functions/imports.sh
-set -euo pipefail
-
-echo -e "\033[34;1mINFO:\033[0m Take down node if called twice with the same arguments (DETACH=true) or on seperate terminals \033[0m"
-cleanup_node $es_node_name
-
-master_node_name=${es_node_name}
-cluster_name=${moniker}${suffix}
-
-declare -a volumes
-environment=($(cat <<-END
-  --env ELASTIC_PASSWORD=$elastic_password
-  --env node.name=$es_node_name
-  --env cluster.name=$cluster_name
-  --env cluster.initial_master_nodes=$master_node_name
-  --env discovery.seed_hosts=$master_node_name
-  --env cluster.routing.allocation.disk.threshold_enabled=false
-  --env bootstrap.memory_lock=true
-  --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
-  --env cluster.deprecation_indexing.enabled=false
-END
-))
-if [[ "$TEST_SUITE" == "platinum" ]]; then
-  environment+=($(cat <<-END
-    --env xpack.security.enabled=true
-    --env xpack.license.self_generated.type=trial
-    --env xpack.security.http.ssl.enabled=true
-    --env xpack.security.http.ssl.verification_mode=certificate
-    --env xpack.security.http.ssl.key=certs/testnode.key
-    --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
-END
-))
-  volumes+=($(cat <<-END
-    --volume $ssl_cert:/usr/share/elasticsearch/config/certs/testnode.crt
-    --volume $ssl_key:/usr/share/elasticsearch/config/certs/testnode.key
-    --volume $ssl_ca:/usr/share/elasticsearch/config/certs/ca.crt
-END
-))
-else
-  environment+=($(cat <<-END
-    --env xpack.security.enabled=false
-    --env xpack.security.http.ssl.enabled=false
-END
-))
-fi
-
-cert_validation_flags=""
-if [[ "$TEST_SUITE" == "platinum" ]]; then
-  cert_validation_flags="--insecure --cacert /usr/share/elasticsearch/config/certs/ca.crt --resolve ${es_node_name}:443:127.0.0.1"
-fi
-
-# Pull the container, retry on failures up to 5 times with
-# short delays between each attempt. Fixes most transient network errors.
-docker_pull_attempts=0
-until [ "$docker_pull_attempts" -ge 5 ]
-do
-   docker pull docker.elastic.co/elasticsearch/"$elasticsearch_container" && break
-   docker_pull_attempts=$((docker_pull_attempts+1))
-   echo "Failed to pull image, retrying in 10 seconds (retry $docker_pull_attempts/5)..."
-   sleep 10
-done
-
-NUMBER_OF_NODES=${NUMBER_OF_NODES-1}
-http_port=9200
-for (( i=0; i<$NUMBER_OF_NODES; i++, http_port++ )); do
-  node_name=${es_node_name}$i
-  node_url=${external_elasticsearch_url/9200/${http_port}}$i
-  if [[ "$i" == "0" ]]; then node_name=$es_node_name; fi
-  environment+=($(cat <<-END
-    --env node.name=$node_name
-END
-))
-  echo "$i: $http_port $node_url "
-  volume_name=${node_name}-${suffix}-data
-  volumes+=($(cat <<-END
-    --volume $volume_name:/usr/share/elasticsearch/data${i}
-END
-))
-
-  # make sure we detach for all but the last node if DETACH=false (default) so all nodes are started
-  local_detach="true"
-  if [[ "$i" == "$((NUMBER_OF_NODES-1))" ]]; then local_detach=$DETACH; fi
-  echo -e "\033[34;1mINFO:\033[0m Starting container $node_name \033[0m"
-  set -x
-  docker run \
-    --name "$node_name" \
-    --network "$network_name" \
-    --env "ES_JAVA_OPTS=-Xms1g -Xmx1g -da:org.elasticsearch.xpack.ccr.index.engine.FollowingEngineAssertions" \
-    "${environment[@]}" \
-    "${volumes[@]}" \
-    --publish "$http_port":9200 \
-    --ulimit nofile=65536:65536 \
-    --ulimit memlock=-1:-1 \
-    --detach="$local_detach" \
-    --health-cmd="curl $cert_validation_flags --fail $elasticsearch_url/_cluster/health || exit 1" \
-    --health-interval=2s \
-    --health-retries=20 \
-    --health-timeout=2s \
-    --rm \
-    docker.elastic.co/elasticsearch/"$elasticsearch_container";
-
-  set +x
-  if wait_for_container "$es_node_name" "$network_name"; then
-    echo -e "\033[32;1mSUCCESS:\033[0m Running on: $node_url\033[0m"
-  fi
-
-done
-

.ci/run-repository.sh

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

.ci/run-tests

@@ -1,23 +1,63 @@
 #!/usr/bin/env bash
+
+#
+# Runs the client tests via Docker with the expectation that the required
+# environment variables have already been exported before running this script.
+#
+# The required environment variables include:
+#
+#   - $ELASTICSEARCH_VERSION
+#   - $NODE_JS_VERSION
+#   - $TEST_SUITE
 #
-# Version 1.1
-# - Moved to .ci folder and seperated out `run-repository.sh`
-# - Add `$RUNSCRIPTS` env var for running Elasticsearch dependent products
-script_path=$(dirname $(realpath -s $0))
-source $script_path/functions/imports.sh
-set -euo pipefail
 
-echo -e "\033[1m>>>>> Start [$STACK_VERSION container] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>\033[0m"
-DETACH=true bash .ci/run-elasticsearch.sh
+set -eo pipefail
 
-if [[ -n "$RUNSCRIPTS" ]]; then
-  for RUNSCRIPT in ${RUNSCRIPTS//,/ } ; do
-    echo -e "\033[1m>>>>> Running run-$RUNSCRIPT.sh >>>>>>>>>>>>>>>>>>>>>>>>>>>>>\033[0m"
-    CONTAINER_NAME=${RUNSCRIPT} \
-      DETACH=true \
-      bash .ci/run-${RUNSCRIPT}.sh
-  done
+ELASTICSEARCH_VERSION=${STACK_VERSION}
+
+docker build \
+  --file .ci/Dockerfile \
+  --tag elastic/elasticsearch-js \
+  --build-arg NODE_JS_VERSION=${NODE_JS_VERSION} \
+  .
+
+NODE_NAME="es1"
+repo=$(pwd)
+testnodecrt="/.ci/certs/testnode.crt"
+testnodekey="/.ci/certs/testnode.key"
+cacrt="/.ci/certs/ca.crt"
+
+elasticsearch_image="elasticsearch"
+elasticsearch_url="https://elastic:changeme@${NODE_NAME}:9200"
+if [[ $TEST_SUITE != "xpack" ]]; then
+  elasticsearch_image="elasticsearch"
+  elasticsearch_url="http://${NODE_NAME}:9200"
 fi
 
-echo -e "\033[1m>>>>> Repository specific tests >>>>>>>>>>>>>>>>>>>>>>>>>>>>>\033[0m"
-bash .ci/run-repository.sh
+docker network create esnet
+
+docker run \
+  --rm \
+  --env "node.attr.testattr=test" \
+  --env "path.repo=/tmp" \
+  --env "repositories.url.allowed_urls=http://snapshot.*" \
+  --env "discovery.zen.ping.unicast.hosts=${NODE_NAME}"  \
+  --env "xpack.security.enabled=false" \
+  --env "xpack.monitoring.enabled=false" \
+  --env "xpack.ml.enabled=false" \
+  --env ES_JAVA_OPTS="-Xms1g -Xmx1g" \
+  --network=esnet \
+  --name=$NODE_NAME \
+  --detach \
+  docker.elastic.co/elasticsearch/elasticsearch:${ELASTICSEARCH_VERSION}
+
+docker run \
+  --network=esnet \
+  --env "TEST_ES_SERVER=${elasticsearch_url}" \
+  --volume $(pwd):/usr/src/app \
+  --volume /usr/src/app/node_modules \
+  --name elasticsearch-js \
+  --rm \
+  elastic/elasticsearch-js \
+  npm run test:integration
+

.ci/test-matrix.yml

@@ -1,14 +1,13 @@
 ---
 STACK_VERSION:
-  - "8.2.4-SNAPSHOT"
+  - 5.6.16
 
 NODE_JS_VERSION:
-  - 18
-  - 16
-  - 14
+  - 12
+  - 10
+  - 8
 
 TEST_SUITE:
-  - free
-  - platinum
+  - oss
 
 exclude: ~

.github/ISSUE_TEMPLATE.md

@@ -3,7 +3,7 @@
 #### You have already researched for similar issues?
 It's not uncommon that somebody already opened an issue or in the best case it's already fixed but not merged. That's the reason why you should [search](https://github.com/elastic/elasticsearch-js/issues) at first before submitting a new one.
 
-#### Are you sure this is an issue with `@elastic/elasticsearch` or are you just looking for some help?
+#### Are you sure this is an issue with @elastic/elasticsearch or are you just looking for some help?
 
 Issues should only be posted in this repository after you have been able to reproduce them and confirm that they are a bug or incorrect/missing information in the [docs](https://github.com/elastic/elasticsearch-js/docs).
 

.github/ISSUE_TEMPLATE/bug.md

@@ -23,14 +23,6 @@ Paste your code here:
 
 ```
 
-<!--
-In some cases, it might be challenging to reproduce the bug in a few lines of code.
-You can fork the following repository, which contains all the configuration needed
-to spin up a three nodes Elasticsearch cluster with security enabled.
-The repository also contains a preconfigured client instance that you can use to reproduce the issue.
-https://github.com/delvedor/es-reproduce-issue
---->
-
 ## Expected behavior
 
 A clear and concise description of what you expected to happen.
@@ -44,6 +36,6 @@ Paste the results here:
 ## Your Environment
 
 - *node version*: 6,8,10
-- `@elastic/elasticsearch` *version*: >=7.0.0
+- *@elastic/elasticsearch version*: >=7.0.0
 - *os*: Mac, Windows, Linux
 - *any other relevant information*

.github/ISSUE_TEMPLATE/regression.md

@@ -29,14 +29,6 @@ Paste your code here:
 
 ```
 
-<!--
-In some cases, it might be challenging to reproduce the bug in a few lines of code.
-You can fork the following repository, which contains all the configuration needed
-to spin up a three nodes Elasticsearch cluster with security enabled.
-The repository also contains a preconfigured client instance that you can use to reproduce the issue.
-https://github.com/delvedor/es-reproduce-issue
---->
-
 ## Expected behavior
 
 A clear and concise description of what you expected to happen.
@@ -50,7 +42,6 @@ Paste the results here:
 ## Your Environment
 
 - *node version*: 6,8,10
-- `@elastic/elasticsearch` *version*: >=7.0.0
-- *typescript version*: 4.x (if applicable)
+- *@elastic/elasticsearch version*: >=7.0.0
 - *os*: Mac, Windows, Linux
 - *any other relevant information*

.github/stale.yml

@@ -9,8 +9,6 @@ exemptLabels:
   - "discussion"
   - "feature request"
   - "bug"
-  - "todo"
-  - "good first issue"
 
 # Label to use when marking an issue as stale
 staleLabel: stale

.github/workflows/nodejs.yml

@@ -1,6 +1,6 @@
 name: Node CI
 
-on: [push, pull_request]
+on: [push]
 
 jobs:
   test:
@@ -9,7 +9,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [14.x, 16.x, 18.x]
+        node-version: [10.x, 12.x, 13.x]
         os: [ubuntu-latest, windows-latest, macOS-latest]
 
     steps:
@@ -32,143 +32,68 @@ jobs:
       run: |
         npm run test:unit
 
-    # - name: Acceptance test
-    #   run: |
-    #     npm run test:acceptance
+    - name: Behavior test
+      run: |
+        npm run test:behavior
 
-  # helpers-integration-test:
-  #   name: Helpers integration test
-  #   runs-on: ubuntu-latest
+    - name: Type Definitions
+      run: |
+        npm run test:types
 
-  #   strategy:
-  #     matrix:
-  #       node-version: [12.x, 14.x, 16.x]
+  test-node-v8:
+    name: Test
+    runs-on: ${{ matrix.os }}
 
-  #   steps:
-  #   - uses: actions/checkout@v2
+    strategy:
+      matrix:
+        node-version: [8.x]
+        os: [ubuntu-latest, windows-latest, macOS-latest]
 
-  #   - name: Configure sysctl limits
-  #     run: |
-  #       sudo swapoff -a
-  #       sudo sysctl -w vm.swappiness=1
-  #       sudo sysctl -w fs.file-max=262144
-  #       sudo sysctl -w vm.max_map_count=262144
+    steps:
+    - uses: actions/checkout@v2
 
-  #   - name: Runs Elasticsearch
-  #     uses: elastic/elastic-github-actions/elasticsearch@master
-  #     with:
-  #       stack-version: 8.0.0-SNAPSHOT
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
 
-  #   - name: Use Node.js ${{ matrix.node-version }}
-  #     uses: actions/setup-node@v1
-  #     with:
-  #       node-version: ${{ matrix.node-version }}
+    - name: Install
+      run: |
+        npm install
 
-  #   - name: Install
-  #     run: |
-  #       npm install
+    - name: Test
+      run: |
+        npm run test:unit -- --node-arg=--harmony-async-iteration
 
-  #   - name: Integration test
-  #     run: |
-  #       npm run test:integration:helpers
+  code-coverage:
+    name: Code coverage
+    runs-on: ubuntu-latest
 
-  # bundler-support:
-  #   name: Bundler support
-  #   runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [12.x]
 
-  #   steps:
-  #   - uses: actions/checkout@v2
+    steps:
+    - uses: actions/checkout@v2
 
-  #   - name: Configure sysctl limits
-  #     run: |
-  #       sudo swapoff -a
-  #       sudo sysctl -w vm.swappiness=1
-  #       sudo sysctl -w fs.file-max=262144
-  #       sudo sysctl -w vm.max_map_count=262144
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
 
-  #   - name: Runs Elasticsearch
-  #     uses: elastic/elastic-github-actions/elasticsearch@master
-  #     with:
-  #       stack-version: 8.0.0-SNAPSHOT
+    - name: Install
+      run: |
+        npm install
 
-  #   - name: Use Node.js 14.x
-  #     uses: actions/setup-node@v1
-  #     with:
-  #       node-version: 14.x
+    - name: Code coverage
+      run: |
+        npm run test:coverage
 
-  #   - name: Install
-  #     run: |
-  #       npm install
-  #       npm install --prefix test/bundlers/parcel-test
-  #       npm install --prefix test/bundlers/rollup-test
-  #       npm install --prefix test/bundlers/webpack-test
-
-  #   - name: Build
-  #     run: |
-  #       npm run build --prefix test/bundlers/parcel-test
-  #       npm run build --prefix test/bundlers/rollup-test
-  #       npm run build --prefix test/bundlers/webpack-test
-
-  #   - name: Run bundle
-  #     run: |
-  #       npm start --prefix test/bundlers/parcel-test
-  #       npm start --prefix test/bundlers/rollup-test
-  #       npm start --prefix test/bundlers/webpack-test
-
-  # mock-support:
-  #   name: Mock support
-  #   runs-on: ubuntu-latest
-
-  #   steps:
-  #   - uses: actions/checkout@v2
-
-  #   - name: Use Node.js 14.x
-  #     uses: actions/setup-node@v1
-  #     with:
-  #       node-version: 14.x
-
-  #   - name: Install
-  #     run: |
-  #       npm install
-  #       npm install --prefix test/mock
-
-  #   - name: Run test
-  #     run: |
-  #       npm test --prefix test/mock
-
-  # code-coverage:
-  #   name: Code coverage
-  #   runs-on: ubuntu-latest
-
-  #   strategy:
-  #     matrix:
-  #       node-version: [14.x]
-
-  #   steps:
-  #   - uses: actions/checkout@v2
-
-  #   - name: Use Node.js ${{ matrix.node-version }}
-  #     uses: actions/setup-node@v1
-  #     with:
-  #       node-version: ${{ matrix.node-version }}
-
-  #   - name: Install
-  #     run: |
-  #       npm install
-
-  #   - name: Code coverage report
-  #     run: |
-  #       npm run test:coverage-report
-
-  #   - name: Upload coverage to Codecov
-  #     uses: codecov/codecov-action@v1
-  #     with:
-  #       file: ./coverage.lcov
-  #       fail_ci_if_error: true
-
-  #   - name: Code coverage 100%
-  #     run: |
-  #       npm run test:coverage-100
+    - name: Upload coverage to Codecov
+      uses: codecov/codecov-action@v1
+      with:
+        file: ./coverage.lcov
+        fail_ci_if_error: true
 
   license:
     name: License check
@@ -176,7 +101,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [16.x]
+        node-version: [12.x]
 
     steps:
     - uses: actions/checkout@v2

.gitignore

@@ -45,9 +45,6 @@ jspm_packages
 # vim swap files
 *.swp
 
-#Jetbrains editor folder
-.idea
-
 package-lock.json
 
 # elasticsearch repo or binary files
@@ -56,10 +53,3 @@ elasticsearch*
 test/benchmarks/macro/fixtures/*
 
 *-junit.xml
-
-.cache
-
-test/bundlers/**/bundle.js
-test/bundlers/parcel-test/.parcel-cache
-
-lib

.npmignore

@@ -70,5 +70,3 @@ certs
 .github
 CODE_OF_CONDUCT.md
 CONTRIBUTING.md
-
-src

CHANGELOG.md

@@ -1,3 +0,0 @@
-303 See Other
-
-Location: https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/changelog-client.html

NOTICE.txt

@@ -1,2 +0,0 @@
-Elasticsearch JavaScript Client
-Copyright 2022 Elasticsearch B.V.

README.md

@@ -2,10 +2,16 @@
 
 # Elasticsearch Node.js client
 
-[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](http://standardjs.com/)  [![Build Status](https://clients-ci.elastic.co/buildStatus/icon?job=elastic%2Belasticsearch-js%2Bmain)](https://clients-ci.elastic.co/view/JavaScript/job/elastic+elasticsearch-js+main/)  [![Node CI](https://github.com/elastic/elasticsearch-js/actions/workflows/nodejs.yml/badge.svg)](https://github.com/elastic/elasticsearch-js/actions/workflows/nodejs.yml)  [![codecov](https://codecov.io/gh/elastic/elasticsearch-js/branch/master/graph/badge.svg)](https://codecov.io/gh/elastic/elasticsearch-js)  [![NPM downloads](https://img.shields.io/npm/dm/@elastic/elasticsearch.svg?style=flat)](https://www.npmjs.com/package/@elastic/elasticsearch)
+[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](http://standardjs.com/)  [![Build Status](https://clients-ci.elastic.co/buildStatus/icon?job=elastic%2Belasticsearch-js%2Bmaster)](https://clients-ci.elastic.co/view/Javascript/job/elastic+elasticsearch-js+master/)  [![codecov](https://codecov.io/gh/elastic/elasticsearch-js/branch/master/graph/badge.svg)](https://codecov.io/gh/elastic/elasticsearch-js)  [![NPM downloads](https://img.shields.io/npm/dm/@elastic/elasticsearch.svg?style=flat)](https://www.npmjs.com/package/@elastic/elasticsearch)
 
 The official Node.js client for Elasticsearch.
 
+---
+
+**Note:** In the past months we have worked on the new Elasticsearch Node.js client and you can use it by following the instructions below. If you're going to use the legacy one or report an issue, however, please check out [elastic/elasticsearch-js-legacy](https://github.com/elastic/elasticsearch-js-legacy).
+
+---
+
 ## Features
 - One-to-one mapping with REST API.
 - Generalized, pluggable architecture.
@@ -20,42 +26,15 @@ The official Node.js client for Elasticsearch.
 npm install @elastic/elasticsearch
 ```
 
-### Node.js support
-
-NOTE: The minimum supported version of Node.js is `v14`.
-
-The client versioning follows the Elastic Stack versioning, this means that
-major, minor, and patch releases are done following a precise schedule that
-often does not coincide with the [Node.js release](https://nodejs.org/en/about/releases/) times.
-
-To avoid support insecure and unsupported versions of Node.js, the
-client **will drop the support of EOL versions of Node.js between minor releases**.
-Typically, as soon as a Node.js version goes into EOL, the client will continue
-to support that version for at least another minor release. If you are using the client
-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, 
-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
-of `^7.10.0`).
-
-| Node.js Version | Node.js EOL date | End of support         |
-| --------------- |------------------| ---------------------- |
-| `8.x`           | `December 2019`  | `7.11` (early 2021)    |
-| `10.x`          | `April 2021`     | `7.12` (mid 2021)      |
-| `12.x`          | `April 2022`     | `8.2` (early 2022)     |
-| `14.x`          | `April 2023`     | `8.8` (early 2023)     |
-
 ### Compatibility
 
-Language clients are forward compatible; meaning that clients support communicating with greater or equal minor versions of Elasticsearch.
-Elasticsearch language clients are only backwards compatible with default distributions and without guarantees made.
+The minimum supported version of Node.js is `v8`.
+
+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.
 
 | Elasticsearch Version | Client Version |
 | --------------------- |----------------|
-| `8.x`                 | `8.x`          |
+| `master`              | `master`       |
 | `7.x`                 | `7.x`          |
 | `6.x`                 | `6.x`          |
 | `5.x`                 | `5.x`          |
@@ -68,38 +47,70 @@ npm install @elastic/elasticsearch@<major>
 #### Browser
 
 WARNING: There is no official support for the browser environment. It exposes your Elasticsearch instance to everyone, which could lead to security issues.
-We recommend that you write a lightweight proxy that uses this client instead, you can see a proxy example [here](./docs/examples/proxy).
+We recommend that you write a lightweight proxy that uses this client instead.
 
 ## Documentation
 
 - [Introduction](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/introduction.html)
-- [Usage](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/client-connecting.html#client-usage)
+- [Usage](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/client-usage.html)
 - [Client configuration](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/client-configuration.html)
 - [API reference](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/api-reference.html)
-- [Authentication](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/client-connecting.html#authentication)
+- [Breaking changes coming from the old client](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/breaking-changes.html)
+- [Authentication](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/auth-reference.html)
 - [Observability](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/observability.html)
-- [Creating a child client](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/child.html)
-- [Client helpers](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/client-helpers.html)
+- [Creating a child client](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/child-client.html)
+- [Extend the client](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/extend-client.html)
 - [Typescript support](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/typescript.html)
-- [Testing](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/client-testing.html)
 - [Examples](https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/examples.html)
 
 ## Quick start
 
+First of all, require the client and initialize it:
+```js
+const { Client } = require('@elastic/elasticsearch')
+const client = new Client({ node: 'http://localhost:9200' })
+```
+
+You can use both the callback-style API and the promise-style API, both behave the same way.
+```js
+// promise API
+const result = await client.search({
+  index: 'my-index',
+  body: { foo: 'bar' }
+})
+
+// callback API
+client.search({
+  index: 'my-index',
+  body: { foo: 'bar' }
+}, (err, result) => {
+  if (err) console.log(err)
+})
+```
+The returned value of **every** API call is formed as follows:
+```ts
+{
+  body: object | boolean
+  statusCode: number
+  headers: object
+  warnings: [string]
+  meta: object
+}
+```
+
+Let's see a complete example!
 ```js
 'use strict'
 
 const { Client } = require('@elastic/elasticsearch')
-const client = new Client({
-  cloud: { id: '<cloud-id>' },
-  auth: { apiKey: 'base64EncodedKey' }
-})
+const client = new Client({ node: 'http://localhost:9200' })
 
 async function run () {
   // Let's start by indexing some data
   await client.index({
     index: 'game-of-thrones',
-    document: {
+    // type: '_doc', // uncomment this line if you are using Elasticsearch ≤ 6
+    body: {
       character: 'Ned Stark',
       quote: 'Winter is coming.'
     }
@@ -107,7 +118,8 @@ async function run () {
 
   await client.index({
     index: 'game-of-thrones',
-    document: {
+    // type: '_doc', // uncomment this line if you are using Elasticsearch ≤ 6
+    body: {
       character: 'Daenerys Targaryen',
       quote: 'I am the blood of the dragon.'
     }
@@ -115,7 +127,8 @@ async function run () {
 
   await client.index({
     index: 'game-of-thrones',
-    document: {
+    // type: '_doc', // uncomment this line if you are using Elasticsearch ≤ 6
+    body: {
       character: 'Tyrion Lannister',
       quote: 'A mind needs books like a sword needs a whetstone.'
     }
@@ -126,14 +139,17 @@ async function run () {
   await client.indices.refresh({ index: 'game-of-thrones' })
 
   // Let's search!
-  const result= await client.search({
+  const { body } = await client.search({
     index: 'game-of-thrones',
-    query: {
-      match: { quote: 'winter' }
+    // type: '_doc', // uncomment this line if you are using Elasticsearch ≤ 6
+    body: {
+      query: {
+        match: { quote: 'winter' }
+      }
     }
   })
 
-  console.log(result.hits.hits)
+  console.log(body.hits.hits)
 }
 
 run().catch(console.log)
@@ -163,24 +179,18 @@ You will require the packages from your code by using the alias you have defined
 const { Client: Client6 } = require('es6')
 const { Client: Client7 } = require('es7')
 
-const client6 = new Client6({
-  cloud: { id: '<cloud-id>' },
-  auth: { apiKey: 'base64EncodedKey' }
-})
-const client7 = new Client7({
-  cloud: { id: '<cloud-id>' },
-  auth: { apiKey: 'base64EncodedKey' }
-})
+const client6 = new Client6({ node: 'http://localhost:9200' })
+const client7 = new Client7({ node: 'http://localhost:9201' })
 
-client6.info().then(console.log, console.log)
-client7.info().then(console.log, console.log)
+client6.info(console.log)
+client7.info(console.log)
 ```
 
-Finally, if you want to install the client for the next version of Elasticsearch *(the one that lives in Elasticsearch’s main branch)*, you can use the following command:
+Finally, if you want to install the client for the next version of Elasticsearch *(the one that lives in Elasticsearch’s master branch)*, you can use the following command:
 ```sh
-npm install esmain@github:elastic/elasticsearch-js
+npm install esmaster@github:elastic/elasticsearch-js
 ```
 
 ## License
 
-This software is licensed under the [Apache License 2.0](./LICENSE).
+This software is licensed under the [Apache 2 license](./LICENSE).

api/api/bulk.js

@@ -0,0 +1,123 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildBulk (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [bulk](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/docs-bulk.html) request
+   *
+   * @param {string} index - Default index for items which don't provide one
+   * @param {string} type - Default document type for items which don't provide one
+   * @param {string} wait_for_active_shards - Sets the number of shard copies that must be active before proceeding with the bulk operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
+   * @param {enum} refresh - If `true` then refresh the effected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
+   * @param {string} routing - Specific routing value
+   * @param {time} timeout - Explicit operation timeout
+   * @param {string} type - Default document type for items which don't provide one
+   * @param {list} fields - Default comma-separated list of fields to return in the response for updates, can be overridden on each sub-request
+   * @param {list} _source - True or false to return the _source field or not, or default list of fields to return, can be overridden on each sub-request
+   * @param {list} _source_exclude - Default list of fields to exclude from the returned _source field, can be overridden on each sub-request
+   * @param {list} _source_include - Default list of fields to extract and return from the _source field, can be overridden on each sub-request
+   * @param {string} pipeline - The pipeline id to preprocess incoming documents with
+   * @param {object} body - The operation definition and data (action-data pairs), separated by newlines
+   */
+
+  const acceptedQuerystring = [
+    'wait_for_active_shards',
+    'refresh',
+    'routing',
+    'timeout',
+    'type',
+    'fields',
+    '_source',
+    '_source_exclude',
+    '_source_include',
+    'pipeline',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    waitForActiveShards: 'wait_for_active_shards',
+    _sourceExclude: '_source_exclude',
+    _sourceInclude: '_source_include',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function bulk (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params['body'] == null) {
+      const err = new ConfigurationError('Missing required parameter: body')
+      return handleError(err, callback)
+    }
+
+    // check required url components
+    if (params['type'] != null && (params['index'] == null)) {
+      const err = new ConfigurationError('Missing required parameter of the url: index')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, type, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'POST'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((index) != null && (type) != null) {
+      path = '/' + encodeURIComponent(index) + '/' + encodeURIComponent(type) + '/' + '_bulk'
+    } else if ((index) != null) {
+      path = '/' + encodeURIComponent(index) + '/' + '_bulk'
+    } else {
+      path = '/' + '_bulk'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      bulkBody: body,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildBulk

api/api/cat.aliases.js

@@ -0,0 +1,105 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildCatAliases (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [cat.aliases](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/cat-alias.html) request
+   *
+   * @param {list} name - A comma-separated list of alias names to return
+   * @param {string} format - a short version of the Accept header, e.g. json, yaml
+   * @param {boolean} local - Return local information, do not retrieve the state from master node (default: false)
+   * @param {time} master_timeout - Explicit operation timeout for connection to master node
+   * @param {list} h - Comma-separated list of column names to display
+   * @param {boolean} help - Return help information
+   * @param {list} s - Comma-separated list of column names or column aliases to sort by
+   * @param {boolean} v - Verbose mode. Display column headers
+   */
+
+  const acceptedQuerystring = [
+    'format',
+    'local',
+    'master_timeout',
+    'h',
+    'help',
+    's',
+    'v',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    masterTimeout: 'master_timeout',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function catAliases (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, name, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((name) != null) {
+      path = '/' + '_cat' + '/' + 'aliases' + '/' + encodeURIComponent(name)
+    } else {
+      path = '/' + '_cat' + '/' + 'aliases'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildCatAliases

api/api/cat.allocation.js

@@ -0,0 +1,107 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildCatAllocation (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [cat.allocation](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/cat-allocation.html) request
+   *
+   * @param {list} node_id - A comma-separated list of node IDs or names to limit the returned information
+   * @param {string} format - a short version of the Accept header, e.g. json, yaml
+   * @param {enum} bytes - The unit in which to display byte values
+   * @param {boolean} local - Return local information, do not retrieve the state from master node (default: false)
+   * @param {time} master_timeout - Explicit operation timeout for connection to master node
+   * @param {list} h - Comma-separated list of column names to display
+   * @param {boolean} help - Return help information
+   * @param {list} s - Comma-separated list of column names or column aliases to sort by
+   * @param {boolean} v - Verbose mode. Display column headers
+   */
+
+  const acceptedQuerystring = [
+    'format',
+    'bytes',
+    'local',
+    'master_timeout',
+    'h',
+    'help',
+    's',
+    'v',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    masterTimeout: 'master_timeout',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function catAllocation (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, nodeId, node_id, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((node_id || nodeId) != null) {
+      path = '/' + '_cat' + '/' + 'allocation' + '/' + encodeURIComponent(node_id || nodeId)
+    } else {
+      path = '/' + '_cat' + '/' + 'allocation'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildCatAllocation

api/api/cat.count.js

@@ -0,0 +1,105 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildCatCount (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [cat.count](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/cat-count.html) request
+   *
+   * @param {list} index - A comma-separated list of index names to limit the returned information
+   * @param {string} format - a short version of the Accept header, e.g. json, yaml
+   * @param {boolean} local - Return local information, do not retrieve the state from master node (default: false)
+   * @param {time} master_timeout - Explicit operation timeout for connection to master node
+   * @param {list} h - Comma-separated list of column names to display
+   * @param {boolean} help - Return help information
+   * @param {list} s - Comma-separated list of column names or column aliases to sort by
+   * @param {boolean} v - Verbose mode. Display column headers
+   */
+
+  const acceptedQuerystring = [
+    'format',
+    'local',
+    'master_timeout',
+    'h',
+    'help',
+    's',
+    'v',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    masterTimeout: 'master_timeout',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function catCount (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((index) != null) {
+      path = '/' + '_cat' + '/' + 'count' + '/' + encodeURIComponent(index)
+    } else {
+      path = '/' + '_cat' + '/' + 'count'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildCatCount

api/api/cat.fielddata.js

@@ -0,0 +1,109 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildCatFielddata (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [cat.fielddata](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/cat-fielddata.html) request
+   *
+   * @param {list} fields - A comma-separated list of fields to return the fielddata size
+   * @param {string} format - a short version of the Accept header, e.g. json, yaml
+   * @param {enum} bytes - The unit in which to display byte values
+   * @param {boolean} local - Return local information, do not retrieve the state from master node (default: false)
+   * @param {time} master_timeout - Explicit operation timeout for connection to master node
+   * @param {list} h - Comma-separated list of column names to display
+   * @param {boolean} help - Return help information
+   * @param {list} s - Comma-separated list of column names or column aliases to sort by
+   * @param {boolean} v - Verbose mode. Display column headers
+   * @param {list} fields - A comma-separated list of fields to return in the output
+   */
+
+  const acceptedQuerystring = [
+    'format',
+    'bytes',
+    'local',
+    'master_timeout',
+    'h',
+    'help',
+    's',
+    'v',
+    'fields',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    masterTimeout: 'master_timeout',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function catFielddata (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, fields, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((fields) != null) {
+      path = '/' + '_cat' + '/' + 'fielddata' + '/' + encodeURIComponent(fields)
+    } else {
+      path = '/' + '_cat' + '/' + 'fielddata'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildCatFielddata

api/api/cat.health.js

@@ -0,0 +1,102 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildCatHealth (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [cat.health](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/cat-health.html) request
+   *
+   * @param {string} format - a short version of the Accept header, e.g. json, yaml
+   * @param {boolean} local - Return local information, do not retrieve the state from master node (default: false)
+   * @param {time} master_timeout - Explicit operation timeout for connection to master node
+   * @param {list} h - Comma-separated list of column names to display
+   * @param {boolean} help - Return help information
+   * @param {list} s - Comma-separated list of column names or column aliases to sort by
+   * @param {boolean} ts - Set to false to disable timestamping
+   * @param {boolean} v - Verbose mode. Display column headers
+   */
+
+  const acceptedQuerystring = [
+    'format',
+    'local',
+    'master_timeout',
+    'h',
+    'help',
+    's',
+    'ts',
+    'v',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    masterTimeout: 'master_timeout',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function catHealth (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + '_cat' + '/' + 'health'
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildCatHealth

api/api/cat.help.js

@@ -0,0 +1,89 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildCatHelp (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [cat.help](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/cat.html) request
+   *
+   * @param {boolean} help - Return help information
+   * @param {list} s - Comma-separated list of column names or column aliases to sort by
+   */
+
+  const acceptedQuerystring = [
+    'help',
+    's',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function catHelp (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + '_cat'
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildCatHelp

api/api/cat.indices.js

@@ -0,0 +1,111 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildCatIndices (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [cat.indices](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/cat-indices.html) request
+   *
+   * @param {list} index - A comma-separated list of index names to limit the returned information
+   * @param {string} format - a short version of the Accept header, e.g. json, yaml
+   * @param {enum} bytes - The unit in which to display byte values
+   * @param {boolean} local - Return local information, do not retrieve the state from master node (default: false)
+   * @param {time} master_timeout - Explicit operation timeout for connection to master node
+   * @param {list} h - Comma-separated list of column names to display
+   * @param {enum} health - A health status ("green", "yellow", or "red" to filter only indices matching the specified health status
+   * @param {boolean} help - Return help information
+   * @param {boolean} pri - Set to true to return stats only for primary shards
+   * @param {list} s - Comma-separated list of column names or column aliases to sort by
+   * @param {boolean} v - Verbose mode. Display column headers
+   */
+
+  const acceptedQuerystring = [
+    'format',
+    'bytes',
+    'local',
+    'master_timeout',
+    'h',
+    'health',
+    'help',
+    'pri',
+    's',
+    'v',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    masterTimeout: 'master_timeout',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function catIndices (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((index) != null) {
+      path = '/' + '_cat' + '/' + 'indices' + '/' + encodeURIComponent(index)
+    } else {
+      path = '/' + '_cat' + '/' + 'indices'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildCatIndices

api/api/cat.master.js

@@ -0,0 +1,100 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildCatMaster (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [cat.master](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/cat-master.html) request
+   *
+   * @param {string} format - a short version of the Accept header, e.g. json, yaml
+   * @param {boolean} local - Return local information, do not retrieve the state from master node (default: false)
+   * @param {time} master_timeout - Explicit operation timeout for connection to master node
+   * @param {list} h - Comma-separated list of column names to display
+   * @param {boolean} help - Return help information
+   * @param {list} s - Comma-separated list of column names or column aliases to sort by
+   * @param {boolean} v - Verbose mode. Display column headers
+   */
+
+  const acceptedQuerystring = [
+    'format',
+    'local',
+    'master_timeout',
+    'h',
+    'help',
+    's',
+    'v',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    masterTimeout: 'master_timeout',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function catMaster (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + '_cat' + '/' + 'master'
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildCatMaster

api/api/cat.nodeattrs.js

@@ -0,0 +1,100 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildCatNodeattrs (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [cat.nodeattrs](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/cat-nodeattrs.html) request
+   *
+   * @param {string} format - a short version of the Accept header, e.g. json, yaml
+   * @param {boolean} local - Return local information, do not retrieve the state from master node (default: false)
+   * @param {time} master_timeout - Explicit operation timeout for connection to master node
+   * @param {list} h - Comma-separated list of column names to display
+   * @param {boolean} help - Return help information
+   * @param {list} s - Comma-separated list of column names or column aliases to sort by
+   * @param {boolean} v - Verbose mode. Display column headers
+   */
+
+  const acceptedQuerystring = [
+    'format',
+    'local',
+    'master_timeout',
+    'h',
+    'help',
+    's',
+    'v',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    masterTimeout: 'master_timeout',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function catNodeattrs (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + '_cat' + '/' + 'nodeattrs'
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildCatNodeattrs

api/api/cat.nodes.js

@@ -0,0 +1,103 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildCatNodes (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [cat.nodes](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/cat-nodes.html) request
+   *
+   * @param {string} format - a short version of the Accept header, e.g. json, yaml
+   * @param {boolean} full_id - Return the full node ID instead of the shortened version (default: false)
+   * @param {boolean} local - Return local information, do not retrieve the state from master node (default: false)
+   * @param {time} master_timeout - Explicit operation timeout for connection to master node
+   * @param {list} h - Comma-separated list of column names to display
+   * @param {boolean} help - Return help information
+   * @param {list} s - Comma-separated list of column names or column aliases to sort by
+   * @param {boolean} v - Verbose mode. Display column headers
+   */
+
+  const acceptedQuerystring = [
+    'format',
+    'full_id',
+    'local',
+    'master_timeout',
+    'h',
+    'help',
+    's',
+    'v',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    fullId: 'full_id',
+    masterTimeout: 'master_timeout',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function catNodes (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + '_cat' + '/' + 'nodes'
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildCatNodes

api/api/cat.pending_tasks.js

@@ -0,0 +1,100 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildCatPendingTasks (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [cat.pending_tasks](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/cat-pending-tasks.html) request
+   *
+   * @param {string} format - a short version of the Accept header, e.g. json, yaml
+   * @param {boolean} local - Return local information, do not retrieve the state from master node (default: false)
+   * @param {time} master_timeout - Explicit operation timeout for connection to master node
+   * @param {list} h - Comma-separated list of column names to display
+   * @param {boolean} help - Return help information
+   * @param {list} s - Comma-separated list of column names or column aliases to sort by
+   * @param {boolean} v - Verbose mode. Display column headers
+   */
+
+  const acceptedQuerystring = [
+    'format',
+    'local',
+    'master_timeout',
+    'h',
+    'help',
+    's',
+    'v',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    masterTimeout: 'master_timeout',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function catPendingTasks (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + '_cat' + '/' + 'pending_tasks'
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildCatPendingTasks

api/api/cat.plugins.js

@@ -0,0 +1,100 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildCatPlugins (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [cat.plugins](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/cat-plugins.html) request
+   *
+   * @param {string} format - a short version of the Accept header, e.g. json, yaml
+   * @param {boolean} local - Return local information, do not retrieve the state from master node (default: false)
+   * @param {time} master_timeout - Explicit operation timeout for connection to master node
+   * @param {list} h - Comma-separated list of column names to display
+   * @param {boolean} help - Return help information
+   * @param {list} s - Comma-separated list of column names or column aliases to sort by
+   * @param {boolean} v - Verbose mode. Display column headers
+   */
+
+  const acceptedQuerystring = [
+    'format',
+    'local',
+    'master_timeout',
+    'h',
+    'help',
+    's',
+    'v',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    masterTimeout: 'master_timeout',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function catPlugins (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + '_cat' + '/' + 'plugins'
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildCatPlugins

api/api/cat.recovery.js

@@ -0,0 +1,105 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildCatRecovery (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [cat.recovery](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/cat-recovery.html) request
+   *
+   * @param {list} index - A comma-separated list of index names to limit the returned information
+   * @param {string} format - a short version of the Accept header, e.g. json, yaml
+   * @param {enum} bytes - The unit in which to display byte values
+   * @param {time} master_timeout - Explicit operation timeout for connection to master node
+   * @param {list} h - Comma-separated list of column names to display
+   * @param {boolean} help - Return help information
+   * @param {list} s - Comma-separated list of column names or column aliases to sort by
+   * @param {boolean} v - Verbose mode. Display column headers
+   */
+
+  const acceptedQuerystring = [
+    'format',
+    'bytes',
+    'master_timeout',
+    'h',
+    'help',
+    's',
+    'v',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    masterTimeout: 'master_timeout',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function catRecovery (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((index) != null) {
+      path = '/' + '_cat' + '/' + 'recovery' + '/' + encodeURIComponent(index)
+    } else {
+      path = '/' + '_cat' + '/' + 'recovery'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildCatRecovery

api/api/cat.repositories.js

@@ -0,0 +1,100 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildCatRepositories (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [cat.repositories](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/cat-repositories.html) request
+   *
+   * @param {string} format - a short version of the Accept header, e.g. json, yaml
+   * @param {boolean} local - Return local information, do not retrieve the state from master node
+   * @param {time} master_timeout - Explicit operation timeout for connection to master node
+   * @param {list} h - Comma-separated list of column names to display
+   * @param {boolean} help - Return help information
+   * @param {list} s - Comma-separated list of column names or column aliases to sort by
+   * @param {boolean} v - Verbose mode. Display column headers
+   */
+
+  const acceptedQuerystring = [
+    'format',
+    'local',
+    'master_timeout',
+    'h',
+    'help',
+    's',
+    'v',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    masterTimeout: 'master_timeout',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function catRepositories (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + '_cat' + '/' + 'repositories'
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildCatRepositories

api/api/cat.segments.js

@@ -0,0 +1,102 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildCatSegments (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [cat.segments](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/cat-segments.html) request
+   *
+   * @param {list} index - A comma-separated list of index names to limit the returned information
+   * @param {string} format - a short version of the Accept header, e.g. json, yaml
+   * @param {enum} bytes - The unit in which to display byte values
+   * @param {list} h - Comma-separated list of column names to display
+   * @param {boolean} help - Return help information
+   * @param {list} s - Comma-separated list of column names or column aliases to sort by
+   * @param {boolean} v - Verbose mode. Display column headers
+   */
+
+  const acceptedQuerystring = [
+    'format',
+    'bytes',
+    'h',
+    'help',
+    's',
+    'v',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function catSegments (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((index) != null) {
+      path = '/' + '_cat' + '/' + 'segments' + '/' + encodeURIComponent(index)
+    } else {
+      path = '/' + '_cat' + '/' + 'segments'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildCatSegments

api/api/cat.shards.js

@@ -0,0 +1,107 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildCatShards (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [cat.shards](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/cat-shards.html) request
+   *
+   * @param {list} index - A comma-separated list of index names to limit the returned information
+   * @param {string} format - a short version of the Accept header, e.g. json, yaml
+   * @param {enum} bytes - The unit in which to display byte values
+   * @param {boolean} local - Return local information, do not retrieve the state from master node (default: false)
+   * @param {time} master_timeout - Explicit operation timeout for connection to master node
+   * @param {list} h - Comma-separated list of column names to display
+   * @param {boolean} help - Return help information
+   * @param {list} s - Comma-separated list of column names or column aliases to sort by
+   * @param {boolean} v - Verbose mode. Display column headers
+   */
+
+  const acceptedQuerystring = [
+    'format',
+    'bytes',
+    'local',
+    'master_timeout',
+    'h',
+    'help',
+    's',
+    'v',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    masterTimeout: 'master_timeout',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function catShards (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((index) != null) {
+      path = '/' + '_cat' + '/' + 'shards' + '/' + encodeURIComponent(index)
+    } else {
+      path = '/' + '_cat' + '/' + 'shards'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildCatShards

api/api/cat.snapshots.js

@@ -0,0 +1,110 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildCatSnapshots (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [cat.snapshots](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/cat-snapshots.html) request
+   *
+   * @param {list} repository - Name of repository from which to fetch the snapshot information
+   * @param {string} format - a short version of the Accept header, e.g. json, yaml
+   * @param {boolean} ignore_unavailable - Set to true to ignore unavailable snapshots
+   * @param {time} master_timeout - Explicit operation timeout for connection to master node
+   * @param {list} h - Comma-separated list of column names to display
+   * @param {boolean} help - Return help information
+   * @param {list} s - Comma-separated list of column names or column aliases to sort by
+   * @param {boolean} v - Verbose mode. Display column headers
+   */
+
+  const acceptedQuerystring = [
+    'format',
+    'ignore_unavailable',
+    'master_timeout',
+    'h',
+    'help',
+    's',
+    'v',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    ignoreUnavailable: 'ignore_unavailable',
+    masterTimeout: 'master_timeout',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function catSnapshots (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params['repository'] == null) {
+      const err = new ConfigurationError('Missing required parameter: repository')
+      return handleError(err, callback)
+    }
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, repository, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((repository) != null) {
+      path = '/' + '_cat' + '/' + 'snapshots' + '/' + encodeURIComponent(repository)
+    } else {
+      path = '/' + '_cat' + '/' + 'snapshots'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildCatSnapshots

api/api/cat.tasks.js

@@ -0,0 +1,108 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildCatTasks (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [cat.tasks](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/tasks.html) request
+   *
+   * @param {string} format - a short version of the Accept header, e.g. json, yaml
+   * @param {list} node_id - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
+   * @param {list} actions - A comma-separated list of actions that should be returned. Leave empty to return all.
+   * @param {boolean} detailed - Return detailed task information (default: false)
+   * @param {string} parent_node - Return tasks with specified parent node.
+   * @param {number} parent_task - Return tasks with specified parent task id. Set to -1 to return all.
+   * @param {list} h - Comma-separated list of column names to display
+   * @param {boolean} help - Return help information
+   * @param {list} s - Comma-separated list of column names or column aliases to sort by
+   * @param {boolean} v - Verbose mode. Display column headers
+   */
+
+  const acceptedQuerystring = [
+    'format',
+    'node_id',
+    'actions',
+    'detailed',
+    'parent_node',
+    'parent_task',
+    'h',
+    'help',
+    's',
+    'v',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    nodeId: 'node_id',
+    parentNode: 'parent_node',
+    parentTask: 'parent_task',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function catTasks (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + '_cat' + '/' + 'tasks'
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildCatTasks

api/api/cat.templates.js

@@ -0,0 +1,105 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildCatTemplates (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [cat.templates](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/cat-templates.html) request
+   *
+   * @param {string} name - A pattern that returned template names must match
+   * @param {string} format - a short version of the Accept header, e.g. json, yaml
+   * @param {boolean} local - Return local information, do not retrieve the state from master node (default: false)
+   * @param {time} master_timeout - Explicit operation timeout for connection to master node
+   * @param {list} h - Comma-separated list of column names to display
+   * @param {boolean} help - Return help information
+   * @param {list} s - Comma-separated list of column names or column aliases to sort by
+   * @param {boolean} v - Verbose mode. Display column headers
+   */
+
+  const acceptedQuerystring = [
+    'format',
+    'local',
+    'master_timeout',
+    'h',
+    'help',
+    's',
+    'v',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    masterTimeout: 'master_timeout',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function catTemplates (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, name, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((name) != null) {
+      path = '/' + '_cat' + '/' + 'templates' + '/' + encodeURIComponent(name)
+    } else {
+      path = '/' + '_cat' + '/' + 'templates'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildCatTemplates

api/api/cat.thread_pool.js

@@ -0,0 +1,107 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildCatThreadPool (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [cat.thread_pool](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/cat-thread-pool.html) request
+   *
+   * @param {list} thread_pool_patterns - A comma-separated list of regular-expressions to filter the thread pools in the output
+   * @param {string} format - a short version of the Accept header, e.g. json, yaml
+   * @param {enum} size - The multiplier in which to display values
+   * @param {boolean} local - Return local information, do not retrieve the state from master node (default: false)
+   * @param {time} master_timeout - Explicit operation timeout for connection to master node
+   * @param {list} h - Comma-separated list of column names to display
+   * @param {boolean} help - Return help information
+   * @param {list} s - Comma-separated list of column names or column aliases to sort by
+   * @param {boolean} v - Verbose mode. Display column headers
+   */
+
+  const acceptedQuerystring = [
+    'format',
+    'size',
+    'local',
+    'master_timeout',
+    'h',
+    'help',
+    's',
+    'v',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    masterTimeout: 'master_timeout',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function catThreadPool (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, threadPoolPatterns, thread_pool_patterns, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((thread_pool_patterns || threadPoolPatterns) != null) {
+      path = '/' + '_cat' + '/' + 'thread_pool' + '/' + encodeURIComponent(thread_pool_patterns || threadPoolPatterns)
+    } else {
+      path = '/' + '_cat' + '/' + 'thread_pool'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildCatThreadPool

api/api/clear_scroll.js

@@ -0,0 +1,85 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildClearScroll (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [clear_scroll](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/search-request-scroll.html) request
+   *
+   * @param {list} scroll_id - A comma-separated list of scroll IDs to clear
+   * @param {object} body - A comma-separated list of scroll IDs to clear if none was specified via the scroll_id parameter
+   */
+
+  const acceptedQuerystring = [
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function clearScroll (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, scrollId, scroll_id, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'DELETE'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((scroll_id || scrollId) != null) {
+      path = '/' + '_search' + '/' + 'scroll' + '/' + encodeURIComponent(scroll_id || scrollId)
+    } else {
+      path = '/' + '_search' + '/' + 'scroll'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: body || '',
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildClearScroll

api/api/cluster.allocation_explain.js

@@ -0,0 +1,86 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildClusterAllocationExplain (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [cluster.allocation_explain](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/cluster-allocation-explain.html) request
+   *
+   * @param {boolean} include_yes_decisions - Return 'YES' decisions in explanation (default: false)
+   * @param {boolean} include_disk_info - Return information about disk usage and shard sizes (default: false)
+   * @param {object} body - The index, shard, and primary flag to explain. Empty means 'explain the first unassigned shard'
+   */
+
+  const acceptedQuerystring = [
+    'include_yes_decisions',
+    'include_disk_info',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    includeYesDecisions: 'include_yes_decisions',
+    includeDiskInfo: 'include_disk_info',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function clusterAllocationExplain (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = body == null ? 'GET' : 'POST'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + '_cluster' + '/' + 'allocation' + '/' + 'explain'
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: body || '',
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildClusterAllocationExplain

api/api/cluster.get_settings.js

@@ -0,0 +1,96 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildClusterGetSettings (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [cluster.get_settings](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/cluster-update-settings.html) request
+   *
+   * @param {boolean} flat_settings - Return settings in flat format (default: false)
+   * @param {time} master_timeout - Explicit operation timeout for connection to master node
+   * @param {time} timeout - Explicit operation timeout
+   * @param {boolean} include_defaults - Whether to return all default clusters setting.
+   */
+
+  const acceptedQuerystring = [
+    'flat_settings',
+    'master_timeout',
+    'timeout',
+    'include_defaults',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    flatSettings: 'flat_settings',
+    masterTimeout: 'master_timeout',
+    includeDefaults: 'include_defaults',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function clusterGetSettings (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + '_cluster' + '/' + 'settings'
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildClusterGetSettings

api/api/cluster.health.js

@@ -0,0 +1,114 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildClusterHealth (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [cluster.health](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/cluster-health.html) request
+   *
+   * @param {list} index - Limit the information returned to a specific index
+   * @param {enum} level - Specify the level of detail for returned information
+   * @param {boolean} local - Return local information, do not retrieve the state from master node (default: false)
+   * @param {time} master_timeout - Explicit operation timeout for connection to master node
+   * @param {time} timeout - Explicit operation timeout
+   * @param {string} wait_for_active_shards - Wait until the specified number of shards is active
+   * @param {string} wait_for_nodes - Wait until the specified number of nodes is available
+   * @param {enum} wait_for_events - Wait until all currently queued events with the given priority are processed
+   * @param {boolean} wait_for_no_relocating_shards - Whether to wait until there are no relocating shards in the cluster
+   * @param {enum} wait_for_status - Wait until cluster is in a specific state
+   */
+
+  const acceptedQuerystring = [
+    'level',
+    'local',
+    'master_timeout',
+    'timeout',
+    'wait_for_active_shards',
+    'wait_for_nodes',
+    'wait_for_events',
+    'wait_for_no_relocating_shards',
+    'wait_for_status',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    masterTimeout: 'master_timeout',
+    waitForActiveShards: 'wait_for_active_shards',
+    waitForNodes: 'wait_for_nodes',
+    waitForEvents: 'wait_for_events',
+    waitForNoRelocatingShards: 'wait_for_no_relocating_shards',
+    waitForStatus: 'wait_for_status',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function clusterHealth (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((index) != null) {
+      path = '/' + '_cluster' + '/' + 'health' + '/' + encodeURIComponent(index)
+    } else {
+      path = '/' + '_cluster' + '/' + 'health'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildClusterHealth

api/api/cluster.pending_tasks.js

@@ -0,0 +1,90 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildClusterPendingTasks (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [cluster.pending_tasks](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/cluster-pending.html) request
+   *
+   * @param {boolean} local - Return local information, do not retrieve the state from master node (default: false)
+   * @param {time} master_timeout - Specify timeout for connection to master
+   */
+
+  const acceptedQuerystring = [
+    'local',
+    'master_timeout',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    masterTimeout: 'master_timeout',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function clusterPendingTasks (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + '_cluster' + '/' + 'pending_tasks'
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildClusterPendingTasks

api/api/cluster.put_settings.js

@@ -0,0 +1,88 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildClusterPutSettings (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [cluster.put_settings](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/cluster-update-settings.html) request
+   *
+   * @param {boolean} flat_settings - Return settings in flat format (default: false)
+   * @param {time} master_timeout - Explicit operation timeout for connection to master node
+   * @param {time} timeout - Explicit operation timeout
+   * @param {object} body - The settings to be updated. Can be either `transient` or `persistent` (survives cluster restart).
+   */
+
+  const acceptedQuerystring = [
+    'flat_settings',
+    'master_timeout',
+    'timeout',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    flatSettings: 'flat_settings',
+    masterTimeout: 'master_timeout',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function clusterPutSettings (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'PUT'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + '_cluster' + '/' + 'settings'
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: body || '',
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildClusterPutSettings

api/api/cluster.remote_info.js

@@ -0,0 +1,85 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildClusterRemoteInfo (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [cluster.remote_info](http://www.elastic.co/guide/en/elasticsearch/reference/5.x/cluster-remote-info.html) request
+   *
+   */
+
+  const acceptedQuerystring = [
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function clusterRemoteInfo (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + '_remote' + '/' + 'info'
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildClusterRemoteInfo

api/api/cluster.reroute.js

@@ -0,0 +1,95 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildClusterReroute (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [cluster.reroute](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/cluster-reroute.html) request
+   *
+   * @param {boolean} dry_run - Simulate the operation only and return the resulting state
+   * @param {boolean} explain - Return an explanation of why the commands can or cannot be executed
+   * @param {boolean} retry_failed - Retries allocation of shards that are blocked due to too many subsequent allocation failures
+   * @param {list} metric - Limit the information returned to the specified metrics. Defaults to all but metadata
+   * @param {time} master_timeout - Explicit operation timeout for connection to master node
+   * @param {time} timeout - Explicit operation timeout
+   * @param {object} body - The definition of `commands` to perform (`move`, `cancel`, `allocate`)
+   */
+
+  const acceptedQuerystring = [
+    'dry_run',
+    'explain',
+    'retry_failed',
+    'metric',
+    'master_timeout',
+    'timeout',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    dryRun: 'dry_run',
+    retryFailed: 'retry_failed',
+    masterTimeout: 'master_timeout',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function clusterReroute (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'POST'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + '_cluster' + '/' + 'reroute'
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: body || '',
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildClusterReroute

api/api/cluster.state.js

@@ -0,0 +1,116 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildClusterState (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [cluster.state](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/cluster-state.html) request
+   *
+   * @param {list} index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
+   * @param {list} metric - Limit the information returned to the specified metrics
+   * @param {boolean} local - Return local information, do not retrieve the state from master node (default: false)
+   * @param {time} master_timeout - Specify timeout for connection to master
+   * @param {boolean} flat_settings - Return settings in flat format (default: false)
+   * @param {boolean} ignore_unavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
+   * @param {boolean} allow_no_indices - Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
+   * @param {enum} expand_wildcards - Whether to expand wildcard expression to concrete indices that are open, closed or both.
+   */
+
+  const acceptedQuerystring = [
+    'local',
+    'master_timeout',
+    'flat_settings',
+    'ignore_unavailable',
+    'allow_no_indices',
+    'expand_wildcards',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    masterTimeout: 'master_timeout',
+    flatSettings: 'flat_settings',
+    ignoreUnavailable: 'ignore_unavailable',
+    allowNoIndices: 'allow_no_indices',
+    expandWildcards: 'expand_wildcards',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function clusterState (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // check required url components
+    if (params['index'] != null && (params['metric'] == null)) {
+      const err = new ConfigurationError('Missing required parameter of the url: metric')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, metric, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((metric) != null && (index) != null) {
+      path = '/' + '_cluster' + '/' + 'state' + '/' + encodeURIComponent(metric) + '/' + encodeURIComponent(index)
+    } else if ((metric) != null) {
+      path = '/' + '_cluster' + '/' + 'state' + '/' + encodeURIComponent(metric)
+    } else {
+      path = '/' + '_cluster' + '/' + 'state'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildClusterState

api/api/cluster.stats.js

@@ -0,0 +1,95 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildClusterStats (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [cluster.stats](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/cluster-stats.html) request
+   *
+   * @param {list} node_id - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
+   * @param {boolean} flat_settings - Return settings in flat format (default: false)
+   * @param {time} timeout - Explicit operation timeout
+   */
+
+  const acceptedQuerystring = [
+    'flat_settings',
+    'timeout',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    flatSettings: 'flat_settings',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function clusterStats (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, nodeId, node_id, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((node_id || nodeId) != null) {
+      path = '/' + '_cluster' + '/' + 'stats' + '/' + 'nodes' + '/' + encodeURIComponent(node_id || nodeId)
+    } else {
+      path = '/' + '_cluster' + '/' + 'stats'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildClusterStats

api/api/count.js

@@ -0,0 +1,127 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildCount (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [count](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/search-count.html) request
+   *
+   * @param {list} index - A comma-separated list of indices to restrict the results
+   * @param {list} type - A comma-separated list of types to restrict the results
+   * @param {boolean} ignore_unavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
+   * @param {boolean} allow_no_indices - Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
+   * @param {enum} expand_wildcards - Whether to expand wildcard expression to concrete indices that are open, closed or both.
+   * @param {number} min_score - Include only documents with a specific `_score` value in the result
+   * @param {string} preference - Specify the node or shard the operation should be performed on (default: random)
+   * @param {list} routing - A comma-separated list of specific routing values
+   * @param {string} q - Query in the Lucene query string syntax
+   * @param {string} analyzer - The analyzer to use for the query string
+   * @param {boolean} analyze_wildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
+   * @param {enum} default_operator - The default operator for query string query (AND or OR)
+   * @param {string} df - The field to use as default where no field prefix is given in the query string
+   * @param {boolean} lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
+   * @param {number} terminate_after - The maximum count for each shard, upon reaching which the query execution will terminate early
+   * @param {object} body - A query to restrict the results specified with the Query DSL (optional)
+   */
+
+  const acceptedQuerystring = [
+    'ignore_unavailable',
+    'allow_no_indices',
+    'expand_wildcards',
+    'min_score',
+    'preference',
+    'routing',
+    'q',
+    'analyzer',
+    'analyze_wildcard',
+    'default_operator',
+    'df',
+    'lenient',
+    'terminate_after',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    ignoreUnavailable: 'ignore_unavailable',
+    allowNoIndices: 'allow_no_indices',
+    expandWildcards: 'expand_wildcards',
+    minScore: 'min_score',
+    analyzeWildcard: 'analyze_wildcard',
+    defaultOperator: 'default_operator',
+    terminateAfter: 'terminate_after',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function count (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required url components
+    if (params['type'] != null && (params['index'] == null)) {
+      const err = new ConfigurationError('Missing required parameter of the url: index')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, type, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = body == null ? 'GET' : 'POST'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((index) != null && (type) != null) {
+      path = '/' + encodeURIComponent(index) + '/' + encodeURIComponent(type) + '/' + '_count'
+    } else if ((index) != null) {
+      path = '/' + encodeURIComponent(index) + '/' + '_count'
+    } else {
+      path = '/' + '_count'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: body || '',
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildCount

api/api/count_percolate.js

@@ -0,0 +1,130 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildCountPercolate (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [count_percolate](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/search-percolate.html) request
+   *
+   * @param {string} index - The index of the document being count percolated.
+   * @param {string} type - The type of the document being count percolated.
+   * @param {string} id - Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.
+   * @param {list} routing - A comma-separated list of specific routing values
+   * @param {string} preference - Specify the node or shard the operation should be performed on (default: random)
+   * @param {boolean} ignore_unavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
+   * @param {boolean} allow_no_indices - Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
+   * @param {enum} expand_wildcards - Whether to expand wildcard expression to concrete indices that are open, closed or both.
+   * @param {string} percolate_index - The index to count percolate the document into. Defaults to index.
+   * @param {string} percolate_type - The type to count percolate document into. Defaults to type.
+   * @param {number} version - Explicit version number for concurrency control
+   * @param {enum} version_type - Specific version type
+   * @param {object} body - The count percolator request definition using the percolate DSL
+   */
+
+  const acceptedQuerystring = [
+    'routing',
+    'preference',
+    'ignore_unavailable',
+    'allow_no_indices',
+    'expand_wildcards',
+    'percolate_index',
+    'percolate_type',
+    'version',
+    'version_type',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    ignoreUnavailable: 'ignore_unavailable',
+    allowNoIndices: 'allow_no_indices',
+    expandWildcards: 'expand_wildcards',
+    percolateIndex: 'percolate_index',
+    percolateType: 'percolate_type',
+    versionType: 'version_type',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function countPercolate (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params['index'] == null) {
+      const err = new ConfigurationError('Missing required parameter: index')
+      return handleError(err, callback)
+    }
+    if (params['type'] == null) {
+      const err = new ConfigurationError('Missing required parameter: type')
+      return handleError(err, callback)
+    }
+
+    // check required url components
+    if (params['id'] != null && (params['type'] == null || params['index'] == null)) {
+      const err = new ConfigurationError('Missing required parameter of the url: type, index')
+      return handleError(err, callback)
+    } else if (params['type'] != null && (params['index'] == null)) {
+      const err = new ConfigurationError('Missing required parameter of the url: index')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, type, id, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = body == null ? 'GET' : 'POST'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((index) != null && (type) != null && (id) != null) {
+      path = '/' + encodeURIComponent(index) + '/' + encodeURIComponent(type) + '/' + encodeURIComponent(id) + '/' + '_percolate' + '/' + 'count'
+    } else {
+      path = '/' + encodeURIComponent(index) + '/' + encodeURIComponent(type) + '/' + '_percolate' + '/' + 'count'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: body || '',
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildCountPercolate

api/api/create.js

@@ -0,0 +1,123 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildCreate (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [create](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/docs-index_.html) request
+   *
+   * @param {string} id - Document ID
+   * @param {string} index - The name of the index
+   * @param {string} type - The type of the document
+   * @param {string} wait_for_active_shards - Sets the number of shard copies that must be active before proceeding with the index operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
+   * @param {string} parent - ID of the parent document
+   * @param {enum} refresh - If `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
+   * @param {string} routing - Specific routing value
+   * @param {time} timeout - Explicit operation timeout
+   * @param {time} timestamp - Explicit timestamp for the document
+   * @param {time} ttl - Expiration time for the document
+   * @param {number} version - Explicit version number for concurrency control
+   * @param {enum} version_type - Specific version type
+   * @param {string} pipeline - The pipeline id to preprocess incoming documents with
+   * @param {object} body - The document
+   */
+
+  const acceptedQuerystring = [
+    'wait_for_active_shards',
+    'parent',
+    'refresh',
+    'routing',
+    'timeout',
+    'timestamp',
+    'ttl',
+    'version',
+    'version_type',
+    'pipeline',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    waitForActiveShards: 'wait_for_active_shards',
+    versionType: 'version_type',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function create (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params['id'] == null) {
+      const err = new ConfigurationError('Missing required parameter: id')
+      return handleError(err, callback)
+    }
+    if (params['index'] == null) {
+      const err = new ConfigurationError('Missing required parameter: index')
+      return handleError(err, callback)
+    }
+    if (params['type'] == null) {
+      const err = new ConfigurationError('Missing required parameter: type')
+      return handleError(err, callback)
+    }
+    if (params['body'] == null) {
+      const err = new ConfigurationError('Missing required parameter: body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, id, index, type, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'PUT'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + encodeURIComponent(index) + '/' + encodeURIComponent(type) + '/' + encodeURIComponent(id) + '/' + '_create'
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: body || '',
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildCreate

api/api/delete.js

@@ -0,0 +1,125 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildDelete (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [delete](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/docs-delete.html) request
+   *
+   * @param {string} id - The document ID
+   * @param {string} index - The name of the index
+   * @param {string} type - The type of the document
+   * @param {string} wait_for_active_shards - Sets the number of shard copies that must be active before proceeding with the delete operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
+   * @param {string} parent - ID of parent document
+   * @param {enum} refresh - If `true` then refresh the effected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
+   * @param {string} routing - Specific routing value
+   * @param {time} timeout - Explicit operation timeout
+   * @param {number} version - Explicit version number for concurrency control
+   * @param {enum} version_type - Specific version type
+   */
+
+  const acceptedQuerystring = [
+    'wait_for_active_shards',
+    'parent',
+    'refresh',
+    'routing',
+    'timeout',
+    'version',
+    'version_type',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    waitForActiveShards: 'wait_for_active_shards',
+    versionType: 'version_type',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function _delete (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params['id'] == null) {
+      const err = new ConfigurationError('Missing required parameter: id')
+      return handleError(err, callback)
+    }
+    if (params['index'] == null) {
+      const err = new ConfigurationError('Missing required parameter: index')
+      return handleError(err, callback)
+    }
+    if (params['type'] == null) {
+      const err = new ConfigurationError('Missing required parameter: type')
+      return handleError(err, callback)
+    }
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // check required url components
+    if (params['id'] != null && (params['type'] == null || params['index'] == null)) {
+      const err = new ConfigurationError('Missing required parameter of the url: type, index')
+      return handleError(err, callback)
+    } else if (params['type'] != null && (params['index'] == null)) {
+      const err = new ConfigurationError('Missing required parameter of the url: index')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, id, index, type, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'DELETE'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + encodeURIComponent(index) + '/' + encodeURIComponent(type) + '/' + encodeURIComponent(id)
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: '',
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildDelete

api/api/delete_by_query.js

@@ -0,0 +1,181 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildDeleteByQuery (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [delete_by_query](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/docs-delete-by-query.html) request
+   *
+   * @param {list} index - A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices
+   * @param {list} type - A comma-separated list of document types to search; leave empty to perform the operation on all types
+   * @param {string} analyzer - The analyzer to use for the query string
+   * @param {boolean} analyze_wildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
+   * @param {enum} default_operator - The default operator for query string query (AND or OR)
+   * @param {string} df - The field to use as default where no field prefix is given in the query string
+   * @param {number} from - Starting offset (default: 0)
+   * @param {boolean} ignore_unavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
+   * @param {boolean} allow_no_indices - Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
+   * @param {enum} conflicts - What to do when the delete-by-query hits version conflicts?
+   * @param {enum} expand_wildcards - Whether to expand wildcard expression to concrete indices that are open, closed or both.
+   * @param {boolean} lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
+   * @param {string} preference - Specify the node or shard the operation should be performed on (default: random)
+   * @param {string} q - Query in the Lucene query string syntax
+   * @param {list} routing - A comma-separated list of specific routing values
+   * @param {time} scroll - Specify how long a consistent view of the index should be maintained for scrolled search
+   * @param {enum} search_type - Search operation type
+   * @param {time} search_timeout - Explicit timeout for each search request. Defaults to no timeout.
+   * @param {number} size - Number of hits to return (default: 10)
+   * @param {list} sort - A comma-separated list of <field>:<direction> pairs
+   * @param {list} _source - True or false to return the _source field or not, or a list of fields to return
+   * @param {list} _source_exclude - A list of fields to exclude from the returned _source field
+   * @param {list} _source_include - A list of fields to extract and return from the _source field
+   * @param {number} terminate_after - The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.
+   * @param {list} stats - Specific 'tag' of the request for logging and statistical purposes
+   * @param {boolean} version - Specify whether to return document version as part of a hit
+   * @param {boolean} request_cache - Specify if request cache should be used for this request or not, defaults to index level setting
+   * @param {boolean} refresh - Should the effected indexes be refreshed?
+   * @param {time} timeout - Time each individual bulk request should wait for shards that are unavailable.
+   * @param {string} wait_for_active_shards - Sets the number of shard copies that must be active before proceeding with the delete by query operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
+   * @param {number} scroll_size - Size on the scroll request powering the update_by_query
+   * @param {boolean} wait_for_completion - Should the request should block until the delete-by-query is complete.
+   * @param {number} requests_per_second - The throttle for this request in sub-requests per second. -1 means no throttle.
+   * @param {number} slices - The number of slices this task should be divided into. Defaults to 1 meaning the task isn't sliced into subtasks.
+   * @param {object} body - The search definition using the Query DSL
+   */
+
+  const acceptedQuerystring = [
+    'analyzer',
+    'analyze_wildcard',
+    'default_operator',
+    'df',
+    'from',
+    'ignore_unavailable',
+    'allow_no_indices',
+    'conflicts',
+    'expand_wildcards',
+    'lenient',
+    'preference',
+    'q',
+    'routing',
+    'scroll',
+    'search_type',
+    'search_timeout',
+    'size',
+    'sort',
+    '_source',
+    '_source_exclude',
+    '_source_include',
+    'terminate_after',
+    'stats',
+    'version',
+    'request_cache',
+    'refresh',
+    'timeout',
+    'wait_for_active_shards',
+    'scroll_size',
+    'wait_for_completion',
+    'requests_per_second',
+    'slices',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    analyzeWildcard: 'analyze_wildcard',
+    defaultOperator: 'default_operator',
+    ignoreUnavailable: 'ignore_unavailable',
+    allowNoIndices: 'allow_no_indices',
+    expandWildcards: 'expand_wildcards',
+    searchType: 'search_type',
+    searchTimeout: 'search_timeout',
+    _sourceExclude: '_source_exclude',
+    _sourceInclude: '_source_include',
+    terminateAfter: 'terminate_after',
+    requestCache: 'request_cache',
+    waitForActiveShards: 'wait_for_active_shards',
+    scrollSize: 'scroll_size',
+    waitForCompletion: 'wait_for_completion',
+    requestsPerSecond: 'requests_per_second',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function deleteByQuery (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params['index'] == null) {
+      const err = new ConfigurationError('Missing required parameter: index')
+      return handleError(err, callback)
+    }
+    if (params['body'] == null) {
+      const err = new ConfigurationError('Missing required parameter: body')
+      return handleError(err, callback)
+    }
+
+    // check required url components
+    if (params['type'] != null && (params['index'] == null)) {
+      const err = new ConfigurationError('Missing required parameter of the url: index')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, type, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'POST'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((index) != null && (type) != null) {
+      path = '/' + encodeURIComponent(index) + '/' + encodeURIComponent(type) + '/' + '_delete_by_query'
+    } else {
+      path = '/' + encodeURIComponent(index) + '/' + '_delete_by_query'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: body || '',
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildDeleteByQuery

api/api/delete_script.js

@@ -0,0 +1,110 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildDeleteScript (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [delete_script](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/modules-scripting.html) request
+   *
+   * @param {string} id - Script ID
+   * @param {string} lang - Script language
+   * @param {time} timeout - Explicit operation timeout
+   * @param {time} master_timeout - Specify timeout for connection to master
+   */
+
+  const acceptedQuerystring = [
+    'timeout',
+    'master_timeout',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    masterTimeout: 'master_timeout',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function deleteScript (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params['id'] == null) {
+      const err = new ConfigurationError('Missing required parameter: id')
+      return handleError(err, callback)
+    }
+    if (params['lang'] == null) {
+      const err = new ConfigurationError('Missing required parameter: lang')
+      return handleError(err, callback)
+    }
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // check required url components
+    if (params['id'] != null && (params['lang'] == null)) {
+      const err = new ConfigurationError('Missing required parameter of the url: lang')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, id, lang, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'DELETE'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((lang) != null && (id) != null) {
+      path = '/' + '_scripts' + '/' + encodeURIComponent(lang) + '/' + encodeURIComponent(id)
+    } else {
+      path = '/' + '_scripts' + '/' + encodeURIComponent(lang)
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: '',
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildDeleteScript

api/api/delete_template.js

@@ -0,0 +1,90 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildDeleteTemplate (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [delete_template](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/search-template.html) request
+   *
+   * @param {string} id - Template ID
+   */
+
+  const acceptedQuerystring = [
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function deleteTemplate (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params['id'] == null) {
+      const err = new ConfigurationError('Missing required parameter: id')
+      return handleError(err, callback)
+    }
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, id, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'DELETE'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + '_search' + '/' + 'template' + '/' + encodeURIComponent(id)
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: '',
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildDeleteTemplate

api/api/exists.js

@@ -0,0 +1,126 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildExists (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [exists](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/docs-get.html) request
+   *
+   * @param {string} id - The document ID
+   * @param {string} index - The name of the index
+   * @param {string} type - The type of the document (use `_all` to fetch the first document matching the ID across all types)
+   * @param {list} stored_fields - A comma-separated list of stored fields to return in the response
+   * @param {string} parent - The ID of the parent document
+   * @param {string} preference - Specify the node or shard the operation should be performed on (default: random)
+   * @param {boolean} realtime - Specify whether to perform the operation in realtime or search mode
+   * @param {boolean} refresh - Refresh the shard containing the document before performing the operation
+   * @param {string} routing - Specific routing value
+   * @param {list} _source - True or false to return the _source field or not, or a list of fields to return
+   * @param {list} _source_exclude - A list of fields to exclude from the returned _source field
+   * @param {list} _source_include - A list of fields to extract and return from the _source field
+   * @param {number} version - Explicit version number for concurrency control
+   * @param {enum} version_type - Specific version type
+   */
+
+  const acceptedQuerystring = [
+    'stored_fields',
+    'parent',
+    'preference',
+    'realtime',
+    'refresh',
+    'routing',
+    '_source',
+    '_source_exclude',
+    '_source_include',
+    'version',
+    'version_type',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    storedFields: 'stored_fields',
+    _sourceExclude: '_source_exclude',
+    _sourceInclude: '_source_include',
+    versionType: 'version_type',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function exists (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params['id'] == null) {
+      const err = new ConfigurationError('Missing required parameter: id')
+      return handleError(err, callback)
+    }
+    if (params['index'] == null) {
+      const err = new ConfigurationError('Missing required parameter: index')
+      return handleError(err, callback)
+    }
+    if (params['type'] == null) {
+      const err = new ConfigurationError('Missing required parameter: type')
+      return handleError(err, callback)
+    }
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, id, index, type, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'HEAD'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + encodeURIComponent(index) + '/' + encodeURIComponent(type) + '/' + encodeURIComponent(id)
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildExists

api/api/exists_source.js

@@ -0,0 +1,132 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildExistsSource (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [exists_source](http://www.elastic.co/guide/en/elasticsearch/reference/master/docs-get.html) request
+   *
+   * @param {string} id - The document ID
+   * @param {string} index - The name of the index
+   * @param {string} type - The type of the document; use `_all` to fetch the first document matching the ID across all types
+   * @param {string} parent - The ID of the parent document
+   * @param {string} preference - Specify the node or shard the operation should be performed on (default: random)
+   * @param {boolean} realtime - Specify whether to perform the operation in realtime or search mode
+   * @param {boolean} refresh - Refresh the shard containing the document before performing the operation
+   * @param {string} routing - Specific routing value
+   * @param {list} _source - True or false to return the _source field or not, or a list of fields to return
+   * @param {list} _source_exclude - A list of fields to exclude from the returned _source field
+   * @param {list} _source_include - A list of fields to extract and return from the _source field
+   * @param {number} version - Explicit version number for concurrency control
+   * @param {enum} version_type - Specific version type
+   */
+
+  const acceptedQuerystring = [
+    'parent',
+    'preference',
+    'realtime',
+    'refresh',
+    'routing',
+    '_source',
+    '_source_exclude',
+    '_source_include',
+    'version',
+    'version_type',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    _sourceExclude: '_source_exclude',
+    _sourceInclude: '_source_include',
+    versionType: 'version_type',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function existsSource (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params['id'] == null) {
+      const err = new ConfigurationError('Missing required parameter: id')
+      return handleError(err, callback)
+    }
+    if (params['index'] == null) {
+      const err = new ConfigurationError('Missing required parameter: index')
+      return handleError(err, callback)
+    }
+    if (params['type'] == null) {
+      const err = new ConfigurationError('Missing required parameter: type')
+      return handleError(err, callback)
+    }
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // check required url components
+    if (params['id'] != null && (params['type'] == null || params['index'] == null)) {
+      const err = new ConfigurationError('Missing required parameter of the url: type, index')
+      return handleError(err, callback)
+    } else if (params['type'] != null && (params['index'] == null)) {
+      const err = new ConfigurationError('Missing required parameter of the url: index')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, id, index, type, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'HEAD'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + encodeURIComponent(index) + '/' + encodeURIComponent(type) + '/' + encodeURIComponent(id) + '/' + '_source'
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildExistsSource

api/api/explain.js

@@ -0,0 +1,128 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildExplain (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [explain](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/search-explain.html) request
+   *
+   * @param {string} id - The document ID
+   * @param {string} index - The name of the index
+   * @param {string} type - The type of the document
+   * @param {boolean} analyze_wildcard - Specify whether wildcards and prefix queries in the query string query should be analyzed (default: false)
+   * @param {string} analyzer - The analyzer for the query string query
+   * @param {enum} default_operator - The default operator for query string query (AND or OR)
+   * @param {string} df - The default field for query string query (default: _all)
+   * @param {list} stored_fields - A comma-separated list of stored fields to return in the response
+   * @param {boolean} lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
+   * @param {string} parent - The ID of the parent document
+   * @param {string} preference - Specify the node or shard the operation should be performed on (default: random)
+   * @param {string} q - Query in the Lucene query string syntax
+   * @param {string} routing - Specific routing value
+   * @param {list} _source - True or false to return the _source field or not, or a list of fields to return
+   * @param {list} _source_exclude - A list of fields to exclude from the returned _source field
+   * @param {list} _source_include - A list of fields to extract and return from the _source field
+   * @param {object} body - The query definition using the Query DSL
+   */
+
+  const acceptedQuerystring = [
+    'analyze_wildcard',
+    'analyzer',
+    'default_operator',
+    'df',
+    'stored_fields',
+    'lenient',
+    'parent',
+    'preference',
+    'q',
+    'routing',
+    '_source',
+    '_source_exclude',
+    '_source_include',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    analyzeWildcard: 'analyze_wildcard',
+    defaultOperator: 'default_operator',
+    storedFields: 'stored_fields',
+    _sourceExclude: '_source_exclude',
+    _sourceInclude: '_source_include',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function explain (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params['id'] == null) {
+      const err = new ConfigurationError('Missing required parameter: id')
+      return handleError(err, callback)
+    }
+    if (params['index'] == null) {
+      const err = new ConfigurationError('Missing required parameter: index')
+      return handleError(err, callback)
+    }
+    if (params['type'] == null) {
+      const err = new ConfigurationError('Missing required parameter: type')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, id, index, type, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = body == null ? 'GET' : 'POST'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + encodeURIComponent(index) + '/' + encodeURIComponent(type) + '/' + encodeURIComponent(id) + '/' + '_explain'
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: body || '',
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildExplain

api/api/field_caps.js

@@ -0,0 +1,96 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildFieldCaps (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [field_caps](http://www.elastic.co/guide/en/elasticsearch/reference/5.x/search-field-caps.html) request
+   *
+   * @param {list} index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
+   * @param {list} fields - A comma-separated list of field names
+   * @param {boolean} ignore_unavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
+   * @param {boolean} allow_no_indices - Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
+   * @param {enum} expand_wildcards - Whether to expand wildcard expression to concrete indices that are open, closed or both.
+   * @param {object} body - Field json objects containing an array of field names
+   */
+
+  const acceptedQuerystring = [
+    'fields',
+    'ignore_unavailable',
+    'allow_no_indices',
+    'expand_wildcards',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    ignoreUnavailable: 'ignore_unavailable',
+    allowNoIndices: 'allow_no_indices',
+    expandWildcards: 'expand_wildcards',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function fieldCaps (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = body == null ? 'GET' : 'POST'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((index) != null) {
+      path = '/' + encodeURIComponent(index) + '/' + '_field_caps'
+    } else {
+      path = '/' + '_field_caps'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: body || '',
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildFieldCaps

api/api/field_stats.js

@@ -0,0 +1,98 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildFieldStats (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [field_stats](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/search-field-stats.html) request
+   *
+   * @param {list} index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
+   * @param {list} fields - A comma-separated list of fields for to get field statistics for (min value, max value, and more)
+   * @param {enum} level - Defines if field stats should be returned on a per index level or on a cluster wide level
+   * @param {boolean} ignore_unavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
+   * @param {boolean} allow_no_indices - Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
+   * @param {enum} expand_wildcards - Whether to expand wildcard expression to concrete indices that are open, closed or both.
+   * @param {object} body - Field json objects containing the name and optionally a range to filter out indices result, that have results outside the defined bounds
+   */
+
+  const acceptedQuerystring = [
+    'fields',
+    'level',
+    'ignore_unavailable',
+    'allow_no_indices',
+    'expand_wildcards',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    ignoreUnavailable: 'ignore_unavailable',
+    allowNoIndices: 'allow_no_indices',
+    expandWildcards: 'expand_wildcards',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function fieldStats (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = body == null ? 'GET' : 'POST'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((index) != null) {
+      path = '/' + encodeURIComponent(index) + '/' + '_field_stats'
+    } else {
+      path = '/' + '_field_stats'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: body || '',
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildFieldStats

api/api/get.js

@@ -0,0 +1,126 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildGet (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [get](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/docs-get.html) request
+   *
+   * @param {string} id - The document ID
+   * @param {string} index - The name of the index
+   * @param {string} type - The type of the document (use `_all` to fetch the first document matching the ID across all types)
+   * @param {list} stored_fields - A comma-separated list of stored fields to return in the response
+   * @param {string} parent - The ID of the parent document
+   * @param {string} preference - Specify the node or shard the operation should be performed on (default: random)
+   * @param {boolean} realtime - Specify whether to perform the operation in realtime or search mode
+   * @param {boolean} refresh - Refresh the shard containing the document before performing the operation
+   * @param {string} routing - Specific routing value
+   * @param {list} _source - True or false to return the _source field or not, or a list of fields to return
+   * @param {list} _source_exclude - A list of fields to exclude from the returned _source field
+   * @param {list} _source_include - A list of fields to extract and return from the _source field
+   * @param {number} version - Explicit version number for concurrency control
+   * @param {enum} version_type - Specific version type
+   */
+
+  const acceptedQuerystring = [
+    'stored_fields',
+    'parent',
+    'preference',
+    'realtime',
+    'refresh',
+    'routing',
+    '_source',
+    '_source_exclude',
+    '_source_include',
+    'version',
+    'version_type',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    storedFields: 'stored_fields',
+    _sourceExclude: '_source_exclude',
+    _sourceInclude: '_source_include',
+    versionType: 'version_type',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function get (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params['id'] == null) {
+      const err = new ConfigurationError('Missing required parameter: id')
+      return handleError(err, callback)
+    }
+    if (params['index'] == null) {
+      const err = new ConfigurationError('Missing required parameter: index')
+      return handleError(err, callback)
+    }
+    if (params['type'] == null) {
+      const err = new ConfigurationError('Missing required parameter: type')
+      return handleError(err, callback)
+    }
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, id, index, type, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + encodeURIComponent(index) + '/' + encodeURIComponent(type) + '/' + encodeURIComponent(id)
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildGet

api/api/get_script.js

@@ -0,0 +1,105 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildGetScript (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [get_script](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/modules-scripting.html) request
+   *
+   * @param {string} id - Script ID
+   * @param {string} lang - Script language
+   */
+
+  const acceptedQuerystring = [
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function getScript (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params['id'] == null) {
+      const err = new ConfigurationError('Missing required parameter: id')
+      return handleError(err, callback)
+    }
+    if (params['lang'] == null) {
+      const err = new ConfigurationError('Missing required parameter: lang')
+      return handleError(err, callback)
+    }
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // check required url components
+    if (params['id'] != null && (params['lang'] == null)) {
+      const err = new ConfigurationError('Missing required parameter of the url: lang')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, id, lang, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((lang) != null && (id) != null) {
+      path = '/' + '_scripts' + '/' + encodeURIComponent(lang) + '/' + encodeURIComponent(id)
+    } else {
+      path = '/' + '_scripts' + '/' + encodeURIComponent(lang)
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildGetScript

api/api/get_source.js

@@ -0,0 +1,123 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildGetSource (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [get_source](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/docs-get.html) request
+   *
+   * @param {string} id - The document ID
+   * @param {string} index - The name of the index
+   * @param {string} type - The type of the document; use `_all` to fetch the first document matching the ID across all types
+   * @param {string} parent - The ID of the parent document
+   * @param {string} preference - Specify the node or shard the operation should be performed on (default: random)
+   * @param {boolean} realtime - Specify whether to perform the operation in realtime or search mode
+   * @param {boolean} refresh - Refresh the shard containing the document before performing the operation
+   * @param {string} routing - Specific routing value
+   * @param {list} _source - True or false to return the _source field or not, or a list of fields to return
+   * @param {list} _source_exclude - A list of fields to exclude from the returned _source field
+   * @param {list} _source_include - A list of fields to extract and return from the _source field
+   * @param {number} version - Explicit version number for concurrency control
+   * @param {enum} version_type - Specific version type
+   */
+
+  const acceptedQuerystring = [
+    'parent',
+    'preference',
+    'realtime',
+    'refresh',
+    'routing',
+    '_source',
+    '_source_exclude',
+    '_source_include',
+    'version',
+    'version_type',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    _sourceExclude: '_source_exclude',
+    _sourceInclude: '_source_include',
+    versionType: 'version_type',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function getSource (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params['id'] == null) {
+      const err = new ConfigurationError('Missing required parameter: id')
+      return handleError(err, callback)
+    }
+    if (params['index'] == null) {
+      const err = new ConfigurationError('Missing required parameter: index')
+      return handleError(err, callback)
+    }
+    if (params['type'] == null) {
+      const err = new ConfigurationError('Missing required parameter: type')
+      return handleError(err, callback)
+    }
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, id, index, type, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + encodeURIComponent(index) + '/' + encodeURIComponent(type) + '/' + encodeURIComponent(id) + '/' + '_source'
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildGetSource

api/api/get_template.js

@@ -0,0 +1,90 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildGetTemplate (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [get_template](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/search-template.html) request
+   *
+   * @param {string} id - Template ID
+   */
+
+  const acceptedQuerystring = [
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function getTemplate (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params['id'] == null) {
+      const err = new ConfigurationError('Missing required parameter: id')
+      return handleError(err, callback)
+    }
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, id, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + '_search' + '/' + 'template' + '/' + encodeURIComponent(id)
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildGetTemplate

api/api/index.js

@@ -0,0 +1,135 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildIndex (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [index](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/docs-index_.html) request
+   *
+   * @param {string} id - Document ID
+   * @param {string} index - The name of the index
+   * @param {string} type - The type of the document
+   * @param {string} wait_for_active_shards - Sets the number of shard copies that must be active before proceeding with the index operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
+   * @param {enum} op_type - Explicit operation type
+   * @param {string} parent - ID of the parent document
+   * @param {enum} refresh - If `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
+   * @param {string} routing - Specific routing value
+   * @param {time} timeout - Explicit operation timeout
+   * @param {time} timestamp - Explicit timestamp for the document
+   * @param {time} ttl - Expiration time for the document
+   * @param {number} version - Explicit version number for concurrency control
+   * @param {enum} version_type - Specific version type
+   * @param {string} pipeline - The pipeline id to preprocess incoming documents with
+   * @param {object} body - The document
+   */
+
+  const acceptedQuerystring = [
+    'wait_for_active_shards',
+    'op_type',
+    'parent',
+    'refresh',
+    'routing',
+    'timeout',
+    'timestamp',
+    'ttl',
+    'version',
+    'version_type',
+    'pipeline',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    waitForActiveShards: 'wait_for_active_shards',
+    opType: 'op_type',
+    versionType: 'version_type',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function _index (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params['index'] == null) {
+      const err = new ConfigurationError('Missing required parameter: index')
+      return handleError(err, callback)
+    }
+    if (params['type'] == null) {
+      const err = new ConfigurationError('Missing required parameter: type')
+      return handleError(err, callback)
+    }
+    if (params['body'] == null) {
+      const err = new ConfigurationError('Missing required parameter: body')
+      return handleError(err, callback)
+    }
+
+    // check required url components
+    if (params['id'] != null && (params['type'] == null || params['index'] == null)) {
+      const err = new ConfigurationError('Missing required parameter of the url: type, index')
+      return handleError(err, callback)
+    } else if (params['type'] != null && (params['index'] == null)) {
+      const err = new ConfigurationError('Missing required parameter of the url: index')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, id, index, type, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'POST'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((index) != null && (type) != null && (id) != null) {
+      path = '/' + encodeURIComponent(index) + '/' + encodeURIComponent(type) + '/' + encodeURIComponent(id)
+    } else {
+      path = '/' + encodeURIComponent(index) + '/' + encodeURIComponent(type)
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: body || '',
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildIndex

api/api/indices.analyze.js

@@ -0,0 +1,109 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildIndicesAnalyze (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [indices.analyze](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/indices-analyze.html) request
+   *
+   * @param {string} index - The name of the index to scope the operation
+   * @param {string} analyzer - The name of the analyzer to use
+   * @param {list} char_filter - A comma-separated list of character filters to use for the analysis
+   * @param {string} field - Use the analyzer configured for this field (instead of passing the analyzer name)
+   * @param {list} filter - A comma-separated list of filters to use for the analysis
+   * @param {string} index - The name of the index to scope the operation
+   * @param {boolean} prefer_local - With `true`, specify that a local shard should be used if available, with `false`, use a random shard (default: true)
+   * @param {list} text - The text on which the analysis should be performed (when request body is not used)
+   * @param {string} tokenizer - The name of the tokenizer to use for the analysis
+   * @param {boolean} explain - With `true`, outputs more advanced details. (default: false)
+   * @param {list} attributes - A comma-separated list of token attributes to output, this parameter works only with `explain=true`
+   * @param {enum} format - Format of the output
+   * @param {object} body - The text on which the analysis should be performed
+   */
+
+  const acceptedQuerystring = [
+    'analyzer',
+    'char_filter',
+    'field',
+    'filter',
+    'index',
+    'prefer_local',
+    'text',
+    'tokenizer',
+    'explain',
+    'attributes',
+    'format',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    charFilter: 'char_filter',
+    preferLocal: 'prefer_local',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function indicesAnalyze (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = body == null ? 'GET' : 'POST'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((index) != null) {
+      path = '/' + encodeURIComponent(index) + '/' + '_analyze'
+    } else {
+      path = '/' + '_analyze'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: body || '',
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildIndicesAnalyze

api/api/indices.clear_cache.js

@@ -0,0 +1,117 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildIndicesClearCache (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [indices.clear_cache](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/indices-clearcache.html) request
+   *
+   * @param {list} index - A comma-separated list of index name to limit the operation
+   * @param {boolean} field_data - Clear field data
+   * @param {boolean} fielddata - Clear field data
+   * @param {list} fields - A comma-separated list of fields to clear when using the `field_data` parameter (default: all)
+   * @param {boolean} query - Clear query caches
+   * @param {boolean} ignore_unavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
+   * @param {boolean} allow_no_indices - Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
+   * @param {enum} expand_wildcards - Whether to expand wildcard expression to concrete indices that are open, closed or both.
+   * @param {list} index - A comma-separated list of index name to limit the operation
+   * @param {boolean} recycler - Clear the recycler cache
+   * @param {boolean} request_cache - Clear request cache
+   * @param {boolean} request - Clear request cache
+   */
+
+  const acceptedQuerystring = [
+    'field_data',
+    'fielddata',
+    'fields',
+    'query',
+    'ignore_unavailable',
+    'allow_no_indices',
+    'expand_wildcards',
+    'index',
+    'recycler',
+    'request_cache',
+    'request',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    fieldData: 'field_data',
+    ignoreUnavailable: 'ignore_unavailable',
+    allowNoIndices: 'allow_no_indices',
+    expandWildcards: 'expand_wildcards',
+    requestCache: 'request_cache',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function indicesClearCache (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = body == null ? 'GET' : 'POST'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((index) != null) {
+      path = '/' + encodeURIComponent(index) + '/' + '_cache' + '/' + 'clear'
+    } else {
+      path = '/' + '_cache' + '/' + 'clear'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: '',
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildIndicesClearCache

api/api/indices.close.js

@@ -0,0 +1,104 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildIndicesClose (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [indices.close](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/indices-open-close.html) request
+   *
+   * @param {list} index - A comma separated list of indices to close
+   * @param {time} timeout - Explicit operation timeout
+   * @param {time} master_timeout - Specify timeout for connection to master
+   * @param {boolean} ignore_unavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
+   * @param {boolean} allow_no_indices - Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
+   * @param {enum} expand_wildcards - Whether to expand wildcard expression to concrete indices that are open, closed or both.
+   */
+
+  const acceptedQuerystring = [
+    'timeout',
+    'master_timeout',
+    'ignore_unavailable',
+    'allow_no_indices',
+    'expand_wildcards',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    masterTimeout: 'master_timeout',
+    ignoreUnavailable: 'ignore_unavailable',
+    allowNoIndices: 'allow_no_indices',
+    expandWildcards: 'expand_wildcards',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function indicesClose (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params['index'] == null) {
+      const err = new ConfigurationError('Missing required parameter: index')
+      return handleError(err, callback)
+    }
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'POST'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + encodeURIComponent(index) + '/' + '_close'
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: '',
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildIndicesClose

api/api/indices.create.js

@@ -0,0 +1,98 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildIndicesCreate (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [indices.create](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/indices-create-index.html) request
+   *
+   * @param {string} index - The name of the index
+   * @param {string} wait_for_active_shards - Set the number of active shards to wait for before the operation returns.
+   * @param {time} timeout - Explicit operation timeout
+   * @param {time} master_timeout - Specify timeout for connection to master
+   * @param {boolean} update_all_types - Whether to update the mapping for all fields with the same name across all types or not
+   * @param {object} body - The configuration for the index (`settings` and `mappings`)
+   */
+
+  const acceptedQuerystring = [
+    'wait_for_active_shards',
+    'timeout',
+    'master_timeout',
+    'update_all_types',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    waitForActiveShards: 'wait_for_active_shards',
+    masterTimeout: 'master_timeout',
+    updateAllTypes: 'update_all_types',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function indicesCreate (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params['index'] == null) {
+      const err = new ConfigurationError('Missing required parameter: index')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'PUT'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + encodeURIComponent(index)
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: body || '',
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildIndicesCreate

api/api/indices.delete.js

@@ -0,0 +1,95 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildIndicesDelete (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [indices.delete](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/indices-delete-index.html) request
+   *
+   * @param {list} index - A comma-separated list of indices to delete; use `_all` or `*` string to delete all indices
+   * @param {time} timeout - Explicit operation timeout
+   * @param {time} master_timeout - Specify timeout for connection to master
+   */
+
+  const acceptedQuerystring = [
+    'timeout',
+    'master_timeout',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    masterTimeout: 'master_timeout',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function indicesDelete (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params['index'] == null) {
+      const err = new ConfigurationError('Missing required parameter: index')
+      return handleError(err, callback)
+    }
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'DELETE'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + encodeURIComponent(index)
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: '',
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildIndicesDelete

api/api/indices.delete_alias.js

@@ -0,0 +1,110 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildIndicesDeleteAlias (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [indices.delete_alias](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/indices-aliases.html) request
+   *
+   * @param {list} index - A comma-separated list of index names (supports wildcards); use `_all` for all indices
+   * @param {list} name - A comma-separated list of aliases to delete (supports wildcards); use `_all` to delete all aliases for the specified indices.
+   * @param {time} timeout - Explicit timestamp for the document
+   * @param {time} master_timeout - Specify timeout for connection to master
+   */
+
+  const acceptedQuerystring = [
+    'timeout',
+    'master_timeout',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    masterTimeout: 'master_timeout',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function indicesDeleteAlias (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params['index'] == null) {
+      const err = new ConfigurationError('Missing required parameter: index')
+      return handleError(err, callback)
+    }
+    if (params['name'] == null) {
+      const err = new ConfigurationError('Missing required parameter: name')
+      return handleError(err, callback)
+    }
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // check required url components
+    if (params['name'] != null && (params['index'] == null)) {
+      const err = new ConfigurationError('Missing required parameter of the url: index')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, name, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'DELETE'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((index) != null && (name) != null) {
+      path = '/' + encodeURIComponent(index) + '/' + '_alias' + '/' + encodeURIComponent(name)
+    } else {
+      path = '/' + encodeURIComponent(index) + '/' + '_aliases' + '/' + encodeURIComponent(name)
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: '',
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildIndicesDeleteAlias

api/api/indices.delete_template.js

@@ -0,0 +1,95 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildIndicesDeleteTemplate (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [indices.delete_template](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/indices-templates.html) request
+   *
+   * @param {string} name - The name of the template
+   * @param {time} timeout - Explicit operation timeout
+   * @param {time} master_timeout - Specify timeout for connection to master
+   */
+
+  const acceptedQuerystring = [
+    'timeout',
+    'master_timeout',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    masterTimeout: 'master_timeout',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function indicesDeleteTemplate (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params['name'] == null) {
+      const err = new ConfigurationError('Missing required parameter: name')
+      return handleError(err, callback)
+    }
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, name, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'DELETE'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + '_template' + '/' + encodeURIComponent(name)
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: '',
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildIndicesDeleteTemplate

api/api/indices.exists.js

@@ -0,0 +1,107 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildIndicesExists (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [indices.exists](http://www.elastic.co/guide/en/elasticsearch/reference/5.x/indices-exists.html) request
+   *
+   * @param {list} index - A comma-separated list of index names
+   * @param {boolean} local - Return local information, do not retrieve the state from master node (default: false)
+   * @param {boolean} ignore_unavailable - Ignore unavailable indexes (default: false)
+   * @param {boolean} allow_no_indices - Ignore if a wildcard expression resolves to no concrete indices (default: false)
+   * @param {enum} expand_wildcards - Whether wildcard expressions should get expanded to open or closed indices (default: open)
+   * @param {boolean} flat_settings - Return settings in flat format (default: false)
+   * @param {boolean} include_defaults - Whether to return all default setting for each of the indices.
+   */
+
+  const acceptedQuerystring = [
+    'local',
+    'ignore_unavailable',
+    'allow_no_indices',
+    'expand_wildcards',
+    'flat_settings',
+    'include_defaults',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    ignoreUnavailable: 'ignore_unavailable',
+    allowNoIndices: 'allow_no_indices',
+    expandWildcards: 'expand_wildcards',
+    flatSettings: 'flat_settings',
+    includeDefaults: 'include_defaults',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function indicesExists (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params['index'] == null) {
+      const err = new ConfigurationError('Missing required parameter: index')
+      return handleError(err, callback)
+    }
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'HEAD'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + encodeURIComponent(index)
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildIndicesExists

api/api/indices.exists_alias.js

@@ -0,0 +1,102 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildIndicesExistsAlias (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [indices.exists_alias](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/indices-aliases.html) request
+   *
+   * @param {list} index - A comma-separated list of index names to filter aliases
+   * @param {list} name - A comma-separated list of alias names to return
+   * @param {boolean} ignore_unavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
+   * @param {boolean} allow_no_indices - Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
+   * @param {enum} expand_wildcards - Whether to expand wildcard expression to concrete indices that are open, closed or both.
+   * @param {boolean} local - Return local information, do not retrieve the state from master node (default: false)
+   */
+
+  const acceptedQuerystring = [
+    'ignore_unavailable',
+    'allow_no_indices',
+    'expand_wildcards',
+    'local',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    ignoreUnavailable: 'ignore_unavailable',
+    allowNoIndices: 'allow_no_indices',
+    expandWildcards: 'expand_wildcards',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function indicesExistsAlias (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, name, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'HEAD'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((index) != null && (name) != null) {
+      path = '/' + encodeURIComponent(index) + '/' + '_alias' + '/' + encodeURIComponent(name)
+    } else {
+      path = '/' + '_alias' + '/' + encodeURIComponent(name)
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildIndicesExistsAlias

api/api/indices.exists_template.js

@@ -0,0 +1,98 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildIndicesExistsTemplate (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [indices.exists_template](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/indices-templates.html) request
+   *
+   * @param {list} name - The comma separated names of the index templates
+   * @param {boolean} flat_settings - Return settings in flat format (default: false)
+   * @param {time} master_timeout - Explicit operation timeout for connection to master node
+   * @param {boolean} local - Return local information, do not retrieve the state from master node (default: false)
+   */
+
+  const acceptedQuerystring = [
+    'flat_settings',
+    'master_timeout',
+    'local',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    flatSettings: 'flat_settings',
+    masterTimeout: 'master_timeout',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function indicesExistsTemplate (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params['name'] == null) {
+      const err = new ConfigurationError('Missing required parameter: name')
+      return handleError(err, callback)
+    }
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, name, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'HEAD'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + '_template' + '/' + encodeURIComponent(name)
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildIndicesExistsTemplate

api/api/indices.exists_type.js

@@ -0,0 +1,112 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildIndicesExistsType (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [indices.exists_type](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/indices-types-exists.html) request
+   *
+   * @param {list} index - A comma-separated list of index names; use `_all` to check the types across all indices
+   * @param {list} type - A comma-separated list of document types to check
+   * @param {boolean} ignore_unavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
+   * @param {boolean} allow_no_indices - Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
+   * @param {enum} expand_wildcards - Whether to expand wildcard expression to concrete indices that are open, closed or both.
+   * @param {boolean} local - Return local information, do not retrieve the state from master node (default: false)
+   */
+
+  const acceptedQuerystring = [
+    'ignore_unavailable',
+    'allow_no_indices',
+    'expand_wildcards',
+    'local',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    ignoreUnavailable: 'ignore_unavailable',
+    allowNoIndices: 'allow_no_indices',
+    expandWildcards: 'expand_wildcards',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function indicesExistsType (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params['index'] == null) {
+      const err = new ConfigurationError('Missing required parameter: index')
+      return handleError(err, callback)
+    }
+    if (params['type'] == null) {
+      const err = new ConfigurationError('Missing required parameter: type')
+      return handleError(err, callback)
+    }
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // check required url components
+    if (params['type'] != null && (params['index'] == null)) {
+      const err = new ConfigurationError('Missing required parameter of the url: index')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, type, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'HEAD'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    path = '/' + encodeURIComponent(index) + '/' + '_mapping' + '/' + encodeURIComponent(type)
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildIndicesExistsType

api/api/indices.flush.js

@@ -0,0 +1,104 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildIndicesFlush (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [indices.flush](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/indices-flush.html) request
+   *
+   * @param {list} index - A comma-separated list of index names; use `_all` or empty string for all indices
+   * @param {boolean} force - Whether a flush should be forced even if it is not necessarily needed ie. if no changes will be committed to the index. This is useful if transaction log IDs should be incremented even if no uncommitted changes are present. (This setting can be considered as internal)
+   * @param {boolean} wait_if_ongoing - If set to true the flush operation will block until the flush can be executed if another flush operation is already executing. The default is true. If set to false the flush will be skipped iff if another flush operation is already running.
+   * @param {boolean} ignore_unavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
+   * @param {boolean} allow_no_indices - Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
+   * @param {enum} expand_wildcards - Whether to expand wildcard expression to concrete indices that are open, closed or both.
+   */
+
+  const acceptedQuerystring = [
+    'force',
+    'wait_if_ongoing',
+    'ignore_unavailable',
+    'allow_no_indices',
+    'expand_wildcards',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    waitIfOngoing: 'wait_if_ongoing',
+    ignoreUnavailable: 'ignore_unavailable',
+    allowNoIndices: 'allow_no_indices',
+    expandWildcards: 'expand_wildcards',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function indicesFlush (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = body == null ? 'GET' : 'POST'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((index) != null) {
+      path = '/' + encodeURIComponent(index) + '/' + '_flush'
+    } else {
+      path = '/' + '_flush'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: '',
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildIndicesFlush

api/api/indices.flush_synced.js

@@ -0,0 +1,99 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildIndicesFlushSynced (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [indices.flush_synced](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/indices-synced-flush.html) request
+   *
+   * @param {list} index - A comma-separated list of index names; use `_all` or empty string for all indices
+   * @param {boolean} ignore_unavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
+   * @param {boolean} allow_no_indices - Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
+   * @param {enum} expand_wildcards - Whether to expand wildcard expression to concrete indices that are open, closed or both.
+   */
+
+  const acceptedQuerystring = [
+    'ignore_unavailable',
+    'allow_no_indices',
+    'expand_wildcards',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    ignoreUnavailable: 'ignore_unavailable',
+    allowNoIndices: 'allow_no_indices',
+    expandWildcards: 'expand_wildcards',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function indicesFlushSynced (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = body == null ? 'GET' : 'POST'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((index) != null) {
+      path = '/' + encodeURIComponent(index) + '/' + '_flush' + '/' + 'synced'
+    } else {
+      path = '/' + '_flush' + '/' + 'synced'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: '',
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildIndicesFlushSynced

api/api/indices.forcemerge.js

@@ -0,0 +1,113 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildIndicesForcemerge (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [indices.forcemerge](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/indices-forcemerge.html) request
+   *
+   * @param {list} index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
+   * @param {boolean} flush - Specify whether the index should be flushed after performing the operation (default: true)
+   * @param {boolean} ignore_unavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
+   * @param {boolean} allow_no_indices - Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
+   * @param {enum} expand_wildcards - Whether to expand wildcard expression to concrete indices that are open, closed or both.
+   * @param {number} max_num_segments - The number of segments the index should be merged into (default: dynamic)
+   * @param {boolean} only_expunge_deletes - Specify whether the operation should only expunge deleted documents
+   * @param {undefined} operation_threading - TODO: ?
+   * @param {boolean} wait_for_merge - Specify whether the request should block until the merge process is finished (default: true)
+   */
+
+  const acceptedQuerystring = [
+    'flush',
+    'ignore_unavailable',
+    'allow_no_indices',
+    'expand_wildcards',
+    'max_num_segments',
+    'only_expunge_deletes',
+    'operation_threading',
+    'wait_for_merge',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    ignoreUnavailable: 'ignore_unavailable',
+    allowNoIndices: 'allow_no_indices',
+    expandWildcards: 'expand_wildcards',
+    maxNumSegments: 'max_num_segments',
+    onlyExpungeDeletes: 'only_expunge_deletes',
+    operationThreading: 'operation_threading',
+    waitForMerge: 'wait_for_merge',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function indicesForcemerge (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'POST'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((index) != null) {
+      path = '/' + encodeURIComponent(index) + '/' + '_forcemerge'
+    } else {
+      path = '/' + '_forcemerge'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: '',
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildIndicesForcemerge

api/api/indices.get.js

@@ -0,0 +1,118 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildIndicesGet (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [indices.get](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/indices-get-index.html) request
+   *
+   * @param {list} index - A comma-separated list of index names
+   * @param {list} feature - A comma-separated list of features
+   * @param {boolean} local - Return local information, do not retrieve the state from master node (default: false)
+   * @param {boolean} ignore_unavailable - Ignore unavailable indexes (default: false)
+   * @param {boolean} allow_no_indices - Ignore if a wildcard expression resolves to no concrete indices (default: false)
+   * @param {enum} expand_wildcards - Whether wildcard expressions should get expanded to open or closed indices (default: open)
+   * @param {boolean} flat_settings - Return settings in flat format (default: false)
+   * @param {boolean} include_defaults - Whether to return all default setting for each of the indices.
+   */
+
+  const acceptedQuerystring = [
+    'local',
+    'ignore_unavailable',
+    'allow_no_indices',
+    'expand_wildcards',
+    'flat_settings',
+    'include_defaults',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    ignoreUnavailable: 'ignore_unavailable',
+    allowNoIndices: 'allow_no_indices',
+    expandWildcards: 'expand_wildcards',
+    flatSettings: 'flat_settings',
+    includeDefaults: 'include_defaults',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function indicesGet (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params['index'] == null) {
+      const err = new ConfigurationError('Missing required parameter: index')
+      return handleError(err, callback)
+    }
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // check required url components
+    if (params['feature'] != null && (params['index'] == null)) {
+      const err = new ConfigurationError('Missing required parameter of the url: index')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, feature, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((index) != null && (feature) != null) {
+      path = '/' + encodeURIComponent(index) + '/' + encodeURIComponent(feature)
+    } else {
+      path = '/' + encodeURIComponent(index)
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildIndicesGet

api/api/indices.get_alias.js

@@ -0,0 +1,106 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildIndicesGetAlias (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [indices.get_alias](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/indices-aliases.html) request
+   *
+   * @param {list} index - A comma-separated list of index names to filter aliases
+   * @param {list} name - A comma-separated list of alias names to return
+   * @param {boolean} ignore_unavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
+   * @param {boolean} allow_no_indices - Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
+   * @param {enum} expand_wildcards - Whether to expand wildcard expression to concrete indices that are open, closed or both.
+   * @param {boolean} local - Return local information, do not retrieve the state from master node (default: false)
+   */
+
+  const acceptedQuerystring = [
+    'ignore_unavailable',
+    'allow_no_indices',
+    'expand_wildcards',
+    'local',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    ignoreUnavailable: 'ignore_unavailable',
+    allowNoIndices: 'allow_no_indices',
+    expandWildcards: 'expand_wildcards',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function indicesGetAlias (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, name, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((index) != null && (name) != null) {
+      path = '/' + encodeURIComponent(index) + '/' + '_alias' + '/' + encodeURIComponent(name)
+    } else if ((name) != null) {
+      path = '/' + '_alias' + '/' + encodeURIComponent(name)
+    } else if ((index) != null) {
+      path = '/' + encodeURIComponent(index) + '/' + '_alias'
+    } else {
+      path = '/' + '_alias'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildIndicesGetAlias

api/api/indices.get_field_mapping.js

@@ -0,0 +1,114 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildIndicesGetFieldMapping (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [indices.get_field_mapping](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/indices-get-field-mapping.html) request
+   *
+   * @param {list} index - A comma-separated list of index names
+   * @param {list} type - A comma-separated list of document types
+   * @param {list} fields - A comma-separated list of fields
+   * @param {boolean} include_defaults - Whether the default mapping values should be returned as well
+   * @param {boolean} ignore_unavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
+   * @param {boolean} allow_no_indices - Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
+   * @param {enum} expand_wildcards - Whether to expand wildcard expression to concrete indices that are open, closed or both.
+   * @param {boolean} local - Return local information, do not retrieve the state from master node (default: false)
+   */
+
+  const acceptedQuerystring = [
+    'include_defaults',
+    'ignore_unavailable',
+    'allow_no_indices',
+    'expand_wildcards',
+    'local',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    includeDefaults: 'include_defaults',
+    ignoreUnavailable: 'ignore_unavailable',
+    allowNoIndices: 'allow_no_indices',
+    expandWildcards: 'expand_wildcards',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function indicesGetFieldMapping (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params['fields'] == null) {
+      const err = new ConfigurationError('Missing required parameter: fields')
+      return handleError(err, callback)
+    }
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, type, fields, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((index) != null && (type) != null && (fields) != null) {
+      path = '/' + encodeURIComponent(index) + '/' + '_mapping' + '/' + encodeURIComponent(type) + '/' + 'field' + '/' + encodeURIComponent(fields)
+    } else if ((index) != null && (fields) != null) {
+      path = '/' + encodeURIComponent(index) + '/' + '_mapping' + '/' + 'field' + '/' + encodeURIComponent(fields)
+    } else if ((type) != null && (fields) != null) {
+      path = '/' + '_mapping' + '/' + encodeURIComponent(type) + '/' + 'field' + '/' + encodeURIComponent(fields)
+    } else {
+      path = '/' + '_mapping' + '/' + 'field' + '/' + encodeURIComponent(fields)
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildIndicesGetFieldMapping

api/api/indices.get_mapping.js

@@ -0,0 +1,106 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildIndicesGetMapping (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [indices.get_mapping](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/indices-get-mapping.html) request
+   *
+   * @param {list} index - A comma-separated list of index names
+   * @param {list} type - A comma-separated list of document types
+   * @param {boolean} ignore_unavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
+   * @param {boolean} allow_no_indices - Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
+   * @param {enum} expand_wildcards - Whether to expand wildcard expression to concrete indices that are open, closed or both.
+   * @param {boolean} local - Return local information, do not retrieve the state from master node (default: false)
+   */
+
+  const acceptedQuerystring = [
+    'ignore_unavailable',
+    'allow_no_indices',
+    'expand_wildcards',
+    'local',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    ignoreUnavailable: 'ignore_unavailable',
+    allowNoIndices: 'allow_no_indices',
+    expandWildcards: 'expand_wildcards',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function indicesGetMapping (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, type, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((index) != null && (type) != null) {
+      path = '/' + encodeURIComponent(index) + '/' + '_mapping' + '/' + encodeURIComponent(type)
+    } else if ((index) != null) {
+      path = '/' + encodeURIComponent(index) + '/' + '_mapping'
+    } else if ((type) != null) {
+      path = '/' + '_mapping' + '/' + encodeURIComponent(type)
+    } else {
+      path = '/' + '_mapping'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildIndicesGetMapping

api/api/indices.get_settings.js

@@ -0,0 +1,112 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildIndicesGetSettings (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [indices.get_settings](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/indices-get-settings.html) request
+   *
+   * @param {list} index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
+   * @param {list} name - The name of the settings that should be included
+   * @param {boolean} ignore_unavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
+   * @param {boolean} allow_no_indices - Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
+   * @param {enum} expand_wildcards - Whether to expand wildcard expression to concrete indices that are open, closed or both.
+   * @param {boolean} flat_settings - Return settings in flat format (default: false)
+   * @param {boolean} local - Return local information, do not retrieve the state from master node (default: false)
+   * @param {boolean} include_defaults - Whether to return all default setting for each of the indices.
+   */
+
+  const acceptedQuerystring = [
+    'ignore_unavailable',
+    'allow_no_indices',
+    'expand_wildcards',
+    'flat_settings',
+    'local',
+    'include_defaults',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    ignoreUnavailable: 'ignore_unavailable',
+    allowNoIndices: 'allow_no_indices',
+    expandWildcards: 'expand_wildcards',
+    flatSettings: 'flat_settings',
+    includeDefaults: 'include_defaults',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function indicesGetSettings (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, name, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((index) != null && (name) != null) {
+      path = '/' + encodeURIComponent(index) + '/' + '_settings' + '/' + encodeURIComponent(name)
+    } else if ((index) != null) {
+      path = '/' + encodeURIComponent(index) + '/' + '_settings'
+    } else if ((name) != null) {
+      path = '/' + '_settings' + '/' + encodeURIComponent(name)
+    } else {
+      path = '/' + '_settings'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildIndicesGetSettings

api/api/indices.get_template.js

@@ -0,0 +1,98 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildIndicesGetTemplate (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [indices.get_template](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/indices-templates.html) request
+   *
+   * @param {list} name - The comma separated names of the index templates
+   * @param {boolean} flat_settings - Return settings in flat format (default: false)
+   * @param {time} master_timeout - Explicit operation timeout for connection to master node
+   * @param {boolean} local - Return local information, do not retrieve the state from master node (default: false)
+   */
+
+  const acceptedQuerystring = [
+    'flat_settings',
+    'master_timeout',
+    'local',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    flatSettings: 'flat_settings',
+    masterTimeout: 'master_timeout',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function indicesGetTemplate (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, name, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((name) != null) {
+      path = '/' + '_template' + '/' + encodeURIComponent(name)
+    } else {
+      path = '/' + '_template'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildIndicesGetTemplate

api/api/indices.get_upgrade.js

@@ -0,0 +1,99 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+'use strict'
+
+/* eslint camelcase: 0 */
+/* eslint no-unused-vars: 0 */
+
+function buildIndicesGetUpgrade (opts) {
+  // eslint-disable-next-line no-unused-vars
+  const { makeRequest, ConfigurationError, handleError, snakeCaseKeys } = opts
+  /**
+   * Perform a [indices.get_upgrade](https://www.elastic.co/guide/en/elasticsearch/reference/5.x/indices-upgrade.html) request
+   *
+   * @param {list} index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
+   * @param {boolean} ignore_unavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
+   * @param {boolean} allow_no_indices - Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
+   * @param {enum} expand_wildcards - Whether to expand wildcard expression to concrete indices that are open, closed or both.
+   */
+
+  const acceptedQuerystring = [
+    'ignore_unavailable',
+    'allow_no_indices',
+    'expand_wildcards',
+    'pretty',
+    'human',
+    'error_trace',
+    'source',
+    'filter_path'
+  ]
+
+  const snakeCase = {
+    ignoreUnavailable: 'ignore_unavailable',
+    allowNoIndices: 'allow_no_indices',
+    expandWildcards: 'expand_wildcards',
+    errorTrace: 'error_trace',
+    filterPath: 'filter_path'
+  }
+
+  return function indicesGetUpgrade (params, options, callback) {
+    options = options || {}
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+    if (typeof params === 'function' || params == null) {
+      callback = params
+      params = {}
+      options = {}
+    }
+
+    // check required parameters
+    if (params.body != null) {
+      const err = new ConfigurationError('This API does not require a body')
+      return handleError(err, callback)
+    }
+
+    // validate headers object
+    if (options.headers != null && typeof options.headers !== 'object') {
+      const err = new ConfigurationError(`Headers should be an object, instead got: ${typeof options.headers}`)
+      return handleError(err, callback)
+    }
+
+    var warnings = []
+    var { method, body, index, ...querystring } = params
+    querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring, warnings)
+
+    if (method == null) {
+      method = 'GET'
+    }
+
+    var ignore = options.ignore
+    if (typeof ignore === 'number') {
+      options.ignore = [ignore]
+    }
+
+    var path = ''
+
+    if ((index) != null) {
+      path = '/' + encodeURIComponent(index) + '/' + '_upgrade'
+    } else {
+      path = '/' + '_upgrade'
+    }
+
+    // build request object
+    const request = {
+      method,
+      path,
+      body: null,
+      querystring
+    }
+
+    options.warnings = warnings.length === 0 ? null : warnings
+    return makeRequest(request, options, callback)
+  }
+}
+
+module.exports = buildIndicesGetUpgrade