From 4a4e7e43bc0cba1e5cf5bdd096bf6e9c5752b3dd Mon Sep 17 00:00:00 2001 From: delvedor Date: Wed, 31 Mar 2021 14:52:03 +0200 Subject: [PATCH 01/10] Updated code generation to use new artifacts api --- scripts/generate.js | 54 ++++++++++++++++------------------- scripts/utils/generateApis.js | 25 +++++----------- scripts/utils/generateMain.js | 23 ++++++--------- scripts/utils/patch.json | 2 +- 4 files changed, 41 insertions(+), 63 deletions(-) diff --git a/scripts/generate.js b/scripts/generate.js index 64412ff2d..6e77a8907 100644 --- a/scripts/generate.js +++ b/scripts/generate.js @@ -20,67 +20,61 @@ 'use strict' const { join } = require('path') -const { readdirSync, readFileSync, writeFileSync } = require('fs') +const { readdirSync, writeFileSync } = require('fs') const minimist = require('minimist') -const semver = require('semver') const ora = require('ora') const rimraf = require('rimraf') const standard = require('standard') +const downloadArtifacts = require('./download-artifacts') const { generate, - cloneAndCheckout, genFactory, generateDocs } = require('./utils') start(minimist(process.argv.slice(2), { - string: ['tag', 'branch'] + string: ['version'] })) function start (opts) { - const log = ora('Loading Elasticsearch Repository').start() - if (opts.branch == null && semver.valid(opts.tag) === null) { - log.fail(`Missing or invalid tag: ${opts.tag}`) - return + if (opts.version == null) { + console.error('Missing version parameter') + process.exit(1) } const packageFolder = join(__dirname, '..', 'api') const apiOutputFolder = join(packageFolder, 'api') const mainOutputFile = join(packageFolder, 'index.js') const docOutputFile = join(__dirname, '..', 'docs', 'reference.asciidoc') - log.text = 'Cleaning API folder...' - rimraf.sync(join(apiOutputFolder, '*.js')) + let log + downloadArtifacts({ version: opts.version }) + .then(onArtifactsDownloaded) + .catch(err => { + console.log(err) + process.exit(1) + }) - cloneAndCheckout({ log, tag: opts.tag, branch: opts.branch }, (err, { apiFolder, xPackFolder }) => { - if (err) { - log.fail(err.message) - return - } + function onArtifactsDownloaded () { + log = ora('Generating APIs').start() - const apiFolderContents = readdirSync(apiFolder) - const xPackFolderContents = readdirSync(xPackFolder) + log.text = 'Cleaning API folder...' + rimraf.sync(join(apiOutputFolder, '*.js')) - const allSpec = apiFolderContents.concat(xPackFolderContents) + const allSpec = readdirSync(downloadArtifacts.locations.specFolder) .filter(file => file !== '_common.json') .filter(file => !file.includes('deprecated')) .sort() - .map(file => { - try { - return JSON.parse(readFileSync(join(apiFolder, file), 'utf8')) - } catch (err) { - return JSON.parse(readFileSync(join(xPackFolder, file), 'utf8')) - } - }) + .map(file => require(join(downloadArtifacts.locations.specFolder, file))) - const namespaces = namespacify(apiFolderContents.concat(xPackFolderContents)) + const namespaces = namespacify(readdirSync(downloadArtifacts.locations.specFolder)) for (const namespace in namespaces) { if (namespace === '_common') continue - const code = generate(namespace, namespaces[namespace], { apiFolder, xPackFolder }, opts.branch || opts.tag) + const code = generate(namespace, namespaces[namespace], downloadArtifacts.locations.specFolder, opts.version) const filePath = join(apiOutputFolder, `${namespace}.js`) writeFileSync(filePath, code, { encoding: 'utf8' }) } - const { fn: factory } = genFactory(apiOutputFolder, [apiFolder, xPackFolder], namespaces) + const { fn: factory } = genFactory(apiOutputFolder, downloadArtifacts.locations.specFolder, namespaces) writeFileSync( mainOutputFile, factory, @@ -91,13 +85,13 @@ function start (opts) { log.text = 'Generating documentation' writeFileSync( docOutputFile, - generateDocs(require(join(apiFolder, '_common.json')), allSpec), + generateDocs(require(join(downloadArtifacts.locations.specFolder, '_common.json')), allSpec), { encoding: 'utf8' } ) log.succeed('Done!') }) - }) + } function lintFiles (log, cb) { log.text = 'Linting...' diff --git a/scripts/utils/generateApis.js b/scripts/utils/generateApis.js index a71afad56..be865a804 100644 --- a/scripts/utils/generateApis.js +++ b/scripts/utils/generateApis.js @@ -23,7 +23,6 @@ const { join } = require('path') const dedent = require('dedent') -const semver = require('semver') const allowedMethods = { noBody: ['GET', 'HEAD', 'DELETE'], body: ['POST', 'PUT', 'DELETE'] @@ -69,8 +68,8 @@ const ndjsonApi = [ 'xpack.monitoring.bulk' ] -function generateNamespace (namespace, nested, folders, version) { - const common = require(join(folders.apiFolder, '_common.json')) +function generateNamespace (namespace, nested, specFolder, version) { + const common = require(join(specFolder, '_common.json')) let code = dedent` /* * Licensed to Elasticsearch B.V. under one or more contributor @@ -108,7 +107,7 @@ function generateNamespace (namespace, nested, folders, version) { getters += `${n}: { get () { return this.${nameSnaked} } },\n` } } - const api = generateMultiApi(version, namespace, nested, common, folders) + const api = generateMultiApi(version, namespace, nested, common, specFolder) if (getters.length > 0) { getters = `Object.defineProperties(${api.namespace}Api.prototype, {\n${getters}})` } @@ -129,12 +128,7 @@ function generateNamespace (namespace, nested, folders, version) { module.exports = ${api.namespace}Api ` } else { - let spec = null - try { - spec = require(join(folders.apiFolder, `${namespace}.json`)) - } catch (err) { - spec = require(join(folders.xPackFolder, `${namespace}.json`)) - } + const spec = require(join(specFolder, `${namespace}.json`)) const api = generateSingleApi(version, spec, common) code += ` const acceptedQuerystring = ${JSON.stringify(api.acceptedQuerystring)} @@ -148,7 +142,7 @@ function generateNamespace (namespace, nested, folders, version) { return code } -function generateMultiApi (version, namespace, nested, common, folders) { +function generateMultiApi (version, namespace, nested, common, specFolder) { const namespaceSnaked = namespace .replace(/\.([a-z])/g, k => k[1].toUpperCase()) .replace(/_([a-z])/g, k => k[1].toUpperCase()) @@ -156,15 +150,10 @@ function generateMultiApi (version, namespace, nested, common, folders) { const snakeCase = {} const acceptedQuerystring = [] for (const n of nested) { - let spec = null const nameSnaked = n .replace(/\.([a-z])/g, k => k[1].toUpperCase()) .replace(/_([a-z])/g, k => k[1].toUpperCase()) - try { - spec = require(join(folders.apiFolder, `${namespace}.${n}.json`)) - } catch (err) { - spec = require(join(folders.xPackFolder, `${namespace}.${n}.json`)) - } + const spec = require(join(specFolder, `${namespace}.${n}.json`)) const api = generateSingleApi(version, spec, common) code += `${Uppercase(namespaceSnaked)}Api.prototype.${nameSnaked} = ${api.code}\n\n` Object.assign(snakeCase, api.snakeCase) @@ -178,7 +167,7 @@ function generateMultiApi (version, namespace, nested, common, folders) { } function generateSingleApi (version, spec, common) { - const release = semver.valid(version) ? semver.major(version) : version + const release = version.charAt(0) const api = Object.keys(spec)[0] const name = api .replace(/\.([a-z])/g, k => k[1].toUpperCase()) diff --git a/scripts/utils/generateMain.js b/scripts/utils/generateMain.js index c615d6476..b2b538c59 100644 --- a/scripts/utils/generateMain.js +++ b/scripts/utils/generateMain.js @@ -35,11 +35,10 @@ const ndjsonApiKey = ndjsonApi }) .map(toPascalCase) -function genFactory (folder, paths, namespaces) { +function genFactory (folder, specFolder, namespaces) { // get all the API files // const apiFiles = readdirSync(folder) - const apiFiles = readdirSync(paths[0]) - .concat(readdirSync(paths[1])) + const apiFiles = readdirSync(specFolder) .filter(file => file !== '_common.json') .filter(file => !file.includes('deprecated')) .sort() @@ -55,7 +54,7 @@ function genFactory (folder, paths, namespaces) { .split('.') .reverse() .reduce((acc, val) => { - const spec = readSpec(paths, file.slice(0, -5)) + const spec = readSpec(specFolder, file.slice(0, -5)) const isHead = isHeadMethod(spec, file.slice(0, -5)) const body = hasBody(spec, file.slice(0, -5)) const methods = acc === null ? buildMethodDefinition({ kibana: false }, val, name, body, isHead) : null @@ -87,7 +86,7 @@ function genFactory (folder, paths, namespaces) { .split('.') .reverse() .reduce((acc, val) => { - const spec = readSpec(paths, file.slice(0, -5)) + const spec = readSpec(specFolder, file.slice(0, -5)) const isHead = isHeadMethod(spec, file.slice(0, -5)) const body = hasBody(spec, file.slice(0, -5)) const methods = acc === null ? buildMethodDefinition({ kibana: true }, val, name, body, isHead) : null @@ -296,16 +295,12 @@ function isHeadMethod (spec, api) { return methods.length === 1 && methods[0] === 'HEAD' } -function readSpec (paths, file) { +function readSpec (specFolder, file) { try { - return require(join(paths[0], file)) - } catch (err) {} - - try { - return require(join(paths[1], file)) - } catch (err) {} - - throw new Error(`Cannot read spec file ${file}`) + return require(join(specFolder, file)) + } catch (err) { + throw new Error(`Cannot read spec file ${file}`) + } } module.exports = genFactory diff --git a/scripts/utils/patch.json b/scripts/utils/patch.json index 392b305cb..3023a6271 100644 --- a/scripts/utils/patch.json +++ b/scripts/utils/patch.json @@ -7,7 +7,7 @@ "_source_includes": "_source_include", "_source_excludes": "_source_exclude" }, - "master": { + "8": { "_source_includes": "_source_include", "_source_excludes": "_source_exclude" } From fb87541bbfa26333f4e9014515a49c9a673cc457 Mon Sep 17 00:00:00 2001 From: delvedor Date: Fri, 2 Apr 2021 09:00:52 +0200 Subject: [PATCH 02/10] Added back legacy type generator --- scripts/download-artifacts.js | 19 +++++++++++++++++++ scripts/generate.js | 26 +++++++++++++++++++++++--- scripts/utils/generateRequestTypes.js | 3 +-- scripts/utils/index.js | 4 +++- 4 files changed, 46 insertions(+), 6 deletions(-) diff --git a/scripts/download-artifacts.js b/scripts/download-artifacts.js index e1d4c5a5d..9618838be 100644 --- a/scripts/download-artifacts.js +++ b/scripts/download-artifacts.js @@ -1,3 +1,22 @@ +/* + * 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. + */ + 'use strict' const { join } = require('path') diff --git a/scripts/generate.js b/scripts/generate.js index 6e77a8907..3b6be0dc4 100644 --- a/scripts/generate.js +++ b/scripts/generate.js @@ -20,7 +20,7 @@ 'use strict' const { join } = require('path') -const { readdirSync, writeFileSync } = require('fs') +const { readdirSync, writeFileSync, readFileSync } = require('fs') const minimist = require('minimist') const ora = require('ora') const rimraf = require('rimraf') @@ -29,7 +29,8 @@ const downloadArtifacts = require('./download-artifacts') const { generate, genFactory, - generateDocs + generateDocs, + generateRequestTypes } = require('./utils') start(minimist(process.argv.slice(2), { @@ -41,10 +42,13 @@ function start (opts) { console.error('Missing version parameter') process.exit(1) } + const packageFolder = join(__dirname, '..', 'api') const apiOutputFolder = join(packageFolder, 'api') const mainOutputFile = join(packageFolder, 'index.js') const docOutputFile = join(__dirname, '..', 'docs', 'reference.asciidoc') + const typeDefFile = join(__dirname, '..', 'index.d.ts') + const requestParamsOutputFile = join(packageFolder, 'requestParams.d.ts') let log downloadArtifacts({ version: opts.version }) @@ -74,13 +78,29 @@ function start (opts) { writeFileSync(filePath, code, { encoding: 'utf8' }) } - const { fn: factory } = genFactory(apiOutputFolder, downloadArtifacts.locations.specFolder, namespaces) + writeFileSync( + requestParamsOutputFile, + generateRequestTypes(opts.version, allSpec), + { encoding: 'utf8' } + ) + + const { fn: factory, types } = genFactory(apiOutputFolder, downloadArtifacts.locations.specFolder, namespaces) writeFileSync( mainOutputFile, factory, { encoding: 'utf8' } ) + const oldTypeDefString = readFileSync(typeDefFile, 'utf8') + const start = oldTypeDefString.indexOf('/* GENERATED */') + const end = oldTypeDefString.indexOf('/* /GENERATED */') + const newTypeDefString = oldTypeDefString.slice(0, start + 15) + '\n' + types + '\n ' + oldTypeDefString.slice(end) + writeFileSync( + typeDefFile, + newTypeDefString, + { encoding: 'utf8' } + ) + lintFiles(log, () => { log.text = 'Generating documentation' writeFileSync( diff --git a/scripts/utils/generateRequestTypes.js b/scripts/utils/generateRequestTypes.js index 1b6fcfbcd..e3afc612f 100644 --- a/scripts/utils/generateRequestTypes.js +++ b/scripts/utils/generateRequestTypes.js @@ -19,7 +19,6 @@ 'use strict' -const semver = require('semver') const deprecatedParameters = require('./patch.json') const { ndjsonApi } = require('./generateApis') @@ -32,7 +31,7 @@ const ndjsonApiKey = ndjsonApi .map(toPascalCase) function generate (version, api) { - const release = semver.valid(version) ? semver.major(version) : version + const release = version.charAt(0) let types = `/* * Licensed to Elasticsearch B.V. under one or more contributor * license agreements. See the NOTICE file distributed with diff --git a/scripts/utils/index.js b/scripts/utils/index.js index 792caaad0..05d955b2e 100644 --- a/scripts/utils/index.js +++ b/scripts/utils/index.js @@ -23,10 +23,12 @@ const generate = require('./generateApis') const cloneAndCheckout = require('./clone-es') const genFactory = require('./generateMain') const generateDocs = require('./generateDocs') +const generateRequestTypes = require('./generateRequestTypes') module.exports = { generate, cloneAndCheckout, genFactory, - generateDocs + generateDocs, + generateRequestTypes } From 76a85b0d6abf43829090ae4f019d527ec179f6dc Mon Sep 17 00:00:00 2001 From: delvedor Date: Fri, 2 Apr 2021 09:13:42 +0200 Subject: [PATCH 03/10] Update type definitions --- api/{esapi.d.ts => new.d.ts} | 165 ++- api/requestParams.d.ts | 23 +- api/types.d.ts | 1704 ++++++++++++++++------ index.d.ts | 2562 +++++++++++++++++++++++++++++++++- 4 files changed, 3987 insertions(+), 467 deletions(-) rename api/{esapi.d.ts => new.d.ts} (95%) diff --git a/api/esapi.d.ts b/api/new.d.ts similarity index 95% rename from api/esapi.d.ts rename to api/new.d.ts index 582501424..492cdbd00 100644 --- a/api/esapi.d.ts +++ b/api/new.d.ts @@ -17,14 +17,27 @@ * under the License. */ -import * as T from './types' +/// + import { - TransportRequestPromise, + ClientOptions, + ConnectionPool, + Serializer, + Transport, + errors, + RequestEvent, + ResurrectEvent, + ApiError +} from '../index' +import Helpers from '../lib/Helpers' +import { + ApiResponse, TransportRequestCallback, - TransportRequestOptions, - ApiError, - ApiResponse + TransportRequestPromise, + TransportRequestParams, + TransportRequestOptions } from '../lib/Transport' +import * as T from './types' /** * We are still working on this type, it will arrive soon. @@ -33,8 +46,41 @@ import { */ type TODO = Record +// Extend API +interface ClientExtendsCallbackOptions { + ConfigurationError: errors.ConfigurationError, + makeRequest(params: TransportRequestParams, options?: TransportRequestOptions): Promise | void; + result: { + body: null, + statusCode: null, + headers: null, + warnings: null + } +} +declare type extendsCallback = (options: ClientExtendsCallbackOptions) => any; +// /Extend API + declare type callbackFn = (err: ApiError, result: ApiResponse) => void; -declare class ESAPI { +interface NewClientTypes { + connectionPool: ConnectionPool + transport: Transport + serializer: Serializer + extend(method: string, fn: extendsCallback): void + extend(method: string, opts: { force: boolean }, fn: extendsCallback): void; + helpers: Helpers + child(opts?: ClientOptions): NewClientTypes + close(callback: Function): void; + close(): Promise; + emit(event: string | symbol, ...args: any[]): boolean; + on(event: 'request', listener: (err: ApiError, meta: RequestEvent) => void): this; + on(event: 'response', listener: (err: ApiError, meta: RequestEvent) => void): this; + on(event: 'sniff', listener: (err: ApiError, meta: RequestEvent) => void): this; + on(event: 'resurrect', listener: (err: null, meta: ResurrectEvent) => void): this; + once(event: 'request', listener: (err: ApiError, meta: RequestEvent) => void): this; + once(event: 'response', listener: (err: ApiError, meta: RequestEvent) => void): this; + once(event: 'sniff', listener: (err: ApiError, meta: RequestEvent) => void): this; + once(event: 'resurrect', listener: (err: null, meta: ResurrectEvent) => void): this; + off(event: string | symbol, listener: (...args: any[]) => void): this; asyncSearch: { delete(params: T.AsyncSearchDeleteRequest, options?: TransportRequestOptions): TransportRequestPromise> delete(params: T.AsyncSearchDeleteRequest, callback: callbackFn): TransportRequestCallback @@ -199,9 +245,9 @@ declare class ESAPI { pauseFollow(params: T.PauseFollowIndexRequest, options?: TransportRequestOptions): TransportRequestPromise> pauseFollow(params: T.PauseFollowIndexRequest, callback: callbackFn): TransportRequestCallback pauseFollow(params: T.PauseFollowIndexRequest, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback - putAutoFollowPattern(params: T.CreateAutoFollowPatternRequest, options?: TransportRequestOptions): TransportRequestPromise> - putAutoFollowPattern(params: T.CreateAutoFollowPatternRequest, callback: callbackFn): TransportRequestCallback - putAutoFollowPattern(params: T.CreateAutoFollowPatternRequest, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putAutoFollowPattern(params: T.PutAutoFollowPatternRequest, options?: TransportRequestOptions): TransportRequestPromise> + putAutoFollowPattern(params: T.PutAutoFollowPatternRequest, callback: callbackFn): TransportRequestCallback + putAutoFollowPattern(params: T.PutAutoFollowPatternRequest, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback resumeAutoFollowPattern(params: T.ResumeAutoFollowPatternRequest, options?: TransportRequestOptions): TransportRequestPromise> resumeAutoFollowPattern(params: T.ResumeAutoFollowPatternRequest, callback: callbackFn): TransportRequestCallback resumeAutoFollowPattern(params: T.ResumeAutoFollowPatternRequest, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback @@ -229,10 +275,9 @@ declare class ESAPI { allocationExplain(callback: callbackFn): TransportRequestCallback allocationExplain(params: T.ClusterAllocationExplainRequest, callback: callbackFn): TransportRequestCallback allocationExplain(params: T.ClusterAllocationExplainRequest, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback - deleteComponentTemplate(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> - deleteComponentTemplate(callback: callbackFn): TransportRequestCallback - deleteComponentTemplate(params: TODO, callback: callbackFn): TransportRequestCallback - deleteComponentTemplate(params: TODO, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteComponentTemplate(params: T.ClusterDeleteComponentTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise> + deleteComponentTemplate(params: T.ClusterDeleteComponentTemplateRequest, callback: callbackFn): TransportRequestCallback + deleteComponentTemplate(params: T.ClusterDeleteComponentTemplateRequest, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback deleteVotingConfigExclusions(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> deleteVotingConfigExclusions(callback: callbackFn): TransportRequestCallback deleteVotingConfigExclusions(params: TODO, callback: callbackFn): TransportRequestCallback @@ -373,22 +418,18 @@ declare class ESAPI { stats(params: T.EnrichStatsRequest, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback } eql: { - delete(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> - delete(callback: callbackFn): TransportRequestCallback - delete(params: TODO, callback: callbackFn): TransportRequestCallback - delete(params: TODO, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback - get(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> - get(callback: callbackFn): TransportRequestCallback - get(params: TODO, callback: callbackFn): TransportRequestCallback - get(params: TODO, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback - getStatus(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> - getStatus(callback: callbackFn): TransportRequestCallback - getStatus(params: TODO, callback: callbackFn): TransportRequestCallback - getStatus(params: TODO, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback - search(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> - search(callback: callbackFn): TransportRequestCallback - search(params: TODO, callback: callbackFn): TransportRequestCallback - search(params: TODO, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete(params: T.EqlDeleteRequest, options?: TransportRequestOptions): TransportRequestPromise> + delete(params: T.EqlDeleteRequest, callback: callbackFn): TransportRequestCallback + delete(params: T.EqlDeleteRequest, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get(params: T.EqlGetRequest, options?: TransportRequestOptions): TransportRequestPromise, TContext>> + get(params: T.EqlGetRequest, callback: callbackFn, TContext>): TransportRequestCallback + get(params: T.EqlGetRequest, options: TransportRequestOptions, callback: callbackFn, TContext>): TransportRequestCallback + getStatus(params: T.EqlGetStatusRequest, options?: TransportRequestOptions): TransportRequestPromise> + getStatus(params: T.EqlGetStatusRequest, callback: callbackFn): TransportRequestCallback + getStatus(params: T.EqlGetStatusRequest, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + search(params: T.EqlSearchRequest, options?: TransportRequestOptions): TransportRequestPromise, TContext>> + search(params: T.EqlSearchRequest, callback: callbackFn, TContext>): TransportRequestCallback + search(params: T.EqlSearchRequest, options: TransportRequestOptions, callback: callbackFn, TContext>): TransportRequestCallback } exists(params: T.DocumentExistsRequest, options?: TransportRequestOptions): TransportRequestPromise> exists(params: T.DocumentExistsRequest, callback: callbackFn): TransportRequestCallback @@ -472,10 +513,9 @@ declare class ESAPI { index(params: T.IndexRequest, callback: callbackFn): TransportRequestCallback index(params: T.IndexRequest, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback indices: { - addBlock(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> - addBlock(callback: callbackFn): TransportRequestCallback - addBlock(params: TODO, callback: callbackFn): TransportRequestCallback - addBlock(params: TODO, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + addBlock(params: T.IndexAddBlockRequest, options?: TransportRequestOptions): TransportRequestPromise> + addBlock(params: T.IndexAddBlockRequest, callback: callbackFn): TransportRequestCallback + addBlock(params: T.IndexAddBlockRequest, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback analyze(params?: T.AnalyzeRequest, options?: TransportRequestOptions): TransportRequestPromise> analyze(callback: callbackFn): TransportRequestCallback analyze(params: T.AnalyzeRequest, callback: callbackFn): TransportRequestCallback @@ -497,20 +537,19 @@ declare class ESAPI { createDataStream(callback: callbackFn): TransportRequestCallback createDataStream(params: TODO, callback: callbackFn): TransportRequestCallback createDataStream(params: TODO, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback - dataStreamsStats(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> - dataStreamsStats(callback: callbackFn): TransportRequestCallback - dataStreamsStats(params: TODO, callback: callbackFn): TransportRequestCallback - dataStreamsStats(params: TODO, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + dataStreamsStats(params?: T.IndicesDataStreamsStatsRequest, options?: TransportRequestOptions): TransportRequestPromise> + dataStreamsStats(callback: callbackFn): TransportRequestCallback + dataStreamsStats(params: T.IndicesDataStreamsStatsRequest, callback: callbackFn): TransportRequestCallback + dataStreamsStats(params: T.IndicesDataStreamsStatsRequest, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback delete(params: T.DeleteIndexRequest, options?: TransportRequestOptions): TransportRequestPromise> delete(params: T.DeleteIndexRequest, callback: callbackFn): TransportRequestCallback delete(params: T.DeleteIndexRequest, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback deleteAlias(params: T.DeleteAliasRequest, options?: TransportRequestOptions): TransportRequestPromise> deleteAlias(params: T.DeleteAliasRequest, callback: callbackFn): TransportRequestCallback deleteAlias(params: T.DeleteAliasRequest, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback - deleteDataStream(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> - deleteDataStream(callback: callbackFn): TransportRequestCallback - deleteDataStream(params: TODO, callback: callbackFn): TransportRequestCallback - deleteDataStream(params: TODO, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteDataStream(params: T.IndicesDeleteDataStreamRequest, options?: TransportRequestOptions): TransportRequestPromise> + deleteDataStream(params: T.IndicesDeleteDataStreamRequest, callback: callbackFn): TransportRequestCallback + deleteDataStream(params: T.IndicesDeleteDataStreamRequest, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback deleteIndexTemplate(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> deleteIndexTemplate(callback: callbackFn): TransportRequestCallback deleteIndexTemplate(params: TODO, callback: callbackFn): TransportRequestCallback @@ -583,10 +622,9 @@ declare class ESAPI { getUpgrade(callback: callbackFn): TransportRequestCallback getUpgrade(params: TODO, callback: callbackFn): TransportRequestCallback getUpgrade(params: TODO, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback - migrateToDataStream(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> - migrateToDataStream(callback: callbackFn): TransportRequestCallback - migrateToDataStream(params: TODO, callback: callbackFn): TransportRequestCallback - migrateToDataStream(params: TODO, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + migrateToDataStream(params: T.IndicesMigrateToDataStreamRequest, options?: TransportRequestOptions): TransportRequestPromise> + migrateToDataStream(params: T.IndicesMigrateToDataStreamRequest, callback: callbackFn): TransportRequestCallback + migrateToDataStream(params: T.IndicesMigrateToDataStreamRequest, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback open(params: T.OpenIndexRequest, options?: TransportRequestOptions): TransportRequestPromise> open(params: T.OpenIndexRequest, callback: callbackFn): TransportRequestCallback open(params: T.OpenIndexRequest, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback @@ -623,10 +661,9 @@ declare class ESAPI { reloadSearchAnalyzers(params: T.ReloadSearchAnalyzersRequest, options?: TransportRequestOptions): TransportRequestPromise> reloadSearchAnalyzers(params: T.ReloadSearchAnalyzersRequest, callback: callbackFn): TransportRequestCallback reloadSearchAnalyzers(params: T.ReloadSearchAnalyzersRequest, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback - resolveIndex(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> - resolveIndex(callback: callbackFn): TransportRequestCallback - resolveIndex(params: TODO, callback: callbackFn): TransportRequestCallback - resolveIndex(params: TODO, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + resolveIndex(params: T.ResolveIndexRequest, options?: TransportRequestOptions): TransportRequestPromise> + resolveIndex(params: T.ResolveIndexRequest, callback: callbackFn): TransportRequestCallback + resolveIndex(params: T.ResolveIndexRequest, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback rollover(params: T.RolloverIndexRequest, options?: TransportRequestOptions): TransportRequestPromise> rollover(params: T.RolloverIndexRequest, callback: callbackFn): TransportRequestCallback rollover(params: T.RolloverIndexRequest, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback @@ -786,14 +823,12 @@ declare class ESAPI { deleteModelSnapshot(params: T.DeleteModelSnapshotRequest, options?: TransportRequestOptions): TransportRequestPromise> deleteModelSnapshot(params: T.DeleteModelSnapshotRequest, callback: callbackFn): TransportRequestCallback deleteModelSnapshot(params: T.DeleteModelSnapshotRequest, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback - deleteTrainedModel(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> - deleteTrainedModel(callback: callbackFn): TransportRequestCallback - deleteTrainedModel(params: TODO, callback: callbackFn): TransportRequestCallback - deleteTrainedModel(params: TODO, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback - deleteTrainedModelAlias(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> - deleteTrainedModelAlias(callback: callbackFn): TransportRequestCallback - deleteTrainedModelAlias(params: TODO, callback: callbackFn): TransportRequestCallback - deleteTrainedModelAlias(params: TODO, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteTrainedModel(params: T.DeleteTrainedModelRequest, options?: TransportRequestOptions): TransportRequestPromise> + deleteTrainedModel(params: T.DeleteTrainedModelRequest, callback: callbackFn): TransportRequestCallback + deleteTrainedModel(params: T.DeleteTrainedModelRequest, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteTrainedModelAlias(params: T.DeleteTrainedModelAliasRequest, options?: TransportRequestOptions): TransportRequestPromise> + deleteTrainedModelAlias(params: T.DeleteTrainedModelAliasRequest, callback: callbackFn): TransportRequestCallback + deleteTrainedModelAlias(params: T.DeleteTrainedModelAliasRequest, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback estimateModelMemory(params?: T.EstimateModelMemoryRequest, options?: TransportRequestOptions): TransportRequestPromise> estimateModelMemory(callback: callbackFn): TransportRequestCallback estimateModelMemory(params: T.EstimateModelMemoryRequest, callback: callbackFn): TransportRequestCallback @@ -1092,10 +1127,9 @@ declare class ESAPI { clearCache(callback: callbackFn): TransportRequestCallback clearCache(params: TODO, callback: callbackFn): TransportRequestCallback clearCache(params: TODO, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback - mount(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> - mount(callback: callbackFn): TransportRequestCallback - mount(params: TODO, callback: callbackFn): TransportRequestCallback - mount(params: TODO, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + mount(params: T.SearchableSnapshotsMountRequest, options?: TransportRequestOptions): TransportRequestPromise> + mount(params: T.SearchableSnapshotsMountRequest, callback: callbackFn): TransportRequestCallback + mount(params: T.SearchableSnapshotsMountRequest, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback repositoryStats(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> repositoryStats(callback: callbackFn): TransportRequestCallback repositoryStats(params: TODO, callback: callbackFn): TransportRequestCallback @@ -1118,10 +1152,9 @@ declare class ESAPI { clearApiKeyCache(callback: callbackFn): TransportRequestCallback clearApiKeyCache(params: T.ClearApiKeyCacheRequest, callback: callbackFn): TransportRequestCallback clearApiKeyCache(params: T.ClearApiKeyCacheRequest, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback - clearCachedPrivileges(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> - clearCachedPrivileges(callback: callbackFn): TransportRequestCallback - clearCachedPrivileges(params: TODO, callback: callbackFn): TransportRequestCallback - clearCachedPrivileges(params: TODO, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + clearCachedPrivileges(params: T.ClearCachedPrivilegesRequest, options?: TransportRequestOptions): TransportRequestPromise> + clearCachedPrivileges(params: T.ClearCachedPrivilegesRequest, callback: callbackFn): TransportRequestCallback + clearCachedPrivileges(params: T.ClearCachedPrivilegesRequest, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback clearCachedRealms(params: T.ClearCachedRealmsRequest, options?: TransportRequestOptions): TransportRequestPromise> clearCachedRealms(params: T.ClearCachedRealmsRequest, callback: callbackFn): TransportRequestCallback clearCachedRealms(params: T.ClearCachedRealmsRequest, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback @@ -1415,4 +1448,4 @@ declare class ESAPI { } } -export default ESAPI +export { NewClientTypes } diff --git a/api/requestParams.d.ts b/api/requestParams.d.ts index 26c0c7797..f5f1ce6b1 100644 --- a/api/requestParams.d.ts +++ b/api/requestParams.d.ts @@ -564,8 +564,8 @@ export interface ClusterReroute extends Generic { } export interface ClusterState extends Generic { - metric?: string | string[]; index?: string | string[]; + metric?: string | string[]; local?: boolean; master_timeout?: string; flat_settings?: boolean; @@ -1362,6 +1362,9 @@ export interface IngestDeletePipeline extends Generic { timeout?: string; } +export interface IngestGeoIpStats extends Generic { +} + export interface IngestGetPipeline extends Generic { id?: string; summary?: boolean; @@ -1728,8 +1731,9 @@ export interface MlPreviewDataFrameAnalytics extends Generic { body?: T; } -export interface MlPreviewDatafeed extends Generic { - datafeed_id: string; +export interface MlPreviewDatafeed extends Generic { + datafeed_id?: string; + body?: T; } export interface MlPutCalendar extends Generic { @@ -2300,6 +2304,19 @@ export interface SecurityPutUser extends Generic { body: T; } +export interface ShutdownDeleteNode extends Generic { + node_id: string; +} + +export interface ShutdownGetNode extends Generic { + node_id?: string; +} + +export interface ShutdownPutNode extends Generic { + node_id: string; + body: T; +} + export interface SlmDeleteLifecycle extends Generic { policy_id: string; } diff --git a/api/types.d.ts b/api/types.d.ts index 3805d360d..0d07dc4b5 100644 --- a/api/types.d.ts +++ b/api/types.d.ts @@ -84,7 +84,7 @@ export interface ActivationState { export interface ActivationStatus { actions: Record state: ActivationState - version: integer + version: VersionNumber } export interface AdaptiveSelectionStats { @@ -218,29 +218,9 @@ export interface AggregationProfileDebug { } export interface AggregationRange { - from?: double + from?: double | string key?: string - to?: double -} - -export interface AlertingCount { - active: long - total: long -} - -export interface AlertingExecution { - actions: Record -} - -export interface AlertingInput { - input: Record - trigger: Record -} - -export interface AlertingUsage extends XPackUsage { - count: AlertingCount - execution: AlertingExecution - watch: AlertingInput + to?: double | string } export interface Alias { @@ -329,6 +309,22 @@ export interface AnalysisMemoryLimit { model_memory_limit: string } +export interface AnalyticsStatsUsage { + boxplot_usage: long + cumulative_cardinality_usage: long + string_stats_usage: long + top_metrics_usage: long + t_test_usage: long + moving_percentiles_usage: long + normalize_usage: long + rate_usage: long + multi_terms_usage?: long +} + +export interface AnalyticsUsage extends XPackUsage { + stats: AnalyticsStatsUsage +} + export interface AnalyzeDetail { analyzer?: AnalyzerDetail charfilters?: Array @@ -423,7 +419,7 @@ export interface AnomalyRecord { export interface ApiKey { name: Name expiration?: Time - role_descriptors?: Array + role_descriptors?: Array> } export interface ApiKeyApplication { @@ -450,9 +446,10 @@ export interface ApiKeys { expiration?: long id: Id invalidated: boolean - name: string + name: Name realm: string - username: string + username: Name + metadata?: Record } export interface AppendProcessor extends ProcessorBase { @@ -580,7 +577,7 @@ export interface AsyncSearchSubmitRequest extends RequestBase { highlight?: Highlight ignore_throttled?: boolean ignore_unavailable?: boolean - indices_boost?: Record + indices_boost?: Array> keep_alive?: Time keep_on_completion?: boolean lenient?: boolean @@ -616,6 +613,7 @@ export interface AsyncSearchSubmitRequest extends RequestBase { typed_keys?: boolean version?: boolean wait_for_completion_timeout?: Time + fields?: Array } } @@ -633,7 +631,7 @@ export interface AttachmentProcessor extends ProcessorBase { } export interface AuditUsage extends SecurityFeatureToggle { - outputs: Array + outputs?: Array } export interface AuthenticateRequest extends RequestBase { @@ -680,24 +678,21 @@ export interface AutoDateHistogramAggregation extends BucketAggregationBase { } export interface AutoFollowPattern { - follow_index_pattern: string - leader_index_patterns: Array - max_outstanding_read_requests: long - max_outstanding_write_requests: integer - read_poll_timeout: Time - max_read_request_operation_count: integer - max_read_request_size: string - max_retry_delay: Time - max_write_buffer_count: integer - max_write_buffer_size: string - max_write_request_operation_count: integer - max_write_request_size: string + active: boolean remote_cluster: string + follow_index_pattern?: IndexPattern + leader_index_patterns: IndexPatterns + max_outstanding_read_requests: integer +} + +export interface AutoFollowPatternItem { + name: Name + pattern: AutoFollowPattern } export interface AutoFollowedCluster { - cluster_name: string - last_seen_metadata_version: long + cluster_name: Name + last_seen_metadata_version: VersionNumber time_since_last_check_millis: DateString } @@ -712,6 +707,10 @@ export interface BaseUrlConfig { url_value: string } +export interface BinaryProperty extends DocValuesPropertyBase { + type: 'binary' +} + export interface BoolQuery extends QueryBase { filter?: QueryContainer | Array minimum_should_match?: MinimumShouldMatch @@ -720,6 +719,14 @@ export interface BoolQuery extends QueryBase { should?: QueryContainer | Array } +export interface BooleanProperty extends DocValuesPropertyBase { + boost?: double + fielddata?: NumericFielddata + index?: boolean + null_value?: boolean + type: 'boolean' +} + export interface BoostingQuery extends QueryBase { negative_boost?: double negative?: QueryContainer @@ -856,7 +863,7 @@ export interface BulkOperation { _index: IndexName retry_on_conflict: integer routing: Routing - version: long + version: VersionNumber version_type: VersionType } @@ -878,7 +885,7 @@ export interface BulkRequest extends RequestBase { _source_includes?: Fields timeout?: Time type_query_string?: string - wait_for_active_shards?: string + wait_for_active_shards?: WaitForActiveShards require_alias?: boolean body: Array } @@ -897,10 +904,10 @@ export interface BulkResponseItemBase { error?: ErrorCause _primary_term?: long result?: string - _seq_no?: long + _seq_no?: SequenceNumber _shards?: ShardStatistics _type?: string - _version?: long + _version?: VersionNumber forced_refresh?: boolean get?: InlineGet> } @@ -1041,20 +1048,20 @@ export interface CatCountRequest extends CatRequestBase { export type CatCountResponse = CatCountRecord[] export interface CatDataFrameAnalyticsRecord { - id?: string - type?: string - t?: string + id?: Id + type?: Type + t?: Type create_time?: string ct?: string createTime?: string - version?: string - v?: string - source_index?: string - si?: string - sourceIndex?: string - dest_index?: string - di?: string - destIndex?: string + version?: VersionString + v?: VersionString + source_index?: IndexName + si?: IndexName + sourceIndex?: IndexName + dest_index?: IndexName + di?: IndexName + destIndex?: IndexName description?: string d?: string model_memory_limit?: string @@ -1070,15 +1077,15 @@ export interface CatDataFrameAnalyticsRecord { assignment_explanation?: string ae?: string assignmentExplanation?: string - 'node.id'?: string - ni?: string - nodeId?: string - 'node.name'?: string - nn?: string - nodeName?: string - 'node.ephemeral_id'?: string - ne?: string - nodeEphemeralId?: string + 'node.id'?: Id + ni?: Id + nodeId?: Id + 'node.name'?: Name + nn?: Name + nodeName?: Name + 'node.ephemeral_id'?: Id + ne?: Id + nodeEphemeralId?: Id 'node.address'?: string na?: string nodeAddress?: string @@ -1737,8 +1744,8 @@ export interface CatNodeAttributesRequest extends CatRequestBase { export type CatNodeAttributesResponse = CatNodeAttributesRecord[] export interface CatNodesRecord { - id?: string - nodeId?: string + id?: Id + nodeId?: Id pid?: string p?: string ip?: string @@ -1747,12 +1754,12 @@ export interface CatNodesRecord { po?: string http_address?: string http?: string - version?: string - v?: string + version?: VersionString + v?: VersionString flavor?: string f?: string - type?: string - t?: string + type?: Type + t?: Type build?: string b?: string jdk?: string @@ -1811,8 +1818,8 @@ export interface CatNodesRecord { nodeRole?: string master?: string m?: string - name?: string - n?: string + name?: Name + n?: Name 'completion.size'?: string cs?: string completionSize?: string @@ -2031,12 +2038,12 @@ export type CatPendingTasksResponse = CatPendingTasksRecord[] export interface CatPluginsRecord { id?: NodeId - name?: string - n?: string + name?: Name + n?: Name component?: string c?: string - version?: string - v?: string + version?: VersionString + v?: VersionString description?: string d?: string type?: Type @@ -2168,8 +2175,8 @@ export interface CatSegmentsRecord { searchable?: string is?: string isSearchable?: string - version?: string - v?: string + version?: VersionString + v?: VersionString compound?: string ico?: string isCompound?: string @@ -2445,15 +2452,15 @@ export interface CatSnapshotsRequest extends CatRequestBase { export type CatSnapshotsResponse = CatSnapshotsRecord[] export interface CatTasksRecord { - id?: string + id?: Id action?: string ac?: string - task_id?: string - ti?: string + task_id?: Id + ti?: Id parent_task_id?: string pti?: string - type?: string - ty?: string + type?: Type + ty?: Type start_time?: string start?: string timestamp?: string @@ -2463,16 +2470,16 @@ export interface CatTasksRecord { running_time_ns?: string running_time?: string time?: string - node_id?: string - ni?: string + node_id?: NodeId + ni?: NodeId ip?: string i?: string port?: string po?: string node?: string n?: string - version?: string - v?: string + version?: VersionString + v?: VersionString x_opaque_id?: string x?: string description?: string @@ -2489,15 +2496,15 @@ export interface CatTasksRequest extends CatRequestBase { export type CatTasksResponse = CatTasksRecord[] export interface CatTemplatesRecord { - name?: string - n?: string + name?: Name + n?: Name index_patterns?: string t?: string order?: string o?: string p?: string - version?: string - v?: string + version?: VersionString + v?: VersionString composed_of?: string c?: string } @@ -2559,7 +2566,7 @@ export interface CatThreadPoolRequest extends CatRequestBase { export type CatThreadPoolResponse = CatThreadPoolRecord[] export interface CatTrainedModelsRecord { - id?: string + id?: Id created_by?: string c?: string createdBy?: string @@ -2573,8 +2580,8 @@ export interface CatTrainedModelsRecord { l?: string create_time?: DateString ct?: DateString - version?: string - v?: string + version?: VersionString + v?: VersionString description?: string d?: string 'ingest.pipelines'?: string @@ -2617,7 +2624,7 @@ export interface CatTrainedModelsRequest extends CatRequestBase { export type CatTrainedModelsResponse = CatTrainedModelsRecord[] export interface CatTransformsRecord { - id?: string + id?: Id state?: string s?: string checkpoint?: string @@ -2636,8 +2643,8 @@ export interface CatTransformsRecord { create_time?: string ct?: string createTime?: string - version?: string - v?: string + version?: VersionString + v?: VersionString source_index?: string si?: string sourceIndex?: string @@ -2765,7 +2772,7 @@ export type CharFilter = HtmlStripCharFilter | MappingCharFilter | PatternReplac export interface CharFilterBase { type: string - version?: string + version?: VersionString } export interface CharFilterDetail { @@ -2840,7 +2847,7 @@ export interface ClearApiKeyCacheNode { } export interface ClearApiKeyCacheRequest extends RequestBase { - ids?: string + ids?: Ids } export interface ClearApiKeyCacheResponse extends ResponseBase { @@ -2863,6 +2870,20 @@ export interface ClearCacheRequest extends RequestBase { export interface ClearCacheResponse extends ShardsOperationResponseBase { } +export interface ClearCachedPrivilegeNode { + name: Name +} + +export interface ClearCachedPrivilegesRequest extends RequestBase { + application: Name +} + +export interface ClearCachedPrivilegesResponse extends ResponseBase { + _nodes: NodeStatistics + cluster_name: Name + nodes: Record +} + export interface ClearCachedRealmsRequest extends RequestBase { realms: Names usernames?: Array @@ -2909,7 +2930,7 @@ export interface CloneIndexRequest extends RequestBase { target: Name master_timeout?: Time timeout?: Time - wait_for_active_shards?: string | number + wait_for_active_shards?: WaitForActiveShards body?: { aliases?: Record settings?: Record @@ -2942,7 +2963,7 @@ export interface CloseIndexRequest extends RequestBase { ignore_unavailable?: boolean master_timeout?: Time timeout?: Time - wait_for_active_shards?: string + wait_for_active_shards?: WaitForActiveShards } export interface CloseIndexResponse extends AcknowledgedResponseBase { @@ -3041,15 +3062,12 @@ export interface ClusterComponentTemplateExistsResponse extends ResponseBase { } export interface ClusterDeleteComponentTemplateRequest extends RequestBase { - stub_a: string - stub_b: string - body?: { - stub_c: string - } + name: Name + master_timeout?: Time + timeout?: Time } -export interface ClusterDeleteComponentTemplateResponse extends ResponseBase { - stub: integer +export interface ClusterDeleteComponentTemplateResponse extends AcknowledgedResponseBase { } export interface ClusterDeleteVotingConfigExclusionsRequest extends RequestBase { @@ -3071,11 +3089,10 @@ export interface ClusterFileSystem { } export interface ClusterGetComponentTemplateRequest extends RequestBase { - stub_a: string - stub_b: string - body?: { - stub_c: string - } + name?: Name + flat_settings?: boolean + local?: boolean + master_timeout?: Time } export interface ClusterGetComponentTemplateResponse extends ResponseBase { @@ -3184,10 +3201,10 @@ export interface ClusterJvmVersion { bundled_jdk: boolean count: integer using_bundled_jdk: boolean - version: string + version: VersionString vm_name: string vm_vendor: string - vm_version: string + vm_version: VersionString } export interface ClusterNetworkTypes { @@ -3203,6 +3220,7 @@ export interface ClusterNodeCount { total: integer voting_only: integer data_cold: integer + data_frozen?: integer data_content: integer data_warm: integer data_hot: integer @@ -3225,12 +3243,17 @@ export interface ClusterNodesStats { versions: Array } +export interface ClusterOperatingSystemArchitecture { + count: integer + arch: string +} + export interface ClusterOperatingSystemName { count: integer name: string } -export interface ClusterOperatingSystemPrettyNane { +export interface ClusterOperatingSystemPrettyName { count: integer pretty_name: string } @@ -3240,7 +3263,8 @@ export interface ClusterOperatingSystemStats { available_processors: integer mem: OperatingSystemMemoryInfo names: Array - pretty_names: Array + pretty_names: Array + architectures?: Array } export interface ClusterPendingTasksRequest extends RequestBase { @@ -3253,11 +3277,10 @@ export interface ClusterPendingTasksResponse extends ResponseBase { } export interface ClusterPostVotingConfigExclusionsRequest extends RequestBase { - stub_a: string - stub_b: string - body?: { - stub_c: string - } + node_names?: Names + node_ids?: Ids + timeout?: Time + wait_for_removal?: boolean } export interface ClusterPostVotingConfigExclusionsResponse extends ResponseBase { @@ -3374,11 +3397,11 @@ export interface ClusterStateBlockIndex { retryable: boolean levels: Array aliases?: Array - aliases_version?: integer - version?: integer - mapping_version?: integer - settings_version?: integer - routing_num_shards?: integer + aliases_version?: VersionNumber + version?: VersionNumber + mapping_version?: VersionNumber + settings_version?: VersionNumber + routing_num_shards?: VersionNumber state?: string } @@ -3418,7 +3441,7 @@ export interface ClusterStateRequest extends RequestBase { ignore_unavailable?: boolean local?: boolean master_timeout?: Time - wait_for_metadata_version?: long + wait_for_metadata_version?: VersionNumber wait_for_timeout?: Time } @@ -3428,7 +3451,7 @@ export interface ClusterStateResponse extends ResponseBase { master_node?: string state?: Array state_uuid?: Uuid - version?: integer + version?: VersionNumber blocks?: ClusterStateBlocks metadata?: ClusterStateMetadata } @@ -3446,12 +3469,13 @@ export interface ClusterStatsRequest extends RequestBase { } export interface ClusterStatsResponse extends NodesResponseBase { - cluster_name: string - cluster_uuid: string + cluster_name: Name + cluster_uuid: Uuid indices: ClusterIndicesStats nodes: ClusterNodesStats status: ClusterStatus timestamp: long + _nodes: NodeStatistics } export type ClusterStatus = 'green' | 'yellow' | 'red' @@ -3489,6 +3513,16 @@ export interface CompareCondition { value: any } +export interface CompletionProperty extends DocValuesPropertyBase { + analyzer?: string + contexts?: Array + max_input_length?: integer + preserve_position_increments?: boolean + preserve_separators?: boolean + search_analyzer?: string + type: 'completion' +} + export interface CompletionStats { size_in_bytes: long fields?: Record @@ -3568,6 +3602,11 @@ export type Conflicts = 'abort' | 'proceed' export type ConnectionScheme = 'http' | 'https' +export interface ConstantKeywordProperty extends PropertyBase { + value?: any + type: 'constant_keyword' +} + export interface ConstantScoreQuery extends QueryBase { filter?: QueryContainer boost?: float @@ -3592,6 +3631,14 @@ export interface CoordinatorStats { remote_requests_total: long } +export type CoreProperty = ObjectProperty | NestedProperty | SearchAsYouTypeProperty | TextProperty | DocValuesProperty + +export interface CorePropertyBase extends PropertyBase { + copy_to?: Fields + similarity?: string + store?: boolean +} + export interface CountRequest extends RequestBase { index?: Indices type?: Types @@ -3636,31 +3683,9 @@ export interface CreateApiKeyResponse extends ResponseBase { name: string } -export interface CreateAutoFollowPatternRequest extends RequestBase { - name: Name - body: { - follow_index_pattern?: string - leader_index_patterns?: Array - max_outstanding_read_requests?: long - max_outstanding_write_requests?: integer - max_poll_timeout?: Time - max_read_request_operation_count?: integer - max_read_request_size?: string - max_retry_delay?: Time - max_write_buffer_count?: integer - max_write_buffer_size?: string - max_write_request_operation_count?: integer - max_write_request_size?: string - remote_cluster?: string - } -} - -export interface CreateAutoFollowPatternResponse extends AcknowledgedResponseBase { -} - export interface CreateFollowIndexRequest extends RequestBase { index: IndexName - wait_for_active_shards?: string + wait_for_active_shards?: WaitForActiveShards body: { leader_index?: IndexName max_outstanding_read_requests?: long @@ -3688,7 +3713,7 @@ export interface CreateIndexRequest extends RequestBase { include_type_name?: boolean master_timeout?: Time timeout?: Time - wait_for_active_shards?: string + wait_for_active_shards?: WaitForActiveShards body?: { aliases?: Record mappings?: Record | TypeMapping @@ -3724,9 +3749,9 @@ export interface CreateRequest extends RequestBase { refresh?: Refresh routing?: Routing timeout?: Time - version?: long + version?: VersionNumber version_type?: VersionType - wait_for_active_shards?: string + wait_for_active_shards?: WaitForActiveShards body: TDocument } @@ -3831,6 +3856,42 @@ export interface DataPathStats { type: string } +export type DataStreamName = string + +export interface DataStreamsStatsItem { + backing_indices: integer + data_stream: Name + store_size?: ByteSize + store_size_bytes: integer + maximum_timestamp: integer +} + +export interface DataStreamsUsage extends XPackUsage { + data_streams: long + indices_count: long +} + +export interface DataTierPhaseCountUsage { + node_count: long + index_count: long + total_shard_count: long + primary_shard_count: long + doc_count: long + total_size_bytes: long + primary_size_bytes: long + primary_shard_size_avg_bytes: long + primary_shard_size_median_bytes: long + primary_shard_size_mad_bytes: long +} + +export interface DataTiersUsage extends XPackUsage { + data_warm: DataTierPhaseCountUsage + data_frozen?: DataTierPhaseCountUsage + data_cold: DataTierPhaseCountUsage + data_content: DataTierPhaseCountUsage + data_hot: DataTierPhaseCountUsage +} + export interface Datafeed { aggregations?: Record aggs?: Record @@ -3934,6 +3995,16 @@ export type DateMath = string export type DateMathTime = string +export interface DateNanosProperty extends DocValuesPropertyBase { + boost?: double + format?: string + ignore_malformed?: boolean + index?: boolean + null_value?: DateString + precision_step?: integer + type: 'date_nanos' +} + export interface DateProcessor extends ProcessorBase { field: Field formats: Array @@ -3942,6 +4013,17 @@ export interface DateProcessor extends ProcessorBase { timezone: string } +export interface DateProperty extends DocValuesPropertyBase { + boost?: double + fielddata?: NumericFielddata + format?: string + ignore_malformed?: boolean + index?: boolean + null_value?: DateString + precision_step?: integer + type: 'date' +} + export interface DateRangeAggregation extends BucketAggregationBase { field?: Field format?: string @@ -3953,11 +4035,17 @@ export interface DateRangeAggregation extends BucketAggregationBase { export interface DateRangeExpression { from?: DateMath | float from_as_string?: string + to_as_string?: string key?: string to?: DateMath | float doc_count?: long } +export interface DateRangeProperty extends RangePropertyBase { + format?: string + type: 'date_range' +} + export type DateRounding = 's' | 'm' | 'h' | 'd' | 'w' | 'M' | 'y' export type DateString = string @@ -4047,6 +4135,7 @@ export interface DeleteByQueryRequest extends RequestBase { request_cache?: boolean requests_per_second?: long routing?: Routing + q?: string scroll?: Time scroll_size?: long search_timeout?: Time @@ -4061,7 +4150,7 @@ export interface DeleteByQueryRequest extends RequestBase { terminate_after?: long timeout?: Time version?: boolean - wait_for_active_shards?: string + wait_for_active_shards?: WaitForActiveShards wait_for_completion?: boolean body: { max_docs?: long @@ -4149,6 +4238,13 @@ export interface DeleteEnrichPolicyResponse extends AcknowledgedResponseBase { } export interface DeleteExpiredDataRequest extends RequestBase { + name?: Name + requests_per_second?: float + timeout?: Time + body?: { + requests_per_second?: float + timeout?: Time + } } export interface DeleteExpiredDataResponse extends ResponseBase { @@ -4256,13 +4352,13 @@ export interface DeleteRequest extends RequestBase { index: IndexName type?: Type if_primary_term?: long - if_seq_no?: long + if_seq_no?: SequenceNumber refresh?: Refresh routing?: Routing timeout?: Time - version?: long + version?: VersionNumber version_type?: VersionType - wait_for_active_shards?: string + wait_for_active_shards?: WaitForActiveShards } export interface DeleteResponse extends WriteResponseBase { @@ -4319,6 +4415,21 @@ export interface DeleteSnapshotRequest extends RequestBase { export interface DeleteSnapshotResponse extends AcknowledgedResponseBase { } +export interface DeleteTrainedModelAliasRequest extends RequestBase { + model_alias: Alias + model_id: Id +} + +export interface DeleteTrainedModelAliasResponse extends AcknowledgedResponseBase { +} + +export interface DeleteTrainedModelRequest extends RequestBase { + model_id: Id +} + +export interface DeleteTrainedModelResponse extends AcknowledgedResponseBase { +} + export interface DeleteTransformRequest extends RequestBase { transform_id: Name force?: boolean @@ -4342,8 +4453,8 @@ export interface DeleteWatchRequest extends RequestBase { export interface DeleteWatchResponse extends ResponseBase { found: boolean - _id: string - _version: integer + _id: Id + _version: VersionNumber } export type DelimitedPayloadEncoding = 'int' | 'float' | 'identity' @@ -4479,6 +4590,12 @@ export interface DocValueField { format?: string } +export type DocValuesProperty = BinaryProperty | BooleanProperty | DateProperty | DateNanosProperty | KeywordProperty | NumberProperty | RangeProperty | GeoPointProperty | GeoShapeProperty | CompletionProperty | GenericProperty | IpProperty | Murmur3HashProperty | ShapeProperty | TokenCountProperty | VersionProperty | WildcardProperty | PointProperty + +export interface DocValuesPropertyBase extends CorePropertyBase { + doc_values?: boolean +} + export interface DocumentExistsRequest extends RequestBase { id: Id index: IndexName @@ -4491,7 +4608,7 @@ export interface DocumentExistsRequest extends RequestBase { source_excludes?: Fields source_includes?: Fields stored_fields?: Fields - version?: long + version?: VersionNumber version_type?: VersionType } @@ -4504,7 +4621,7 @@ export interface DocumentSimulation { _parent?: string _routing?: string _source: Record - _type: Type + _type?: Type } export interface DotExpanderProcessor extends ProcessorBase { @@ -4512,10 +4629,14 @@ export interface DotExpanderProcessor extends ProcessorBase { path?: string } +export interface DoubleRangeProperty extends RangePropertyBase { + type: 'double_range' +} + export interface DropProcessor extends ProcessorBase { } -export type DynamicMapping = 'strict' +export type DynamicMapping = 'strict' | 'runtime' | 'true' | 'false' export interface DynamicTemplate { mapping?: PropertyBase @@ -4548,9 +4669,9 @@ export interface ElasticsearchVersionInfo { build_hash: string build_snapshot: boolean build_type: string - lucene_version: string - minimum_index_compatibility_version: string - minimum_wire_compatibility_version: string + lucene_version: VersionString + minimum_index_compatibility_version: VersionString + minimum_wire_compatibility_version: VersionString number: string } @@ -4626,51 +4747,136 @@ export interface EnrichStatsResponse extends ResponseBase { export type EpochMillis = string | long export interface EqlDeleteRequest extends RequestBase { - stub_a: string - stub_b: string - body?: { - stub_c: string - } + id: Id } -export interface EqlDeleteResponse extends ResponseBase { - stub: integer +export interface EqlDeleteResponse extends AcknowledgedResponseBase { +} + +export interface EqlFeaturesJoinUsage { + join_queries_two: uint + join_queries_three: uint + join_until: uint + join_queries_five_or_more: uint + join_queries_four: uint +} + +export interface EqlFeaturesKeysUsage { + join_keys_two: uint + join_keys_one: uint + join_keys_three: uint + join_keys_five_or_more: uint + join_keys_four: uint +} + +export interface EqlFeaturesPipesUsage { + pipe_tail: uint + pipe_head: uint +} + +export interface EqlFeaturesSequencesUsage { + sequence_queries_three: uint + sequence_queries_four: uint + sequence_queries_two: uint + sequence_until: uint + sequence_queries_five_or_more: uint + sequence_maxspan: uint +} + +export interface EqlFeaturesUsage { + join: uint + joins: EqlFeaturesJoinUsage + keys: EqlFeaturesKeysUsage + event: uint + pipes: EqlFeaturesPipesUsage + sequence: uint + sequences: EqlFeaturesSequencesUsage } export interface EqlGetRequest extends RequestBase { - stub_a: string - stub_b: string - body?: { - stub_c: string - } + id: Id + keep_alive?: Time + wait_for_completion_timeout?: Time } -export interface EqlGetResponse extends ResponseBase { - stub: integer +export interface EqlGetResponse extends EqlSearchResponseBase { } export interface EqlGetStatusRequest extends RequestBase { - stub_a: string - stub_b: string - body?: { - stub_c: string - } + id: Id } export interface EqlGetStatusResponse extends ResponseBase { - stub: integer + id: Id + is_partial: boolean + is_running: boolean + start_time_in_millis?: EpochMillis + expiration_time_in_millis?: EpochMillis + completion_status?: integer +} + +export interface EqlHits { + total?: TotalHits + events?: Array> + sequences?: Array> +} + +export interface EqlHitsEvent { + _index: IndexName + _id: Id + _source: TEvent + fields?: Record> +} + +export interface EqlHitsSequence { + events: Array> + join_keys: Array +} + +export interface EqlSearchFieldFormatted { + field: Field + format: string } export interface EqlSearchRequest extends RequestBase { - stub_a: string - stub_b: string + index: IndexName + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcards + ignore_unavailable?: boolean + keep_alive?: Time + keep_on_completion?: boolean + wait_for_completion_timeout?: Time body: { - stub_c: string + query: string + case_sensitive?: boolean + event_category_field?: Field + tiebreaker_field?: Field + timestamp_field?: Field + fetch_size?: uint + filter?: QueryContainer | Array + keep_alive?: Time + keep_on_completion?: boolean + wait_for_completion_timeout?: Time + size?: integer | float + fields?: Array } } -export interface EqlSearchResponse extends ResponseBase { - stub: integer +export interface EqlSearchResponse extends EqlSearchResponseBase { +} + +export interface EqlSearchResponseBase extends ResponseBase { + id?: Id + is_partial?: boolean + is_running?: boolean + took?: integer + timed_out?: boolean + hits: EqlHits +} + +export interface EqlUsage extends XPackUsage { + features: EqlFeaturesUsage + queries: Record } export interface ErrorCause { @@ -4679,6 +4885,7 @@ export interface ErrorCause { caused_by?: ErrorCause shard?: integer | string stack_trace?: string + root_cause?: Array bytes_limit?: long bytes_wanted?: long column?: integer @@ -4694,8 +4901,8 @@ export interface ErrorCause { phase?: string property_name?: string processor_type?: string - resource_id?: Array - 'resource.id'?: Id + resource_id?: Ids + 'resource.id'?: Ids resource_type?: string 'resource.type'?: string script?: string @@ -4792,11 +4999,6 @@ export interface ExecutingPolicy { task: TaskInfo } -export interface ExecutionAction { - total: long - total_in_ms: long -} - export type ExecutionPhase = 'awaits_execution' | 'started' | 'input' | 'condition' | 'actions' | 'watch_transform' | 'aborted' | 'finished' export interface ExecutionResult { @@ -4896,7 +5098,7 @@ export interface ExplainRequest extends RequestBase { export interface ExplainResponse extends ResponseBase { _index: IndexName - _type?: TypeName + _type?: Type _id: Id matched: boolean explanation?: ExplanationDetail @@ -4950,6 +5152,11 @@ export interface FailProcessor extends ProcessorBase { export type Field = string +export interface FieldAliasProperty extends PropertyBase { + path?: Field + type: 'alias' +} + export interface FieldCapabilities { aggregatable: boolean indices?: Indices @@ -5062,6 +5269,7 @@ export type FieldType = 'none' | 'geo_point' | 'geo_shape' | 'ip' | 'binary' | ' export interface FieldTypesMappings { field_types: Array + runtime_field_types?: Array } export interface FieldTypesStats { @@ -5079,6 +5287,12 @@ export interface FieldValueFactorScoreFunction extends ScoreFunctionBase { modifier?: FieldValueFactorModifier } +export interface FielddataFrequencyFilter { + max: double + min: double + min_segment_size: integer +} + export interface FielddataStats { evictions?: long memory_size_in_bytes: long @@ -5171,10 +5385,27 @@ export interface FingerprintTokenFilter extends TokenFilterBase { separator: string } +export interface FlattenedProperty extends PropertyBase { + boost?: double + depth_limit?: integer + doc_values?: boolean + eager_global_ordinals?: boolean + index?: boolean + index_options?: IndexOptions + null_value?: string + similarity?: string + split_queries_on_whitespace?: boolean + type: 'flattened' +} + export interface FlattenedUsage extends XPackUsage { field_count: integer } +export interface FloatRangeProperty extends RangePropertyBase { + type: 'float_range' +} + export interface FlushJobRequest extends RequestBase { job_id: Id skip_time?: string @@ -5188,6 +5419,7 @@ export interface FlushJobRequest extends RequestBase { export interface FlushJobResponse extends ResponseBase { flushed: boolean + last_finalized_bucket_end?: integer } export interface FlushRequest extends RequestBase { @@ -5224,7 +5456,7 @@ export interface FollowConfig { export interface FollowIndexReadException { exception: ErrorCause - from_seq_no: long + from_seq_no: SequenceNumber retries: integer } @@ -5232,17 +5464,17 @@ export interface FollowIndexShardStats { bytes_read: long failed_read_requests: long failed_write_requests: long - fatal_exception: ErrorCause - follower_aliases_version: long + fatal_exception?: ErrorCause + follower_aliases_version: VersionNumber follower_global_checkpoint: long follower_index: string - follower_mapping_version: long - follower_max_seq_no: long - follower_settings_version: long - last_requested_seq_no: long + follower_mapping_version: VersionNumber + follower_max_seq_no: SequenceNumber + follower_settings_version: VersionNumber + last_requested_seq_no: SequenceNumber leader_global_checkpoint: long leader_index: string - leader_max_seq_no: long + leader_max_seq_no: SequenceNumber operations_read: long operations_written: long outstanding_read_requests: integer @@ -5252,16 +5484,16 @@ export interface FollowIndexShardStats { shard_id: integer successful_read_requests: long successful_write_requests: long - time_since_last_read_millis: long - total_read_remote_exec_time_millis: long - total_read_time_millis: long - total_write_time_millis: long + time_since_last_read_millis: EpochMillis + total_read_remote_exec_time_millis: EpochMillis + total_read_time_millis: EpochMillis + total_write_time_millis: EpochMillis write_buffer_operation_count: long - write_buffer_size_in_bytes: long + write_buffer_size_in_bytes: ByteSize } export interface FollowIndexStats { - index: string + index: IndexName shards: Array } @@ -5284,10 +5516,10 @@ export interface FollowInfoResponse extends ResponseBase { export type FollowerIndexStatus = 'active' | 'paused' export interface FollowerInfo { - follower_index: string - leader_index: string - parameters: FollowConfig - remote_cluster: string + follower_index: IndexName + leader_index: IndexName + parameters?: FollowConfig + remote_cluster: Name status: FollowerIndexStatus } @@ -5355,13 +5587,17 @@ export interface FreezeIndexRequest extends RequestBase { ignore_unavailable?: boolean master_timeout?: Time timeout?: Time - wait_for_active_shards?: string | number + wait_for_active_shards?: WaitForActiveShards } export interface FreezeIndexResponse extends AcknowledgedResponseBase { shards_acknowledged: boolean } +export interface FrozenIndicesUsage extends XPackUsage { + indices_count: long +} + export type FunctionBoostMode = 'multiply' | 'replace' | 'sum' | 'avg' | 'max' | 'min' export interface FunctionScoreContainer { @@ -5410,6 +5646,21 @@ export interface GarbageCollectionStats { collectors: Record } +export interface GenericProperty extends DocValuesPropertyBase { + analyzer: string + boost: double + fielddata: StringFielddata + ignore_malformed: boolean + index: boolean + index_options: IndexOptions + norms: boolean + null_value: string + position_increment_gap: integer + search_analyzer: string + term_vector: TermVectorOption + type: string +} + export interface GeoBoundingBoxQuery extends QueryBase { bounding_box?: BoundingBox type?: GeoExecution @@ -5522,6 +5773,15 @@ export interface GeoLineSort { export type GeoLocation = string | Array | TwoDimensionalPoint +export type GeoOrientation = 'right' | 'counterclockwise' | 'ccw' | 'left' | 'clockwise' | 'cw' + +export interface GeoPointProperty extends DocValuesPropertyBase { + ignore_malformed?: boolean + ignore_z_value?: boolean + null_value?: GeoLocation + type: 'geo_point' +} + export interface GeoPolygonQuery extends QueryBase { points?: Array validation_method?: GeoValidationMethod @@ -5531,6 +5791,15 @@ export interface GeoShape { type?: string } +export interface GeoShapeProperty extends DocValuesPropertyBase { + coerce?: boolean + ignore_malformed?: boolean + ignore_z_value?: boolean + orientation?: GeoOrientation + strategy?: GeoStrategy + type: 'geo_shape' +} + export interface GeoShapeQuery extends QueryBase { ignore_unmapped?: boolean indexed_shape?: FieldLookup @@ -5540,6 +5809,8 @@ export interface GeoShapeQuery extends QueryBase { export type GeoShapeRelation = 'intersects' | 'disjoint' | 'within' | 'contains' +export type GeoStrategy = 'recursive' | 'term' + export interface GeoTileGridAggregation extends BucketAggregationBase { field?: Field precision?: GeoTilePrecision @@ -5598,7 +5869,7 @@ export interface GetAutoFollowPatternRequest extends RequestBase { } export interface GetAutoFollowPatternResponse extends ResponseBase { - patterns: Record + patterns: Array } export interface GetAutoscalingCapacityRequest extends RequestBase { @@ -5929,6 +6200,7 @@ export interface GetOverallBucketsResponse extends ResponseBase { export interface GetPipelineRequest extends RequestBase { id?: Id master_timeout?: Time + summary?: boolean } export interface GetPipelineResponse extends DictionaryResponseBase { @@ -5963,22 +6235,22 @@ export interface GetRequest extends RequestBase { _source_excludes?: Fields _source_includes?: Fields stored_fields?: Fields - version?: long + version?: VersionNumber version_type?: VersionType _source?: boolean | string | Array } export interface GetResponse extends ResponseBase { - _index: string + _index: IndexName fields?: Record found: boolean - _id: string + _id: Id _primary_term?: long _routing?: string - _seq_no?: long + _seq_no?: SequenceNumber _source?: TDocument - _type: string - _version?: long + _type: Type + _version?: VersionNumber } export interface GetRoleMappingRequest extends RequestBase { @@ -6067,7 +6339,8 @@ export interface GetSnapshotRequest extends RequestBase { } export interface GetSnapshotResponse extends ResponseBase { - snapshots: Array + responses?: Array + snapshots?: Array } export interface GetStats { @@ -6093,6 +6366,7 @@ export interface GetTaskResponse extends ResponseBase { completed: boolean task: TaskInfo response?: TaskStatus + error?: ErrorCause } export interface GetTransformRequest extends RequestBase { @@ -6100,6 +6374,7 @@ export interface GetTransformRequest extends RequestBase { allow_no_match?: boolean from?: integer size?: integer + exclude_generated?: boolean } export interface GetTransformResponse extends ResponseBase { @@ -6175,8 +6450,8 @@ export interface GetWatchResponse extends ResponseBase { status?: WatchStatus watch?: Watch _primary_term?: integer - _seq_no?: integer - _version?: integer + _seq_no?: SequenceNumber + _version?: VersionNumber } export interface GlobalAggregation extends BucketAggregationBase { @@ -6216,7 +6491,7 @@ export interface GraphConnection { export interface GraphExploreControls { sample_diversity?: SampleDiversity - sample_size: integer + sample_size?: integer timeout?: Time use_significance: boolean } @@ -6413,6 +6688,11 @@ export interface HistogramOrder { _key?: SortOrder } +export interface HistogramProperty extends PropertyBase { + ignore_malformed?: boolean + type: 'histogram' +} + export interface HistogramRollupGrouping { fields: Fields interval: long @@ -6434,9 +6714,9 @@ export interface Hit { _node?: string _routing?: string _source?: TDocument - _seq_no?: long + _seq_no?: SequenceNumber _primary_term?: long - _version?: long + _version?: VersionNumber sort?: SortResults } @@ -6583,16 +6863,38 @@ export interface IndexActionResultIndexResponse { id: Id index: IndexName result: Result - version: integer + version: VersionNumber type?: Type } +export interface IndexAddBlockRequest extends RequestBase { + index: IndexName + block: IndexBlockOptions + allow_no_indices?: boolean + expand_wildcards?: ExpandWildcardOptions + ignore_unavailable?: boolean + master_timeout?: Time + timeout?: Time +} + +export interface IndexAddBlockResponse extends AcknowledgedResponseBase { + shards_acknowledged: boolean + indices: Array +} + export type IndexAlias = string export interface IndexAliases { aliases: Record } +export type IndexBlockOptions = 'metadata' | 'read' | 'read_only' | 'write' + +export interface IndexBlockStatus { + name: IndexName + blocked: boolean +} + export interface IndexExistsRequest extends RequestBase { index: Indices allow_no_indices?: boolean @@ -6628,6 +6930,12 @@ export interface IndexMappings { export type IndexName = string +export type IndexOptions = 'docs' | 'freqs' | 'positions' | 'offsets' + +export type IndexPattern = string + +export type IndexPatterns = Array + export interface IndexPrivilegesCheck { names: Array privileges: Array @@ -6638,15 +6946,15 @@ export interface IndexRequest extends RequestBase { index: IndexName type?: Type if_primary_term?: long - if_seq_no?: long + if_seq_no?: SequenceNumber op_type?: OpType pipeline?: string refresh?: Refresh routing?: Routing timeout?: Time - version?: long + version?: VersionNumber version_type?: VersionType - wait_for_active_shards?: string + wait_for_active_shards?: WaitForActiveShards require_alias?: boolean body: TDocument } @@ -6717,6 +7025,56 @@ export interface IndexingStats { export type Indices = string | Array +export interface IndicesCreateDataStreamRequest extends RequestBase { + stub_a: integer + stub_b: integer + body?: { + stub_c: integer + } +} + +export interface IndicesCreateDataStreamResponse extends ResponseBase { + stub: integer +} + +export interface IndicesDataStreamsStatsRequest extends RequestBase { + name?: IndexName + expand_wildcards?: ExpandWildcardOptions + human?: boolean +} + +export interface IndicesDataStreamsStatsResponse extends ResponseBase { + _shards: ShardStatistics + backing_indices: integer + data_stream_count: integer + total_store_sizes?: ByteSize + total_store_size_bytes: integer + data_streams: Array +} + +export interface IndicesDeleteDataStreamRequest extends RequestBase { + name: DataStreamName +} + +export interface IndicesDeleteDataStreamResponse extends AcknowledgedResponseBase { +} + +export interface IndicesGetDataStreamRequest extends RequestBase { + name?: IndexName + expand_wildcards?: ExpandWildcardOptions +} + +export interface IndicesGetDataStreamResponse extends ResponseBase { + stub: integer +} + +export interface IndicesMigrateToDataStreamRequest extends RequestBase { + name: IndexName +} + +export interface IndicesMigrateToDataStreamResponse extends AcknowledgedResponseBase { +} + export interface IndicesOptions { allow_no_indices: boolean expand_wildcards: ExpandWildcards @@ -6731,6 +7089,14 @@ export interface IndicesPrivileges { allow_restricted_indices?: boolean } +export interface IndicesPromoteDataStreamRequest extends RequestBase { + name: IndexName +} + +export interface IndicesPromoteDataStreamResponse extends ResponseBase { + stub: integer +} + export interface IndicesResponseBase extends AcknowledgedResponseBase { _shards?: ShardStatistics } @@ -6783,7 +7149,7 @@ export interface IndicesVersionsStats { index_count: integer primary_shard_count: integer total_primary_bytes: long - version: string + version: VersionString } export interface InferenceAggregation extends PipelineAggregationBase { @@ -6832,18 +7198,27 @@ export interface IngestStats { export interface InlineGet { fields?: Record found: boolean - _seq_no: long + _seq_no: SequenceNumber _primary_term: long _routing?: Routing _source: TDocument } +export interface InlineRoleTemplate { + template: InlineRoleTemplateSource + format?: RoleTemplateFormat +} + +export interface InlineRoleTemplateSource { + source: string +} + export interface InlineScript extends ScriptBase { source: string } export interface InnerHits { - name?: string + name?: Name size?: integer from?: integer collapse?: FieldCollapse @@ -6878,6 +7253,10 @@ export interface InputContainer { export type InputType = 'http' | 'search' | 'simple' +export interface IntegerRangeProperty extends RangePropertyBase { + type: 'integer_range' +} + export interface Interval extends ScheduleBase { factor: long unit: IntervalUnit @@ -6957,6 +7336,11 @@ export interface IntervalsWildcard { use_field?: Field } +export interface InvalidRoleTemplate { + template: string + format?: RoleTemplateFormat +} + export interface InvalidateApiKeyRequest extends RequestBase { body: { id?: string @@ -6996,6 +7380,13 @@ export interface IpFilterUsage { transport: boolean } +export interface IpProperty extends DocValuesPropertyBase { + boost?: double + index?: boolean + null_value?: string + type: 'ip' +} + export interface IpRangeAggregation extends BucketAggregationBase { field?: Field ranges?: Array @@ -7012,27 +7403,36 @@ export interface IpRangeBucketKeys { export type IpRangeBucket = IpRangeBucketKeys | { [property: string]: Aggregate } +export interface IpRangeProperty extends RangePropertyBase { + type: 'ip_range' +} + export interface Job { allow_lazy_open?: boolean - analysis_config: AnalysisConfig + analysis_config?: AnalysisConfig analysis_limits?: AnalysisLimits - background_persist_interval: Time - create_time: integer - data_description: DataDescription - description: string - finished_time: integer - job_id: string - job_type: string - model_plot: ModelPlotConfig - model_snapshot_id: string - model_snapshot_retention_days: long - renormalization_window_days: long + background_persist_interval?: Time + count: integer + created_by: EmptyObject + create_time?: integer + detectors?: JobStatistics + data_description?: DataDescription + description?: string + finished_time?: integer + forecasts: MlJobForecasts + job_id?: Id + job_type?: string + model_plot?: ModelPlotConfig + model_size?: JobStatistics + model_snapshot_id?: Id + model_snapshot_retention_days?: long + renormalization_window_days?: long results_index_name?: IndexName - results_retention_days: long - groups: Array + results_retention_days?: long + groups?: Array model_plot_config?: ModelPlotConfig custom_settings?: CustomSettings - job_version?: string + job_version?: VersionString deleting?: boolean daily_model_snapshot_retention_after_days?: long } @@ -7073,6 +7473,11 @@ export interface JoinProcessor extends ProcessorBase { target_field?: Field } +export interface JoinProperty extends PropertyBase { + relations?: Record> + type: 'join' +} + export interface JsonProcessor extends ProcessorBase { add_to_root: boolean field: Field @@ -7139,6 +7544,18 @@ export interface KeywordMarkerTokenFilter extends TokenFilterBase { keywords_pattern: string } +export interface KeywordProperty extends DocValuesPropertyBase { + boost?: double + eager_global_ordinals?: boolean + index?: boolean + index_options?: IndexOptions + normalizer?: string + norms?: boolean + null_value?: string + split_queries_on_whitespace?: boolean + type: 'keyword' +} + export interface KeywordTokenizer extends TokenizerBase { buffer_size: integer } @@ -7207,21 +7624,28 @@ export interface LifecycleAction { } export interface LifecycleExplain { - action: string - action_time_millis: DateString + action: Name + action_time_millis: EpochMillis age: Time - failed_step: string - failed_step_retry_count: integer + failed_step?: Name + failed_step_retry_count?: integer index: IndexName - is_auto_retryable_error: boolean - lifecycle_date_millis: DateString + is_auto_retryable_error?: boolean + lifecycle_date_millis: EpochMillis managed: boolean - phase: string - phase_time_millis: DateString - policy: string - step: string - step_info: Record - step_time_millis: DateString + phase: Name + phase_time_millis: EpochMillis + policy: Name + step: Name + step_info?: Record + step_time_millis: EpochMillis + phase_execution: LifecycleExplainPhaseExecution +} + +export interface LifecycleExplainPhaseExecution { + policy: Name + version: VersionNumber + modified_date_in_millis: EpochMillis } export interface LifecycleExplainProject { @@ -7238,7 +7662,7 @@ export type LifecycleOperationMode = 'RUNNING' | 'STOPPING' | 'STOPPED' export interface LifecyclePolicy { modified_date: DateString policy: Policy - version: integer + version: VersionNumber } export type Like = string | LikeDocument @@ -7286,7 +7710,7 @@ export interface ListDanglingIndicesResponse extends ResponseBase { } export interface ListTasksRequest extends RequestBase { - actions?: string + actions?: string | Array detailed?: boolean group_by?: GroupBy nodes?: Array @@ -7341,6 +7765,10 @@ export interface LogstashPutPipelineResponse extends ResponseBase { stub: integer } +export interface LongRangeProperty extends RangePropertyBase { + type: 'long_range' +} + export interface LowercaseProcessor extends ProcessorBase { field: Field ignore_missing?: boolean @@ -7367,6 +7795,8 @@ export interface MachineLearningUsage extends XPackUsage { datafeeds: Record jobs: Record node_count: integer + data_frame_analytics_jobs: MlDataFrameAnalyticsJobsUsage + inference: MlInferenceUsage } export interface MainError extends ErrorCause { @@ -7513,7 +7943,7 @@ export interface MinBucketAggregation extends PipelineAggregationBase { } export interface MinimalLicenseInformation { - expiry_date_in_millis: long + expiry_date_in_millis: EpochMillis mode: LicenseType status: LicenseStatus type: LicenseType @@ -7531,6 +7961,62 @@ export interface MissingAggregation extends BucketAggregationBase { missing?: Missing } +export interface MlDataFrameAnalyticsJobsCountUsage { + count: long +} + +export interface MlDataFrameAnalyticsJobsMemoryUsage { + peak_usage_bytes: JobStatistics +} + +export interface MlDataFrameAnalyticsJobsUsage { + memory_usage?: MlDataFrameAnalyticsJobsMemoryUsage + _all: MlDataFrameAnalyticsJobsCountUsage + analysis_counts?: EmptyObject +} + +export interface MlInferenceIngestProcessorCountUsage { + max: long + sum: long + min: long +} + +export interface MlInferenceIngestProcessorUsage { + num_docs_processed: MlInferenceIngestProcessorCountUsage + pipelines: MlUsageCounter + num_failures: MlInferenceIngestProcessorCountUsage + time_ms: MlInferenceIngestProcessorCountUsage +} + +export interface MlInferenceTrainedModelsCountUsage { + total: long + prepackaged: long + other: long + regression: long + classification: long +} + +export interface MlInferenceTrainedModelsUsage { + estimated_operations?: JobStatistics + estimated_heap_memory_usage_bytes?: JobStatistics + count?: MlInferenceTrainedModelsCountUsage + _all: MlUsageCounter +} + +export interface MlInferenceUsage { + ingest_processors: Record + trained_models: MlInferenceTrainedModelsUsage +} + +export interface MlJobForecasts { + total: long + forecasted_jobs: long +} + +export interface MlUsageCounter { + count: long +} + export type ModelCategorizationStatus = 'ok' | 'warn' export type ModelMemoryStatus = 'ok' | 'soft_limit' | 'hard_limit' @@ -7547,27 +8033,34 @@ export interface ModelPlotConfigEnabled { export interface ModelSizeStats { bucket_allocation_failures_count: long - job_id: string - log_time: DateString + job_id: Id + log_time: Time memory_status: MemoryStatus model_bytes: long result_type: string - timestamp: DateString total_by_field_count: long total_over_field_count: long total_partition_field_count: long + categorization_status: string + categorized_doc_count: integer + dead_category_count: integer + failed_category_count: integer + frequent_category_count: integer + rare_category_count: integer + total_category_count: integer } export interface ModelSnapshot { description: string - job_id: string - latest_record_time_stamp: DateString - latest_result_time_stamp: DateString + job_id: Id + latest_record_time_stamp: Time + latest_result_time_stamp: Time model_size_stats: ModelSizeStats retain: boolean snapshot_doc_count: long - snapshot_id: string - timestamp: DateString + snapshot_id: Id + timestamp: Time + min_version: VersionString } export interface MonitoringUsage extends XPackUsage { @@ -7594,7 +8087,7 @@ export interface MoreLikeThisQuery extends QueryBase { routing?: Routing stop_words?: StopWords unlike?: Like | Array - version?: long + version?: VersionNumber version_type?: VersionType } @@ -7640,25 +8133,27 @@ export interface MultiGetHit { error?: MainError fields?: Record found?: boolean - _id: string - _index: string + _id: Id + _index: IndexName _primary_term?: long _routing?: Routing - _seq_no?: long + _seq_no?: SequenceNumber _source?: TDocument _type?: Type - _version?: long + _version?: VersionNumber } +export type MultiGetId = string | integer + export interface MultiGetOperation { can_be_flattened?: boolean - _id: Id + _id: MultiGetId _index?: IndexName routing?: Routing _source?: boolean | Fields | SourceFilter stored_fields?: Fields _type?: Type - version?: long + version?: VersionNumber version_type?: VersionType } @@ -7676,7 +8171,7 @@ export interface MultiGetRequest extends RequestBase { stored_fields?: Fields body: { docs?: Array - ids?: Array + ids?: Array } } @@ -7760,7 +8255,7 @@ export interface MultiTermVectorOperation { positions: boolean routing: Routing term_statistics: boolean - version: long + version: VersionNumber version_type: VersionType } @@ -7776,7 +8271,7 @@ export interface MultiTermVectorsRequest extends RequestBase { realtime?: boolean routing?: Routing term_statistics?: boolean - version?: long + version?: VersionNumber version_type?: VersionType body?: { docs?: Array @@ -7799,6 +8294,10 @@ export interface MultiplexerTokenFilter extends TokenFilterBase { preserve_original: boolean } +export interface Murmur3HashProperty extends DocValuesPropertyBase { + type: 'murmur3' +} + export interface MutualInformationHeuristic { background_is_superset: boolean include_negatives: boolean @@ -7843,7 +8342,7 @@ export type Names = string | Array export interface NativeCodeInformation { build_hash: string - version: string + version: VersionString } export interface NestedAggregation extends BucketAggregationBase { @@ -7856,6 +8355,15 @@ export interface NestedIdentity { _nested?: NestedIdentity } +export interface NestedProperty extends CorePropertyBase { + dynamic?: boolean | DynamicMapping + enabled?: boolean + properties?: Record + include_in_parent?: boolean + include_in_root?: boolean + type: 'nested' +} + export interface NestedQuery extends QueryBase { ignore_unmapped?: boolean inner_hits?: InnerHits @@ -7932,7 +8440,7 @@ export interface NodeInfo { total_indexing_buffer: long transport: NodeInfoTransport transport_address: string - version: string + version: VersionString } export interface NodeInfoHttp { @@ -7998,10 +8506,10 @@ export interface NodeJvmInfo { memory_pools: Array pid: integer start_time_in_millis: long - version: string - vm_name: string + version: VersionString + vm_name: Name vm_vendor: string - vm_version: string + vm_version: VersionString } export interface NodeJvmStats { @@ -8021,10 +8529,10 @@ export interface NodeOperatingSystemInfo { cpu: NodeInfoOSCPU mem: NodeInfoMemory name: string - pretty_name: string + pretty_name: Name refresh_interval_in_millis: integer swap: NodeInfoMemory - version: string + version: VersionString } export interface NodePackagingType { @@ -8040,8 +8548,8 @@ export interface NodeProcessInfo { } export interface NodeReloadException { - name: string - reload_exception: NodeReloadExceptionCausedBy + name: Name + reload_exception?: NodeReloadExceptionCausedBy } export interface NodeReloadExceptionCausedBy { @@ -8175,11 +8683,37 @@ export interface NormalizeAggregation extends PipelineAggregationBase { export type NormalizeMethod = 'rescale_0_1' | 'rescale_0_100' | 'percent_of_sum' | 'mean' | 'zscore' | 'softmax' +export interface NumberProperty extends DocValuesPropertyBase { + boost?: double + coerce?: boolean + fielddata?: NumericFielddata + ignore_malformed?: boolean + index?: boolean + null_value?: double + scaling_factor?: double + type: NumberType +} + +export type NumberType = 'float' | 'half_float' | 'scaled_float' | 'double' | 'integer' | 'long' | 'short' | 'byte' | 'unsigned_long' + export interface NumericDecayFunctionKeys extends DecayFunctionBase { } export type NumericDecayFunction = NumericDecayFunctionKeys | { [property: string]: DecayPlacement } +export interface NumericFielddata { + format: NumericFielddataFormat +} + +export type NumericFielddataFormat = 'array' | 'disabled' + +export interface ObjectProperty extends CorePropertyBase { + dynamic?: boolean | DynamicMapping + enabled?: boolean + properties?: Record + type: 'object' +} + export type OpType = 'index' | 'create' export interface OpenIndexRequest extends RequestBase { @@ -8189,7 +8723,7 @@ export interface OpenIndexRequest extends RequestBase { ignore_unavailable?: boolean master_timeout?: Time timeout?: Time - wait_for_active_shards?: string + wait_for_active_shards?: WaitForActiveShards } export interface OpenIndexResponse extends AcknowledgedResponseBase { @@ -8208,7 +8742,7 @@ export interface OpenJobResponse extends ResponseBase { } export interface OpenPointInTimeRequest extends RequestBase { - index: IndexName + index: Indices keep_alive?: Time } @@ -8400,11 +8934,15 @@ export interface PercolateQuery extends QueryBase { index?: IndexName preference?: string routing?: Routing - version?: long + version?: VersionNumber +} + +export interface PercolatorProperty extends PropertyBase { + type: 'percolator' } export interface Phase { - actions: Record + actions: Record | Array min_age?: Time } @@ -8467,7 +9005,7 @@ export interface Pipeline { description?: string on_failure?: Array processors?: Array - version?: long + version?: VersionNumber } export interface PipelineAggregationBase extends Aggregation { @@ -8491,12 +9029,12 @@ export interface PipelineSimulation { export interface PluginStats { classname: string description: string - elasticsearch_version: string + elasticsearch_version: VersionString extended_plugins: Array has_native_controller: boolean - java_version: string + java_version: VersionString name: string - version: string + version: VersionString licensed: boolean type: string } @@ -8506,8 +9044,16 @@ export interface PointInTimeReference { keep_alive?: Time } +export interface PointProperty extends DocValuesPropertyBase { + ignore_malformed?: boolean + ignore_z_value?: boolean + null_value?: string + type: 'point' +} + export interface Policy { phases: Phases + name?: string } export interface PorterStemTokenFilter extends TokenFilterBase { @@ -8662,15 +9208,16 @@ export interface Profile { shards: Array } +export type Property = FlattenedProperty | JoinProperty | PercolatorProperty | RankFeatureProperty | RankFeaturesProperty | ConstantKeywordProperty | FieldAliasProperty | HistogramProperty | CoreProperty + export interface PropertyBase { local_metadata?: Record meta?: Record name?: PropertyName - type?: string - properties?: Record + properties?: Record ignore_above?: integer dynamic?: boolean | DynamicMapping - fields?: Record + fields?: Record } export type PropertyName = string @@ -8692,6 +9239,29 @@ export interface PutAliasRequest extends RequestBase { export interface PutAliasResponse extends ResponseBase { } +export interface PutAutoFollowPatternRequest extends RequestBase { + name: Name + body: { + remote_cluster: string + follow_index_pattern?: IndexPattern + leader_index_patterns?: IndexPatterns + max_outstanding_read_requests?: integer + settings?: Record + max_outstanding_write_requests?: integer + read_poll_timeout?: Time + max_read_request_operation_count?: integer + max_read_request_size?: ByteSize + max_retry_delay?: Time + max_write_buffer_count?: integer + max_write_buffer_size?: ByteSize + max_write_request_operation_count?: integer + max_write_request_size?: ByteSize + } +} + +export interface PutAutoFollowPatternResponse extends AcknowledgedResponseBase { +} + export interface PutAutoscalingPolicyRequest extends RequestBase { stub_a: string stub_b: string @@ -8801,7 +9371,7 @@ export interface PutIndexTemplateRequest extends RequestBase { mappings?: TypeMapping order?: integer settings?: Record - version?: integer + version?: VersionNumber } } @@ -8860,6 +9430,7 @@ export interface PutMappingRequest extends RequestBase { include_type_name?: boolean master_timeout?: Time timeout?: Time + write_index_only?: boolean body: { all_field?: AllField date_detection?: boolean @@ -8870,7 +9441,7 @@ export interface PutMappingRequest extends RequestBase { index_field?: IndexField meta?: Record numeric_detection?: boolean - properties?: Record + properties?: Record routing_field?: RoutingField size_field?: SizeField source_field?: SourceField @@ -8888,7 +9459,7 @@ export interface PutPipelineRequest extends RequestBase { description?: string on_failure?: Array processors?: Array - version?: long + version?: VersionNumber } } @@ -8938,6 +9509,7 @@ export interface PutRoleRequest extends RequestBase { indices?: Array metadata?: Record run_as?: Array + transient_metadata?: TransientMetadata } } @@ -9016,7 +9588,7 @@ export interface PutWatchRequest extends RequestBase { active?: boolean if_primary_term?: long if_sequence_number?: long - version?: long + version?: VersionNumber body?: { actions?: Record condition?: ConditionContainer @@ -9030,10 +9602,10 @@ export interface PutWatchRequest extends RequestBase { export interface PutWatchResponse extends ResponseBase { created: boolean - _id: string + _id: Id _primary_term: long - _seq_no: long - _version: integer + _seq_no: SequenceNumber + _version: VersionNumber } export type Quantifier = 'some' | 'all' @@ -9193,10 +9765,10 @@ export interface QueryTemplate { } export interface QueryUsage { - count: integer - failed: integer - paging: integer - total: integer + count?: integer + failed?: integer + paging?: integer + total?: integer } export interface QueryUserPrivileges { @@ -9231,6 +9803,14 @@ export interface RangeBucketKeys { export type RangeBucket = RangeBucketKeys | { [property: string]: Aggregate } +export type RangeProperty = LongRangeProperty | IpRangeProperty | IntegerRangeProperty | FloatRangeProperty | DoubleRangeProperty | DateRangeProperty + +export interface RangePropertyBase extends DocValuesPropertyBase { + boost?: double + coerce?: boolean + index?: boolean +} + export interface RangeQuery extends QueryBase { gt?: double | DateMath gte?: double | DateMath @@ -9247,10 +9827,19 @@ export type RangeRelation = 'within' | 'contains' | 'intersects' export interface RankFeatureFunction { } +export interface RankFeatureProperty extends PropertyBase { + positive_score_impact?: boolean + type: 'rank_feature' +} + export interface RankFeatureQuery extends QueryBase { function?: RankFeatureFunction } +export interface RankFeaturesProperty extends PropertyBase { + type: 'rank_features' +} + export interface RareTermsAggregation extends BucketAggregationBase { exclude?: string | Array field?: Field @@ -9273,15 +9862,24 @@ export interface RateAggregation extends FormatMetricAggregationBase { export type RateMode = 'sum' | 'value_count' +export interface RealmCacheUsage { + size: long +} + export interface RealmInfo { name: string type: string } export interface RealmUsage extends XPackUsage { - name: Array - order: Array - size: Array + name?: Array + order?: Array + size?: Array + cache?: Array + has_authorization_realms?: Array + has_default_username_pattern?: Array + has_truststore?: Array + is_authentication_delegated?: Array } export interface RecoveryBytes { @@ -9324,10 +9922,15 @@ export interface RecoveryOrigin { hostname?: string host?: string transport_address?: string - id?: string + id?: Id ip?: string - name?: string + name?: Name bootstrap_new_history_uuid?: boolean + repository?: Name + snapshot?: Name + version?: VersionString + restoreUUID?: Uuid + index?: IndexName } export interface RecoveryStartStatus { @@ -9429,7 +10032,7 @@ export interface ReindexRequest extends RequestBase { scroll?: Time slices?: long timeout?: Time - wait_for_active_shards?: string + wait_for_active_shards?: WaitForActiveShards wait_for_completion?: boolean require_alias?: boolean body: { @@ -9538,7 +10141,7 @@ export interface ReloadSecureSettingsRequest extends RequestBase { } export interface ReloadSecureSettingsResponse extends NodesResponseBase { - cluster_name: string + cluster_name: Name nodes: Record } @@ -9630,6 +10233,35 @@ export interface ReservedSize { shards: Array } +export interface ResolveIndexAliasItem { + name: Name + indices: Indices +} + +export interface ResolveIndexDataStreamsItem { + name: DataStreamName + timestamp_field: Field + backing_indices: Indices +} + +export interface ResolveIndexItem { + name: Name + aliases?: Array + attributes: Array + data_stream?: DataStreamName +} + +export interface ResolveIndexRequest extends RequestBase { + name: Names + expand_wildcards?: ExpandWildcards +} + +export interface ResolveIndexResponse extends ResponseBase { + indices: Array + aliases: Array + data_streams: Array +} + export type ResourcePrivileges = Record export interface ResponseBase { @@ -9740,11 +10372,9 @@ export interface RoleMappingUsage { size: integer } -export interface RoleUsage { - dls: boolean - fls: boolean - size: long -} +export type RoleTemplate = InlineRoleTemplate | StoredRoleTemplate | InvalidRoleTemplate + +export type RoleTemplateFormat = 'string' | 'json' export interface RolloverConditions { max_age?: Time @@ -9760,7 +10390,7 @@ export interface RolloverIndexRequest extends RequestBase { include_type_name?: boolean master_timeout?: Time timeout?: Time - wait_for_active_shards?: integer + wait_for_active_shards?: WaitForActiveShards body?: { aliases?: Record conditions?: RolloverConditions @@ -9929,8 +10559,46 @@ export interface RuntimeField { type: FieldType } +export interface RuntimeFieldTypesStats { + name: Name + count: integer + index_count: integer + scriptless_count: integer + shadowed_count: integer + lang: Array + lines_max: integer + lines_total: integer + chars_max: integer + chars_total: integer + source_max: integer + source_total: integer + doc_max: integer + doc_total: integer +} + export type RuntimeFields = Record +export interface RuntimeFieldsTypeUsage { + chars_max: long + chars_total: long + count: long + doc_max: long + doc_total: long + index_count: long + lang: Array + lines_max: long + lines_total: long + name: Field + scriptless_count: long + shadowed_count: long + source_max: long + source_total: long +} + +export interface RuntimeFieldsUsage extends XPackUsage { + field_types: Array +} + export interface SampleDiversity { field: Field max_docs_per_value: integer @@ -10077,6 +10745,18 @@ export interface ScrollResponseFailedShard { reason: ScrollResponseErrorReason } +export interface SearchAsYouTypeProperty extends CorePropertyBase { + analyzer?: string + index?: boolean + index_options?: IndexOptions + max_shingle_size?: integer + norms?: boolean + search_analyzer?: string + search_quote_analyzer?: string + term_vector?: TermVectorOption + type: 'search_as_you_type' +} + export interface SearchInput { extract: Array request: SearchInputRequestDefinition @@ -10268,6 +10948,72 @@ export interface SearchTransform { export type SearchType = 'query_then_fetch' | 'dfs_query_then_fetch' +export interface SearchableSnapshotsClearCacheRequest extends RequestBase { + stub_a: integer + stub_b: integer + body?: { + stub_c: integer + } +} + +export interface SearchableSnapshotsClearCacheResponse extends ResponseBase { + stub: integer +} + +export interface SearchableSnapshotsMountRequest extends RequestBase { + repository: Name + snapshot: Name + master_timeout?: Time + wait_for_completion?: boolean + storage?: string + body: { + index: IndexName + renamed_index?: IndexName + index_settings?: Record + ignore_index_settings?: Array + } +} + +export interface SearchableSnapshotsMountResponse extends ResponseBase { + snapshot: SearchableSnapshotsMountSnapshot +} + +export interface SearchableSnapshotsMountSnapshot { + snapshot: Name + indices: Indices + shards: ShardStatistics +} + +export interface SearchableSnapshotsRepositoryStatsRequest extends RequestBase { + stub_a: integer + stub_b: integer + body?: { + stub_c: integer + } +} + +export interface SearchableSnapshotsRepositoryStatsResponse extends ResponseBase { + stub: integer +} + +export interface SearchableSnapshotsStatsRequest extends RequestBase { + stub_a: integer + stub_b: integer + body?: { + stub_c: integer + } +} + +export interface SearchableSnapshotsStatsResponse extends ResponseBase { + stub: integer +} + +export interface SearchableSnapshotsUsage extends XPackUsage { + indices_count: integer + full_copy_indices_count?: integer + shared_cache_indices_count?: integer +} + export interface SecurityFeatureToggle { enabled: boolean } @@ -10276,15 +11022,47 @@ export interface SecurityNode { name: string } +export interface SecurityRolesDlsBitSetCacheUsage { + count: integer + memory: ByteSize + memory_in_bytes: ulong +} + +export interface SecurityRolesDlsUsage { + bit_set_cache: SecurityRolesDlsBitSetCacheUsage +} + +export interface SecurityRolesFileUsage { + dls: boolean + fls: boolean + size: long +} + +export interface SecurityRolesNativeUsage { + dls: boolean + fls: boolean + size: long +} + +export interface SecurityRolesUsage { + native: SecurityRolesNativeUsage + dls: SecurityRolesDlsUsage + file: SecurityRolesFileUsage +} + export interface SecurityUsage extends XPackUsage { + api_key_service: SecurityFeatureToggle anonymous: SecurityFeatureToggle audit: AuditUsage + fips_140: SecurityFeatureToggle ipfilter: IpFilterUsage realms: Record role_mapping: Record - roles: Record + roles: SecurityRolesUsage ssl: SslUsage - system_key: SecurityFeatureToggle + system_key?: SecurityFeatureToggle + token_service: SecurityFeatureToggle + operator_privileges: XPackUsage } export interface Segment { @@ -10297,7 +11075,7 @@ export interface Segment { search: boolean size_in_bytes: double num_docs: long - version: string + version: VersionString } export interface SegmentsRequest extends RequestBase { @@ -10330,6 +11108,8 @@ export interface SegmentsStats { version_map_memory_in_bytes: long } +export type SequenceNumber = integer + export interface SerialDifferencingAggregation extends PipelineAggregationBase { lag?: integer } @@ -10353,6 +11133,16 @@ export interface SetUpgradeModeRequest extends RequestBase { export interface SetUpgradeModeResponse extends AcknowledgedResponseBase { } +export type ShapeOrientation = 'right' | 'counterclockwise' | 'ccw' | 'left' | 'clockwise' | 'cw' + +export interface ShapeProperty extends DocValuesPropertyBase { + coerce?: boolean + ignore_malformed?: boolean + ignore_z_value?: boolean + orientation?: ShapeOrientation + type: 'shape' +} + export interface ShapeQuery extends QueryBase { ignore_unmapped?: boolean indexed_shape?: FieldLookup @@ -10437,8 +11227,8 @@ export interface ShardIndexing { } export interface ShardLease { - id: string - retaining_seq_no: long + id: Id + retaining_seq_no: SequenceNumber timestamp: long source: string } @@ -10493,7 +11283,7 @@ export interface ShardRecovery { total_time?: DateString total_time_in_millis: EpochMillis translog: RecoveryTranslogStatus - type: string + type: Type verify_index: RecoveryVerifyIndex } @@ -10514,7 +11304,7 @@ export interface ShardRequestCache { export interface ShardRetentionLeases { primary_term: long - version: long + version: VersionNumber leases: Array } @@ -10568,7 +11358,7 @@ export interface ShardSegments { export interface ShardSequenceNumber { global_checkpoint: long local_checkpoint: long - max_seq_no: long + max_seq_no: SequenceNumber } export interface ShardStatistics { @@ -10619,8 +11409,8 @@ export interface ShardStore { allocation_id: Id attributes: Record id: Id - legacy_version: long - name: string + legacy_version: VersionNumber + name: Name store_exception: ShardStoreException transport_address: string } @@ -10675,7 +11465,7 @@ export interface ShrinkIndexRequest extends RequestBase { target: IndexName master_timeout?: Time timeout?: Time - wait_for_active_shards?: string + wait_for_active_shards?: WaitForActiveShards body?: { aliases?: Record settings?: Record @@ -10847,8 +11637,8 @@ export interface SlicedScroll { } export interface SlmUsage extends XPackUsage { - policy_count: integer - policy_stats: SnapshotLifecycleStats + policy_count?: integer + policy_stats?: SnapshotLifecycleStats } export interface SmoothingModelContainer { @@ -10879,8 +11669,8 @@ export interface SnapshotInfo { start_time_in_millis?: EpochMillis state?: string uuid: Uuid - version?: string - version_id?: integer + version?: VersionString + version_id?: VersionNumber feature_states?: Array } @@ -10924,7 +11714,7 @@ export interface SnapshotLifecyclePolicyMetadata { next_execution?: DateString next_execution_millis: EpochMillis policy: SnapshotLifecyclePolicy - version: integer + version: VersionNumber stats: SnapshotLifecycleStats } @@ -10979,6 +11769,12 @@ export interface SnapshotResponse extends ResponseBase { snapshot?: SnapshotInfo } +export interface SnapshotResponseItem { + repository: Name + snapshots?: Array + error?: ErrorCause +} + export interface SnapshotRestore { indices: Array snapshot: string @@ -11079,7 +11875,7 @@ export interface SourceExistsRequest extends RequestBase { source_enabled?: boolean source_excludes?: Fields source_includes?: Fields - version?: long + version?: VersionNumber version_type?: VersionType } @@ -11111,7 +11907,7 @@ export interface SourceRequest extends RequestBase { source_enabled?: boolean _source_excludes?: Fields _source_includes?: Fields - version?: long + version?: VersionNumber version_type?: VersionType } @@ -11188,7 +11984,7 @@ export interface SplitIndexRequest extends RequestBase { target: IndexName master_timeout?: Time timeout?: Time - wait_for_active_shards?: string + wait_for_active_shards?: WaitForActiveShards body?: { aliases?: Record settings?: Record @@ -11197,6 +11993,7 @@ export interface SplitIndexRequest extends RequestBase { export interface SplitIndexResponse extends AcknowledgedResponseBase { shards_acknowledged: boolean + index: IndexName } export interface SplitProcessor extends ProcessorBase { @@ -11406,13 +12203,28 @@ export interface StoreStats { reserved_in_bytes: double } +export interface StoredRoleTemplate { + template: StoredRoleTemplateId + format?: RoleTemplateFormat +} + +export interface StoredRoleTemplateId { + id: string +} + export interface StoredScript { - lang: string + lang?: string source: string } export type StringDistance = 'internal' | 'damerau_levenshtein' | 'levenshtein' | 'jaro_winkler' | 'ngram' +export interface StringFielddata { + format: StringFielddataFormat +} + +export type StringFielddataFormat = 'paged_bytes' | 'disabled' + export interface StringStatsAggregate extends AggregateBase { count: long min_length: integer @@ -11446,6 +12258,12 @@ export interface SuggestContainer { text?: string } +export interface SuggestContext { + name: string + path: Field + type: string +} + export interface SuggestContextQuery { boost?: double context: Context @@ -11603,7 +12421,7 @@ export interface TemplateMapping { mappings: TypeMapping order: integer settings: Record - version: integer + version?: VersionNumber } export interface TermQuery extends QueryBase { @@ -11650,6 +12468,8 @@ export interface TermVectorFilter { min_word_length?: integer } +export type TermVectorOption = 'no' | 'yes' | 'with_offsets' | 'with_positions' | 'with_positions_offsets' | 'with_positions_offsets_payloads' + export interface TermVectorTerm { doc_freq?: integer score?: double @@ -11671,7 +12491,7 @@ export interface TermVectorsRequest extends RequestBase { realtime?: boolean routing?: Routing term_statistics?: boolean - version?: long + version?: VersionNumber version_type?: VersionType body?: { doc?: TDocument @@ -11686,17 +12506,17 @@ export interface TermVectorsResponse extends ResponseBase { _index: IndexName term_vectors?: Record took: long - _type: Type - _version: long + _type?: Type + _version: VersionNumber } export interface TermVectorsResult { found: boolean - id: string - index: string + id: Id + index: IndexName term_vectors: Record took: long - version: long + version: VersionNumber } export interface TermsAggregate extends MultiBucketAggregate { @@ -11756,6 +12576,29 @@ export interface TestPopulation { filter?: QueryContainer } +export interface TextIndexPrefixes { + max_chars: integer + min_chars: integer +} + +export interface TextProperty extends CorePropertyBase { + analyzer?: string + boost?: double + eager_global_ordinals?: boolean + fielddata?: boolean + fielddata_frequency_filter?: FielddataFrequencyFilter + index?: boolean + index_options?: IndexOptions + index_phrases?: boolean + index_prefixes?: TextIndexPrefixes + norms?: boolean + position_increment_gap?: integer + search_analyzer?: string + search_quote_analyzer?: string + term_vector?: TermVectorOption + type: 'text' +} + export type TextQueryType = 'best_fields' | 'most_fields' | 'cross_fields' | 'phrase' | 'phrase_prefix' | 'bool_prefix' export type TextToAnalyze = string | Array @@ -11833,6 +12676,15 @@ export interface Token { export type TokenChar = 'letter' | 'digit' | 'whitespace' | 'punctuation' | 'symbol' | 'custom' +export interface TokenCountProperty extends DocValuesPropertyBase { + analyzer?: string + boost?: double + index?: boolean + null_value?: double + enable_position_increments?: boolean + type: 'token_count' +} + export interface TokenDetail { name: string tokens: Array @@ -11842,14 +12694,14 @@ export type TokenFilter = AsciiFoldingTokenFilter | CommonGramsTokenFilter | Con export interface TokenFilterBase { type: string - version?: string + version?: VersionString } export type Tokenizer = CharGroupTokenizer | EdgeNGramTokenizer | KeywordTokenizer | LetterTokenizer | LowercaseTokenizer | NGramTokenizer | NoriTokenizer | PathHierarchyTokenizer | StandardTokenizer | UaxEmailUrlTokenizer | WhitespaceTokenizer export interface TokenizerBase { type: string - version?: string + version?: VersionString } export interface TopHit { @@ -11963,7 +12815,7 @@ export interface TransformIndexerStats { export interface TransformPivot { aggregations: Record group_by: Record - max_page_search_size: integer + max_page_search_size?: integer } export interface TransformProgress { @@ -12096,15 +12948,13 @@ export interface TypeMapping { index_field?: IndexField _meta?: Record numeric_detection?: boolean - properties?: Record + properties?: Record _routing?: RoutingField _size?: SizeField _source?: SourceField runtime?: Record } -export type TypeName = string - export interface TypeQuery extends QueryBase { value: string } @@ -12185,7 +13035,7 @@ export interface UpdateByQueryRequest extends RequestBase { timeout?: Time version?: boolean version_type?: boolean - wait_for_active_shards?: string + wait_for_active_shards?: WaitForActiveShards wait_for_completion?: boolean body?: { max_docs?: long @@ -12323,7 +13173,7 @@ export interface UpdateRequest index: IndexName type?: Type if_primary_term?: long - if_seq_no?: long + if_seq_no?: SequenceNumber lang?: string refresh?: Refresh require_alias?: boolean @@ -12331,7 +13181,7 @@ export interface UpdateRequest routing?: Routing source_enabled?: boolean timeout?: Time - wait_for_active_shards?: string + wait_for_active_shards?: WaitForActiveShards _source?: boolean | string | Array _source_excludes?: Fields _source_includes?: Fields @@ -12372,7 +13222,7 @@ export interface UpdateTransformResponse extends ResponseBase { pivot: TransformPivot source: TransformSource sync: TransformSyncContainer - version: string + version: VersionString } export interface UppercaseProcessor extends ProcessorBase { @@ -12394,6 +13244,11 @@ export interface UrlDecodeProcessor extends ProcessorBase { target_field?: Field } +export interface UsageCount { + active: long + total: long +} + export interface UserAgentProcessor extends ProcessorBase { field: Field ignore_missing: boolean @@ -12494,7 +13349,7 @@ export interface VariableWidthHistogramAggregation { export interface VectorUsage extends XPackUsage { dense_vector_dims_avg_count: integer dense_vector_fields_count: integer - sparse_vector_fields_count: integer + sparse_vector_fields_count?: integer } export interface VerifyRepositoryRequest extends RequestBase { @@ -12507,11 +13362,19 @@ export interface VerifyRepositoryResponse extends ResponseBase { nodes: Record } +export type VersionNumber = long + +export interface VersionProperty extends DocValuesPropertyBase { + type: 'version' +} + +export type VersionString = string + export type VersionType = 'internal' | 'external' | 'external_gte' | 'force' export type WaitForActiveShardOptions = 'all' -export type WaitForActiveShards = byte | WaitForActiveShardOptions +export type WaitForActiveShards = integer | WaitForActiveShardOptions export type WaitForEvents = 'immediate' | 'urgent' | 'high' | 'normal' | 'low' | 'languid' @@ -12554,7 +13417,6 @@ export interface WatchRecordQueuedStats { export interface WatchRecordStats extends WatchRecordQueuedStats { execution_phase: ExecutionPhase - execution_time: DateString triggered_time: DateString executed_actions?: Array watch_id: Id @@ -12566,14 +13428,23 @@ export interface WatchStatus { last_checked?: DateString last_met_condition?: DateString state: ActivationState - version: integer + version: VersionNumber execution_state?: string } +export interface WatcherActionTotalsUsage { + total: long + total_time_in_ms: long +} + +export interface WatcherActionsUsage { + actions: Record +} + export interface WatcherNodeStats { - current_watches: Array + current_watches?: Array execution_thread_pool: ExecutionThreadPool - queued_watches: Array + queued_watches?: Array watch_count: long watcher_state: WatcherState node_id: Id @@ -12593,6 +13464,29 @@ export interface WatcherStatsResponse extends ResponseBase { _nodes: NodeStatistics } +export interface WatcherUsage extends XPackUsage { + execution: WatcherActionsUsage + watch: WatcherWatchUsage + count: UsageCount +} + +export interface WatcherWatchTriggerScheduleUsage extends UsageCount { + cron: UsageCount + _all: UsageCount +} + +export interface WatcherWatchTriggerUsage { + schedule?: WatcherWatchTriggerScheduleUsage + _all: UsageCount +} + +export interface WatcherWatchUsage { + input: Record + condition?: Record + action?: Record + trigger: WatcherWatchTriggerUsage +} + export interface WebhookActionResult { request: HttpInputRequestResult response?: HttpInputResponseResult @@ -12615,6 +13509,10 @@ export interface WhitespaceTokenizer extends TokenizerBase { max_token_length: integer } +export interface WildcardProperty extends DocValuesPropertyBase { + type: 'wildcard' +} + export interface WildcardQuery extends QueryBase { rewrite?: MultiTermQueryRewrite value: string @@ -12654,15 +13552,16 @@ export interface WordDelimiterTokenFilter extends TokenFilterBase { } export interface WriteResponseBase extends ResponseBase { - _id: string - _index: string + _id: Id + _index: IndexName _primary_term: long result: Result - _seq_no: long + _seq_no: SequenceNumber _shards: ShardStatistics - _type?: string - _version: long + _type?: Type + _version: VersionNumber forced_refresh?: boolean + error?: ErrorCause } export interface XPackBuildInformation { @@ -12672,18 +13571,22 @@ export interface XPackBuildInformation { export interface XPackFeature { available: boolean - description: string + description?: string enabled: boolean - native_code_info: NativeCodeInformation + native_code_info?: NativeCodeInformation } export interface XPackFeatures { + aggregate_metric: XPackFeature analytics: XPackFeature ccr: XPackFeature - data_frame: XPackFeature - data_science: XPackFeature + data_frame?: XPackFeature + data_science?: XPackFeature + data_streams: XPackFeature + data_tiers: XPackFeature enrich: XPackFeature - flattened: XPackFeature + eql: XPackFeature + flattened?: XPackFeature frozen_indices: XPackFeature graph: XPackFeature ilm: XPackFeature @@ -12691,6 +13594,8 @@ export interface XPackFeatures { ml: XPackFeature monitoring: XPackFeature rollup: XPackFeature + runtime_fields?: XPackFeature + searchable_snapshots: XPackFeature security: XPackFeature slm: XPackFeature spatial: XPackFeature @@ -12718,6 +13623,8 @@ export interface XPackRole { metadata: Record run_as: Array transient_metadata: TransientMetadata + applications: Array + role_templates?: Array } export interface XPackRoleMapping { @@ -12737,18 +13644,27 @@ export interface XPackUsageRequest extends RequestBase { } export interface XPackUsageResponse extends ResponseBase { - watcher: AlertingUsage + aggregate_metric: XPackUsage + analytics: AnalyticsUsage + watcher: WatcherUsage ccr: CcrUsage - data_frame: XPackUsage - data_science: XPackUsage - enrich: XPackUsage - flattened: FlattenedUsage + data_frame?: XPackUsage + data_science?: XPackUsage + data_streams?: DataStreamsUsage + data_tiers: DataTiersUsage + enrich?: XPackUsage + eql: EqlUsage + flattened?: FlattenedUsage + frozen_indices: FrozenIndicesUsage graph: XPackUsage ilm: IlmUsage logstash: XPackUsage ml: MachineLearningUsage monitoring: MonitoringUsage rollup: XPackUsage + runtime_fields?: RuntimeFieldsUsage + spatial: XPackUsage + searchable_snapshots: SearchableSnapshotsUsage security: SecurityUsage slm: SlmUsage sql: SqlUsage @@ -12768,8 +13684,6 @@ export interface XPackUser { export type ZeroTermsQuery = 'all' | 'none' -export type byte = number - export type double = number export type float = number diff --git a/index.d.ts b/index.d.ts index 76c0c090c..e881268d5 100644 --- a/index.d.ts +++ b/index.d.ts @@ -48,8 +48,10 @@ import { import Serializer from './lib/Serializer'; import Helpers from './lib/Helpers'; import * as errors from './lib/errors'; -import ESAPI from './api/esapi' import * as estypes from './api/types' +import * as RequestParams from './api/requestParams' + +declare type callbackFn = (err: ApiError, result: ApiResponse) => void; // Extend API interface ClientExtendsCallbackOptions { @@ -117,7 +119,7 @@ interface ClientOptions { disablePrototypePoisoningProtection?: boolean | 'proto' | 'constructor'; } -declare class Client extends ESAPI { +declare class Client { constructor(opts: ClientOptions); connectionPool: ConnectionPool; transport: Transport; @@ -126,7 +128,6 @@ declare class Client extends ESAPI { extend(method: string, opts: { force: boolean }, fn: extendsCallback): void; helpers: Helpers; child(opts?: ClientOptions): Client; - close(): Promise; close(callback: Function): void; close(): Promise; emit(event: string | symbol, ...args: any[]): boolean; @@ -139,6 +140,2560 @@ declare class Client extends ESAPI { once(event: 'sniff', listener: (err: ApiError, meta: RequestEvent) => void): this; once(event: 'resurrect', listener: (err: null, meta: ResurrectEvent) => void): this; off(event: string | symbol, listener: (...args: any[]) => void): this; + /* GENERATED */ + async_search: { + delete, TContext = Context>(params?: RequestParams.AsyncSearchDelete, options?: TransportRequestOptions): TransportRequestPromise> + delete, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete, TContext = Context>(params: RequestParams.AsyncSearchDelete, callback: callbackFn): TransportRequestCallback + delete, TContext = Context>(params: RequestParams.AsyncSearchDelete, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get, TContext = Context>(params?: RequestParams.AsyncSearchGet, options?: TransportRequestOptions): TransportRequestPromise> + get, TContext = Context>(callback: callbackFn): TransportRequestCallback + get, TContext = Context>(params: RequestParams.AsyncSearchGet, callback: callbackFn): TransportRequestCallback + get, TContext = Context>(params: RequestParams.AsyncSearchGet, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + status, TContext = Context>(params?: RequestParams.AsyncSearchStatus, options?: TransportRequestOptions): TransportRequestPromise> + status, TContext = Context>(callback: callbackFn): TransportRequestCallback + status, TContext = Context>(params: RequestParams.AsyncSearchStatus, callback: callbackFn): TransportRequestCallback + status, TContext = Context>(params: RequestParams.AsyncSearchStatus, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + submit, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.AsyncSearchSubmit, options?: TransportRequestOptions): TransportRequestPromise> + submit, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + submit, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.AsyncSearchSubmit, callback: callbackFn): TransportRequestCallback + submit, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.AsyncSearchSubmit, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + asyncSearch: { + delete, TContext = Context>(params?: RequestParams.AsyncSearchDelete, options?: TransportRequestOptions): TransportRequestPromise> + delete, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete, TContext = Context>(params: RequestParams.AsyncSearchDelete, callback: callbackFn): TransportRequestCallback + delete, TContext = Context>(params: RequestParams.AsyncSearchDelete, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get, TContext = Context>(params?: RequestParams.AsyncSearchGet, options?: TransportRequestOptions): TransportRequestPromise> + get, TContext = Context>(callback: callbackFn): TransportRequestCallback + get, TContext = Context>(params: RequestParams.AsyncSearchGet, callback: callbackFn): TransportRequestCallback + get, TContext = Context>(params: RequestParams.AsyncSearchGet, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + status, TContext = Context>(params?: RequestParams.AsyncSearchStatus, options?: TransportRequestOptions): TransportRequestPromise> + status, TContext = Context>(callback: callbackFn): TransportRequestCallback + status, TContext = Context>(params: RequestParams.AsyncSearchStatus, callback: callbackFn): TransportRequestCallback + status, TContext = Context>(params: RequestParams.AsyncSearchStatus, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + submit, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.AsyncSearchSubmit, options?: TransportRequestOptions): TransportRequestPromise> + submit, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + submit, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.AsyncSearchSubmit, callback: callbackFn): TransportRequestCallback + submit, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.AsyncSearchSubmit, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + autoscaling: { + delete_autoscaling_policy, TContext = Context>(params?: RequestParams.AutoscalingDeleteAutoscalingPolicy, options?: TransportRequestOptions): TransportRequestPromise> + delete_autoscaling_policy, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_autoscaling_policy, TContext = Context>(params: RequestParams.AutoscalingDeleteAutoscalingPolicy, callback: callbackFn): TransportRequestCallback + delete_autoscaling_policy, TContext = Context>(params: RequestParams.AutoscalingDeleteAutoscalingPolicy, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteAutoscalingPolicy, TContext = Context>(params?: RequestParams.AutoscalingDeleteAutoscalingPolicy, options?: TransportRequestOptions): TransportRequestPromise> + deleteAutoscalingPolicy, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteAutoscalingPolicy, TContext = Context>(params: RequestParams.AutoscalingDeleteAutoscalingPolicy, callback: callbackFn): TransportRequestCallback + deleteAutoscalingPolicy, TContext = Context>(params: RequestParams.AutoscalingDeleteAutoscalingPolicy, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_autoscaling_capacity, TContext = Context>(params?: RequestParams.AutoscalingGetAutoscalingCapacity, options?: TransportRequestOptions): TransportRequestPromise> + get_autoscaling_capacity, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_autoscaling_capacity, TContext = Context>(params: RequestParams.AutoscalingGetAutoscalingCapacity, callback: callbackFn): TransportRequestCallback + get_autoscaling_capacity, TContext = Context>(params: RequestParams.AutoscalingGetAutoscalingCapacity, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getAutoscalingCapacity, TContext = Context>(params?: RequestParams.AutoscalingGetAutoscalingCapacity, options?: TransportRequestOptions): TransportRequestPromise> + getAutoscalingCapacity, TContext = Context>(callback: callbackFn): TransportRequestCallback + getAutoscalingCapacity, TContext = Context>(params: RequestParams.AutoscalingGetAutoscalingCapacity, callback: callbackFn): TransportRequestCallback + getAutoscalingCapacity, TContext = Context>(params: RequestParams.AutoscalingGetAutoscalingCapacity, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_autoscaling_policy, TContext = Context>(params?: RequestParams.AutoscalingGetAutoscalingPolicy, options?: TransportRequestOptions): TransportRequestPromise> + get_autoscaling_policy, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_autoscaling_policy, TContext = Context>(params: RequestParams.AutoscalingGetAutoscalingPolicy, callback: callbackFn): TransportRequestCallback + get_autoscaling_policy, TContext = Context>(params: RequestParams.AutoscalingGetAutoscalingPolicy, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getAutoscalingPolicy, TContext = Context>(params?: RequestParams.AutoscalingGetAutoscalingPolicy, options?: TransportRequestOptions): TransportRequestPromise> + getAutoscalingPolicy, TContext = Context>(callback: callbackFn): TransportRequestCallback + getAutoscalingPolicy, TContext = Context>(params: RequestParams.AutoscalingGetAutoscalingPolicy, callback: callbackFn): TransportRequestCallback + getAutoscalingPolicy, TContext = Context>(params: RequestParams.AutoscalingGetAutoscalingPolicy, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_autoscaling_policy, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.AutoscalingPutAutoscalingPolicy, options?: TransportRequestOptions): TransportRequestPromise> + put_autoscaling_policy, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_autoscaling_policy, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.AutoscalingPutAutoscalingPolicy, callback: callbackFn): TransportRequestCallback + put_autoscaling_policy, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.AutoscalingPutAutoscalingPolicy, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putAutoscalingPolicy, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.AutoscalingPutAutoscalingPolicy, options?: TransportRequestOptions): TransportRequestPromise> + putAutoscalingPolicy, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + putAutoscalingPolicy, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.AutoscalingPutAutoscalingPolicy, callback: callbackFn): TransportRequestCallback + putAutoscalingPolicy, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.AutoscalingPutAutoscalingPolicy, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + bulk, TRequestBody extends RequestNDBody = Record[], TContext = Context>(params?: RequestParams.Bulk, options?: TransportRequestOptions): TransportRequestPromise> + bulk, TRequestBody extends RequestNDBody = Record[], TContext = Context>(callback: callbackFn): TransportRequestCallback + bulk, TRequestBody extends RequestNDBody = Record[], TContext = Context>(params: RequestParams.Bulk, callback: callbackFn): TransportRequestCallback + bulk, TRequestBody extends RequestNDBody = Record[], TContext = Context>(params: RequestParams.Bulk, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + cat: { + aliases, TContext = Context>(params?: RequestParams.CatAliases, options?: TransportRequestOptions): TransportRequestPromise> + aliases, TContext = Context>(callback: callbackFn): TransportRequestCallback + aliases, TContext = Context>(params: RequestParams.CatAliases, callback: callbackFn): TransportRequestCallback + aliases, TContext = Context>(params: RequestParams.CatAliases, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + allocation, TContext = Context>(params?: RequestParams.CatAllocation, options?: TransportRequestOptions): TransportRequestPromise> + allocation, TContext = Context>(callback: callbackFn): TransportRequestCallback + allocation, TContext = Context>(params: RequestParams.CatAllocation, callback: callbackFn): TransportRequestCallback + allocation, TContext = Context>(params: RequestParams.CatAllocation, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + count, TContext = Context>(params?: RequestParams.CatCount, options?: TransportRequestOptions): TransportRequestPromise> + count, TContext = Context>(callback: callbackFn): TransportRequestCallback + count, TContext = Context>(params: RequestParams.CatCount, callback: callbackFn): TransportRequestCallback + count, TContext = Context>(params: RequestParams.CatCount, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + fielddata, TContext = Context>(params?: RequestParams.CatFielddata, options?: TransportRequestOptions): TransportRequestPromise> + fielddata, TContext = Context>(callback: callbackFn): TransportRequestCallback + fielddata, TContext = Context>(params: RequestParams.CatFielddata, callback: callbackFn): TransportRequestCallback + fielddata, TContext = Context>(params: RequestParams.CatFielddata, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + health, TContext = Context>(params?: RequestParams.CatHealth, options?: TransportRequestOptions): TransportRequestPromise> + health, TContext = Context>(callback: callbackFn): TransportRequestCallback + health, TContext = Context>(params: RequestParams.CatHealth, callback: callbackFn): TransportRequestCallback + health, TContext = Context>(params: RequestParams.CatHealth, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + help, TContext = Context>(params?: RequestParams.CatHelp, options?: TransportRequestOptions): TransportRequestPromise> + help, TContext = Context>(callback: callbackFn): TransportRequestCallback + help, TContext = Context>(params: RequestParams.CatHelp, callback: callbackFn): TransportRequestCallback + help, TContext = Context>(params: RequestParams.CatHelp, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + indices, TContext = Context>(params?: RequestParams.CatIndices, options?: TransportRequestOptions): TransportRequestPromise> + indices, TContext = Context>(callback: callbackFn): TransportRequestCallback + indices, TContext = Context>(params: RequestParams.CatIndices, callback: callbackFn): TransportRequestCallback + indices, TContext = Context>(params: RequestParams.CatIndices, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + master, TContext = Context>(params?: RequestParams.CatMaster, options?: TransportRequestOptions): TransportRequestPromise> + master, TContext = Context>(callback: callbackFn): TransportRequestCallback + master, TContext = Context>(params: RequestParams.CatMaster, callback: callbackFn): TransportRequestCallback + master, TContext = Context>(params: RequestParams.CatMaster, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + ml_data_frame_analytics, TContext = Context>(params?: RequestParams.CatMlDataFrameAnalytics, options?: TransportRequestOptions): TransportRequestPromise> + ml_data_frame_analytics, TContext = Context>(callback: callbackFn): TransportRequestCallback + ml_data_frame_analytics, TContext = Context>(params: RequestParams.CatMlDataFrameAnalytics, callback: callbackFn): TransportRequestCallback + ml_data_frame_analytics, TContext = Context>(params: RequestParams.CatMlDataFrameAnalytics, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + mlDataFrameAnalytics, TContext = Context>(params?: RequestParams.CatMlDataFrameAnalytics, options?: TransportRequestOptions): TransportRequestPromise> + mlDataFrameAnalytics, TContext = Context>(callback: callbackFn): TransportRequestCallback + mlDataFrameAnalytics, TContext = Context>(params: RequestParams.CatMlDataFrameAnalytics, callback: callbackFn): TransportRequestCallback + mlDataFrameAnalytics, TContext = Context>(params: RequestParams.CatMlDataFrameAnalytics, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + ml_datafeeds, TContext = Context>(params?: RequestParams.CatMlDatafeeds, options?: TransportRequestOptions): TransportRequestPromise> + ml_datafeeds, TContext = Context>(callback: callbackFn): TransportRequestCallback + ml_datafeeds, TContext = Context>(params: RequestParams.CatMlDatafeeds, callback: callbackFn): TransportRequestCallback + ml_datafeeds, TContext = Context>(params: RequestParams.CatMlDatafeeds, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + mlDatafeeds, TContext = Context>(params?: RequestParams.CatMlDatafeeds, options?: TransportRequestOptions): TransportRequestPromise> + mlDatafeeds, TContext = Context>(callback: callbackFn): TransportRequestCallback + mlDatafeeds, TContext = Context>(params: RequestParams.CatMlDatafeeds, callback: callbackFn): TransportRequestCallback + mlDatafeeds, TContext = Context>(params: RequestParams.CatMlDatafeeds, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + ml_jobs, TContext = Context>(params?: RequestParams.CatMlJobs, options?: TransportRequestOptions): TransportRequestPromise> + ml_jobs, TContext = Context>(callback: callbackFn): TransportRequestCallback + ml_jobs, TContext = Context>(params: RequestParams.CatMlJobs, callback: callbackFn): TransportRequestCallback + ml_jobs, TContext = Context>(params: RequestParams.CatMlJobs, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + mlJobs, TContext = Context>(params?: RequestParams.CatMlJobs, options?: TransportRequestOptions): TransportRequestPromise> + mlJobs, TContext = Context>(callback: callbackFn): TransportRequestCallback + mlJobs, TContext = Context>(params: RequestParams.CatMlJobs, callback: callbackFn): TransportRequestCallback + mlJobs, TContext = Context>(params: RequestParams.CatMlJobs, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + ml_trained_models, TContext = Context>(params?: RequestParams.CatMlTrainedModels, options?: TransportRequestOptions): TransportRequestPromise> + ml_trained_models, TContext = Context>(callback: callbackFn): TransportRequestCallback + ml_trained_models, TContext = Context>(params: RequestParams.CatMlTrainedModels, callback: callbackFn): TransportRequestCallback + ml_trained_models, TContext = Context>(params: RequestParams.CatMlTrainedModels, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + mlTrainedModels, TContext = Context>(params?: RequestParams.CatMlTrainedModels, options?: TransportRequestOptions): TransportRequestPromise> + mlTrainedModels, TContext = Context>(callback: callbackFn): TransportRequestCallback + mlTrainedModels, TContext = Context>(params: RequestParams.CatMlTrainedModels, callback: callbackFn): TransportRequestCallback + mlTrainedModels, TContext = Context>(params: RequestParams.CatMlTrainedModels, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + nodeattrs, TContext = Context>(params?: RequestParams.CatNodeattrs, options?: TransportRequestOptions): TransportRequestPromise> + nodeattrs, TContext = Context>(callback: callbackFn): TransportRequestCallback + nodeattrs, TContext = Context>(params: RequestParams.CatNodeattrs, callback: callbackFn): TransportRequestCallback + nodeattrs, TContext = Context>(params: RequestParams.CatNodeattrs, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + nodes, TContext = Context>(params?: RequestParams.CatNodes, options?: TransportRequestOptions): TransportRequestPromise> + nodes, TContext = Context>(callback: callbackFn): TransportRequestCallback + nodes, TContext = Context>(params: RequestParams.CatNodes, callback: callbackFn): TransportRequestCallback + nodes, TContext = Context>(params: RequestParams.CatNodes, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + pending_tasks, TContext = Context>(params?: RequestParams.CatPendingTasks, options?: TransportRequestOptions): TransportRequestPromise> + pending_tasks, TContext = Context>(callback: callbackFn): TransportRequestCallback + pending_tasks, TContext = Context>(params: RequestParams.CatPendingTasks, callback: callbackFn): TransportRequestCallback + pending_tasks, TContext = Context>(params: RequestParams.CatPendingTasks, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + pendingTasks, TContext = Context>(params?: RequestParams.CatPendingTasks, options?: TransportRequestOptions): TransportRequestPromise> + pendingTasks, TContext = Context>(callback: callbackFn): TransportRequestCallback + pendingTasks, TContext = Context>(params: RequestParams.CatPendingTasks, callback: callbackFn): TransportRequestCallback + pendingTasks, TContext = Context>(params: RequestParams.CatPendingTasks, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + plugins, TContext = Context>(params?: RequestParams.CatPlugins, options?: TransportRequestOptions): TransportRequestPromise> + plugins, TContext = Context>(callback: callbackFn): TransportRequestCallback + plugins, TContext = Context>(params: RequestParams.CatPlugins, callback: callbackFn): TransportRequestCallback + plugins, TContext = Context>(params: RequestParams.CatPlugins, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + recovery, TContext = Context>(params?: RequestParams.CatRecovery, options?: TransportRequestOptions): TransportRequestPromise> + recovery, TContext = Context>(callback: callbackFn): TransportRequestCallback + recovery, TContext = Context>(params: RequestParams.CatRecovery, callback: callbackFn): TransportRequestCallback + recovery, TContext = Context>(params: RequestParams.CatRecovery, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + repositories, TContext = Context>(params?: RequestParams.CatRepositories, options?: TransportRequestOptions): TransportRequestPromise> + repositories, TContext = Context>(callback: callbackFn): TransportRequestCallback + repositories, TContext = Context>(params: RequestParams.CatRepositories, callback: callbackFn): TransportRequestCallback + repositories, TContext = Context>(params: RequestParams.CatRepositories, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + segments, TContext = Context>(params?: RequestParams.CatSegments, options?: TransportRequestOptions): TransportRequestPromise> + segments, TContext = Context>(callback: callbackFn): TransportRequestCallback + segments, TContext = Context>(params: RequestParams.CatSegments, callback: callbackFn): TransportRequestCallback + segments, TContext = Context>(params: RequestParams.CatSegments, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + shards, TContext = Context>(params?: RequestParams.CatShards, options?: TransportRequestOptions): TransportRequestPromise> + shards, TContext = Context>(callback: callbackFn): TransportRequestCallback + shards, TContext = Context>(params: RequestParams.CatShards, callback: callbackFn): TransportRequestCallback + shards, TContext = Context>(params: RequestParams.CatShards, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + snapshots, TContext = Context>(params?: RequestParams.CatSnapshots, options?: TransportRequestOptions): TransportRequestPromise> + snapshots, TContext = Context>(callback: callbackFn): TransportRequestCallback + snapshots, TContext = Context>(params: RequestParams.CatSnapshots, callback: callbackFn): TransportRequestCallback + snapshots, TContext = Context>(params: RequestParams.CatSnapshots, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + tasks, TContext = Context>(params?: RequestParams.CatTasks, options?: TransportRequestOptions): TransportRequestPromise> + tasks, TContext = Context>(callback: callbackFn): TransportRequestCallback + tasks, TContext = Context>(params: RequestParams.CatTasks, callback: callbackFn): TransportRequestCallback + tasks, TContext = Context>(params: RequestParams.CatTasks, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + templates, TContext = Context>(params?: RequestParams.CatTemplates, options?: TransportRequestOptions): TransportRequestPromise> + templates, TContext = Context>(callback: callbackFn): TransportRequestCallback + templates, TContext = Context>(params: RequestParams.CatTemplates, callback: callbackFn): TransportRequestCallback + templates, TContext = Context>(params: RequestParams.CatTemplates, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + thread_pool, TContext = Context>(params?: RequestParams.CatThreadPool, options?: TransportRequestOptions): TransportRequestPromise> + thread_pool, TContext = Context>(callback: callbackFn): TransportRequestCallback + thread_pool, TContext = Context>(params: RequestParams.CatThreadPool, callback: callbackFn): TransportRequestCallback + thread_pool, TContext = Context>(params: RequestParams.CatThreadPool, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + threadPool, TContext = Context>(params?: RequestParams.CatThreadPool, options?: TransportRequestOptions): TransportRequestPromise> + threadPool, TContext = Context>(callback: callbackFn): TransportRequestCallback + threadPool, TContext = Context>(params: RequestParams.CatThreadPool, callback: callbackFn): TransportRequestCallback + threadPool, TContext = Context>(params: RequestParams.CatThreadPool, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + transforms, TContext = Context>(params?: RequestParams.CatTransforms, options?: TransportRequestOptions): TransportRequestPromise> + transforms, TContext = Context>(callback: callbackFn): TransportRequestCallback + transforms, TContext = Context>(params: RequestParams.CatTransforms, callback: callbackFn): TransportRequestCallback + transforms, TContext = Context>(params: RequestParams.CatTransforms, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + ccr: { + delete_auto_follow_pattern, TContext = Context>(params?: RequestParams.CcrDeleteAutoFollowPattern, options?: TransportRequestOptions): TransportRequestPromise> + delete_auto_follow_pattern, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_auto_follow_pattern, TContext = Context>(params: RequestParams.CcrDeleteAutoFollowPattern, callback: callbackFn): TransportRequestCallback + delete_auto_follow_pattern, TContext = Context>(params: RequestParams.CcrDeleteAutoFollowPattern, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteAutoFollowPattern, TContext = Context>(params?: RequestParams.CcrDeleteAutoFollowPattern, options?: TransportRequestOptions): TransportRequestPromise> + deleteAutoFollowPattern, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteAutoFollowPattern, TContext = Context>(params: RequestParams.CcrDeleteAutoFollowPattern, callback: callbackFn): TransportRequestCallback + deleteAutoFollowPattern, TContext = Context>(params: RequestParams.CcrDeleteAutoFollowPattern, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + follow, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.CcrFollow, options?: TransportRequestOptions): TransportRequestPromise> + follow, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + follow, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.CcrFollow, callback: callbackFn): TransportRequestCallback + follow, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.CcrFollow, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + follow_info, TContext = Context>(params?: RequestParams.CcrFollowInfo, options?: TransportRequestOptions): TransportRequestPromise> + follow_info, TContext = Context>(callback: callbackFn): TransportRequestCallback + follow_info, TContext = Context>(params: RequestParams.CcrFollowInfo, callback: callbackFn): TransportRequestCallback + follow_info, TContext = Context>(params: RequestParams.CcrFollowInfo, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + followInfo, TContext = Context>(params?: RequestParams.CcrFollowInfo, options?: TransportRequestOptions): TransportRequestPromise> + followInfo, TContext = Context>(callback: callbackFn): TransportRequestCallback + followInfo, TContext = Context>(params: RequestParams.CcrFollowInfo, callback: callbackFn): TransportRequestCallback + followInfo, TContext = Context>(params: RequestParams.CcrFollowInfo, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + follow_stats, TContext = Context>(params?: RequestParams.CcrFollowStats, options?: TransportRequestOptions): TransportRequestPromise> + follow_stats, TContext = Context>(callback: callbackFn): TransportRequestCallback + follow_stats, TContext = Context>(params: RequestParams.CcrFollowStats, callback: callbackFn): TransportRequestCallback + follow_stats, TContext = Context>(params: RequestParams.CcrFollowStats, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + followStats, TContext = Context>(params?: RequestParams.CcrFollowStats, options?: TransportRequestOptions): TransportRequestPromise> + followStats, TContext = Context>(callback: callbackFn): TransportRequestCallback + followStats, TContext = Context>(params: RequestParams.CcrFollowStats, callback: callbackFn): TransportRequestCallback + followStats, TContext = Context>(params: RequestParams.CcrFollowStats, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + forget_follower, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.CcrForgetFollower, options?: TransportRequestOptions): TransportRequestPromise> + forget_follower, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + forget_follower, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.CcrForgetFollower, callback: callbackFn): TransportRequestCallback + forget_follower, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.CcrForgetFollower, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + forgetFollower, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.CcrForgetFollower, options?: TransportRequestOptions): TransportRequestPromise> + forgetFollower, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + forgetFollower, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.CcrForgetFollower, callback: callbackFn): TransportRequestCallback + forgetFollower, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.CcrForgetFollower, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_auto_follow_pattern, TContext = Context>(params?: RequestParams.CcrGetAutoFollowPattern, options?: TransportRequestOptions): TransportRequestPromise> + get_auto_follow_pattern, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_auto_follow_pattern, TContext = Context>(params: RequestParams.CcrGetAutoFollowPattern, callback: callbackFn): TransportRequestCallback + get_auto_follow_pattern, TContext = Context>(params: RequestParams.CcrGetAutoFollowPattern, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getAutoFollowPattern, TContext = Context>(params?: RequestParams.CcrGetAutoFollowPattern, options?: TransportRequestOptions): TransportRequestPromise> + getAutoFollowPattern, TContext = Context>(callback: callbackFn): TransportRequestCallback + getAutoFollowPattern, TContext = Context>(params: RequestParams.CcrGetAutoFollowPattern, callback: callbackFn): TransportRequestCallback + getAutoFollowPattern, TContext = Context>(params: RequestParams.CcrGetAutoFollowPattern, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + pause_auto_follow_pattern, TContext = Context>(params?: RequestParams.CcrPauseAutoFollowPattern, options?: TransportRequestOptions): TransportRequestPromise> + pause_auto_follow_pattern, TContext = Context>(callback: callbackFn): TransportRequestCallback + pause_auto_follow_pattern, TContext = Context>(params: RequestParams.CcrPauseAutoFollowPattern, callback: callbackFn): TransportRequestCallback + pause_auto_follow_pattern, TContext = Context>(params: RequestParams.CcrPauseAutoFollowPattern, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + pauseAutoFollowPattern, TContext = Context>(params?: RequestParams.CcrPauseAutoFollowPattern, options?: TransportRequestOptions): TransportRequestPromise> + pauseAutoFollowPattern, TContext = Context>(callback: callbackFn): TransportRequestCallback + pauseAutoFollowPattern, TContext = Context>(params: RequestParams.CcrPauseAutoFollowPattern, callback: callbackFn): TransportRequestCallback + pauseAutoFollowPattern, TContext = Context>(params: RequestParams.CcrPauseAutoFollowPattern, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + pause_follow, TContext = Context>(params?: RequestParams.CcrPauseFollow, options?: TransportRequestOptions): TransportRequestPromise> + pause_follow, TContext = Context>(callback: callbackFn): TransportRequestCallback + pause_follow, TContext = Context>(params: RequestParams.CcrPauseFollow, callback: callbackFn): TransportRequestCallback + pause_follow, TContext = Context>(params: RequestParams.CcrPauseFollow, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + pauseFollow, TContext = Context>(params?: RequestParams.CcrPauseFollow, options?: TransportRequestOptions): TransportRequestPromise> + pauseFollow, TContext = Context>(callback: callbackFn): TransportRequestCallback + pauseFollow, TContext = Context>(params: RequestParams.CcrPauseFollow, callback: callbackFn): TransportRequestCallback + pauseFollow, TContext = Context>(params: RequestParams.CcrPauseFollow, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_auto_follow_pattern, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.CcrPutAutoFollowPattern, options?: TransportRequestOptions): TransportRequestPromise> + put_auto_follow_pattern, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_auto_follow_pattern, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.CcrPutAutoFollowPattern, callback: callbackFn): TransportRequestCallback + put_auto_follow_pattern, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.CcrPutAutoFollowPattern, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putAutoFollowPattern, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.CcrPutAutoFollowPattern, options?: TransportRequestOptions): TransportRequestPromise> + putAutoFollowPattern, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + putAutoFollowPattern, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.CcrPutAutoFollowPattern, callback: callbackFn): TransportRequestCallback + putAutoFollowPattern, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.CcrPutAutoFollowPattern, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + resume_auto_follow_pattern, TContext = Context>(params?: RequestParams.CcrResumeAutoFollowPattern, options?: TransportRequestOptions): TransportRequestPromise> + resume_auto_follow_pattern, TContext = Context>(callback: callbackFn): TransportRequestCallback + resume_auto_follow_pattern, TContext = Context>(params: RequestParams.CcrResumeAutoFollowPattern, callback: callbackFn): TransportRequestCallback + resume_auto_follow_pattern, TContext = Context>(params: RequestParams.CcrResumeAutoFollowPattern, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + resumeAutoFollowPattern, TContext = Context>(params?: RequestParams.CcrResumeAutoFollowPattern, options?: TransportRequestOptions): TransportRequestPromise> + resumeAutoFollowPattern, TContext = Context>(callback: callbackFn): TransportRequestCallback + resumeAutoFollowPattern, TContext = Context>(params: RequestParams.CcrResumeAutoFollowPattern, callback: callbackFn): TransportRequestCallback + resumeAutoFollowPattern, TContext = Context>(params: RequestParams.CcrResumeAutoFollowPattern, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + resume_follow, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.CcrResumeFollow, options?: TransportRequestOptions): TransportRequestPromise> + resume_follow, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + resume_follow, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.CcrResumeFollow, callback: callbackFn): TransportRequestCallback + resume_follow, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.CcrResumeFollow, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + resumeFollow, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.CcrResumeFollow, options?: TransportRequestOptions): TransportRequestPromise> + resumeFollow, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + resumeFollow, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.CcrResumeFollow, callback: callbackFn): TransportRequestCallback + resumeFollow, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.CcrResumeFollow, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + stats, TContext = Context>(params?: RequestParams.CcrStats, options?: TransportRequestOptions): TransportRequestPromise> + stats, TContext = Context>(callback: callbackFn): TransportRequestCallback + stats, TContext = Context>(params: RequestParams.CcrStats, callback: callbackFn): TransportRequestCallback + stats, TContext = Context>(params: RequestParams.CcrStats, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + unfollow, TContext = Context>(params?: RequestParams.CcrUnfollow, options?: TransportRequestOptions): TransportRequestPromise> + unfollow, TContext = Context>(callback: callbackFn): TransportRequestCallback + unfollow, TContext = Context>(params: RequestParams.CcrUnfollow, callback: callbackFn): TransportRequestCallback + unfollow, TContext = Context>(params: RequestParams.CcrUnfollow, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + clear_scroll, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.ClearScroll, options?: TransportRequestOptions): TransportRequestPromise> + clear_scroll, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + clear_scroll, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ClearScroll, callback: callbackFn): TransportRequestCallback + clear_scroll, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ClearScroll, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + clearScroll, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.ClearScroll, options?: TransportRequestOptions): TransportRequestPromise> + clearScroll, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + clearScroll, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ClearScroll, callback: callbackFn): TransportRequestCallback + clearScroll, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ClearScroll, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + close_point_in_time, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.ClosePointInTime, options?: TransportRequestOptions): TransportRequestPromise> + close_point_in_time, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + close_point_in_time, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ClosePointInTime, callback: callbackFn): TransportRequestCallback + close_point_in_time, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ClosePointInTime, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + closePointInTime, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.ClosePointInTime, options?: TransportRequestOptions): TransportRequestPromise> + closePointInTime, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + closePointInTime, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ClosePointInTime, callback: callbackFn): TransportRequestCallback + closePointInTime, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ClosePointInTime, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + cluster: { + allocation_explain, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.ClusterAllocationExplain, options?: TransportRequestOptions): TransportRequestPromise> + allocation_explain, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + allocation_explain, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ClusterAllocationExplain, callback: callbackFn): TransportRequestCallback + allocation_explain, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ClusterAllocationExplain, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + allocationExplain, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.ClusterAllocationExplain, options?: TransportRequestOptions): TransportRequestPromise> + allocationExplain, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + allocationExplain, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ClusterAllocationExplain, callback: callbackFn): TransportRequestCallback + allocationExplain, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ClusterAllocationExplain, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete_component_template, TContext = Context>(params?: RequestParams.ClusterDeleteComponentTemplate, options?: TransportRequestOptions): TransportRequestPromise> + delete_component_template, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_component_template, TContext = Context>(params: RequestParams.ClusterDeleteComponentTemplate, callback: callbackFn): TransportRequestCallback + delete_component_template, TContext = Context>(params: RequestParams.ClusterDeleteComponentTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteComponentTemplate, TContext = Context>(params?: RequestParams.ClusterDeleteComponentTemplate, options?: TransportRequestOptions): TransportRequestPromise> + deleteComponentTemplate, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteComponentTemplate, TContext = Context>(params: RequestParams.ClusterDeleteComponentTemplate, callback: callbackFn): TransportRequestCallback + deleteComponentTemplate, TContext = Context>(params: RequestParams.ClusterDeleteComponentTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete_voting_config_exclusions, TContext = Context>(params?: RequestParams.ClusterDeleteVotingConfigExclusions, options?: TransportRequestOptions): TransportRequestPromise> + delete_voting_config_exclusions, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_voting_config_exclusions, TContext = Context>(params: RequestParams.ClusterDeleteVotingConfigExclusions, callback: callbackFn): TransportRequestCallback + delete_voting_config_exclusions, TContext = Context>(params: RequestParams.ClusterDeleteVotingConfigExclusions, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteVotingConfigExclusions, TContext = Context>(params?: RequestParams.ClusterDeleteVotingConfigExclusions, options?: TransportRequestOptions): TransportRequestPromise> + deleteVotingConfigExclusions, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteVotingConfigExclusions, TContext = Context>(params: RequestParams.ClusterDeleteVotingConfigExclusions, callback: callbackFn): TransportRequestCallback + deleteVotingConfigExclusions, TContext = Context>(params: RequestParams.ClusterDeleteVotingConfigExclusions, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + exists_component_template(params?: RequestParams.ClusterExistsComponentTemplate, options?: TransportRequestOptions): TransportRequestPromise> + exists_component_template(callback: callbackFn): TransportRequestCallback + exists_component_template(params: RequestParams.ClusterExistsComponentTemplate, callback: callbackFn): TransportRequestCallback + exists_component_template(params: RequestParams.ClusterExistsComponentTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + existsComponentTemplate(params?: RequestParams.ClusterExistsComponentTemplate, options?: TransportRequestOptions): TransportRequestPromise> + existsComponentTemplate(callback: callbackFn): TransportRequestCallback + existsComponentTemplate(params: RequestParams.ClusterExistsComponentTemplate, callback: callbackFn): TransportRequestCallback + existsComponentTemplate(params: RequestParams.ClusterExistsComponentTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_component_template, TContext = Context>(params?: RequestParams.ClusterGetComponentTemplate, options?: TransportRequestOptions): TransportRequestPromise> + get_component_template, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_component_template, TContext = Context>(params: RequestParams.ClusterGetComponentTemplate, callback: callbackFn): TransportRequestCallback + get_component_template, TContext = Context>(params: RequestParams.ClusterGetComponentTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getComponentTemplate, TContext = Context>(params?: RequestParams.ClusterGetComponentTemplate, options?: TransportRequestOptions): TransportRequestPromise> + getComponentTemplate, TContext = Context>(callback: callbackFn): TransportRequestCallback + getComponentTemplate, TContext = Context>(params: RequestParams.ClusterGetComponentTemplate, callback: callbackFn): TransportRequestCallback + getComponentTemplate, TContext = Context>(params: RequestParams.ClusterGetComponentTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_settings, TContext = Context>(params?: RequestParams.ClusterGetSettings, options?: TransportRequestOptions): TransportRequestPromise> + get_settings, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_settings, TContext = Context>(params: RequestParams.ClusterGetSettings, callback: callbackFn): TransportRequestCallback + get_settings, TContext = Context>(params: RequestParams.ClusterGetSettings, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getSettings, TContext = Context>(params?: RequestParams.ClusterGetSettings, options?: TransportRequestOptions): TransportRequestPromise> + getSettings, TContext = Context>(callback: callbackFn): TransportRequestCallback + getSettings, TContext = Context>(params: RequestParams.ClusterGetSettings, callback: callbackFn): TransportRequestCallback + getSettings, TContext = Context>(params: RequestParams.ClusterGetSettings, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + health, TContext = Context>(params?: RequestParams.ClusterHealth, options?: TransportRequestOptions): TransportRequestPromise> + health, TContext = Context>(callback: callbackFn): TransportRequestCallback + health, TContext = Context>(params: RequestParams.ClusterHealth, callback: callbackFn): TransportRequestCallback + health, TContext = Context>(params: RequestParams.ClusterHealth, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + pending_tasks, TContext = Context>(params?: RequestParams.ClusterPendingTasks, options?: TransportRequestOptions): TransportRequestPromise> + pending_tasks, TContext = Context>(callback: callbackFn): TransportRequestCallback + pending_tasks, TContext = Context>(params: RequestParams.ClusterPendingTasks, callback: callbackFn): TransportRequestCallback + pending_tasks, TContext = Context>(params: RequestParams.ClusterPendingTasks, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + pendingTasks, TContext = Context>(params?: RequestParams.ClusterPendingTasks, options?: TransportRequestOptions): TransportRequestPromise> + pendingTasks, TContext = Context>(callback: callbackFn): TransportRequestCallback + pendingTasks, TContext = Context>(params: RequestParams.ClusterPendingTasks, callback: callbackFn): TransportRequestCallback + pendingTasks, TContext = Context>(params: RequestParams.ClusterPendingTasks, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + post_voting_config_exclusions, TContext = Context>(params?: RequestParams.ClusterPostVotingConfigExclusions, options?: TransportRequestOptions): TransportRequestPromise> + post_voting_config_exclusions, TContext = Context>(callback: callbackFn): TransportRequestCallback + post_voting_config_exclusions, TContext = Context>(params: RequestParams.ClusterPostVotingConfigExclusions, callback: callbackFn): TransportRequestCallback + post_voting_config_exclusions, TContext = Context>(params: RequestParams.ClusterPostVotingConfigExclusions, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + postVotingConfigExclusions, TContext = Context>(params?: RequestParams.ClusterPostVotingConfigExclusions, options?: TransportRequestOptions): TransportRequestPromise> + postVotingConfigExclusions, TContext = Context>(callback: callbackFn): TransportRequestCallback + postVotingConfigExclusions, TContext = Context>(params: RequestParams.ClusterPostVotingConfigExclusions, callback: callbackFn): TransportRequestCallback + postVotingConfigExclusions, TContext = Context>(params: RequestParams.ClusterPostVotingConfigExclusions, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_component_template, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.ClusterPutComponentTemplate, options?: TransportRequestOptions): TransportRequestPromise> + put_component_template, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_component_template, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ClusterPutComponentTemplate, callback: callbackFn): TransportRequestCallback + put_component_template, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ClusterPutComponentTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putComponentTemplate, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.ClusterPutComponentTemplate, options?: TransportRequestOptions): TransportRequestPromise> + putComponentTemplate, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + putComponentTemplate, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ClusterPutComponentTemplate, callback: callbackFn): TransportRequestCallback + putComponentTemplate, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ClusterPutComponentTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_settings, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.ClusterPutSettings, options?: TransportRequestOptions): TransportRequestPromise> + put_settings, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_settings, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ClusterPutSettings, callback: callbackFn): TransportRequestCallback + put_settings, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ClusterPutSettings, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putSettings, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.ClusterPutSettings, options?: TransportRequestOptions): TransportRequestPromise> + putSettings, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + putSettings, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ClusterPutSettings, callback: callbackFn): TransportRequestCallback + putSettings, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ClusterPutSettings, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + remote_info, TContext = Context>(params?: RequestParams.ClusterRemoteInfo, options?: TransportRequestOptions): TransportRequestPromise> + remote_info, TContext = Context>(callback: callbackFn): TransportRequestCallback + remote_info, TContext = Context>(params: RequestParams.ClusterRemoteInfo, callback: callbackFn): TransportRequestCallback + remote_info, TContext = Context>(params: RequestParams.ClusterRemoteInfo, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + remoteInfo, TContext = Context>(params?: RequestParams.ClusterRemoteInfo, options?: TransportRequestOptions): TransportRequestPromise> + remoteInfo, TContext = Context>(callback: callbackFn): TransportRequestCallback + remoteInfo, TContext = Context>(params: RequestParams.ClusterRemoteInfo, callback: callbackFn): TransportRequestCallback + remoteInfo, TContext = Context>(params: RequestParams.ClusterRemoteInfo, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + reroute, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.ClusterReroute, options?: TransportRequestOptions): TransportRequestPromise> + reroute, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + reroute, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ClusterReroute, callback: callbackFn): TransportRequestCallback + reroute, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ClusterReroute, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + state, TContext = Context>(params?: RequestParams.ClusterState, options?: TransportRequestOptions): TransportRequestPromise> + state, TContext = Context>(callback: callbackFn): TransportRequestCallback + state, TContext = Context>(params: RequestParams.ClusterState, callback: callbackFn): TransportRequestCallback + state, TContext = Context>(params: RequestParams.ClusterState, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + stats, TContext = Context>(params?: RequestParams.ClusterStats, options?: TransportRequestOptions): TransportRequestPromise> + stats, TContext = Context>(callback: callbackFn): TransportRequestCallback + stats, TContext = Context>(params: RequestParams.ClusterStats, callback: callbackFn): TransportRequestCallback + stats, TContext = Context>(params: RequestParams.ClusterStats, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + count, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.Count, options?: TransportRequestOptions): TransportRequestPromise> + count, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + count, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.Count, callback: callbackFn): TransportRequestCallback + count, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.Count, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + create, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.Create, options?: TransportRequestOptions): TransportRequestPromise> + create, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + create, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.Create, callback: callbackFn): TransportRequestCallback + create, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.Create, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + dangling_indices: { + delete_dangling_index, TContext = Context>(params?: RequestParams.DanglingIndicesDeleteDanglingIndex, options?: TransportRequestOptions): TransportRequestPromise> + delete_dangling_index, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_dangling_index, TContext = Context>(params: RequestParams.DanglingIndicesDeleteDanglingIndex, callback: callbackFn): TransportRequestCallback + delete_dangling_index, TContext = Context>(params: RequestParams.DanglingIndicesDeleteDanglingIndex, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteDanglingIndex, TContext = Context>(params?: RequestParams.DanglingIndicesDeleteDanglingIndex, options?: TransportRequestOptions): TransportRequestPromise> + deleteDanglingIndex, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteDanglingIndex, TContext = Context>(params: RequestParams.DanglingIndicesDeleteDanglingIndex, callback: callbackFn): TransportRequestCallback + deleteDanglingIndex, TContext = Context>(params: RequestParams.DanglingIndicesDeleteDanglingIndex, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + import_dangling_index, TContext = Context>(params?: RequestParams.DanglingIndicesImportDanglingIndex, options?: TransportRequestOptions): TransportRequestPromise> + import_dangling_index, TContext = Context>(callback: callbackFn): TransportRequestCallback + import_dangling_index, TContext = Context>(params: RequestParams.DanglingIndicesImportDanglingIndex, callback: callbackFn): TransportRequestCallback + import_dangling_index, TContext = Context>(params: RequestParams.DanglingIndicesImportDanglingIndex, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + importDanglingIndex, TContext = Context>(params?: RequestParams.DanglingIndicesImportDanglingIndex, options?: TransportRequestOptions): TransportRequestPromise> + importDanglingIndex, TContext = Context>(callback: callbackFn): TransportRequestCallback + importDanglingIndex, TContext = Context>(params: RequestParams.DanglingIndicesImportDanglingIndex, callback: callbackFn): TransportRequestCallback + importDanglingIndex, TContext = Context>(params: RequestParams.DanglingIndicesImportDanglingIndex, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + list_dangling_indices, TContext = Context>(params?: RequestParams.DanglingIndicesListDanglingIndices, options?: TransportRequestOptions): TransportRequestPromise> + list_dangling_indices, TContext = Context>(callback: callbackFn): TransportRequestCallback + list_dangling_indices, TContext = Context>(params: RequestParams.DanglingIndicesListDanglingIndices, callback: callbackFn): TransportRequestCallback + list_dangling_indices, TContext = Context>(params: RequestParams.DanglingIndicesListDanglingIndices, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + listDanglingIndices, TContext = Context>(params?: RequestParams.DanglingIndicesListDanglingIndices, options?: TransportRequestOptions): TransportRequestPromise> + listDanglingIndices, TContext = Context>(callback: callbackFn): TransportRequestCallback + listDanglingIndices, TContext = Context>(params: RequestParams.DanglingIndicesListDanglingIndices, callback: callbackFn): TransportRequestCallback + listDanglingIndices, TContext = Context>(params: RequestParams.DanglingIndicesListDanglingIndices, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + danglingIndices: { + delete_dangling_index, TContext = Context>(params?: RequestParams.DanglingIndicesDeleteDanglingIndex, options?: TransportRequestOptions): TransportRequestPromise> + delete_dangling_index, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_dangling_index, TContext = Context>(params: RequestParams.DanglingIndicesDeleteDanglingIndex, callback: callbackFn): TransportRequestCallback + delete_dangling_index, TContext = Context>(params: RequestParams.DanglingIndicesDeleteDanglingIndex, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteDanglingIndex, TContext = Context>(params?: RequestParams.DanglingIndicesDeleteDanglingIndex, options?: TransportRequestOptions): TransportRequestPromise> + deleteDanglingIndex, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteDanglingIndex, TContext = Context>(params: RequestParams.DanglingIndicesDeleteDanglingIndex, callback: callbackFn): TransportRequestCallback + deleteDanglingIndex, TContext = Context>(params: RequestParams.DanglingIndicesDeleteDanglingIndex, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + import_dangling_index, TContext = Context>(params?: RequestParams.DanglingIndicesImportDanglingIndex, options?: TransportRequestOptions): TransportRequestPromise> + import_dangling_index, TContext = Context>(callback: callbackFn): TransportRequestCallback + import_dangling_index, TContext = Context>(params: RequestParams.DanglingIndicesImportDanglingIndex, callback: callbackFn): TransportRequestCallback + import_dangling_index, TContext = Context>(params: RequestParams.DanglingIndicesImportDanglingIndex, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + importDanglingIndex, TContext = Context>(params?: RequestParams.DanglingIndicesImportDanglingIndex, options?: TransportRequestOptions): TransportRequestPromise> + importDanglingIndex, TContext = Context>(callback: callbackFn): TransportRequestCallback + importDanglingIndex, TContext = Context>(params: RequestParams.DanglingIndicesImportDanglingIndex, callback: callbackFn): TransportRequestCallback + importDanglingIndex, TContext = Context>(params: RequestParams.DanglingIndicesImportDanglingIndex, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + list_dangling_indices, TContext = Context>(params?: RequestParams.DanglingIndicesListDanglingIndices, options?: TransportRequestOptions): TransportRequestPromise> + list_dangling_indices, TContext = Context>(callback: callbackFn): TransportRequestCallback + list_dangling_indices, TContext = Context>(params: RequestParams.DanglingIndicesListDanglingIndices, callback: callbackFn): TransportRequestCallback + list_dangling_indices, TContext = Context>(params: RequestParams.DanglingIndicesListDanglingIndices, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + listDanglingIndices, TContext = Context>(params?: RequestParams.DanglingIndicesListDanglingIndices, options?: TransportRequestOptions): TransportRequestPromise> + listDanglingIndices, TContext = Context>(callback: callbackFn): TransportRequestCallback + listDanglingIndices, TContext = Context>(params: RequestParams.DanglingIndicesListDanglingIndices, callback: callbackFn): TransportRequestCallback + listDanglingIndices, TContext = Context>(params: RequestParams.DanglingIndicesListDanglingIndices, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + delete, TContext = Context>(params?: RequestParams.Delete, options?: TransportRequestOptions): TransportRequestPromise> + delete, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete, TContext = Context>(params: RequestParams.Delete, callback: callbackFn): TransportRequestCallback + delete, TContext = Context>(params: RequestParams.Delete, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete_by_query, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.DeleteByQuery, options?: TransportRequestOptions): TransportRequestPromise> + delete_by_query, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_by_query, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.DeleteByQuery, callback: callbackFn): TransportRequestCallback + delete_by_query, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.DeleteByQuery, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteByQuery, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.DeleteByQuery, options?: TransportRequestOptions): TransportRequestPromise> + deleteByQuery, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteByQuery, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.DeleteByQuery, callback: callbackFn): TransportRequestCallback + deleteByQuery, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.DeleteByQuery, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete_by_query_rethrottle, TContext = Context>(params?: RequestParams.DeleteByQueryRethrottle, options?: TransportRequestOptions): TransportRequestPromise> + delete_by_query_rethrottle, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_by_query_rethrottle, TContext = Context>(params: RequestParams.DeleteByQueryRethrottle, callback: callbackFn): TransportRequestCallback + delete_by_query_rethrottle, TContext = Context>(params: RequestParams.DeleteByQueryRethrottle, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteByQueryRethrottle, TContext = Context>(params?: RequestParams.DeleteByQueryRethrottle, options?: TransportRequestOptions): TransportRequestPromise> + deleteByQueryRethrottle, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteByQueryRethrottle, TContext = Context>(params: RequestParams.DeleteByQueryRethrottle, callback: callbackFn): TransportRequestCallback + deleteByQueryRethrottle, TContext = Context>(params: RequestParams.DeleteByQueryRethrottle, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete_script, TContext = Context>(params?: RequestParams.DeleteScript, options?: TransportRequestOptions): TransportRequestPromise> + delete_script, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_script, TContext = Context>(params: RequestParams.DeleteScript, callback: callbackFn): TransportRequestCallback + delete_script, TContext = Context>(params: RequestParams.DeleteScript, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteScript, TContext = Context>(params?: RequestParams.DeleteScript, options?: TransportRequestOptions): TransportRequestPromise> + deleteScript, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteScript, TContext = Context>(params: RequestParams.DeleteScript, callback: callbackFn): TransportRequestCallback + deleteScript, TContext = Context>(params: RequestParams.DeleteScript, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + enrich: { + delete_policy, TContext = Context>(params?: RequestParams.EnrichDeletePolicy, options?: TransportRequestOptions): TransportRequestPromise> + delete_policy, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_policy, TContext = Context>(params: RequestParams.EnrichDeletePolicy, callback: callbackFn): TransportRequestCallback + delete_policy, TContext = Context>(params: RequestParams.EnrichDeletePolicy, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deletePolicy, TContext = Context>(params?: RequestParams.EnrichDeletePolicy, options?: TransportRequestOptions): TransportRequestPromise> + deletePolicy, TContext = Context>(callback: callbackFn): TransportRequestCallback + deletePolicy, TContext = Context>(params: RequestParams.EnrichDeletePolicy, callback: callbackFn): TransportRequestCallback + deletePolicy, TContext = Context>(params: RequestParams.EnrichDeletePolicy, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + execute_policy, TContext = Context>(params?: RequestParams.EnrichExecutePolicy, options?: TransportRequestOptions): TransportRequestPromise> + execute_policy, TContext = Context>(callback: callbackFn): TransportRequestCallback + execute_policy, TContext = Context>(params: RequestParams.EnrichExecutePolicy, callback: callbackFn): TransportRequestCallback + execute_policy, TContext = Context>(params: RequestParams.EnrichExecutePolicy, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + executePolicy, TContext = Context>(params?: RequestParams.EnrichExecutePolicy, options?: TransportRequestOptions): TransportRequestPromise> + executePolicy, TContext = Context>(callback: callbackFn): TransportRequestCallback + executePolicy, TContext = Context>(params: RequestParams.EnrichExecutePolicy, callback: callbackFn): TransportRequestCallback + executePolicy, TContext = Context>(params: RequestParams.EnrichExecutePolicy, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_policy, TContext = Context>(params?: RequestParams.EnrichGetPolicy, options?: TransportRequestOptions): TransportRequestPromise> + get_policy, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_policy, TContext = Context>(params: RequestParams.EnrichGetPolicy, callback: callbackFn): TransportRequestCallback + get_policy, TContext = Context>(params: RequestParams.EnrichGetPolicy, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getPolicy, TContext = Context>(params?: RequestParams.EnrichGetPolicy, options?: TransportRequestOptions): TransportRequestPromise> + getPolicy, TContext = Context>(callback: callbackFn): TransportRequestCallback + getPolicy, TContext = Context>(params: RequestParams.EnrichGetPolicy, callback: callbackFn): TransportRequestCallback + getPolicy, TContext = Context>(params: RequestParams.EnrichGetPolicy, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_policy, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.EnrichPutPolicy, options?: TransportRequestOptions): TransportRequestPromise> + put_policy, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_policy, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.EnrichPutPolicy, callback: callbackFn): TransportRequestCallback + put_policy, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.EnrichPutPolicy, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putPolicy, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.EnrichPutPolicy, options?: TransportRequestOptions): TransportRequestPromise> + putPolicy, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + putPolicy, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.EnrichPutPolicy, callback: callbackFn): TransportRequestCallback + putPolicy, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.EnrichPutPolicy, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + stats, TContext = Context>(params?: RequestParams.EnrichStats, options?: TransportRequestOptions): TransportRequestPromise> + stats, TContext = Context>(callback: callbackFn): TransportRequestCallback + stats, TContext = Context>(params: RequestParams.EnrichStats, callback: callbackFn): TransportRequestCallback + stats, TContext = Context>(params: RequestParams.EnrichStats, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + eql: { + delete, TContext = Context>(params?: RequestParams.EqlDelete, options?: TransportRequestOptions): TransportRequestPromise> + delete, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete, TContext = Context>(params: RequestParams.EqlDelete, callback: callbackFn): TransportRequestCallback + delete, TContext = Context>(params: RequestParams.EqlDelete, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get, TContext = Context>(params?: RequestParams.EqlGet, options?: TransportRequestOptions): TransportRequestPromise> + get, TContext = Context>(callback: callbackFn): TransportRequestCallback + get, TContext = Context>(params: RequestParams.EqlGet, callback: callbackFn): TransportRequestCallback + get, TContext = Context>(params: RequestParams.EqlGet, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_status, TContext = Context>(params?: RequestParams.EqlGetStatus, options?: TransportRequestOptions): TransportRequestPromise> + get_status, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_status, TContext = Context>(params: RequestParams.EqlGetStatus, callback: callbackFn): TransportRequestCallback + get_status, TContext = Context>(params: RequestParams.EqlGetStatus, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getStatus, TContext = Context>(params?: RequestParams.EqlGetStatus, options?: TransportRequestOptions): TransportRequestPromise> + getStatus, TContext = Context>(callback: callbackFn): TransportRequestCallback + getStatus, TContext = Context>(params: RequestParams.EqlGetStatus, callback: callbackFn): TransportRequestCallback + getStatus, TContext = Context>(params: RequestParams.EqlGetStatus, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + search, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.EqlSearch, options?: TransportRequestOptions): TransportRequestPromise> + search, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + search, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.EqlSearch, callback: callbackFn): TransportRequestCallback + search, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.EqlSearch, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + exists(params?: RequestParams.Exists, options?: TransportRequestOptions): TransportRequestPromise> + exists(callback: callbackFn): TransportRequestCallback + exists(params: RequestParams.Exists, callback: callbackFn): TransportRequestCallback + exists(params: RequestParams.Exists, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + exists_source(params?: RequestParams.ExistsSource, options?: TransportRequestOptions): TransportRequestPromise> + exists_source(callback: callbackFn): TransportRequestCallback + exists_source(params: RequestParams.ExistsSource, callback: callbackFn): TransportRequestCallback + exists_source(params: RequestParams.ExistsSource, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + existsSource(params?: RequestParams.ExistsSource, options?: TransportRequestOptions): TransportRequestPromise> + existsSource(callback: callbackFn): TransportRequestCallback + existsSource(params: RequestParams.ExistsSource, callback: callbackFn): TransportRequestCallback + existsSource(params: RequestParams.ExistsSource, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + explain, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.Explain, options?: TransportRequestOptions): TransportRequestPromise> + explain, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + explain, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.Explain, callback: callbackFn): TransportRequestCallback + explain, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.Explain, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + features: { + get_features, TContext = Context>(params?: RequestParams.FeaturesGetFeatures, options?: TransportRequestOptions): TransportRequestPromise> + get_features, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_features, TContext = Context>(params: RequestParams.FeaturesGetFeatures, callback: callbackFn): TransportRequestCallback + get_features, TContext = Context>(params: RequestParams.FeaturesGetFeatures, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getFeatures, TContext = Context>(params?: RequestParams.FeaturesGetFeatures, options?: TransportRequestOptions): TransportRequestPromise> + getFeatures, TContext = Context>(callback: callbackFn): TransportRequestCallback + getFeatures, TContext = Context>(params: RequestParams.FeaturesGetFeatures, callback: callbackFn): TransportRequestCallback + getFeatures, TContext = Context>(params: RequestParams.FeaturesGetFeatures, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + reset_features, TContext = Context>(params?: RequestParams.FeaturesResetFeatures, options?: TransportRequestOptions): TransportRequestPromise> + reset_features, TContext = Context>(callback: callbackFn): TransportRequestCallback + reset_features, TContext = Context>(params: RequestParams.FeaturesResetFeatures, callback: callbackFn): TransportRequestCallback + reset_features, TContext = Context>(params: RequestParams.FeaturesResetFeatures, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + resetFeatures, TContext = Context>(params?: RequestParams.FeaturesResetFeatures, options?: TransportRequestOptions): TransportRequestPromise> + resetFeatures, TContext = Context>(callback: callbackFn): TransportRequestCallback + resetFeatures, TContext = Context>(params: RequestParams.FeaturesResetFeatures, callback: callbackFn): TransportRequestCallback + resetFeatures, TContext = Context>(params: RequestParams.FeaturesResetFeatures, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + field_caps, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.FieldCaps, options?: TransportRequestOptions): TransportRequestPromise> + field_caps, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + field_caps, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.FieldCaps, callback: callbackFn): TransportRequestCallback + field_caps, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.FieldCaps, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + fieldCaps, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.FieldCaps, options?: TransportRequestOptions): TransportRequestPromise> + fieldCaps, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + fieldCaps, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.FieldCaps, callback: callbackFn): TransportRequestCallback + fieldCaps, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.FieldCaps, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get, TContext = Context>(params?: RequestParams.Get, options?: TransportRequestOptions): TransportRequestPromise> + get, TContext = Context>(callback: callbackFn): TransportRequestCallback + get, TContext = Context>(params: RequestParams.Get, callback: callbackFn): TransportRequestCallback + get, TContext = Context>(params: RequestParams.Get, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_script, TContext = Context>(params?: RequestParams.GetScript, options?: TransportRequestOptions): TransportRequestPromise> + get_script, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_script, TContext = Context>(params: RequestParams.GetScript, callback: callbackFn): TransportRequestCallback + get_script, TContext = Context>(params: RequestParams.GetScript, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getScript, TContext = Context>(params?: RequestParams.GetScript, options?: TransportRequestOptions): TransportRequestPromise> + getScript, TContext = Context>(callback: callbackFn): TransportRequestCallback + getScript, TContext = Context>(params: RequestParams.GetScript, callback: callbackFn): TransportRequestCallback + getScript, TContext = Context>(params: RequestParams.GetScript, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_script_context, TContext = Context>(params?: RequestParams.GetScriptContext, options?: TransportRequestOptions): TransportRequestPromise> + get_script_context, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_script_context, TContext = Context>(params: RequestParams.GetScriptContext, callback: callbackFn): TransportRequestCallback + get_script_context, TContext = Context>(params: RequestParams.GetScriptContext, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getScriptContext, TContext = Context>(params?: RequestParams.GetScriptContext, options?: TransportRequestOptions): TransportRequestPromise> + getScriptContext, TContext = Context>(callback: callbackFn): TransportRequestCallback + getScriptContext, TContext = Context>(params: RequestParams.GetScriptContext, callback: callbackFn): TransportRequestCallback + getScriptContext, TContext = Context>(params: RequestParams.GetScriptContext, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_script_languages, TContext = Context>(params?: RequestParams.GetScriptLanguages, options?: TransportRequestOptions): TransportRequestPromise> + get_script_languages, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_script_languages, TContext = Context>(params: RequestParams.GetScriptLanguages, callback: callbackFn): TransportRequestCallback + get_script_languages, TContext = Context>(params: RequestParams.GetScriptLanguages, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getScriptLanguages, TContext = Context>(params?: RequestParams.GetScriptLanguages, options?: TransportRequestOptions): TransportRequestPromise> + getScriptLanguages, TContext = Context>(callback: callbackFn): TransportRequestCallback + getScriptLanguages, TContext = Context>(params: RequestParams.GetScriptLanguages, callback: callbackFn): TransportRequestCallback + getScriptLanguages, TContext = Context>(params: RequestParams.GetScriptLanguages, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_source, TContext = Context>(params?: RequestParams.GetSource, options?: TransportRequestOptions): TransportRequestPromise> + get_source, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_source, TContext = Context>(params: RequestParams.GetSource, callback: callbackFn): TransportRequestCallback + get_source, TContext = Context>(params: RequestParams.GetSource, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getSource, TContext = Context>(params?: RequestParams.GetSource, options?: TransportRequestOptions): TransportRequestPromise> + getSource, TContext = Context>(callback: callbackFn): TransportRequestCallback + getSource, TContext = Context>(params: RequestParams.GetSource, callback: callbackFn): TransportRequestCallback + getSource, TContext = Context>(params: RequestParams.GetSource, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + graph: { + explore, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.GraphExplore, options?: TransportRequestOptions): TransportRequestPromise> + explore, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + explore, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.GraphExplore, callback: callbackFn): TransportRequestCallback + explore, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.GraphExplore, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + ilm: { + delete_lifecycle, TContext = Context>(params?: RequestParams.IlmDeleteLifecycle, options?: TransportRequestOptions): TransportRequestPromise> + delete_lifecycle, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_lifecycle, TContext = Context>(params: RequestParams.IlmDeleteLifecycle, callback: callbackFn): TransportRequestCallback + delete_lifecycle, TContext = Context>(params: RequestParams.IlmDeleteLifecycle, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteLifecycle, TContext = Context>(params?: RequestParams.IlmDeleteLifecycle, options?: TransportRequestOptions): TransportRequestPromise> + deleteLifecycle, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteLifecycle, TContext = Context>(params: RequestParams.IlmDeleteLifecycle, callback: callbackFn): TransportRequestCallback + deleteLifecycle, TContext = Context>(params: RequestParams.IlmDeleteLifecycle, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + explain_lifecycle, TContext = Context>(params?: RequestParams.IlmExplainLifecycle, options?: TransportRequestOptions): TransportRequestPromise> + explain_lifecycle, TContext = Context>(callback: callbackFn): TransportRequestCallback + explain_lifecycle, TContext = Context>(params: RequestParams.IlmExplainLifecycle, callback: callbackFn): TransportRequestCallback + explain_lifecycle, TContext = Context>(params: RequestParams.IlmExplainLifecycle, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + explainLifecycle, TContext = Context>(params?: RequestParams.IlmExplainLifecycle, options?: TransportRequestOptions): TransportRequestPromise> + explainLifecycle, TContext = Context>(callback: callbackFn): TransportRequestCallback + explainLifecycle, TContext = Context>(params: RequestParams.IlmExplainLifecycle, callback: callbackFn): TransportRequestCallback + explainLifecycle, TContext = Context>(params: RequestParams.IlmExplainLifecycle, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_lifecycle, TContext = Context>(params?: RequestParams.IlmGetLifecycle, options?: TransportRequestOptions): TransportRequestPromise> + get_lifecycle, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_lifecycle, TContext = Context>(params: RequestParams.IlmGetLifecycle, callback: callbackFn): TransportRequestCallback + get_lifecycle, TContext = Context>(params: RequestParams.IlmGetLifecycle, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getLifecycle, TContext = Context>(params?: RequestParams.IlmGetLifecycle, options?: TransportRequestOptions): TransportRequestPromise> + getLifecycle, TContext = Context>(callback: callbackFn): TransportRequestCallback + getLifecycle, TContext = Context>(params: RequestParams.IlmGetLifecycle, callback: callbackFn): TransportRequestCallback + getLifecycle, TContext = Context>(params: RequestParams.IlmGetLifecycle, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_status, TContext = Context>(params?: RequestParams.IlmGetStatus, options?: TransportRequestOptions): TransportRequestPromise> + get_status, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_status, TContext = Context>(params: RequestParams.IlmGetStatus, callback: callbackFn): TransportRequestCallback + get_status, TContext = Context>(params: RequestParams.IlmGetStatus, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getStatus, TContext = Context>(params?: RequestParams.IlmGetStatus, options?: TransportRequestOptions): TransportRequestPromise> + getStatus, TContext = Context>(callback: callbackFn): TransportRequestCallback + getStatus, TContext = Context>(params: RequestParams.IlmGetStatus, callback: callbackFn): TransportRequestCallback + getStatus, TContext = Context>(params: RequestParams.IlmGetStatus, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + move_to_step, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IlmMoveToStep, options?: TransportRequestOptions): TransportRequestPromise> + move_to_step, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + move_to_step, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IlmMoveToStep, callback: callbackFn): TransportRequestCallback + move_to_step, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IlmMoveToStep, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + moveToStep, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IlmMoveToStep, options?: TransportRequestOptions): TransportRequestPromise> + moveToStep, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + moveToStep, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IlmMoveToStep, callback: callbackFn): TransportRequestCallback + moveToStep, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IlmMoveToStep, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_lifecycle, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IlmPutLifecycle, options?: TransportRequestOptions): TransportRequestPromise> + put_lifecycle, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_lifecycle, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IlmPutLifecycle, callback: callbackFn): TransportRequestCallback + put_lifecycle, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IlmPutLifecycle, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putLifecycle, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IlmPutLifecycle, options?: TransportRequestOptions): TransportRequestPromise> + putLifecycle, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + putLifecycle, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IlmPutLifecycle, callback: callbackFn): TransportRequestCallback + putLifecycle, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IlmPutLifecycle, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + remove_policy, TContext = Context>(params?: RequestParams.IlmRemovePolicy, options?: TransportRequestOptions): TransportRequestPromise> + remove_policy, TContext = Context>(callback: callbackFn): TransportRequestCallback + remove_policy, TContext = Context>(params: RequestParams.IlmRemovePolicy, callback: callbackFn): TransportRequestCallback + remove_policy, TContext = Context>(params: RequestParams.IlmRemovePolicy, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + removePolicy, TContext = Context>(params?: RequestParams.IlmRemovePolicy, options?: TransportRequestOptions): TransportRequestPromise> + removePolicy, TContext = Context>(callback: callbackFn): TransportRequestCallback + removePolicy, TContext = Context>(params: RequestParams.IlmRemovePolicy, callback: callbackFn): TransportRequestCallback + removePolicy, TContext = Context>(params: RequestParams.IlmRemovePolicy, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + retry, TContext = Context>(params?: RequestParams.IlmRetry, options?: TransportRequestOptions): TransportRequestPromise> + retry, TContext = Context>(callback: callbackFn): TransportRequestCallback + retry, TContext = Context>(params: RequestParams.IlmRetry, callback: callbackFn): TransportRequestCallback + retry, TContext = Context>(params: RequestParams.IlmRetry, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + start, TContext = Context>(params?: RequestParams.IlmStart, options?: TransportRequestOptions): TransportRequestPromise> + start, TContext = Context>(callback: callbackFn): TransportRequestCallback + start, TContext = Context>(params: RequestParams.IlmStart, callback: callbackFn): TransportRequestCallback + start, TContext = Context>(params: RequestParams.IlmStart, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + stop, TContext = Context>(params?: RequestParams.IlmStop, options?: TransportRequestOptions): TransportRequestPromise> + stop, TContext = Context>(callback: callbackFn): TransportRequestCallback + stop, TContext = Context>(params: RequestParams.IlmStop, callback: callbackFn): TransportRequestCallback + stop, TContext = Context>(params: RequestParams.IlmStop, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + index, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.Index, options?: TransportRequestOptions): TransportRequestPromise> + index, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + index, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.Index, callback: callbackFn): TransportRequestCallback + index, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.Index, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + indices: { + add_block, TContext = Context>(params?: RequestParams.IndicesAddBlock, options?: TransportRequestOptions): TransportRequestPromise> + add_block, TContext = Context>(callback: callbackFn): TransportRequestCallback + add_block, TContext = Context>(params: RequestParams.IndicesAddBlock, callback: callbackFn): TransportRequestCallback + add_block, TContext = Context>(params: RequestParams.IndicesAddBlock, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + addBlock, TContext = Context>(params?: RequestParams.IndicesAddBlock, options?: TransportRequestOptions): TransportRequestPromise> + addBlock, TContext = Context>(callback: callbackFn): TransportRequestCallback + addBlock, TContext = Context>(params: RequestParams.IndicesAddBlock, callback: callbackFn): TransportRequestCallback + addBlock, TContext = Context>(params: RequestParams.IndicesAddBlock, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + analyze, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IndicesAnalyze, options?: TransportRequestOptions): TransportRequestPromise> + analyze, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + analyze, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesAnalyze, callback: callbackFn): TransportRequestCallback + analyze, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesAnalyze, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + clear_cache, TContext = Context>(params?: RequestParams.IndicesClearCache, options?: TransportRequestOptions): TransportRequestPromise> + clear_cache, TContext = Context>(callback: callbackFn): TransportRequestCallback + clear_cache, TContext = Context>(params: RequestParams.IndicesClearCache, callback: callbackFn): TransportRequestCallback + clear_cache, TContext = Context>(params: RequestParams.IndicesClearCache, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + clearCache, TContext = Context>(params?: RequestParams.IndicesClearCache, options?: TransportRequestOptions): TransportRequestPromise> + clearCache, TContext = Context>(callback: callbackFn): TransportRequestCallback + clearCache, TContext = Context>(params: RequestParams.IndicesClearCache, callback: callbackFn): TransportRequestCallback + clearCache, TContext = Context>(params: RequestParams.IndicesClearCache, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + clone, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IndicesClone, options?: TransportRequestOptions): TransportRequestPromise> + clone, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + clone, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesClone, callback: callbackFn): TransportRequestCallback + clone, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesClone, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + close, TContext = Context>(params?: RequestParams.IndicesClose, options?: TransportRequestOptions): TransportRequestPromise> + close, TContext = Context>(callback: callbackFn): TransportRequestCallback + close, TContext = Context>(params: RequestParams.IndicesClose, callback: callbackFn): TransportRequestCallback + close, TContext = Context>(params: RequestParams.IndicesClose, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + create, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IndicesCreate, options?: TransportRequestOptions): TransportRequestPromise> + create, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + create, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesCreate, callback: callbackFn): TransportRequestCallback + create, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesCreate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + create_data_stream, TContext = Context>(params?: RequestParams.IndicesCreateDataStream, options?: TransportRequestOptions): TransportRequestPromise> + create_data_stream, TContext = Context>(callback: callbackFn): TransportRequestCallback + create_data_stream, TContext = Context>(params: RequestParams.IndicesCreateDataStream, callback: callbackFn): TransportRequestCallback + create_data_stream, TContext = Context>(params: RequestParams.IndicesCreateDataStream, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + createDataStream, TContext = Context>(params?: RequestParams.IndicesCreateDataStream, options?: TransportRequestOptions): TransportRequestPromise> + createDataStream, TContext = Context>(callback: callbackFn): TransportRequestCallback + createDataStream, TContext = Context>(params: RequestParams.IndicesCreateDataStream, callback: callbackFn): TransportRequestCallback + createDataStream, TContext = Context>(params: RequestParams.IndicesCreateDataStream, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + data_streams_stats, TContext = Context>(params?: RequestParams.IndicesDataStreamsStats, options?: TransportRequestOptions): TransportRequestPromise> + data_streams_stats, TContext = Context>(callback: callbackFn): TransportRequestCallback + data_streams_stats, TContext = Context>(params: RequestParams.IndicesDataStreamsStats, callback: callbackFn): TransportRequestCallback + data_streams_stats, TContext = Context>(params: RequestParams.IndicesDataStreamsStats, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + dataStreamsStats, TContext = Context>(params?: RequestParams.IndicesDataStreamsStats, options?: TransportRequestOptions): TransportRequestPromise> + dataStreamsStats, TContext = Context>(callback: callbackFn): TransportRequestCallback + dataStreamsStats, TContext = Context>(params: RequestParams.IndicesDataStreamsStats, callback: callbackFn): TransportRequestCallback + dataStreamsStats, TContext = Context>(params: RequestParams.IndicesDataStreamsStats, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete, TContext = Context>(params?: RequestParams.IndicesDelete, options?: TransportRequestOptions): TransportRequestPromise> + delete, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete, TContext = Context>(params: RequestParams.IndicesDelete, callback: callbackFn): TransportRequestCallback + delete, TContext = Context>(params: RequestParams.IndicesDelete, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete_alias, TContext = Context>(params?: RequestParams.IndicesDeleteAlias, options?: TransportRequestOptions): TransportRequestPromise> + delete_alias, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_alias, TContext = Context>(params: RequestParams.IndicesDeleteAlias, callback: callbackFn): TransportRequestCallback + delete_alias, TContext = Context>(params: RequestParams.IndicesDeleteAlias, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteAlias, TContext = Context>(params?: RequestParams.IndicesDeleteAlias, options?: TransportRequestOptions): TransportRequestPromise> + deleteAlias, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteAlias, TContext = Context>(params: RequestParams.IndicesDeleteAlias, callback: callbackFn): TransportRequestCallback + deleteAlias, TContext = Context>(params: RequestParams.IndicesDeleteAlias, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete_data_stream, TContext = Context>(params?: RequestParams.IndicesDeleteDataStream, options?: TransportRequestOptions): TransportRequestPromise> + delete_data_stream, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_data_stream, TContext = Context>(params: RequestParams.IndicesDeleteDataStream, callback: callbackFn): TransportRequestCallback + delete_data_stream, TContext = Context>(params: RequestParams.IndicesDeleteDataStream, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteDataStream, TContext = Context>(params?: RequestParams.IndicesDeleteDataStream, options?: TransportRequestOptions): TransportRequestPromise> + deleteDataStream, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteDataStream, TContext = Context>(params: RequestParams.IndicesDeleteDataStream, callback: callbackFn): TransportRequestCallback + deleteDataStream, TContext = Context>(params: RequestParams.IndicesDeleteDataStream, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete_index_template, TContext = Context>(params?: RequestParams.IndicesDeleteIndexTemplate, options?: TransportRequestOptions): TransportRequestPromise> + delete_index_template, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_index_template, TContext = Context>(params: RequestParams.IndicesDeleteIndexTemplate, callback: callbackFn): TransportRequestCallback + delete_index_template, TContext = Context>(params: RequestParams.IndicesDeleteIndexTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteIndexTemplate, TContext = Context>(params?: RequestParams.IndicesDeleteIndexTemplate, options?: TransportRequestOptions): TransportRequestPromise> + deleteIndexTemplate, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteIndexTemplate, TContext = Context>(params: RequestParams.IndicesDeleteIndexTemplate, callback: callbackFn): TransportRequestCallback + deleteIndexTemplate, TContext = Context>(params: RequestParams.IndicesDeleteIndexTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete_template, TContext = Context>(params?: RequestParams.IndicesDeleteTemplate, options?: TransportRequestOptions): TransportRequestPromise> + delete_template, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_template, TContext = Context>(params: RequestParams.IndicesDeleteTemplate, callback: callbackFn): TransportRequestCallback + delete_template, TContext = Context>(params: RequestParams.IndicesDeleteTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteTemplate, TContext = Context>(params?: RequestParams.IndicesDeleteTemplate, options?: TransportRequestOptions): TransportRequestPromise> + deleteTemplate, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteTemplate, TContext = Context>(params: RequestParams.IndicesDeleteTemplate, callback: callbackFn): TransportRequestCallback + deleteTemplate, TContext = Context>(params: RequestParams.IndicesDeleteTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + exists(params?: RequestParams.IndicesExists, options?: TransportRequestOptions): TransportRequestPromise> + exists(callback: callbackFn): TransportRequestCallback + exists(params: RequestParams.IndicesExists, callback: callbackFn): TransportRequestCallback + exists(params: RequestParams.IndicesExists, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + exists_alias(params?: RequestParams.IndicesExistsAlias, options?: TransportRequestOptions): TransportRequestPromise> + exists_alias(callback: callbackFn): TransportRequestCallback + exists_alias(params: RequestParams.IndicesExistsAlias, callback: callbackFn): TransportRequestCallback + exists_alias(params: RequestParams.IndicesExistsAlias, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + existsAlias(params?: RequestParams.IndicesExistsAlias, options?: TransportRequestOptions): TransportRequestPromise> + existsAlias(callback: callbackFn): TransportRequestCallback + existsAlias(params: RequestParams.IndicesExistsAlias, callback: callbackFn): TransportRequestCallback + existsAlias(params: RequestParams.IndicesExistsAlias, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + exists_index_template(params?: RequestParams.IndicesExistsIndexTemplate, options?: TransportRequestOptions): TransportRequestPromise> + exists_index_template(callback: callbackFn): TransportRequestCallback + exists_index_template(params: RequestParams.IndicesExistsIndexTemplate, callback: callbackFn): TransportRequestCallback + exists_index_template(params: RequestParams.IndicesExistsIndexTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + existsIndexTemplate(params?: RequestParams.IndicesExistsIndexTemplate, options?: TransportRequestOptions): TransportRequestPromise> + existsIndexTemplate(callback: callbackFn): TransportRequestCallback + existsIndexTemplate(params: RequestParams.IndicesExistsIndexTemplate, callback: callbackFn): TransportRequestCallback + existsIndexTemplate(params: RequestParams.IndicesExistsIndexTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + exists_template(params?: RequestParams.IndicesExistsTemplate, options?: TransportRequestOptions): TransportRequestPromise> + exists_template(callback: callbackFn): TransportRequestCallback + exists_template(params: RequestParams.IndicesExistsTemplate, callback: callbackFn): TransportRequestCallback + exists_template(params: RequestParams.IndicesExistsTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + existsTemplate(params?: RequestParams.IndicesExistsTemplate, options?: TransportRequestOptions): TransportRequestPromise> + existsTemplate(callback: callbackFn): TransportRequestCallback + existsTemplate(params: RequestParams.IndicesExistsTemplate, callback: callbackFn): TransportRequestCallback + existsTemplate(params: RequestParams.IndicesExistsTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + exists_type(params?: RequestParams.IndicesExistsType, options?: TransportRequestOptions): TransportRequestPromise> + exists_type(callback: callbackFn): TransportRequestCallback + exists_type(params: RequestParams.IndicesExistsType, callback: callbackFn): TransportRequestCallback + exists_type(params: RequestParams.IndicesExistsType, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + existsType(params?: RequestParams.IndicesExistsType, options?: TransportRequestOptions): TransportRequestPromise> + existsType(callback: callbackFn): TransportRequestCallback + existsType(params: RequestParams.IndicesExistsType, callback: callbackFn): TransportRequestCallback + existsType(params: RequestParams.IndicesExistsType, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + flush, TContext = Context>(params?: RequestParams.IndicesFlush, options?: TransportRequestOptions): TransportRequestPromise> + flush, TContext = Context>(callback: callbackFn): TransportRequestCallback + flush, TContext = Context>(params: RequestParams.IndicesFlush, callback: callbackFn): TransportRequestCallback + flush, TContext = Context>(params: RequestParams.IndicesFlush, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + forcemerge, TContext = Context>(params?: RequestParams.IndicesForcemerge, options?: TransportRequestOptions): TransportRequestPromise> + forcemerge, TContext = Context>(callback: callbackFn): TransportRequestCallback + forcemerge, TContext = Context>(params: RequestParams.IndicesForcemerge, callback: callbackFn): TransportRequestCallback + forcemerge, TContext = Context>(params: RequestParams.IndicesForcemerge, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + freeze, TContext = Context>(params?: RequestParams.IndicesFreeze, options?: TransportRequestOptions): TransportRequestPromise> + freeze, TContext = Context>(callback: callbackFn): TransportRequestCallback + freeze, TContext = Context>(params: RequestParams.IndicesFreeze, callback: callbackFn): TransportRequestCallback + freeze, TContext = Context>(params: RequestParams.IndicesFreeze, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get, TContext = Context>(params?: RequestParams.IndicesGet, options?: TransportRequestOptions): TransportRequestPromise> + get, TContext = Context>(callback: callbackFn): TransportRequestCallback + get, TContext = Context>(params: RequestParams.IndicesGet, callback: callbackFn): TransportRequestCallback + get, TContext = Context>(params: RequestParams.IndicesGet, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_alias, TContext = Context>(params?: RequestParams.IndicesGetAlias, options?: TransportRequestOptions): TransportRequestPromise> + get_alias, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_alias, TContext = Context>(params: RequestParams.IndicesGetAlias, callback: callbackFn): TransportRequestCallback + get_alias, TContext = Context>(params: RequestParams.IndicesGetAlias, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getAlias, TContext = Context>(params?: RequestParams.IndicesGetAlias, options?: TransportRequestOptions): TransportRequestPromise> + getAlias, TContext = Context>(callback: callbackFn): TransportRequestCallback + getAlias, TContext = Context>(params: RequestParams.IndicesGetAlias, callback: callbackFn): TransportRequestCallback + getAlias, TContext = Context>(params: RequestParams.IndicesGetAlias, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_data_stream, TContext = Context>(params?: RequestParams.IndicesGetDataStream, options?: TransportRequestOptions): TransportRequestPromise> + get_data_stream, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_data_stream, TContext = Context>(params: RequestParams.IndicesGetDataStream, callback: callbackFn): TransportRequestCallback + get_data_stream, TContext = Context>(params: RequestParams.IndicesGetDataStream, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getDataStream, TContext = Context>(params?: RequestParams.IndicesGetDataStream, options?: TransportRequestOptions): TransportRequestPromise> + getDataStream, TContext = Context>(callback: callbackFn): TransportRequestCallback + getDataStream, TContext = Context>(params: RequestParams.IndicesGetDataStream, callback: callbackFn): TransportRequestCallback + getDataStream, TContext = Context>(params: RequestParams.IndicesGetDataStream, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_field_mapping, TContext = Context>(params?: RequestParams.IndicesGetFieldMapping, options?: TransportRequestOptions): TransportRequestPromise> + get_field_mapping, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_field_mapping, TContext = Context>(params: RequestParams.IndicesGetFieldMapping, callback: callbackFn): TransportRequestCallback + get_field_mapping, TContext = Context>(params: RequestParams.IndicesGetFieldMapping, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getFieldMapping, TContext = Context>(params?: RequestParams.IndicesGetFieldMapping, options?: TransportRequestOptions): TransportRequestPromise> + getFieldMapping, TContext = Context>(callback: callbackFn): TransportRequestCallback + getFieldMapping, TContext = Context>(params: RequestParams.IndicesGetFieldMapping, callback: callbackFn): TransportRequestCallback + getFieldMapping, TContext = Context>(params: RequestParams.IndicesGetFieldMapping, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_index_template, TContext = Context>(params?: RequestParams.IndicesGetIndexTemplate, options?: TransportRequestOptions): TransportRequestPromise> + get_index_template, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_index_template, TContext = Context>(params: RequestParams.IndicesGetIndexTemplate, callback: callbackFn): TransportRequestCallback + get_index_template, TContext = Context>(params: RequestParams.IndicesGetIndexTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getIndexTemplate, TContext = Context>(params?: RequestParams.IndicesGetIndexTemplate, options?: TransportRequestOptions): TransportRequestPromise> + getIndexTemplate, TContext = Context>(callback: callbackFn): TransportRequestCallback + getIndexTemplate, TContext = Context>(params: RequestParams.IndicesGetIndexTemplate, callback: callbackFn): TransportRequestCallback + getIndexTemplate, TContext = Context>(params: RequestParams.IndicesGetIndexTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_mapping, TContext = Context>(params?: RequestParams.IndicesGetMapping, options?: TransportRequestOptions): TransportRequestPromise> + get_mapping, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_mapping, TContext = Context>(params: RequestParams.IndicesGetMapping, callback: callbackFn): TransportRequestCallback + get_mapping, TContext = Context>(params: RequestParams.IndicesGetMapping, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getMapping, TContext = Context>(params?: RequestParams.IndicesGetMapping, options?: TransportRequestOptions): TransportRequestPromise> + getMapping, TContext = Context>(callback: callbackFn): TransportRequestCallback + getMapping, TContext = Context>(params: RequestParams.IndicesGetMapping, callback: callbackFn): TransportRequestCallback + getMapping, TContext = Context>(params: RequestParams.IndicesGetMapping, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_settings, TContext = Context>(params?: RequestParams.IndicesGetSettings, options?: TransportRequestOptions): TransportRequestPromise> + get_settings, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_settings, TContext = Context>(params: RequestParams.IndicesGetSettings, callback: callbackFn): TransportRequestCallback + get_settings, TContext = Context>(params: RequestParams.IndicesGetSettings, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getSettings, TContext = Context>(params?: RequestParams.IndicesGetSettings, options?: TransportRequestOptions): TransportRequestPromise> + getSettings, TContext = Context>(callback: callbackFn): TransportRequestCallback + getSettings, TContext = Context>(params: RequestParams.IndicesGetSettings, callback: callbackFn): TransportRequestCallback + getSettings, TContext = Context>(params: RequestParams.IndicesGetSettings, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_template, TContext = Context>(params?: RequestParams.IndicesGetTemplate, options?: TransportRequestOptions): TransportRequestPromise> + get_template, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_template, TContext = Context>(params: RequestParams.IndicesGetTemplate, callback: callbackFn): TransportRequestCallback + get_template, TContext = Context>(params: RequestParams.IndicesGetTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getTemplate, TContext = Context>(params?: RequestParams.IndicesGetTemplate, options?: TransportRequestOptions): TransportRequestPromise> + getTemplate, TContext = Context>(callback: callbackFn): TransportRequestCallback + getTemplate, TContext = Context>(params: RequestParams.IndicesGetTemplate, callback: callbackFn): TransportRequestCallback + getTemplate, TContext = Context>(params: RequestParams.IndicesGetTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + migrate_to_data_stream, TContext = Context>(params?: RequestParams.IndicesMigrateToDataStream, options?: TransportRequestOptions): TransportRequestPromise> + migrate_to_data_stream, TContext = Context>(callback: callbackFn): TransportRequestCallback + migrate_to_data_stream, TContext = Context>(params: RequestParams.IndicesMigrateToDataStream, callback: callbackFn): TransportRequestCallback + migrate_to_data_stream, TContext = Context>(params: RequestParams.IndicesMigrateToDataStream, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + migrateToDataStream, TContext = Context>(params?: RequestParams.IndicesMigrateToDataStream, options?: TransportRequestOptions): TransportRequestPromise> + migrateToDataStream, TContext = Context>(callback: callbackFn): TransportRequestCallback + migrateToDataStream, TContext = Context>(params: RequestParams.IndicesMigrateToDataStream, callback: callbackFn): TransportRequestCallback + migrateToDataStream, TContext = Context>(params: RequestParams.IndicesMigrateToDataStream, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + open, TContext = Context>(params?: RequestParams.IndicesOpen, options?: TransportRequestOptions): TransportRequestPromise> + open, TContext = Context>(callback: callbackFn): TransportRequestCallback + open, TContext = Context>(params: RequestParams.IndicesOpen, callback: callbackFn): TransportRequestCallback + open, TContext = Context>(params: RequestParams.IndicesOpen, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + promote_data_stream, TContext = Context>(params?: RequestParams.IndicesPromoteDataStream, options?: TransportRequestOptions): TransportRequestPromise> + promote_data_stream, TContext = Context>(callback: callbackFn): TransportRequestCallback + promote_data_stream, TContext = Context>(params: RequestParams.IndicesPromoteDataStream, callback: callbackFn): TransportRequestCallback + promote_data_stream, TContext = Context>(params: RequestParams.IndicesPromoteDataStream, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + promoteDataStream, TContext = Context>(params?: RequestParams.IndicesPromoteDataStream, options?: TransportRequestOptions): TransportRequestPromise> + promoteDataStream, TContext = Context>(callback: callbackFn): TransportRequestCallback + promoteDataStream, TContext = Context>(params: RequestParams.IndicesPromoteDataStream, callback: callbackFn): TransportRequestCallback + promoteDataStream, TContext = Context>(params: RequestParams.IndicesPromoteDataStream, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_alias, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IndicesPutAlias, options?: TransportRequestOptions): TransportRequestPromise> + put_alias, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_alias, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesPutAlias, callback: callbackFn): TransportRequestCallback + put_alias, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesPutAlias, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putAlias, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IndicesPutAlias, options?: TransportRequestOptions): TransportRequestPromise> + putAlias, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + putAlias, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesPutAlias, callback: callbackFn): TransportRequestCallback + putAlias, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesPutAlias, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_index_template, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IndicesPutIndexTemplate, options?: TransportRequestOptions): TransportRequestPromise> + put_index_template, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_index_template, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesPutIndexTemplate, callback: callbackFn): TransportRequestCallback + put_index_template, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesPutIndexTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putIndexTemplate, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IndicesPutIndexTemplate, options?: TransportRequestOptions): TransportRequestPromise> + putIndexTemplate, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + putIndexTemplate, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesPutIndexTemplate, callback: callbackFn): TransportRequestCallback + putIndexTemplate, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesPutIndexTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_mapping, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IndicesPutMapping, options?: TransportRequestOptions): TransportRequestPromise> + put_mapping, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_mapping, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesPutMapping, callback: callbackFn): TransportRequestCallback + put_mapping, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesPutMapping, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putMapping, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IndicesPutMapping, options?: TransportRequestOptions): TransportRequestPromise> + putMapping, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + putMapping, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesPutMapping, callback: callbackFn): TransportRequestCallback + putMapping, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesPutMapping, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_settings, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IndicesPutSettings, options?: TransportRequestOptions): TransportRequestPromise> + put_settings, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_settings, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesPutSettings, callback: callbackFn): TransportRequestCallback + put_settings, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesPutSettings, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putSettings, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IndicesPutSettings, options?: TransportRequestOptions): TransportRequestPromise> + putSettings, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + putSettings, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesPutSettings, callback: callbackFn): TransportRequestCallback + putSettings, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesPutSettings, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_template, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IndicesPutTemplate, options?: TransportRequestOptions): TransportRequestPromise> + put_template, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_template, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesPutTemplate, callback: callbackFn): TransportRequestCallback + put_template, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesPutTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putTemplate, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IndicesPutTemplate, options?: TransportRequestOptions): TransportRequestPromise> + putTemplate, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + putTemplate, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesPutTemplate, callback: callbackFn): TransportRequestCallback + putTemplate, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesPutTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + recovery, TContext = Context>(params?: RequestParams.IndicesRecovery, options?: TransportRequestOptions): TransportRequestPromise> + recovery, TContext = Context>(callback: callbackFn): TransportRequestCallback + recovery, TContext = Context>(params: RequestParams.IndicesRecovery, callback: callbackFn): TransportRequestCallback + recovery, TContext = Context>(params: RequestParams.IndicesRecovery, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + refresh, TContext = Context>(params?: RequestParams.IndicesRefresh, options?: TransportRequestOptions): TransportRequestPromise> + refresh, TContext = Context>(callback: callbackFn): TransportRequestCallback + refresh, TContext = Context>(params: RequestParams.IndicesRefresh, callback: callbackFn): TransportRequestCallback + refresh, TContext = Context>(params: RequestParams.IndicesRefresh, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + reload_search_analyzers, TContext = Context>(params?: RequestParams.IndicesReloadSearchAnalyzers, options?: TransportRequestOptions): TransportRequestPromise> + reload_search_analyzers, TContext = Context>(callback: callbackFn): TransportRequestCallback + reload_search_analyzers, TContext = Context>(params: RequestParams.IndicesReloadSearchAnalyzers, callback: callbackFn): TransportRequestCallback + reload_search_analyzers, TContext = Context>(params: RequestParams.IndicesReloadSearchAnalyzers, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + reloadSearchAnalyzers, TContext = Context>(params?: RequestParams.IndicesReloadSearchAnalyzers, options?: TransportRequestOptions): TransportRequestPromise> + reloadSearchAnalyzers, TContext = Context>(callback: callbackFn): TransportRequestCallback + reloadSearchAnalyzers, TContext = Context>(params: RequestParams.IndicesReloadSearchAnalyzers, callback: callbackFn): TransportRequestCallback + reloadSearchAnalyzers, TContext = Context>(params: RequestParams.IndicesReloadSearchAnalyzers, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + resolve_index, TContext = Context>(params?: RequestParams.IndicesResolveIndex, options?: TransportRequestOptions): TransportRequestPromise> + resolve_index, TContext = Context>(callback: callbackFn): TransportRequestCallback + resolve_index, TContext = Context>(params: RequestParams.IndicesResolveIndex, callback: callbackFn): TransportRequestCallback + resolve_index, TContext = Context>(params: RequestParams.IndicesResolveIndex, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + resolveIndex, TContext = Context>(params?: RequestParams.IndicesResolveIndex, options?: TransportRequestOptions): TransportRequestPromise> + resolveIndex, TContext = Context>(callback: callbackFn): TransportRequestCallback + resolveIndex, TContext = Context>(params: RequestParams.IndicesResolveIndex, callback: callbackFn): TransportRequestCallback + resolveIndex, TContext = Context>(params: RequestParams.IndicesResolveIndex, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + rollover, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IndicesRollover, options?: TransportRequestOptions): TransportRequestPromise> + rollover, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + rollover, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesRollover, callback: callbackFn): TransportRequestCallback + rollover, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesRollover, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + segments, TContext = Context>(params?: RequestParams.IndicesSegments, options?: TransportRequestOptions): TransportRequestPromise> + segments, TContext = Context>(callback: callbackFn): TransportRequestCallback + segments, TContext = Context>(params: RequestParams.IndicesSegments, callback: callbackFn): TransportRequestCallback + segments, TContext = Context>(params: RequestParams.IndicesSegments, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + shard_stores, TContext = Context>(params?: RequestParams.IndicesShardStores, options?: TransportRequestOptions): TransportRequestPromise> + shard_stores, TContext = Context>(callback: callbackFn): TransportRequestCallback + shard_stores, TContext = Context>(params: RequestParams.IndicesShardStores, callback: callbackFn): TransportRequestCallback + shard_stores, TContext = Context>(params: RequestParams.IndicesShardStores, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + shardStores, TContext = Context>(params?: RequestParams.IndicesShardStores, options?: TransportRequestOptions): TransportRequestPromise> + shardStores, TContext = Context>(callback: callbackFn): TransportRequestCallback + shardStores, TContext = Context>(params: RequestParams.IndicesShardStores, callback: callbackFn): TransportRequestCallback + shardStores, TContext = Context>(params: RequestParams.IndicesShardStores, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + shrink, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IndicesShrink, options?: TransportRequestOptions): TransportRequestPromise> + shrink, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + shrink, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesShrink, callback: callbackFn): TransportRequestCallback + shrink, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesShrink, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + simulate_index_template, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IndicesSimulateIndexTemplate, options?: TransportRequestOptions): TransportRequestPromise> + simulate_index_template, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + simulate_index_template, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesSimulateIndexTemplate, callback: callbackFn): TransportRequestCallback + simulate_index_template, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesSimulateIndexTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + simulateIndexTemplate, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IndicesSimulateIndexTemplate, options?: TransportRequestOptions): TransportRequestPromise> + simulateIndexTemplate, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + simulateIndexTemplate, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesSimulateIndexTemplate, callback: callbackFn): TransportRequestCallback + simulateIndexTemplate, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesSimulateIndexTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + simulate_template, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IndicesSimulateTemplate, options?: TransportRequestOptions): TransportRequestPromise> + simulate_template, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + simulate_template, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesSimulateTemplate, callback: callbackFn): TransportRequestCallback + simulate_template, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesSimulateTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + simulateTemplate, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IndicesSimulateTemplate, options?: TransportRequestOptions): TransportRequestPromise> + simulateTemplate, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + simulateTemplate, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesSimulateTemplate, callback: callbackFn): TransportRequestCallback + simulateTemplate, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesSimulateTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + split, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IndicesSplit, options?: TransportRequestOptions): TransportRequestPromise> + split, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + split, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesSplit, callback: callbackFn): TransportRequestCallback + split, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesSplit, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + stats, TContext = Context>(params?: RequestParams.IndicesStats, options?: TransportRequestOptions): TransportRequestPromise> + stats, TContext = Context>(callback: callbackFn): TransportRequestCallback + stats, TContext = Context>(params: RequestParams.IndicesStats, callback: callbackFn): TransportRequestCallback + stats, TContext = Context>(params: RequestParams.IndicesStats, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + unfreeze, TContext = Context>(params?: RequestParams.IndicesUnfreeze, options?: TransportRequestOptions): TransportRequestPromise> + unfreeze, TContext = Context>(callback: callbackFn): TransportRequestCallback + unfreeze, TContext = Context>(params: RequestParams.IndicesUnfreeze, callback: callbackFn): TransportRequestCallback + unfreeze, TContext = Context>(params: RequestParams.IndicesUnfreeze, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + update_aliases, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IndicesUpdateAliases, options?: TransportRequestOptions): TransportRequestPromise> + update_aliases, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + update_aliases, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesUpdateAliases, callback: callbackFn): TransportRequestCallback + update_aliases, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesUpdateAliases, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + updateAliases, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IndicesUpdateAliases, options?: TransportRequestOptions): TransportRequestPromise> + updateAliases, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + updateAliases, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesUpdateAliases, callback: callbackFn): TransportRequestCallback + updateAliases, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesUpdateAliases, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + validate_query, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IndicesValidateQuery, options?: TransportRequestOptions): TransportRequestPromise> + validate_query, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + validate_query, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesValidateQuery, callback: callbackFn): TransportRequestCallback + validate_query, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesValidateQuery, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + validateQuery, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IndicesValidateQuery, options?: TransportRequestOptions): TransportRequestPromise> + validateQuery, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + validateQuery, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesValidateQuery, callback: callbackFn): TransportRequestCallback + validateQuery, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IndicesValidateQuery, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + info, TContext = Context>(params?: RequestParams.Info, options?: TransportRequestOptions): TransportRequestPromise> + info, TContext = Context>(callback: callbackFn): TransportRequestCallback + info, TContext = Context>(params: RequestParams.Info, callback: callbackFn): TransportRequestCallback + info, TContext = Context>(params: RequestParams.Info, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + ingest: { + delete_pipeline, TContext = Context>(params?: RequestParams.IngestDeletePipeline, options?: TransportRequestOptions): TransportRequestPromise> + delete_pipeline, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_pipeline, TContext = Context>(params: RequestParams.IngestDeletePipeline, callback: callbackFn): TransportRequestCallback + delete_pipeline, TContext = Context>(params: RequestParams.IngestDeletePipeline, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deletePipeline, TContext = Context>(params?: RequestParams.IngestDeletePipeline, options?: TransportRequestOptions): TransportRequestPromise> + deletePipeline, TContext = Context>(callback: callbackFn): TransportRequestCallback + deletePipeline, TContext = Context>(params: RequestParams.IngestDeletePipeline, callback: callbackFn): TransportRequestCallback + deletePipeline, TContext = Context>(params: RequestParams.IngestDeletePipeline, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + geo_ip_stats, TContext = Context>(params?: RequestParams.IngestGeoIpStats, options?: TransportRequestOptions): TransportRequestPromise> + geo_ip_stats, TContext = Context>(callback: callbackFn): TransportRequestCallback + geo_ip_stats, TContext = Context>(params: RequestParams.IngestGeoIpStats, callback: callbackFn): TransportRequestCallback + geo_ip_stats, TContext = Context>(params: RequestParams.IngestGeoIpStats, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + geoIpStats, TContext = Context>(params?: RequestParams.IngestGeoIpStats, options?: TransportRequestOptions): TransportRequestPromise> + geoIpStats, TContext = Context>(callback: callbackFn): TransportRequestCallback + geoIpStats, TContext = Context>(params: RequestParams.IngestGeoIpStats, callback: callbackFn): TransportRequestCallback + geoIpStats, TContext = Context>(params: RequestParams.IngestGeoIpStats, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_pipeline, TContext = Context>(params?: RequestParams.IngestGetPipeline, options?: TransportRequestOptions): TransportRequestPromise> + get_pipeline, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_pipeline, TContext = Context>(params: RequestParams.IngestGetPipeline, callback: callbackFn): TransportRequestCallback + get_pipeline, TContext = Context>(params: RequestParams.IngestGetPipeline, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getPipeline, TContext = Context>(params?: RequestParams.IngestGetPipeline, options?: TransportRequestOptions): TransportRequestPromise> + getPipeline, TContext = Context>(callback: callbackFn): TransportRequestCallback + getPipeline, TContext = Context>(params: RequestParams.IngestGetPipeline, callback: callbackFn): TransportRequestCallback + getPipeline, TContext = Context>(params: RequestParams.IngestGetPipeline, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + processor_grok, TContext = Context>(params?: RequestParams.IngestProcessorGrok, options?: TransportRequestOptions): TransportRequestPromise> + processor_grok, TContext = Context>(callback: callbackFn): TransportRequestCallback + processor_grok, TContext = Context>(params: RequestParams.IngestProcessorGrok, callback: callbackFn): TransportRequestCallback + processor_grok, TContext = Context>(params: RequestParams.IngestProcessorGrok, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + processorGrok, TContext = Context>(params?: RequestParams.IngestProcessorGrok, options?: TransportRequestOptions): TransportRequestPromise> + processorGrok, TContext = Context>(callback: callbackFn): TransportRequestCallback + processorGrok, TContext = Context>(params: RequestParams.IngestProcessorGrok, callback: callbackFn): TransportRequestCallback + processorGrok, TContext = Context>(params: RequestParams.IngestProcessorGrok, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_pipeline, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IngestPutPipeline, options?: TransportRequestOptions): TransportRequestPromise> + put_pipeline, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_pipeline, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IngestPutPipeline, callback: callbackFn): TransportRequestCallback + put_pipeline, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IngestPutPipeline, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putPipeline, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IngestPutPipeline, options?: TransportRequestOptions): TransportRequestPromise> + putPipeline, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + putPipeline, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IngestPutPipeline, callback: callbackFn): TransportRequestCallback + putPipeline, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IngestPutPipeline, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + simulate, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.IngestSimulate, options?: TransportRequestOptions): TransportRequestPromise> + simulate, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + simulate, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IngestSimulate, callback: callbackFn): TransportRequestCallback + simulate, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.IngestSimulate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + license: { + delete, TContext = Context>(params?: RequestParams.LicenseDelete, options?: TransportRequestOptions): TransportRequestPromise> + delete, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete, TContext = Context>(params: RequestParams.LicenseDelete, callback: callbackFn): TransportRequestCallback + delete, TContext = Context>(params: RequestParams.LicenseDelete, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get, TContext = Context>(params?: RequestParams.LicenseGet, options?: TransportRequestOptions): TransportRequestPromise> + get, TContext = Context>(callback: callbackFn): TransportRequestCallback + get, TContext = Context>(params: RequestParams.LicenseGet, callback: callbackFn): TransportRequestCallback + get, TContext = Context>(params: RequestParams.LicenseGet, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_basic_status, TContext = Context>(params?: RequestParams.LicenseGetBasicStatus, options?: TransportRequestOptions): TransportRequestPromise> + get_basic_status, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_basic_status, TContext = Context>(params: RequestParams.LicenseGetBasicStatus, callback: callbackFn): TransportRequestCallback + get_basic_status, TContext = Context>(params: RequestParams.LicenseGetBasicStatus, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getBasicStatus, TContext = Context>(params?: RequestParams.LicenseGetBasicStatus, options?: TransportRequestOptions): TransportRequestPromise> + getBasicStatus, TContext = Context>(callback: callbackFn): TransportRequestCallback + getBasicStatus, TContext = Context>(params: RequestParams.LicenseGetBasicStatus, callback: callbackFn): TransportRequestCallback + getBasicStatus, TContext = Context>(params: RequestParams.LicenseGetBasicStatus, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_trial_status, TContext = Context>(params?: RequestParams.LicenseGetTrialStatus, options?: TransportRequestOptions): TransportRequestPromise> + get_trial_status, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_trial_status, TContext = Context>(params: RequestParams.LicenseGetTrialStatus, callback: callbackFn): TransportRequestCallback + get_trial_status, TContext = Context>(params: RequestParams.LicenseGetTrialStatus, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getTrialStatus, TContext = Context>(params?: RequestParams.LicenseGetTrialStatus, options?: TransportRequestOptions): TransportRequestPromise> + getTrialStatus, TContext = Context>(callback: callbackFn): TransportRequestCallback + getTrialStatus, TContext = Context>(params: RequestParams.LicenseGetTrialStatus, callback: callbackFn): TransportRequestCallback + getTrialStatus, TContext = Context>(params: RequestParams.LicenseGetTrialStatus, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + post, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.LicensePost, options?: TransportRequestOptions): TransportRequestPromise> + post, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + post, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.LicensePost, callback: callbackFn): TransportRequestCallback + post, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.LicensePost, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + post_start_basic, TContext = Context>(params?: RequestParams.LicensePostStartBasic, options?: TransportRequestOptions): TransportRequestPromise> + post_start_basic, TContext = Context>(callback: callbackFn): TransportRequestCallback + post_start_basic, TContext = Context>(params: RequestParams.LicensePostStartBasic, callback: callbackFn): TransportRequestCallback + post_start_basic, TContext = Context>(params: RequestParams.LicensePostStartBasic, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + postStartBasic, TContext = Context>(params?: RequestParams.LicensePostStartBasic, options?: TransportRequestOptions): TransportRequestPromise> + postStartBasic, TContext = Context>(callback: callbackFn): TransportRequestCallback + postStartBasic, TContext = Context>(params: RequestParams.LicensePostStartBasic, callback: callbackFn): TransportRequestCallback + postStartBasic, TContext = Context>(params: RequestParams.LicensePostStartBasic, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + post_start_trial, TContext = Context>(params?: RequestParams.LicensePostStartTrial, options?: TransportRequestOptions): TransportRequestPromise> + post_start_trial, TContext = Context>(callback: callbackFn): TransportRequestCallback + post_start_trial, TContext = Context>(params: RequestParams.LicensePostStartTrial, callback: callbackFn): TransportRequestCallback + post_start_trial, TContext = Context>(params: RequestParams.LicensePostStartTrial, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + postStartTrial, TContext = Context>(params?: RequestParams.LicensePostStartTrial, options?: TransportRequestOptions): TransportRequestPromise> + postStartTrial, TContext = Context>(callback: callbackFn): TransportRequestCallback + postStartTrial, TContext = Context>(params: RequestParams.LicensePostStartTrial, callback: callbackFn): TransportRequestCallback + postStartTrial, TContext = Context>(params: RequestParams.LicensePostStartTrial, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + logstash: { + delete_pipeline, TContext = Context>(params?: RequestParams.LogstashDeletePipeline, options?: TransportRequestOptions): TransportRequestPromise> + delete_pipeline, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_pipeline, TContext = Context>(params: RequestParams.LogstashDeletePipeline, callback: callbackFn): TransportRequestCallback + delete_pipeline, TContext = Context>(params: RequestParams.LogstashDeletePipeline, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deletePipeline, TContext = Context>(params?: RequestParams.LogstashDeletePipeline, options?: TransportRequestOptions): TransportRequestPromise> + deletePipeline, TContext = Context>(callback: callbackFn): TransportRequestCallback + deletePipeline, TContext = Context>(params: RequestParams.LogstashDeletePipeline, callback: callbackFn): TransportRequestCallback + deletePipeline, TContext = Context>(params: RequestParams.LogstashDeletePipeline, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_pipeline, TContext = Context>(params?: RequestParams.LogstashGetPipeline, options?: TransportRequestOptions): TransportRequestPromise> + get_pipeline, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_pipeline, TContext = Context>(params: RequestParams.LogstashGetPipeline, callback: callbackFn): TransportRequestCallback + get_pipeline, TContext = Context>(params: RequestParams.LogstashGetPipeline, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getPipeline, TContext = Context>(params?: RequestParams.LogstashGetPipeline, options?: TransportRequestOptions): TransportRequestPromise> + getPipeline, TContext = Context>(callback: callbackFn): TransportRequestCallback + getPipeline, TContext = Context>(params: RequestParams.LogstashGetPipeline, callback: callbackFn): TransportRequestCallback + getPipeline, TContext = Context>(params: RequestParams.LogstashGetPipeline, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_pipeline, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.LogstashPutPipeline, options?: TransportRequestOptions): TransportRequestPromise> + put_pipeline, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_pipeline, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.LogstashPutPipeline, callback: callbackFn): TransportRequestCallback + put_pipeline, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.LogstashPutPipeline, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putPipeline, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.LogstashPutPipeline, options?: TransportRequestOptions): TransportRequestPromise> + putPipeline, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + putPipeline, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.LogstashPutPipeline, callback: callbackFn): TransportRequestCallback + putPipeline, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.LogstashPutPipeline, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + mget, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.Mget, options?: TransportRequestOptions): TransportRequestPromise> + mget, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + mget, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.Mget, callback: callbackFn): TransportRequestCallback + mget, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.Mget, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + migration: { + deprecations, TContext = Context>(params?: RequestParams.MigrationDeprecations, options?: TransportRequestOptions): TransportRequestPromise> + deprecations, TContext = Context>(callback: callbackFn): TransportRequestCallback + deprecations, TContext = Context>(params: RequestParams.MigrationDeprecations, callback: callbackFn): TransportRequestCallback + deprecations, TContext = Context>(params: RequestParams.MigrationDeprecations, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + ml: { + close_job, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlCloseJob, options?: TransportRequestOptions): TransportRequestPromise> + close_job, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + close_job, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlCloseJob, callback: callbackFn): TransportRequestCallback + close_job, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlCloseJob, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + closeJob, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlCloseJob, options?: TransportRequestOptions): TransportRequestPromise> + closeJob, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + closeJob, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlCloseJob, callback: callbackFn): TransportRequestCallback + closeJob, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlCloseJob, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete_calendar, TContext = Context>(params?: RequestParams.MlDeleteCalendar, options?: TransportRequestOptions): TransportRequestPromise> + delete_calendar, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_calendar, TContext = Context>(params: RequestParams.MlDeleteCalendar, callback: callbackFn): TransportRequestCallback + delete_calendar, TContext = Context>(params: RequestParams.MlDeleteCalendar, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteCalendar, TContext = Context>(params?: RequestParams.MlDeleteCalendar, options?: TransportRequestOptions): TransportRequestPromise> + deleteCalendar, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteCalendar, TContext = Context>(params: RequestParams.MlDeleteCalendar, callback: callbackFn): TransportRequestCallback + deleteCalendar, TContext = Context>(params: RequestParams.MlDeleteCalendar, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete_calendar_event, TContext = Context>(params?: RequestParams.MlDeleteCalendarEvent, options?: TransportRequestOptions): TransportRequestPromise> + delete_calendar_event, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_calendar_event, TContext = Context>(params: RequestParams.MlDeleteCalendarEvent, callback: callbackFn): TransportRequestCallback + delete_calendar_event, TContext = Context>(params: RequestParams.MlDeleteCalendarEvent, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteCalendarEvent, TContext = Context>(params?: RequestParams.MlDeleteCalendarEvent, options?: TransportRequestOptions): TransportRequestPromise> + deleteCalendarEvent, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteCalendarEvent, TContext = Context>(params: RequestParams.MlDeleteCalendarEvent, callback: callbackFn): TransportRequestCallback + deleteCalendarEvent, TContext = Context>(params: RequestParams.MlDeleteCalendarEvent, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete_calendar_job, TContext = Context>(params?: RequestParams.MlDeleteCalendarJob, options?: TransportRequestOptions): TransportRequestPromise> + delete_calendar_job, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_calendar_job, TContext = Context>(params: RequestParams.MlDeleteCalendarJob, callback: callbackFn): TransportRequestCallback + delete_calendar_job, TContext = Context>(params: RequestParams.MlDeleteCalendarJob, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteCalendarJob, TContext = Context>(params?: RequestParams.MlDeleteCalendarJob, options?: TransportRequestOptions): TransportRequestPromise> + deleteCalendarJob, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteCalendarJob, TContext = Context>(params: RequestParams.MlDeleteCalendarJob, callback: callbackFn): TransportRequestCallback + deleteCalendarJob, TContext = Context>(params: RequestParams.MlDeleteCalendarJob, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete_data_frame_analytics, TContext = Context>(params?: RequestParams.MlDeleteDataFrameAnalytics, options?: TransportRequestOptions): TransportRequestPromise> + delete_data_frame_analytics, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_data_frame_analytics, TContext = Context>(params: RequestParams.MlDeleteDataFrameAnalytics, callback: callbackFn): TransportRequestCallback + delete_data_frame_analytics, TContext = Context>(params: RequestParams.MlDeleteDataFrameAnalytics, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteDataFrameAnalytics, TContext = Context>(params?: RequestParams.MlDeleteDataFrameAnalytics, options?: TransportRequestOptions): TransportRequestPromise> + deleteDataFrameAnalytics, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteDataFrameAnalytics, TContext = Context>(params: RequestParams.MlDeleteDataFrameAnalytics, callback: callbackFn): TransportRequestCallback + deleteDataFrameAnalytics, TContext = Context>(params: RequestParams.MlDeleteDataFrameAnalytics, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete_datafeed, TContext = Context>(params?: RequestParams.MlDeleteDatafeed, options?: TransportRequestOptions): TransportRequestPromise> + delete_datafeed, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_datafeed, TContext = Context>(params: RequestParams.MlDeleteDatafeed, callback: callbackFn): TransportRequestCallback + delete_datafeed, TContext = Context>(params: RequestParams.MlDeleteDatafeed, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteDatafeed, TContext = Context>(params?: RequestParams.MlDeleteDatafeed, options?: TransportRequestOptions): TransportRequestPromise> + deleteDatafeed, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteDatafeed, TContext = Context>(params: RequestParams.MlDeleteDatafeed, callback: callbackFn): TransportRequestCallback + deleteDatafeed, TContext = Context>(params: RequestParams.MlDeleteDatafeed, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete_expired_data, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlDeleteExpiredData, options?: TransportRequestOptions): TransportRequestPromise> + delete_expired_data, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_expired_data, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlDeleteExpiredData, callback: callbackFn): TransportRequestCallback + delete_expired_data, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlDeleteExpiredData, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteExpiredData, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlDeleteExpiredData, options?: TransportRequestOptions): TransportRequestPromise> + deleteExpiredData, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteExpiredData, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlDeleteExpiredData, callback: callbackFn): TransportRequestCallback + deleteExpiredData, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlDeleteExpiredData, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete_filter, TContext = Context>(params?: RequestParams.MlDeleteFilter, options?: TransportRequestOptions): TransportRequestPromise> + delete_filter, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_filter, TContext = Context>(params: RequestParams.MlDeleteFilter, callback: callbackFn): TransportRequestCallback + delete_filter, TContext = Context>(params: RequestParams.MlDeleteFilter, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteFilter, TContext = Context>(params?: RequestParams.MlDeleteFilter, options?: TransportRequestOptions): TransportRequestPromise> + deleteFilter, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteFilter, TContext = Context>(params: RequestParams.MlDeleteFilter, callback: callbackFn): TransportRequestCallback + deleteFilter, TContext = Context>(params: RequestParams.MlDeleteFilter, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete_forecast, TContext = Context>(params?: RequestParams.MlDeleteForecast, options?: TransportRequestOptions): TransportRequestPromise> + delete_forecast, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_forecast, TContext = Context>(params: RequestParams.MlDeleteForecast, callback: callbackFn): TransportRequestCallback + delete_forecast, TContext = Context>(params: RequestParams.MlDeleteForecast, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteForecast, TContext = Context>(params?: RequestParams.MlDeleteForecast, options?: TransportRequestOptions): TransportRequestPromise> + deleteForecast, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteForecast, TContext = Context>(params: RequestParams.MlDeleteForecast, callback: callbackFn): TransportRequestCallback + deleteForecast, TContext = Context>(params: RequestParams.MlDeleteForecast, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete_job, TContext = Context>(params?: RequestParams.MlDeleteJob, options?: TransportRequestOptions): TransportRequestPromise> + delete_job, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_job, TContext = Context>(params: RequestParams.MlDeleteJob, callback: callbackFn): TransportRequestCallback + delete_job, TContext = Context>(params: RequestParams.MlDeleteJob, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteJob, TContext = Context>(params?: RequestParams.MlDeleteJob, options?: TransportRequestOptions): TransportRequestPromise> + deleteJob, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteJob, TContext = Context>(params: RequestParams.MlDeleteJob, callback: callbackFn): TransportRequestCallback + deleteJob, TContext = Context>(params: RequestParams.MlDeleteJob, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete_model_snapshot, TContext = Context>(params?: RequestParams.MlDeleteModelSnapshot, options?: TransportRequestOptions): TransportRequestPromise> + delete_model_snapshot, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_model_snapshot, TContext = Context>(params: RequestParams.MlDeleteModelSnapshot, callback: callbackFn): TransportRequestCallback + delete_model_snapshot, TContext = Context>(params: RequestParams.MlDeleteModelSnapshot, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteModelSnapshot, TContext = Context>(params?: RequestParams.MlDeleteModelSnapshot, options?: TransportRequestOptions): TransportRequestPromise> + deleteModelSnapshot, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteModelSnapshot, TContext = Context>(params: RequestParams.MlDeleteModelSnapshot, callback: callbackFn): TransportRequestCallback + deleteModelSnapshot, TContext = Context>(params: RequestParams.MlDeleteModelSnapshot, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete_trained_model, TContext = Context>(params?: RequestParams.MlDeleteTrainedModel, options?: TransportRequestOptions): TransportRequestPromise> + delete_trained_model, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_trained_model, TContext = Context>(params: RequestParams.MlDeleteTrainedModel, callback: callbackFn): TransportRequestCallback + delete_trained_model, TContext = Context>(params: RequestParams.MlDeleteTrainedModel, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteTrainedModel, TContext = Context>(params?: RequestParams.MlDeleteTrainedModel, options?: TransportRequestOptions): TransportRequestPromise> + deleteTrainedModel, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteTrainedModel, TContext = Context>(params: RequestParams.MlDeleteTrainedModel, callback: callbackFn): TransportRequestCallback + deleteTrainedModel, TContext = Context>(params: RequestParams.MlDeleteTrainedModel, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete_trained_model_alias, TContext = Context>(params?: RequestParams.MlDeleteTrainedModelAlias, options?: TransportRequestOptions): TransportRequestPromise> + delete_trained_model_alias, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_trained_model_alias, TContext = Context>(params: RequestParams.MlDeleteTrainedModelAlias, callback: callbackFn): TransportRequestCallback + delete_trained_model_alias, TContext = Context>(params: RequestParams.MlDeleteTrainedModelAlias, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteTrainedModelAlias, TContext = Context>(params?: RequestParams.MlDeleteTrainedModelAlias, options?: TransportRequestOptions): TransportRequestPromise> + deleteTrainedModelAlias, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteTrainedModelAlias, TContext = Context>(params: RequestParams.MlDeleteTrainedModelAlias, callback: callbackFn): TransportRequestCallback + deleteTrainedModelAlias, TContext = Context>(params: RequestParams.MlDeleteTrainedModelAlias, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + estimate_model_memory, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlEstimateModelMemory, options?: TransportRequestOptions): TransportRequestPromise> + estimate_model_memory, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + estimate_model_memory, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlEstimateModelMemory, callback: callbackFn): TransportRequestCallback + estimate_model_memory, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlEstimateModelMemory, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + estimateModelMemory, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlEstimateModelMemory, options?: TransportRequestOptions): TransportRequestPromise> + estimateModelMemory, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + estimateModelMemory, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlEstimateModelMemory, callback: callbackFn): TransportRequestCallback + estimateModelMemory, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlEstimateModelMemory, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + evaluate_data_frame, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlEvaluateDataFrame, options?: TransportRequestOptions): TransportRequestPromise> + evaluate_data_frame, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + evaluate_data_frame, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlEvaluateDataFrame, callback: callbackFn): TransportRequestCallback + evaluate_data_frame, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlEvaluateDataFrame, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + evaluateDataFrame, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlEvaluateDataFrame, options?: TransportRequestOptions): TransportRequestPromise> + evaluateDataFrame, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + evaluateDataFrame, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlEvaluateDataFrame, callback: callbackFn): TransportRequestCallback + evaluateDataFrame, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlEvaluateDataFrame, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + explain_data_frame_analytics, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlExplainDataFrameAnalytics, options?: TransportRequestOptions): TransportRequestPromise> + explain_data_frame_analytics, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + explain_data_frame_analytics, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlExplainDataFrameAnalytics, callback: callbackFn): TransportRequestCallback + explain_data_frame_analytics, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlExplainDataFrameAnalytics, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + explainDataFrameAnalytics, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlExplainDataFrameAnalytics, options?: TransportRequestOptions): TransportRequestPromise> + explainDataFrameAnalytics, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + explainDataFrameAnalytics, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlExplainDataFrameAnalytics, callback: callbackFn): TransportRequestCallback + explainDataFrameAnalytics, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlExplainDataFrameAnalytics, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + flush_job, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlFlushJob, options?: TransportRequestOptions): TransportRequestPromise> + flush_job, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + flush_job, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlFlushJob, callback: callbackFn): TransportRequestCallback + flush_job, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlFlushJob, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + flushJob, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlFlushJob, options?: TransportRequestOptions): TransportRequestPromise> + flushJob, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + flushJob, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlFlushJob, callback: callbackFn): TransportRequestCallback + flushJob, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlFlushJob, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + forecast, TContext = Context>(params?: RequestParams.MlForecast, options?: TransportRequestOptions): TransportRequestPromise> + forecast, TContext = Context>(callback: callbackFn): TransportRequestCallback + forecast, TContext = Context>(params: RequestParams.MlForecast, callback: callbackFn): TransportRequestCallback + forecast, TContext = Context>(params: RequestParams.MlForecast, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_buckets, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlGetBuckets, options?: TransportRequestOptions): TransportRequestPromise> + get_buckets, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_buckets, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlGetBuckets, callback: callbackFn): TransportRequestCallback + get_buckets, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlGetBuckets, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getBuckets, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlGetBuckets, options?: TransportRequestOptions): TransportRequestPromise> + getBuckets, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + getBuckets, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlGetBuckets, callback: callbackFn): TransportRequestCallback + getBuckets, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlGetBuckets, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_calendar_events, TContext = Context>(params?: RequestParams.MlGetCalendarEvents, options?: TransportRequestOptions): TransportRequestPromise> + get_calendar_events, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_calendar_events, TContext = Context>(params: RequestParams.MlGetCalendarEvents, callback: callbackFn): TransportRequestCallback + get_calendar_events, TContext = Context>(params: RequestParams.MlGetCalendarEvents, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getCalendarEvents, TContext = Context>(params?: RequestParams.MlGetCalendarEvents, options?: TransportRequestOptions): TransportRequestPromise> + getCalendarEvents, TContext = Context>(callback: callbackFn): TransportRequestCallback + getCalendarEvents, TContext = Context>(params: RequestParams.MlGetCalendarEvents, callback: callbackFn): TransportRequestCallback + getCalendarEvents, TContext = Context>(params: RequestParams.MlGetCalendarEvents, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_calendars, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlGetCalendars, options?: TransportRequestOptions): TransportRequestPromise> + get_calendars, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_calendars, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlGetCalendars, callback: callbackFn): TransportRequestCallback + get_calendars, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlGetCalendars, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getCalendars, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlGetCalendars, options?: TransportRequestOptions): TransportRequestPromise> + getCalendars, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + getCalendars, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlGetCalendars, callback: callbackFn): TransportRequestCallback + getCalendars, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlGetCalendars, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_categories, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlGetCategories, options?: TransportRequestOptions): TransportRequestPromise> + get_categories, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_categories, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlGetCategories, callback: callbackFn): TransportRequestCallback + get_categories, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlGetCategories, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getCategories, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlGetCategories, options?: TransportRequestOptions): TransportRequestPromise> + getCategories, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + getCategories, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlGetCategories, callback: callbackFn): TransportRequestCallback + getCategories, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlGetCategories, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_data_frame_analytics, TContext = Context>(params?: RequestParams.MlGetDataFrameAnalytics, options?: TransportRequestOptions): TransportRequestPromise> + get_data_frame_analytics, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_data_frame_analytics, TContext = Context>(params: RequestParams.MlGetDataFrameAnalytics, callback: callbackFn): TransportRequestCallback + get_data_frame_analytics, TContext = Context>(params: RequestParams.MlGetDataFrameAnalytics, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getDataFrameAnalytics, TContext = Context>(params?: RequestParams.MlGetDataFrameAnalytics, options?: TransportRequestOptions): TransportRequestPromise> + getDataFrameAnalytics, TContext = Context>(callback: callbackFn): TransportRequestCallback + getDataFrameAnalytics, TContext = Context>(params: RequestParams.MlGetDataFrameAnalytics, callback: callbackFn): TransportRequestCallback + getDataFrameAnalytics, TContext = Context>(params: RequestParams.MlGetDataFrameAnalytics, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_data_frame_analytics_stats, TContext = Context>(params?: RequestParams.MlGetDataFrameAnalyticsStats, options?: TransportRequestOptions): TransportRequestPromise> + get_data_frame_analytics_stats, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_data_frame_analytics_stats, TContext = Context>(params: RequestParams.MlGetDataFrameAnalyticsStats, callback: callbackFn): TransportRequestCallback + get_data_frame_analytics_stats, TContext = Context>(params: RequestParams.MlGetDataFrameAnalyticsStats, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getDataFrameAnalyticsStats, TContext = Context>(params?: RequestParams.MlGetDataFrameAnalyticsStats, options?: TransportRequestOptions): TransportRequestPromise> + getDataFrameAnalyticsStats, TContext = Context>(callback: callbackFn): TransportRequestCallback + getDataFrameAnalyticsStats, TContext = Context>(params: RequestParams.MlGetDataFrameAnalyticsStats, callback: callbackFn): TransportRequestCallback + getDataFrameAnalyticsStats, TContext = Context>(params: RequestParams.MlGetDataFrameAnalyticsStats, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_datafeed_stats, TContext = Context>(params?: RequestParams.MlGetDatafeedStats, options?: TransportRequestOptions): TransportRequestPromise> + get_datafeed_stats, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_datafeed_stats, TContext = Context>(params: RequestParams.MlGetDatafeedStats, callback: callbackFn): TransportRequestCallback + get_datafeed_stats, TContext = Context>(params: RequestParams.MlGetDatafeedStats, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getDatafeedStats, TContext = Context>(params?: RequestParams.MlGetDatafeedStats, options?: TransportRequestOptions): TransportRequestPromise> + getDatafeedStats, TContext = Context>(callback: callbackFn): TransportRequestCallback + getDatafeedStats, TContext = Context>(params: RequestParams.MlGetDatafeedStats, callback: callbackFn): TransportRequestCallback + getDatafeedStats, TContext = Context>(params: RequestParams.MlGetDatafeedStats, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_datafeeds, TContext = Context>(params?: RequestParams.MlGetDatafeeds, options?: TransportRequestOptions): TransportRequestPromise> + get_datafeeds, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_datafeeds, TContext = Context>(params: RequestParams.MlGetDatafeeds, callback: callbackFn): TransportRequestCallback + get_datafeeds, TContext = Context>(params: RequestParams.MlGetDatafeeds, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getDatafeeds, TContext = Context>(params?: RequestParams.MlGetDatafeeds, options?: TransportRequestOptions): TransportRequestPromise> + getDatafeeds, TContext = Context>(callback: callbackFn): TransportRequestCallback + getDatafeeds, TContext = Context>(params: RequestParams.MlGetDatafeeds, callback: callbackFn): TransportRequestCallback + getDatafeeds, TContext = Context>(params: RequestParams.MlGetDatafeeds, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_filters, TContext = Context>(params?: RequestParams.MlGetFilters, options?: TransportRequestOptions): TransportRequestPromise> + get_filters, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_filters, TContext = Context>(params: RequestParams.MlGetFilters, callback: callbackFn): TransportRequestCallback + get_filters, TContext = Context>(params: RequestParams.MlGetFilters, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getFilters, TContext = Context>(params?: RequestParams.MlGetFilters, options?: TransportRequestOptions): TransportRequestPromise> + getFilters, TContext = Context>(callback: callbackFn): TransportRequestCallback + getFilters, TContext = Context>(params: RequestParams.MlGetFilters, callback: callbackFn): TransportRequestCallback + getFilters, TContext = Context>(params: RequestParams.MlGetFilters, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_influencers, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlGetInfluencers, options?: TransportRequestOptions): TransportRequestPromise> + get_influencers, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_influencers, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlGetInfluencers, callback: callbackFn): TransportRequestCallback + get_influencers, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlGetInfluencers, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getInfluencers, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlGetInfluencers, options?: TransportRequestOptions): TransportRequestPromise> + getInfluencers, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + getInfluencers, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlGetInfluencers, callback: callbackFn): TransportRequestCallback + getInfluencers, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlGetInfluencers, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_job_stats, TContext = Context>(params?: RequestParams.MlGetJobStats, options?: TransportRequestOptions): TransportRequestPromise> + get_job_stats, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_job_stats, TContext = Context>(params: RequestParams.MlGetJobStats, callback: callbackFn): TransportRequestCallback + get_job_stats, TContext = Context>(params: RequestParams.MlGetJobStats, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getJobStats, TContext = Context>(params?: RequestParams.MlGetJobStats, options?: TransportRequestOptions): TransportRequestPromise> + getJobStats, TContext = Context>(callback: callbackFn): TransportRequestCallback + getJobStats, TContext = Context>(params: RequestParams.MlGetJobStats, callback: callbackFn): TransportRequestCallback + getJobStats, TContext = Context>(params: RequestParams.MlGetJobStats, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_jobs, TContext = Context>(params?: RequestParams.MlGetJobs, options?: TransportRequestOptions): TransportRequestPromise> + get_jobs, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_jobs, TContext = Context>(params: RequestParams.MlGetJobs, callback: callbackFn): TransportRequestCallback + get_jobs, TContext = Context>(params: RequestParams.MlGetJobs, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getJobs, TContext = Context>(params?: RequestParams.MlGetJobs, options?: TransportRequestOptions): TransportRequestPromise> + getJobs, TContext = Context>(callback: callbackFn): TransportRequestCallback + getJobs, TContext = Context>(params: RequestParams.MlGetJobs, callback: callbackFn): TransportRequestCallback + getJobs, TContext = Context>(params: RequestParams.MlGetJobs, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_model_snapshots, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlGetModelSnapshots, options?: TransportRequestOptions): TransportRequestPromise> + get_model_snapshots, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_model_snapshots, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlGetModelSnapshots, callback: callbackFn): TransportRequestCallback + get_model_snapshots, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlGetModelSnapshots, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getModelSnapshots, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlGetModelSnapshots, options?: TransportRequestOptions): TransportRequestPromise> + getModelSnapshots, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + getModelSnapshots, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlGetModelSnapshots, callback: callbackFn): TransportRequestCallback + getModelSnapshots, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlGetModelSnapshots, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_overall_buckets, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlGetOverallBuckets, options?: TransportRequestOptions): TransportRequestPromise> + get_overall_buckets, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_overall_buckets, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlGetOverallBuckets, callback: callbackFn): TransportRequestCallback + get_overall_buckets, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlGetOverallBuckets, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getOverallBuckets, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlGetOverallBuckets, options?: TransportRequestOptions): TransportRequestPromise> + getOverallBuckets, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + getOverallBuckets, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlGetOverallBuckets, callback: callbackFn): TransportRequestCallback + getOverallBuckets, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlGetOverallBuckets, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_records, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlGetRecords, options?: TransportRequestOptions): TransportRequestPromise> + get_records, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_records, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlGetRecords, callback: callbackFn): TransportRequestCallback + get_records, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlGetRecords, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getRecords, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlGetRecords, options?: TransportRequestOptions): TransportRequestPromise> + getRecords, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + getRecords, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlGetRecords, callback: callbackFn): TransportRequestCallback + getRecords, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlGetRecords, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_trained_models, TContext = Context>(params?: RequestParams.MlGetTrainedModels, options?: TransportRequestOptions): TransportRequestPromise> + get_trained_models, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_trained_models, TContext = Context>(params: RequestParams.MlGetTrainedModels, callback: callbackFn): TransportRequestCallback + get_trained_models, TContext = Context>(params: RequestParams.MlGetTrainedModels, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getTrainedModels, TContext = Context>(params?: RequestParams.MlGetTrainedModels, options?: TransportRequestOptions): TransportRequestPromise> + getTrainedModels, TContext = Context>(callback: callbackFn): TransportRequestCallback + getTrainedModels, TContext = Context>(params: RequestParams.MlGetTrainedModels, callback: callbackFn): TransportRequestCallback + getTrainedModels, TContext = Context>(params: RequestParams.MlGetTrainedModels, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_trained_models_stats, TContext = Context>(params?: RequestParams.MlGetTrainedModelsStats, options?: TransportRequestOptions): TransportRequestPromise> + get_trained_models_stats, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_trained_models_stats, TContext = Context>(params: RequestParams.MlGetTrainedModelsStats, callback: callbackFn): TransportRequestCallback + get_trained_models_stats, TContext = Context>(params: RequestParams.MlGetTrainedModelsStats, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getTrainedModelsStats, TContext = Context>(params?: RequestParams.MlGetTrainedModelsStats, options?: TransportRequestOptions): TransportRequestPromise> + getTrainedModelsStats, TContext = Context>(callback: callbackFn): TransportRequestCallback + getTrainedModelsStats, TContext = Context>(params: RequestParams.MlGetTrainedModelsStats, callback: callbackFn): TransportRequestCallback + getTrainedModelsStats, TContext = Context>(params: RequestParams.MlGetTrainedModelsStats, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + info, TContext = Context>(params?: RequestParams.MlInfo, options?: TransportRequestOptions): TransportRequestPromise> + info, TContext = Context>(callback: callbackFn): TransportRequestCallback + info, TContext = Context>(params: RequestParams.MlInfo, callback: callbackFn): TransportRequestCallback + info, TContext = Context>(params: RequestParams.MlInfo, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + open_job, TContext = Context>(params?: RequestParams.MlOpenJob, options?: TransportRequestOptions): TransportRequestPromise> + open_job, TContext = Context>(callback: callbackFn): TransportRequestCallback + open_job, TContext = Context>(params: RequestParams.MlOpenJob, callback: callbackFn): TransportRequestCallback + open_job, TContext = Context>(params: RequestParams.MlOpenJob, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + openJob, TContext = Context>(params?: RequestParams.MlOpenJob, options?: TransportRequestOptions): TransportRequestPromise> + openJob, TContext = Context>(callback: callbackFn): TransportRequestCallback + openJob, TContext = Context>(params: RequestParams.MlOpenJob, callback: callbackFn): TransportRequestCallback + openJob, TContext = Context>(params: RequestParams.MlOpenJob, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + post_calendar_events, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlPostCalendarEvents, options?: TransportRequestOptions): TransportRequestPromise> + post_calendar_events, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + post_calendar_events, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPostCalendarEvents, callback: callbackFn): TransportRequestCallback + post_calendar_events, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPostCalendarEvents, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + postCalendarEvents, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlPostCalendarEvents, options?: TransportRequestOptions): TransportRequestPromise> + postCalendarEvents, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + postCalendarEvents, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPostCalendarEvents, callback: callbackFn): TransportRequestCallback + postCalendarEvents, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPostCalendarEvents, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + post_data, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlPostData, options?: TransportRequestOptions): TransportRequestPromise> + post_data, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + post_data, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPostData, callback: callbackFn): TransportRequestCallback + post_data, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPostData, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + postData, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlPostData, options?: TransportRequestOptions): TransportRequestPromise> + postData, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + postData, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPostData, callback: callbackFn): TransportRequestCallback + postData, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPostData, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + preview_data_frame_analytics, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlPreviewDataFrameAnalytics, options?: TransportRequestOptions): TransportRequestPromise> + preview_data_frame_analytics, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + preview_data_frame_analytics, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPreviewDataFrameAnalytics, callback: callbackFn): TransportRequestCallback + preview_data_frame_analytics, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPreviewDataFrameAnalytics, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + previewDataFrameAnalytics, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlPreviewDataFrameAnalytics, options?: TransportRequestOptions): TransportRequestPromise> + previewDataFrameAnalytics, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + previewDataFrameAnalytics, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPreviewDataFrameAnalytics, callback: callbackFn): TransportRequestCallback + previewDataFrameAnalytics, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPreviewDataFrameAnalytics, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + preview_datafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlPreviewDatafeed, options?: TransportRequestOptions): TransportRequestPromise> + preview_datafeed, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + preview_datafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPreviewDatafeed, callback: callbackFn): TransportRequestCallback + preview_datafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPreviewDatafeed, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + previewDatafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlPreviewDatafeed, options?: TransportRequestOptions): TransportRequestPromise> + previewDatafeed, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + previewDatafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPreviewDatafeed, callback: callbackFn): TransportRequestCallback + previewDatafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPreviewDatafeed, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_calendar, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlPutCalendar, options?: TransportRequestOptions): TransportRequestPromise> + put_calendar, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_calendar, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPutCalendar, callback: callbackFn): TransportRequestCallback + put_calendar, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPutCalendar, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putCalendar, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlPutCalendar, options?: TransportRequestOptions): TransportRequestPromise> + putCalendar, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + putCalendar, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPutCalendar, callback: callbackFn): TransportRequestCallback + putCalendar, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPutCalendar, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_calendar_job, TContext = Context>(params?: RequestParams.MlPutCalendarJob, options?: TransportRequestOptions): TransportRequestPromise> + put_calendar_job, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_calendar_job, TContext = Context>(params: RequestParams.MlPutCalendarJob, callback: callbackFn): TransportRequestCallback + put_calendar_job, TContext = Context>(params: RequestParams.MlPutCalendarJob, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putCalendarJob, TContext = Context>(params?: RequestParams.MlPutCalendarJob, options?: TransportRequestOptions): TransportRequestPromise> + putCalendarJob, TContext = Context>(callback: callbackFn): TransportRequestCallback + putCalendarJob, TContext = Context>(params: RequestParams.MlPutCalendarJob, callback: callbackFn): TransportRequestCallback + putCalendarJob, TContext = Context>(params: RequestParams.MlPutCalendarJob, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_data_frame_analytics, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlPutDataFrameAnalytics, options?: TransportRequestOptions): TransportRequestPromise> + put_data_frame_analytics, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_data_frame_analytics, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPutDataFrameAnalytics, callback: callbackFn): TransportRequestCallback + put_data_frame_analytics, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPutDataFrameAnalytics, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putDataFrameAnalytics, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlPutDataFrameAnalytics, options?: TransportRequestOptions): TransportRequestPromise> + putDataFrameAnalytics, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + putDataFrameAnalytics, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPutDataFrameAnalytics, callback: callbackFn): TransportRequestCallback + putDataFrameAnalytics, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPutDataFrameAnalytics, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_datafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlPutDatafeed, options?: TransportRequestOptions): TransportRequestPromise> + put_datafeed, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_datafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPutDatafeed, callback: callbackFn): TransportRequestCallback + put_datafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPutDatafeed, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putDatafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlPutDatafeed, options?: TransportRequestOptions): TransportRequestPromise> + putDatafeed, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + putDatafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPutDatafeed, callback: callbackFn): TransportRequestCallback + putDatafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPutDatafeed, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_filter, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlPutFilter, options?: TransportRequestOptions): TransportRequestPromise> + put_filter, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_filter, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPutFilter, callback: callbackFn): TransportRequestCallback + put_filter, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPutFilter, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putFilter, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlPutFilter, options?: TransportRequestOptions): TransportRequestPromise> + putFilter, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + putFilter, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPutFilter, callback: callbackFn): TransportRequestCallback + putFilter, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPutFilter, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_job, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlPutJob, options?: TransportRequestOptions): TransportRequestPromise> + put_job, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_job, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPutJob, callback: callbackFn): TransportRequestCallback + put_job, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPutJob, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putJob, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlPutJob, options?: TransportRequestOptions): TransportRequestPromise> + putJob, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + putJob, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPutJob, callback: callbackFn): TransportRequestCallback + putJob, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPutJob, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_trained_model, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlPutTrainedModel, options?: TransportRequestOptions): TransportRequestPromise> + put_trained_model, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_trained_model, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPutTrainedModel, callback: callbackFn): TransportRequestCallback + put_trained_model, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPutTrainedModel, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putTrainedModel, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlPutTrainedModel, options?: TransportRequestOptions): TransportRequestPromise> + putTrainedModel, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + putTrainedModel, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPutTrainedModel, callback: callbackFn): TransportRequestCallback + putTrainedModel, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlPutTrainedModel, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_trained_model_alias, TContext = Context>(params?: RequestParams.MlPutTrainedModelAlias, options?: TransportRequestOptions): TransportRequestPromise> + put_trained_model_alias, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_trained_model_alias, TContext = Context>(params: RequestParams.MlPutTrainedModelAlias, callback: callbackFn): TransportRequestCallback + put_trained_model_alias, TContext = Context>(params: RequestParams.MlPutTrainedModelAlias, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putTrainedModelAlias, TContext = Context>(params?: RequestParams.MlPutTrainedModelAlias, options?: TransportRequestOptions): TransportRequestPromise> + putTrainedModelAlias, TContext = Context>(callback: callbackFn): TransportRequestCallback + putTrainedModelAlias, TContext = Context>(params: RequestParams.MlPutTrainedModelAlias, callback: callbackFn): TransportRequestCallback + putTrainedModelAlias, TContext = Context>(params: RequestParams.MlPutTrainedModelAlias, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + revert_model_snapshot, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlRevertModelSnapshot, options?: TransportRequestOptions): TransportRequestPromise> + revert_model_snapshot, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + revert_model_snapshot, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlRevertModelSnapshot, callback: callbackFn): TransportRequestCallback + revert_model_snapshot, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlRevertModelSnapshot, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + revertModelSnapshot, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlRevertModelSnapshot, options?: TransportRequestOptions): TransportRequestPromise> + revertModelSnapshot, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + revertModelSnapshot, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlRevertModelSnapshot, callback: callbackFn): TransportRequestCallback + revertModelSnapshot, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlRevertModelSnapshot, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + set_upgrade_mode, TContext = Context>(params?: RequestParams.MlSetUpgradeMode, options?: TransportRequestOptions): TransportRequestPromise> + set_upgrade_mode, TContext = Context>(callback: callbackFn): TransportRequestCallback + set_upgrade_mode, TContext = Context>(params: RequestParams.MlSetUpgradeMode, callback: callbackFn): TransportRequestCallback + set_upgrade_mode, TContext = Context>(params: RequestParams.MlSetUpgradeMode, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + setUpgradeMode, TContext = Context>(params?: RequestParams.MlSetUpgradeMode, options?: TransportRequestOptions): TransportRequestPromise> + setUpgradeMode, TContext = Context>(callback: callbackFn): TransportRequestCallback + setUpgradeMode, TContext = Context>(params: RequestParams.MlSetUpgradeMode, callback: callbackFn): TransportRequestCallback + setUpgradeMode, TContext = Context>(params: RequestParams.MlSetUpgradeMode, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + start_data_frame_analytics, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlStartDataFrameAnalytics, options?: TransportRequestOptions): TransportRequestPromise> + start_data_frame_analytics, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + start_data_frame_analytics, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlStartDataFrameAnalytics, callback: callbackFn): TransportRequestCallback + start_data_frame_analytics, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlStartDataFrameAnalytics, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + startDataFrameAnalytics, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlStartDataFrameAnalytics, options?: TransportRequestOptions): TransportRequestPromise> + startDataFrameAnalytics, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + startDataFrameAnalytics, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlStartDataFrameAnalytics, callback: callbackFn): TransportRequestCallback + startDataFrameAnalytics, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlStartDataFrameAnalytics, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + start_datafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlStartDatafeed, options?: TransportRequestOptions): TransportRequestPromise> + start_datafeed, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + start_datafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlStartDatafeed, callback: callbackFn): TransportRequestCallback + start_datafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlStartDatafeed, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + startDatafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlStartDatafeed, options?: TransportRequestOptions): TransportRequestPromise> + startDatafeed, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + startDatafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlStartDatafeed, callback: callbackFn): TransportRequestCallback + startDatafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlStartDatafeed, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + stop_data_frame_analytics, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlStopDataFrameAnalytics, options?: TransportRequestOptions): TransportRequestPromise> + stop_data_frame_analytics, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + stop_data_frame_analytics, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlStopDataFrameAnalytics, callback: callbackFn): TransportRequestCallback + stop_data_frame_analytics, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlStopDataFrameAnalytics, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + stopDataFrameAnalytics, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlStopDataFrameAnalytics, options?: TransportRequestOptions): TransportRequestPromise> + stopDataFrameAnalytics, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + stopDataFrameAnalytics, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlStopDataFrameAnalytics, callback: callbackFn): TransportRequestCallback + stopDataFrameAnalytics, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlStopDataFrameAnalytics, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + stop_datafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlStopDatafeed, options?: TransportRequestOptions): TransportRequestPromise> + stop_datafeed, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + stop_datafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlStopDatafeed, callback: callbackFn): TransportRequestCallback + stop_datafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlStopDatafeed, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + stopDatafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlStopDatafeed, options?: TransportRequestOptions): TransportRequestPromise> + stopDatafeed, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + stopDatafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlStopDatafeed, callback: callbackFn): TransportRequestCallback + stopDatafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlStopDatafeed, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + update_data_frame_analytics, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlUpdateDataFrameAnalytics, options?: TransportRequestOptions): TransportRequestPromise> + update_data_frame_analytics, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + update_data_frame_analytics, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlUpdateDataFrameAnalytics, callback: callbackFn): TransportRequestCallback + update_data_frame_analytics, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlUpdateDataFrameAnalytics, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + updateDataFrameAnalytics, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlUpdateDataFrameAnalytics, options?: TransportRequestOptions): TransportRequestPromise> + updateDataFrameAnalytics, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + updateDataFrameAnalytics, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlUpdateDataFrameAnalytics, callback: callbackFn): TransportRequestCallback + updateDataFrameAnalytics, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlUpdateDataFrameAnalytics, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + update_datafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlUpdateDatafeed, options?: TransportRequestOptions): TransportRequestPromise> + update_datafeed, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + update_datafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlUpdateDatafeed, callback: callbackFn): TransportRequestCallback + update_datafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlUpdateDatafeed, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + updateDatafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlUpdateDatafeed, options?: TransportRequestOptions): TransportRequestPromise> + updateDatafeed, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + updateDatafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlUpdateDatafeed, callback: callbackFn): TransportRequestCallback + updateDatafeed, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlUpdateDatafeed, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + update_filter, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlUpdateFilter, options?: TransportRequestOptions): TransportRequestPromise> + update_filter, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + update_filter, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlUpdateFilter, callback: callbackFn): TransportRequestCallback + update_filter, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlUpdateFilter, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + updateFilter, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlUpdateFilter, options?: TransportRequestOptions): TransportRequestPromise> + updateFilter, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + updateFilter, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlUpdateFilter, callback: callbackFn): TransportRequestCallback + updateFilter, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlUpdateFilter, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + update_job, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlUpdateJob, options?: TransportRequestOptions): TransportRequestPromise> + update_job, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + update_job, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlUpdateJob, callback: callbackFn): TransportRequestCallback + update_job, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlUpdateJob, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + updateJob, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlUpdateJob, options?: TransportRequestOptions): TransportRequestPromise> + updateJob, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + updateJob, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlUpdateJob, callback: callbackFn): TransportRequestCallback + updateJob, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlUpdateJob, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + update_model_snapshot, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlUpdateModelSnapshot, options?: TransportRequestOptions): TransportRequestPromise> + update_model_snapshot, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + update_model_snapshot, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlUpdateModelSnapshot, callback: callbackFn): TransportRequestCallback + update_model_snapshot, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlUpdateModelSnapshot, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + updateModelSnapshot, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlUpdateModelSnapshot, options?: TransportRequestOptions): TransportRequestPromise> + updateModelSnapshot, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + updateModelSnapshot, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlUpdateModelSnapshot, callback: callbackFn): TransportRequestCallback + updateModelSnapshot, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlUpdateModelSnapshot, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + upgrade_job_snapshot, TContext = Context>(params?: RequestParams.MlUpgradeJobSnapshot, options?: TransportRequestOptions): TransportRequestPromise> + upgrade_job_snapshot, TContext = Context>(callback: callbackFn): TransportRequestCallback + upgrade_job_snapshot, TContext = Context>(params: RequestParams.MlUpgradeJobSnapshot, callback: callbackFn): TransportRequestCallback + upgrade_job_snapshot, TContext = Context>(params: RequestParams.MlUpgradeJobSnapshot, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + upgradeJobSnapshot, TContext = Context>(params?: RequestParams.MlUpgradeJobSnapshot, options?: TransportRequestOptions): TransportRequestPromise> + upgradeJobSnapshot, TContext = Context>(callback: callbackFn): TransportRequestCallback + upgradeJobSnapshot, TContext = Context>(params: RequestParams.MlUpgradeJobSnapshot, callback: callbackFn): TransportRequestCallback + upgradeJobSnapshot, TContext = Context>(params: RequestParams.MlUpgradeJobSnapshot, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + validate, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlValidate, options?: TransportRequestOptions): TransportRequestPromise> + validate, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + validate, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlValidate, callback: callbackFn): TransportRequestCallback + validate, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlValidate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + validate_detector, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlValidateDetector, options?: TransportRequestOptions): TransportRequestPromise> + validate_detector, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + validate_detector, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlValidateDetector, callback: callbackFn): TransportRequestCallback + validate_detector, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlValidateDetector, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + validateDetector, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.MlValidateDetector, options?: TransportRequestOptions): TransportRequestPromise> + validateDetector, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + validateDetector, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlValidateDetector, callback: callbackFn): TransportRequestCallback + validateDetector, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.MlValidateDetector, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + monitoring: { + bulk, TRequestBody extends RequestNDBody = Record[], TContext = Context>(params?: RequestParams.MonitoringBulk, options?: TransportRequestOptions): TransportRequestPromise> + bulk, TRequestBody extends RequestNDBody = Record[], TContext = Context>(callback: callbackFn): TransportRequestCallback + bulk, TRequestBody extends RequestNDBody = Record[], TContext = Context>(params: RequestParams.MonitoringBulk, callback: callbackFn): TransportRequestCallback + bulk, TRequestBody extends RequestNDBody = Record[], TContext = Context>(params: RequestParams.MonitoringBulk, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + msearch, TRequestBody extends RequestNDBody = Record[], TContext = Context>(params?: RequestParams.Msearch, options?: TransportRequestOptions): TransportRequestPromise> + msearch, TRequestBody extends RequestNDBody = Record[], TContext = Context>(callback: callbackFn): TransportRequestCallback + msearch, TRequestBody extends RequestNDBody = Record[], TContext = Context>(params: RequestParams.Msearch, callback: callbackFn): TransportRequestCallback + msearch, TRequestBody extends RequestNDBody = Record[], TContext = Context>(params: RequestParams.Msearch, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + msearch_template, TRequestBody extends RequestNDBody = Record[], TContext = Context>(params?: RequestParams.MsearchTemplate, options?: TransportRequestOptions): TransportRequestPromise> + msearch_template, TRequestBody extends RequestNDBody = Record[], TContext = Context>(callback: callbackFn): TransportRequestCallback + msearch_template, TRequestBody extends RequestNDBody = Record[], TContext = Context>(params: RequestParams.MsearchTemplate, callback: callbackFn): TransportRequestCallback + msearch_template, TRequestBody extends RequestNDBody = Record[], TContext = Context>(params: RequestParams.MsearchTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + msearchTemplate, TRequestBody extends RequestNDBody = Record[], TContext = Context>(params?: RequestParams.MsearchTemplate, options?: TransportRequestOptions): TransportRequestPromise> + msearchTemplate, TRequestBody extends RequestNDBody = Record[], TContext = Context>(callback: callbackFn): TransportRequestCallback + msearchTemplate, TRequestBody extends RequestNDBody = Record[], TContext = Context>(params: RequestParams.MsearchTemplate, callback: callbackFn): TransportRequestCallback + msearchTemplate, TRequestBody extends RequestNDBody = Record[], TContext = Context>(params: RequestParams.MsearchTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + mtermvectors, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.Mtermvectors, options?: TransportRequestOptions): TransportRequestPromise> + mtermvectors, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + mtermvectors, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.Mtermvectors, callback: callbackFn): TransportRequestCallback + mtermvectors, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.Mtermvectors, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + nodes: { + hot_threads, TContext = Context>(params?: RequestParams.NodesHotThreads, options?: TransportRequestOptions): TransportRequestPromise> + hot_threads, TContext = Context>(callback: callbackFn): TransportRequestCallback + hot_threads, TContext = Context>(params: RequestParams.NodesHotThreads, callback: callbackFn): TransportRequestCallback + hot_threads, TContext = Context>(params: RequestParams.NodesHotThreads, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + hotThreads, TContext = Context>(params?: RequestParams.NodesHotThreads, options?: TransportRequestOptions): TransportRequestPromise> + hotThreads, TContext = Context>(callback: callbackFn): TransportRequestCallback + hotThreads, TContext = Context>(params: RequestParams.NodesHotThreads, callback: callbackFn): TransportRequestCallback + hotThreads, TContext = Context>(params: RequestParams.NodesHotThreads, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + info, TContext = Context>(params?: RequestParams.NodesInfo, options?: TransportRequestOptions): TransportRequestPromise> + info, TContext = Context>(callback: callbackFn): TransportRequestCallback + info, TContext = Context>(params: RequestParams.NodesInfo, callback: callbackFn): TransportRequestCallback + info, TContext = Context>(params: RequestParams.NodesInfo, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + reload_secure_settings, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.NodesReloadSecureSettings, options?: TransportRequestOptions): TransportRequestPromise> + reload_secure_settings, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + reload_secure_settings, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.NodesReloadSecureSettings, callback: callbackFn): TransportRequestCallback + reload_secure_settings, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.NodesReloadSecureSettings, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + reloadSecureSettings, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.NodesReloadSecureSettings, options?: TransportRequestOptions): TransportRequestPromise> + reloadSecureSettings, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + reloadSecureSettings, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.NodesReloadSecureSettings, callback: callbackFn): TransportRequestCallback + reloadSecureSettings, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.NodesReloadSecureSettings, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + stats, TContext = Context>(params?: RequestParams.NodesStats, options?: TransportRequestOptions): TransportRequestPromise> + stats, TContext = Context>(callback: callbackFn): TransportRequestCallback + stats, TContext = Context>(params: RequestParams.NodesStats, callback: callbackFn): TransportRequestCallback + stats, TContext = Context>(params: RequestParams.NodesStats, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + usage, TContext = Context>(params?: RequestParams.NodesUsage, options?: TransportRequestOptions): TransportRequestPromise> + usage, TContext = Context>(callback: callbackFn): TransportRequestCallback + usage, TContext = Context>(params: RequestParams.NodesUsage, callback: callbackFn): TransportRequestCallback + usage, TContext = Context>(params: RequestParams.NodesUsage, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + open_point_in_time, TContext = Context>(params?: RequestParams.OpenPointInTime, options?: TransportRequestOptions): TransportRequestPromise> + open_point_in_time, TContext = Context>(callback: callbackFn): TransportRequestCallback + open_point_in_time, TContext = Context>(params: RequestParams.OpenPointInTime, callback: callbackFn): TransportRequestCallback + open_point_in_time, TContext = Context>(params: RequestParams.OpenPointInTime, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + openPointInTime, TContext = Context>(params?: RequestParams.OpenPointInTime, options?: TransportRequestOptions): TransportRequestPromise> + openPointInTime, TContext = Context>(callback: callbackFn): TransportRequestCallback + openPointInTime, TContext = Context>(params: RequestParams.OpenPointInTime, callback: callbackFn): TransportRequestCallback + openPointInTime, TContext = Context>(params: RequestParams.OpenPointInTime, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + ping(params?: RequestParams.Ping, options?: TransportRequestOptions): TransportRequestPromise> + ping(callback: callbackFn): TransportRequestCallback + ping(params: RequestParams.Ping, callback: callbackFn): TransportRequestCallback + ping(params: RequestParams.Ping, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_script, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.PutScript, options?: TransportRequestOptions): TransportRequestPromise> + put_script, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_script, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.PutScript, callback: callbackFn): TransportRequestCallback + put_script, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.PutScript, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putScript, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.PutScript, options?: TransportRequestOptions): TransportRequestPromise> + putScript, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + putScript, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.PutScript, callback: callbackFn): TransportRequestCallback + putScript, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.PutScript, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + rank_eval, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.RankEval, options?: TransportRequestOptions): TransportRequestPromise> + rank_eval, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + rank_eval, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.RankEval, callback: callbackFn): TransportRequestCallback + rank_eval, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.RankEval, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + rankEval, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.RankEval, options?: TransportRequestOptions): TransportRequestPromise> + rankEval, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + rankEval, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.RankEval, callback: callbackFn): TransportRequestCallback + rankEval, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.RankEval, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + reindex, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.Reindex, options?: TransportRequestOptions): TransportRequestPromise> + reindex, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + reindex, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.Reindex, callback: callbackFn): TransportRequestCallback + reindex, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.Reindex, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + reindex_rethrottle, TContext = Context>(params?: RequestParams.ReindexRethrottle, options?: TransportRequestOptions): TransportRequestPromise> + reindex_rethrottle, TContext = Context>(callback: callbackFn): TransportRequestCallback + reindex_rethrottle, TContext = Context>(params: RequestParams.ReindexRethrottle, callback: callbackFn): TransportRequestCallback + reindex_rethrottle, TContext = Context>(params: RequestParams.ReindexRethrottle, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + reindexRethrottle, TContext = Context>(params?: RequestParams.ReindexRethrottle, options?: TransportRequestOptions): TransportRequestPromise> + reindexRethrottle, TContext = Context>(callback: callbackFn): TransportRequestCallback + reindexRethrottle, TContext = Context>(params: RequestParams.ReindexRethrottle, callback: callbackFn): TransportRequestCallback + reindexRethrottle, TContext = Context>(params: RequestParams.ReindexRethrottle, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + render_search_template, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.RenderSearchTemplate, options?: TransportRequestOptions): TransportRequestPromise> + render_search_template, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + render_search_template, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.RenderSearchTemplate, callback: callbackFn): TransportRequestCallback + render_search_template, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.RenderSearchTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + renderSearchTemplate, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.RenderSearchTemplate, options?: TransportRequestOptions): TransportRequestPromise> + renderSearchTemplate, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + renderSearchTemplate, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.RenderSearchTemplate, callback: callbackFn): TransportRequestCallback + renderSearchTemplate, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.RenderSearchTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + rollup: { + delete_job, TContext = Context>(params?: RequestParams.RollupDeleteJob, options?: TransportRequestOptions): TransportRequestPromise> + delete_job, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_job, TContext = Context>(params: RequestParams.RollupDeleteJob, callback: callbackFn): TransportRequestCallback + delete_job, TContext = Context>(params: RequestParams.RollupDeleteJob, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteJob, TContext = Context>(params?: RequestParams.RollupDeleteJob, options?: TransportRequestOptions): TransportRequestPromise> + deleteJob, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteJob, TContext = Context>(params: RequestParams.RollupDeleteJob, callback: callbackFn): TransportRequestCallback + deleteJob, TContext = Context>(params: RequestParams.RollupDeleteJob, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_jobs, TContext = Context>(params?: RequestParams.RollupGetJobs, options?: TransportRequestOptions): TransportRequestPromise> + get_jobs, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_jobs, TContext = Context>(params: RequestParams.RollupGetJobs, callback: callbackFn): TransportRequestCallback + get_jobs, TContext = Context>(params: RequestParams.RollupGetJobs, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getJobs, TContext = Context>(params?: RequestParams.RollupGetJobs, options?: TransportRequestOptions): TransportRequestPromise> + getJobs, TContext = Context>(callback: callbackFn): TransportRequestCallback + getJobs, TContext = Context>(params: RequestParams.RollupGetJobs, callback: callbackFn): TransportRequestCallback + getJobs, TContext = Context>(params: RequestParams.RollupGetJobs, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_rollup_caps, TContext = Context>(params?: RequestParams.RollupGetRollupCaps, options?: TransportRequestOptions): TransportRequestPromise> + get_rollup_caps, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_rollup_caps, TContext = Context>(params: RequestParams.RollupGetRollupCaps, callback: callbackFn): TransportRequestCallback + get_rollup_caps, TContext = Context>(params: RequestParams.RollupGetRollupCaps, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getRollupCaps, TContext = Context>(params?: RequestParams.RollupGetRollupCaps, options?: TransportRequestOptions): TransportRequestPromise> + getRollupCaps, TContext = Context>(callback: callbackFn): TransportRequestCallback + getRollupCaps, TContext = Context>(params: RequestParams.RollupGetRollupCaps, callback: callbackFn): TransportRequestCallback + getRollupCaps, TContext = Context>(params: RequestParams.RollupGetRollupCaps, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_rollup_index_caps, TContext = Context>(params?: RequestParams.RollupGetRollupIndexCaps, options?: TransportRequestOptions): TransportRequestPromise> + get_rollup_index_caps, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_rollup_index_caps, TContext = Context>(params: RequestParams.RollupGetRollupIndexCaps, callback: callbackFn): TransportRequestCallback + get_rollup_index_caps, TContext = Context>(params: RequestParams.RollupGetRollupIndexCaps, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getRollupIndexCaps, TContext = Context>(params?: RequestParams.RollupGetRollupIndexCaps, options?: TransportRequestOptions): TransportRequestPromise> + getRollupIndexCaps, TContext = Context>(callback: callbackFn): TransportRequestCallback + getRollupIndexCaps, TContext = Context>(params: RequestParams.RollupGetRollupIndexCaps, callback: callbackFn): TransportRequestCallback + getRollupIndexCaps, TContext = Context>(params: RequestParams.RollupGetRollupIndexCaps, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_job, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.RollupPutJob, options?: TransportRequestOptions): TransportRequestPromise> + put_job, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_job, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.RollupPutJob, callback: callbackFn): TransportRequestCallback + put_job, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.RollupPutJob, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putJob, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.RollupPutJob, options?: TransportRequestOptions): TransportRequestPromise> + putJob, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + putJob, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.RollupPutJob, callback: callbackFn): TransportRequestCallback + putJob, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.RollupPutJob, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + rollup, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.RollupRollup, options?: TransportRequestOptions): TransportRequestPromise> + rollup, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + rollup, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.RollupRollup, callback: callbackFn): TransportRequestCallback + rollup, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.RollupRollup, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + rollup_search, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.RollupRollupSearch, options?: TransportRequestOptions): TransportRequestPromise> + rollup_search, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + rollup_search, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.RollupRollupSearch, callback: callbackFn): TransportRequestCallback + rollup_search, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.RollupRollupSearch, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + rollupSearch, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.RollupRollupSearch, options?: TransportRequestOptions): TransportRequestPromise> + rollupSearch, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + rollupSearch, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.RollupRollupSearch, callback: callbackFn): TransportRequestCallback + rollupSearch, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.RollupRollupSearch, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + start_job, TContext = Context>(params?: RequestParams.RollupStartJob, options?: TransportRequestOptions): TransportRequestPromise> + start_job, TContext = Context>(callback: callbackFn): TransportRequestCallback + start_job, TContext = Context>(params: RequestParams.RollupStartJob, callback: callbackFn): TransportRequestCallback + start_job, TContext = Context>(params: RequestParams.RollupStartJob, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + startJob, TContext = Context>(params?: RequestParams.RollupStartJob, options?: TransportRequestOptions): TransportRequestPromise> + startJob, TContext = Context>(callback: callbackFn): TransportRequestCallback + startJob, TContext = Context>(params: RequestParams.RollupStartJob, callback: callbackFn): TransportRequestCallback + startJob, TContext = Context>(params: RequestParams.RollupStartJob, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + stop_job, TContext = Context>(params?: RequestParams.RollupStopJob, options?: TransportRequestOptions): TransportRequestPromise> + stop_job, TContext = Context>(callback: callbackFn): TransportRequestCallback + stop_job, TContext = Context>(params: RequestParams.RollupStopJob, callback: callbackFn): TransportRequestCallback + stop_job, TContext = Context>(params: RequestParams.RollupStopJob, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + stopJob, TContext = Context>(params?: RequestParams.RollupStopJob, options?: TransportRequestOptions): TransportRequestPromise> + stopJob, TContext = Context>(callback: callbackFn): TransportRequestCallback + stopJob, TContext = Context>(params: RequestParams.RollupStopJob, callback: callbackFn): TransportRequestCallback + stopJob, TContext = Context>(params: RequestParams.RollupStopJob, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + scripts_painless_execute, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.ScriptsPainlessExecute, options?: TransportRequestOptions): TransportRequestPromise> + scripts_painless_execute, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + scripts_painless_execute, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ScriptsPainlessExecute, callback: callbackFn): TransportRequestCallback + scripts_painless_execute, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ScriptsPainlessExecute, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + scriptsPainlessExecute, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.ScriptsPainlessExecute, options?: TransportRequestOptions): TransportRequestPromise> + scriptsPainlessExecute, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + scriptsPainlessExecute, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ScriptsPainlessExecute, callback: callbackFn): TransportRequestCallback + scriptsPainlessExecute, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ScriptsPainlessExecute, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + scroll, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.Scroll, options?: TransportRequestOptions): TransportRequestPromise> + scroll, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + scroll, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.Scroll, callback: callbackFn): TransportRequestCallback + scroll, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.Scroll, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + search, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.Search, options?: TransportRequestOptions): TransportRequestPromise> + search, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + search, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.Search, callback: callbackFn): TransportRequestCallback + search, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.Search, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + search_shards, TContext = Context>(params?: RequestParams.SearchShards, options?: TransportRequestOptions): TransportRequestPromise> + search_shards, TContext = Context>(callback: callbackFn): TransportRequestCallback + search_shards, TContext = Context>(params: RequestParams.SearchShards, callback: callbackFn): TransportRequestCallback + search_shards, TContext = Context>(params: RequestParams.SearchShards, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + searchShards, TContext = Context>(params?: RequestParams.SearchShards, options?: TransportRequestOptions): TransportRequestPromise> + searchShards, TContext = Context>(callback: callbackFn): TransportRequestCallback + searchShards, TContext = Context>(params: RequestParams.SearchShards, callback: callbackFn): TransportRequestCallback + searchShards, TContext = Context>(params: RequestParams.SearchShards, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + search_template, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SearchTemplate, options?: TransportRequestOptions): TransportRequestPromise> + search_template, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + search_template, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SearchTemplate, callback: callbackFn): TransportRequestCallback + search_template, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SearchTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + searchTemplate, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SearchTemplate, options?: TransportRequestOptions): TransportRequestPromise> + searchTemplate, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + searchTemplate, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SearchTemplate, callback: callbackFn): TransportRequestCallback + searchTemplate, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SearchTemplate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + searchable_snapshots: { + clear_cache, TContext = Context>(params?: RequestParams.SearchableSnapshotsClearCache, options?: TransportRequestOptions): TransportRequestPromise> + clear_cache, TContext = Context>(callback: callbackFn): TransportRequestCallback + clear_cache, TContext = Context>(params: RequestParams.SearchableSnapshotsClearCache, callback: callbackFn): TransportRequestCallback + clear_cache, TContext = Context>(params: RequestParams.SearchableSnapshotsClearCache, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + clearCache, TContext = Context>(params?: RequestParams.SearchableSnapshotsClearCache, options?: TransportRequestOptions): TransportRequestPromise> + clearCache, TContext = Context>(callback: callbackFn): TransportRequestCallback + clearCache, TContext = Context>(params: RequestParams.SearchableSnapshotsClearCache, callback: callbackFn): TransportRequestCallback + clearCache, TContext = Context>(params: RequestParams.SearchableSnapshotsClearCache, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + mount, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SearchableSnapshotsMount, options?: TransportRequestOptions): TransportRequestPromise> + mount, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + mount, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SearchableSnapshotsMount, callback: callbackFn): TransportRequestCallback + mount, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SearchableSnapshotsMount, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + stats, TContext = Context>(params?: RequestParams.SearchableSnapshotsStats, options?: TransportRequestOptions): TransportRequestPromise> + stats, TContext = Context>(callback: callbackFn): TransportRequestCallback + stats, TContext = Context>(params: RequestParams.SearchableSnapshotsStats, callback: callbackFn): TransportRequestCallback + stats, TContext = Context>(params: RequestParams.SearchableSnapshotsStats, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + searchableSnapshots: { + clear_cache, TContext = Context>(params?: RequestParams.SearchableSnapshotsClearCache, options?: TransportRequestOptions): TransportRequestPromise> + clear_cache, TContext = Context>(callback: callbackFn): TransportRequestCallback + clear_cache, TContext = Context>(params: RequestParams.SearchableSnapshotsClearCache, callback: callbackFn): TransportRequestCallback + clear_cache, TContext = Context>(params: RequestParams.SearchableSnapshotsClearCache, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + clearCache, TContext = Context>(params?: RequestParams.SearchableSnapshotsClearCache, options?: TransportRequestOptions): TransportRequestPromise> + clearCache, TContext = Context>(callback: callbackFn): TransportRequestCallback + clearCache, TContext = Context>(params: RequestParams.SearchableSnapshotsClearCache, callback: callbackFn): TransportRequestCallback + clearCache, TContext = Context>(params: RequestParams.SearchableSnapshotsClearCache, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + mount, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SearchableSnapshotsMount, options?: TransportRequestOptions): TransportRequestPromise> + mount, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + mount, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SearchableSnapshotsMount, callback: callbackFn): TransportRequestCallback + mount, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SearchableSnapshotsMount, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + stats, TContext = Context>(params?: RequestParams.SearchableSnapshotsStats, options?: TransportRequestOptions): TransportRequestPromise> + stats, TContext = Context>(callback: callbackFn): TransportRequestCallback + stats, TContext = Context>(params: RequestParams.SearchableSnapshotsStats, callback: callbackFn): TransportRequestCallback + stats, TContext = Context>(params: RequestParams.SearchableSnapshotsStats, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + security: { + authenticate, TContext = Context>(params?: RequestParams.SecurityAuthenticate, options?: TransportRequestOptions): TransportRequestPromise> + authenticate, TContext = Context>(callback: callbackFn): TransportRequestCallback + authenticate, TContext = Context>(params: RequestParams.SecurityAuthenticate, callback: callbackFn): TransportRequestCallback + authenticate, TContext = Context>(params: RequestParams.SecurityAuthenticate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + change_password, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SecurityChangePassword, options?: TransportRequestOptions): TransportRequestPromise> + change_password, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + change_password, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityChangePassword, callback: callbackFn): TransportRequestCallback + change_password, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityChangePassword, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + changePassword, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SecurityChangePassword, options?: TransportRequestOptions): TransportRequestPromise> + changePassword, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + changePassword, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityChangePassword, callback: callbackFn): TransportRequestCallback + changePassword, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityChangePassword, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + clear_api_key_cache, TContext = Context>(params?: RequestParams.SecurityClearApiKeyCache, options?: TransportRequestOptions): TransportRequestPromise> + clear_api_key_cache, TContext = Context>(callback: callbackFn): TransportRequestCallback + clear_api_key_cache, TContext = Context>(params: RequestParams.SecurityClearApiKeyCache, callback: callbackFn): TransportRequestCallback + clear_api_key_cache, TContext = Context>(params: RequestParams.SecurityClearApiKeyCache, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + clearApiKeyCache, TContext = Context>(params?: RequestParams.SecurityClearApiKeyCache, options?: TransportRequestOptions): TransportRequestPromise> + clearApiKeyCache, TContext = Context>(callback: callbackFn): TransportRequestCallback + clearApiKeyCache, TContext = Context>(params: RequestParams.SecurityClearApiKeyCache, callback: callbackFn): TransportRequestCallback + clearApiKeyCache, TContext = Context>(params: RequestParams.SecurityClearApiKeyCache, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + clear_cached_privileges, TContext = Context>(params?: RequestParams.SecurityClearCachedPrivileges, options?: TransportRequestOptions): TransportRequestPromise> + clear_cached_privileges, TContext = Context>(callback: callbackFn): TransportRequestCallback + clear_cached_privileges, TContext = Context>(params: RequestParams.SecurityClearCachedPrivileges, callback: callbackFn): TransportRequestCallback + clear_cached_privileges, TContext = Context>(params: RequestParams.SecurityClearCachedPrivileges, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + clearCachedPrivileges, TContext = Context>(params?: RequestParams.SecurityClearCachedPrivileges, options?: TransportRequestOptions): TransportRequestPromise> + clearCachedPrivileges, TContext = Context>(callback: callbackFn): TransportRequestCallback + clearCachedPrivileges, TContext = Context>(params: RequestParams.SecurityClearCachedPrivileges, callback: callbackFn): TransportRequestCallback + clearCachedPrivileges, TContext = Context>(params: RequestParams.SecurityClearCachedPrivileges, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + clear_cached_realms, TContext = Context>(params?: RequestParams.SecurityClearCachedRealms, options?: TransportRequestOptions): TransportRequestPromise> + clear_cached_realms, TContext = Context>(callback: callbackFn): TransportRequestCallback + clear_cached_realms, TContext = Context>(params: RequestParams.SecurityClearCachedRealms, callback: callbackFn): TransportRequestCallback + clear_cached_realms, TContext = Context>(params: RequestParams.SecurityClearCachedRealms, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + clearCachedRealms, TContext = Context>(params?: RequestParams.SecurityClearCachedRealms, options?: TransportRequestOptions): TransportRequestPromise> + clearCachedRealms, TContext = Context>(callback: callbackFn): TransportRequestCallback + clearCachedRealms, TContext = Context>(params: RequestParams.SecurityClearCachedRealms, callback: callbackFn): TransportRequestCallback + clearCachedRealms, TContext = Context>(params: RequestParams.SecurityClearCachedRealms, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + clear_cached_roles, TContext = Context>(params?: RequestParams.SecurityClearCachedRoles, options?: TransportRequestOptions): TransportRequestPromise> + clear_cached_roles, TContext = Context>(callback: callbackFn): TransportRequestCallback + clear_cached_roles, TContext = Context>(params: RequestParams.SecurityClearCachedRoles, callback: callbackFn): TransportRequestCallback + clear_cached_roles, TContext = Context>(params: RequestParams.SecurityClearCachedRoles, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + clearCachedRoles, TContext = Context>(params?: RequestParams.SecurityClearCachedRoles, options?: TransportRequestOptions): TransportRequestPromise> + clearCachedRoles, TContext = Context>(callback: callbackFn): TransportRequestCallback + clearCachedRoles, TContext = Context>(params: RequestParams.SecurityClearCachedRoles, callback: callbackFn): TransportRequestCallback + clearCachedRoles, TContext = Context>(params: RequestParams.SecurityClearCachedRoles, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + create_api_key, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SecurityCreateApiKey, options?: TransportRequestOptions): TransportRequestPromise> + create_api_key, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + create_api_key, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityCreateApiKey, callback: callbackFn): TransportRequestCallback + create_api_key, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityCreateApiKey, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + createApiKey, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SecurityCreateApiKey, options?: TransportRequestOptions): TransportRequestPromise> + createApiKey, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + createApiKey, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityCreateApiKey, callback: callbackFn): TransportRequestCallback + createApiKey, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityCreateApiKey, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete_privileges, TContext = Context>(params?: RequestParams.SecurityDeletePrivileges, options?: TransportRequestOptions): TransportRequestPromise> + delete_privileges, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_privileges, TContext = Context>(params: RequestParams.SecurityDeletePrivileges, callback: callbackFn): TransportRequestCallback + delete_privileges, TContext = Context>(params: RequestParams.SecurityDeletePrivileges, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deletePrivileges, TContext = Context>(params?: RequestParams.SecurityDeletePrivileges, options?: TransportRequestOptions): TransportRequestPromise> + deletePrivileges, TContext = Context>(callback: callbackFn): TransportRequestCallback + deletePrivileges, TContext = Context>(params: RequestParams.SecurityDeletePrivileges, callback: callbackFn): TransportRequestCallback + deletePrivileges, TContext = Context>(params: RequestParams.SecurityDeletePrivileges, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete_role, TContext = Context>(params?: RequestParams.SecurityDeleteRole, options?: TransportRequestOptions): TransportRequestPromise> + delete_role, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_role, TContext = Context>(params: RequestParams.SecurityDeleteRole, callback: callbackFn): TransportRequestCallback + delete_role, TContext = Context>(params: RequestParams.SecurityDeleteRole, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteRole, TContext = Context>(params?: RequestParams.SecurityDeleteRole, options?: TransportRequestOptions): TransportRequestPromise> + deleteRole, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteRole, TContext = Context>(params: RequestParams.SecurityDeleteRole, callback: callbackFn): TransportRequestCallback + deleteRole, TContext = Context>(params: RequestParams.SecurityDeleteRole, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete_role_mapping, TContext = Context>(params?: RequestParams.SecurityDeleteRoleMapping, options?: TransportRequestOptions): TransportRequestPromise> + delete_role_mapping, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_role_mapping, TContext = Context>(params: RequestParams.SecurityDeleteRoleMapping, callback: callbackFn): TransportRequestCallback + delete_role_mapping, TContext = Context>(params: RequestParams.SecurityDeleteRoleMapping, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteRoleMapping, TContext = Context>(params?: RequestParams.SecurityDeleteRoleMapping, options?: TransportRequestOptions): TransportRequestPromise> + deleteRoleMapping, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteRoleMapping, TContext = Context>(params: RequestParams.SecurityDeleteRoleMapping, callback: callbackFn): TransportRequestCallback + deleteRoleMapping, TContext = Context>(params: RequestParams.SecurityDeleteRoleMapping, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete_user, TContext = Context>(params?: RequestParams.SecurityDeleteUser, options?: TransportRequestOptions): TransportRequestPromise> + delete_user, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_user, TContext = Context>(params: RequestParams.SecurityDeleteUser, callback: callbackFn): TransportRequestCallback + delete_user, TContext = Context>(params: RequestParams.SecurityDeleteUser, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteUser, TContext = Context>(params?: RequestParams.SecurityDeleteUser, options?: TransportRequestOptions): TransportRequestPromise> + deleteUser, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteUser, TContext = Context>(params: RequestParams.SecurityDeleteUser, callback: callbackFn): TransportRequestCallback + deleteUser, TContext = Context>(params: RequestParams.SecurityDeleteUser, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + disable_user, TContext = Context>(params?: RequestParams.SecurityDisableUser, options?: TransportRequestOptions): TransportRequestPromise> + disable_user, TContext = Context>(callback: callbackFn): TransportRequestCallback + disable_user, TContext = Context>(params: RequestParams.SecurityDisableUser, callback: callbackFn): TransportRequestCallback + disable_user, TContext = Context>(params: RequestParams.SecurityDisableUser, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + disableUser, TContext = Context>(params?: RequestParams.SecurityDisableUser, options?: TransportRequestOptions): TransportRequestPromise> + disableUser, TContext = Context>(callback: callbackFn): TransportRequestCallback + disableUser, TContext = Context>(params: RequestParams.SecurityDisableUser, callback: callbackFn): TransportRequestCallback + disableUser, TContext = Context>(params: RequestParams.SecurityDisableUser, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + enable_user, TContext = Context>(params?: RequestParams.SecurityEnableUser, options?: TransportRequestOptions): TransportRequestPromise> + enable_user, TContext = Context>(callback: callbackFn): TransportRequestCallback + enable_user, TContext = Context>(params: RequestParams.SecurityEnableUser, callback: callbackFn): TransportRequestCallback + enable_user, TContext = Context>(params: RequestParams.SecurityEnableUser, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + enableUser, TContext = Context>(params?: RequestParams.SecurityEnableUser, options?: TransportRequestOptions): TransportRequestPromise> + enableUser, TContext = Context>(callback: callbackFn): TransportRequestCallback + enableUser, TContext = Context>(params: RequestParams.SecurityEnableUser, callback: callbackFn): TransportRequestCallback + enableUser, TContext = Context>(params: RequestParams.SecurityEnableUser, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_api_key, TContext = Context>(params?: RequestParams.SecurityGetApiKey, options?: TransportRequestOptions): TransportRequestPromise> + get_api_key, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_api_key, TContext = Context>(params: RequestParams.SecurityGetApiKey, callback: callbackFn): TransportRequestCallback + get_api_key, TContext = Context>(params: RequestParams.SecurityGetApiKey, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getApiKey, TContext = Context>(params?: RequestParams.SecurityGetApiKey, options?: TransportRequestOptions): TransportRequestPromise> + getApiKey, TContext = Context>(callback: callbackFn): TransportRequestCallback + getApiKey, TContext = Context>(params: RequestParams.SecurityGetApiKey, callback: callbackFn): TransportRequestCallback + getApiKey, TContext = Context>(params: RequestParams.SecurityGetApiKey, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_builtin_privileges, TContext = Context>(params?: RequestParams.SecurityGetBuiltinPrivileges, options?: TransportRequestOptions): TransportRequestPromise> + get_builtin_privileges, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_builtin_privileges, TContext = Context>(params: RequestParams.SecurityGetBuiltinPrivileges, callback: callbackFn): TransportRequestCallback + get_builtin_privileges, TContext = Context>(params: RequestParams.SecurityGetBuiltinPrivileges, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getBuiltinPrivileges, TContext = Context>(params?: RequestParams.SecurityGetBuiltinPrivileges, options?: TransportRequestOptions): TransportRequestPromise> + getBuiltinPrivileges, TContext = Context>(callback: callbackFn): TransportRequestCallback + getBuiltinPrivileges, TContext = Context>(params: RequestParams.SecurityGetBuiltinPrivileges, callback: callbackFn): TransportRequestCallback + getBuiltinPrivileges, TContext = Context>(params: RequestParams.SecurityGetBuiltinPrivileges, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_privileges, TContext = Context>(params?: RequestParams.SecurityGetPrivileges, options?: TransportRequestOptions): TransportRequestPromise> + get_privileges, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_privileges, TContext = Context>(params: RequestParams.SecurityGetPrivileges, callback: callbackFn): TransportRequestCallback + get_privileges, TContext = Context>(params: RequestParams.SecurityGetPrivileges, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getPrivileges, TContext = Context>(params?: RequestParams.SecurityGetPrivileges, options?: TransportRequestOptions): TransportRequestPromise> + getPrivileges, TContext = Context>(callback: callbackFn): TransportRequestCallback + getPrivileges, TContext = Context>(params: RequestParams.SecurityGetPrivileges, callback: callbackFn): TransportRequestCallback + getPrivileges, TContext = Context>(params: RequestParams.SecurityGetPrivileges, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_role, TContext = Context>(params?: RequestParams.SecurityGetRole, options?: TransportRequestOptions): TransportRequestPromise> + get_role, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_role, TContext = Context>(params: RequestParams.SecurityGetRole, callback: callbackFn): TransportRequestCallback + get_role, TContext = Context>(params: RequestParams.SecurityGetRole, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getRole, TContext = Context>(params?: RequestParams.SecurityGetRole, options?: TransportRequestOptions): TransportRequestPromise> + getRole, TContext = Context>(callback: callbackFn): TransportRequestCallback + getRole, TContext = Context>(params: RequestParams.SecurityGetRole, callback: callbackFn): TransportRequestCallback + getRole, TContext = Context>(params: RequestParams.SecurityGetRole, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_role_mapping, TContext = Context>(params?: RequestParams.SecurityGetRoleMapping, options?: TransportRequestOptions): TransportRequestPromise> + get_role_mapping, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_role_mapping, TContext = Context>(params: RequestParams.SecurityGetRoleMapping, callback: callbackFn): TransportRequestCallback + get_role_mapping, TContext = Context>(params: RequestParams.SecurityGetRoleMapping, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getRoleMapping, TContext = Context>(params?: RequestParams.SecurityGetRoleMapping, options?: TransportRequestOptions): TransportRequestPromise> + getRoleMapping, TContext = Context>(callback: callbackFn): TransportRequestCallback + getRoleMapping, TContext = Context>(params: RequestParams.SecurityGetRoleMapping, callback: callbackFn): TransportRequestCallback + getRoleMapping, TContext = Context>(params: RequestParams.SecurityGetRoleMapping, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_token, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SecurityGetToken, options?: TransportRequestOptions): TransportRequestPromise> + get_token, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_token, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityGetToken, callback: callbackFn): TransportRequestCallback + get_token, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityGetToken, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getToken, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SecurityGetToken, options?: TransportRequestOptions): TransportRequestPromise> + getToken, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + getToken, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityGetToken, callback: callbackFn): TransportRequestCallback + getToken, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityGetToken, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_user, TContext = Context>(params?: RequestParams.SecurityGetUser, options?: TransportRequestOptions): TransportRequestPromise> + get_user, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_user, TContext = Context>(params: RequestParams.SecurityGetUser, callback: callbackFn): TransportRequestCallback + get_user, TContext = Context>(params: RequestParams.SecurityGetUser, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getUser, TContext = Context>(params?: RequestParams.SecurityGetUser, options?: TransportRequestOptions): TransportRequestPromise> + getUser, TContext = Context>(callback: callbackFn): TransportRequestCallback + getUser, TContext = Context>(params: RequestParams.SecurityGetUser, callback: callbackFn): TransportRequestCallback + getUser, TContext = Context>(params: RequestParams.SecurityGetUser, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_user_privileges, TContext = Context>(params?: RequestParams.SecurityGetUserPrivileges, options?: TransportRequestOptions): TransportRequestPromise> + get_user_privileges, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_user_privileges, TContext = Context>(params: RequestParams.SecurityGetUserPrivileges, callback: callbackFn): TransportRequestCallback + get_user_privileges, TContext = Context>(params: RequestParams.SecurityGetUserPrivileges, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getUserPrivileges, TContext = Context>(params?: RequestParams.SecurityGetUserPrivileges, options?: TransportRequestOptions): TransportRequestPromise> + getUserPrivileges, TContext = Context>(callback: callbackFn): TransportRequestCallback + getUserPrivileges, TContext = Context>(params: RequestParams.SecurityGetUserPrivileges, callback: callbackFn): TransportRequestCallback + getUserPrivileges, TContext = Context>(params: RequestParams.SecurityGetUserPrivileges, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + grant_api_key, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SecurityGrantApiKey, options?: TransportRequestOptions): TransportRequestPromise> + grant_api_key, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + grant_api_key, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityGrantApiKey, callback: callbackFn): TransportRequestCallback + grant_api_key, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityGrantApiKey, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + grantApiKey, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SecurityGrantApiKey, options?: TransportRequestOptions): TransportRequestPromise> + grantApiKey, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + grantApiKey, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityGrantApiKey, callback: callbackFn): TransportRequestCallback + grantApiKey, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityGrantApiKey, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + has_privileges, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SecurityHasPrivileges, options?: TransportRequestOptions): TransportRequestPromise> + has_privileges, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + has_privileges, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityHasPrivileges, callback: callbackFn): TransportRequestCallback + has_privileges, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityHasPrivileges, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + hasPrivileges, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SecurityHasPrivileges, options?: TransportRequestOptions): TransportRequestPromise> + hasPrivileges, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + hasPrivileges, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityHasPrivileges, callback: callbackFn): TransportRequestCallback + hasPrivileges, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityHasPrivileges, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + invalidate_api_key, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SecurityInvalidateApiKey, options?: TransportRequestOptions): TransportRequestPromise> + invalidate_api_key, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + invalidate_api_key, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityInvalidateApiKey, callback: callbackFn): TransportRequestCallback + invalidate_api_key, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityInvalidateApiKey, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + invalidateApiKey, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SecurityInvalidateApiKey, options?: TransportRequestOptions): TransportRequestPromise> + invalidateApiKey, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + invalidateApiKey, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityInvalidateApiKey, callback: callbackFn): TransportRequestCallback + invalidateApiKey, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityInvalidateApiKey, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + invalidate_token, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SecurityInvalidateToken, options?: TransportRequestOptions): TransportRequestPromise> + invalidate_token, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + invalidate_token, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityInvalidateToken, callback: callbackFn): TransportRequestCallback + invalidate_token, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityInvalidateToken, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + invalidateToken, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SecurityInvalidateToken, options?: TransportRequestOptions): TransportRequestPromise> + invalidateToken, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + invalidateToken, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityInvalidateToken, callback: callbackFn): TransportRequestCallback + invalidateToken, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityInvalidateToken, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_privileges, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SecurityPutPrivileges, options?: TransportRequestOptions): TransportRequestPromise> + put_privileges, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_privileges, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityPutPrivileges, callback: callbackFn): TransportRequestCallback + put_privileges, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityPutPrivileges, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putPrivileges, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SecurityPutPrivileges, options?: TransportRequestOptions): TransportRequestPromise> + putPrivileges, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + putPrivileges, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityPutPrivileges, callback: callbackFn): TransportRequestCallback + putPrivileges, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityPutPrivileges, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_role, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SecurityPutRole, options?: TransportRequestOptions): TransportRequestPromise> + put_role, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_role, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityPutRole, callback: callbackFn): TransportRequestCallback + put_role, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityPutRole, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putRole, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SecurityPutRole, options?: TransportRequestOptions): TransportRequestPromise> + putRole, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + putRole, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityPutRole, callback: callbackFn): TransportRequestCallback + putRole, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityPutRole, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_role_mapping, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SecurityPutRoleMapping, options?: TransportRequestOptions): TransportRequestPromise> + put_role_mapping, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_role_mapping, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityPutRoleMapping, callback: callbackFn): TransportRequestCallback + put_role_mapping, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityPutRoleMapping, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putRoleMapping, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SecurityPutRoleMapping, options?: TransportRequestOptions): TransportRequestPromise> + putRoleMapping, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + putRoleMapping, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityPutRoleMapping, callback: callbackFn): TransportRequestCallback + putRoleMapping, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityPutRoleMapping, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_user, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SecurityPutUser, options?: TransportRequestOptions): TransportRequestPromise> + put_user, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_user, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityPutUser, callback: callbackFn): TransportRequestCallback + put_user, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityPutUser, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putUser, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SecurityPutUser, options?: TransportRequestOptions): TransportRequestPromise> + putUser, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + putUser, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityPutUser, callback: callbackFn): TransportRequestCallback + putUser, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SecurityPutUser, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + shutdown: { + delete_node, TContext = Context>(params?: RequestParams.ShutdownDeleteNode, options?: TransportRequestOptions): TransportRequestPromise> + delete_node, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_node, TContext = Context>(params: RequestParams.ShutdownDeleteNode, callback: callbackFn): TransportRequestCallback + delete_node, TContext = Context>(params: RequestParams.ShutdownDeleteNode, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteNode, TContext = Context>(params?: RequestParams.ShutdownDeleteNode, options?: TransportRequestOptions): TransportRequestPromise> + deleteNode, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteNode, TContext = Context>(params: RequestParams.ShutdownDeleteNode, callback: callbackFn): TransportRequestCallback + deleteNode, TContext = Context>(params: RequestParams.ShutdownDeleteNode, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_node, TContext = Context>(params?: RequestParams.ShutdownGetNode, options?: TransportRequestOptions): TransportRequestPromise> + get_node, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_node, TContext = Context>(params: RequestParams.ShutdownGetNode, callback: callbackFn): TransportRequestCallback + get_node, TContext = Context>(params: RequestParams.ShutdownGetNode, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getNode, TContext = Context>(params?: RequestParams.ShutdownGetNode, options?: TransportRequestOptions): TransportRequestPromise> + getNode, TContext = Context>(callback: callbackFn): TransportRequestCallback + getNode, TContext = Context>(params: RequestParams.ShutdownGetNode, callback: callbackFn): TransportRequestCallback + getNode, TContext = Context>(params: RequestParams.ShutdownGetNode, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_node, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.ShutdownPutNode, options?: TransportRequestOptions): TransportRequestPromise> + put_node, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_node, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ShutdownPutNode, callback: callbackFn): TransportRequestCallback + put_node, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ShutdownPutNode, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putNode, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.ShutdownPutNode, options?: TransportRequestOptions): TransportRequestPromise> + putNode, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + putNode, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ShutdownPutNode, callback: callbackFn): TransportRequestCallback + putNode, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.ShutdownPutNode, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + slm: { + delete_lifecycle, TContext = Context>(params?: RequestParams.SlmDeleteLifecycle, options?: TransportRequestOptions): TransportRequestPromise> + delete_lifecycle, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_lifecycle, TContext = Context>(params: RequestParams.SlmDeleteLifecycle, callback: callbackFn): TransportRequestCallback + delete_lifecycle, TContext = Context>(params: RequestParams.SlmDeleteLifecycle, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteLifecycle, TContext = Context>(params?: RequestParams.SlmDeleteLifecycle, options?: TransportRequestOptions): TransportRequestPromise> + deleteLifecycle, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteLifecycle, TContext = Context>(params: RequestParams.SlmDeleteLifecycle, callback: callbackFn): TransportRequestCallback + deleteLifecycle, TContext = Context>(params: RequestParams.SlmDeleteLifecycle, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + execute_lifecycle, TContext = Context>(params?: RequestParams.SlmExecuteLifecycle, options?: TransportRequestOptions): TransportRequestPromise> + execute_lifecycle, TContext = Context>(callback: callbackFn): TransportRequestCallback + execute_lifecycle, TContext = Context>(params: RequestParams.SlmExecuteLifecycle, callback: callbackFn): TransportRequestCallback + execute_lifecycle, TContext = Context>(params: RequestParams.SlmExecuteLifecycle, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + executeLifecycle, TContext = Context>(params?: RequestParams.SlmExecuteLifecycle, options?: TransportRequestOptions): TransportRequestPromise> + executeLifecycle, TContext = Context>(callback: callbackFn): TransportRequestCallback + executeLifecycle, TContext = Context>(params: RequestParams.SlmExecuteLifecycle, callback: callbackFn): TransportRequestCallback + executeLifecycle, TContext = Context>(params: RequestParams.SlmExecuteLifecycle, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + execute_retention, TContext = Context>(params?: RequestParams.SlmExecuteRetention, options?: TransportRequestOptions): TransportRequestPromise> + execute_retention, TContext = Context>(callback: callbackFn): TransportRequestCallback + execute_retention, TContext = Context>(params: RequestParams.SlmExecuteRetention, callback: callbackFn): TransportRequestCallback + execute_retention, TContext = Context>(params: RequestParams.SlmExecuteRetention, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + executeRetention, TContext = Context>(params?: RequestParams.SlmExecuteRetention, options?: TransportRequestOptions): TransportRequestPromise> + executeRetention, TContext = Context>(callback: callbackFn): TransportRequestCallback + executeRetention, TContext = Context>(params: RequestParams.SlmExecuteRetention, callback: callbackFn): TransportRequestCallback + executeRetention, TContext = Context>(params: RequestParams.SlmExecuteRetention, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_lifecycle, TContext = Context>(params?: RequestParams.SlmGetLifecycle, options?: TransportRequestOptions): TransportRequestPromise> + get_lifecycle, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_lifecycle, TContext = Context>(params: RequestParams.SlmGetLifecycle, callback: callbackFn): TransportRequestCallback + get_lifecycle, TContext = Context>(params: RequestParams.SlmGetLifecycle, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getLifecycle, TContext = Context>(params?: RequestParams.SlmGetLifecycle, options?: TransportRequestOptions): TransportRequestPromise> + getLifecycle, TContext = Context>(callback: callbackFn): TransportRequestCallback + getLifecycle, TContext = Context>(params: RequestParams.SlmGetLifecycle, callback: callbackFn): TransportRequestCallback + getLifecycle, TContext = Context>(params: RequestParams.SlmGetLifecycle, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_stats, TContext = Context>(params?: RequestParams.SlmGetStats, options?: TransportRequestOptions): TransportRequestPromise> + get_stats, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_stats, TContext = Context>(params: RequestParams.SlmGetStats, callback: callbackFn): TransportRequestCallback + get_stats, TContext = Context>(params: RequestParams.SlmGetStats, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getStats, TContext = Context>(params?: RequestParams.SlmGetStats, options?: TransportRequestOptions): TransportRequestPromise> + getStats, TContext = Context>(callback: callbackFn): TransportRequestCallback + getStats, TContext = Context>(params: RequestParams.SlmGetStats, callback: callbackFn): TransportRequestCallback + getStats, TContext = Context>(params: RequestParams.SlmGetStats, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_status, TContext = Context>(params?: RequestParams.SlmGetStatus, options?: TransportRequestOptions): TransportRequestPromise> + get_status, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_status, TContext = Context>(params: RequestParams.SlmGetStatus, callback: callbackFn): TransportRequestCallback + get_status, TContext = Context>(params: RequestParams.SlmGetStatus, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getStatus, TContext = Context>(params?: RequestParams.SlmGetStatus, options?: TransportRequestOptions): TransportRequestPromise> + getStatus, TContext = Context>(callback: callbackFn): TransportRequestCallback + getStatus, TContext = Context>(params: RequestParams.SlmGetStatus, callback: callbackFn): TransportRequestCallback + getStatus, TContext = Context>(params: RequestParams.SlmGetStatus, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_lifecycle, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SlmPutLifecycle, options?: TransportRequestOptions): TransportRequestPromise> + put_lifecycle, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_lifecycle, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SlmPutLifecycle, callback: callbackFn): TransportRequestCallback + put_lifecycle, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SlmPutLifecycle, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putLifecycle, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SlmPutLifecycle, options?: TransportRequestOptions): TransportRequestPromise> + putLifecycle, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + putLifecycle, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SlmPutLifecycle, callback: callbackFn): TransportRequestCallback + putLifecycle, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SlmPutLifecycle, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + start, TContext = Context>(params?: RequestParams.SlmStart, options?: TransportRequestOptions): TransportRequestPromise> + start, TContext = Context>(callback: callbackFn): TransportRequestCallback + start, TContext = Context>(params: RequestParams.SlmStart, callback: callbackFn): TransportRequestCallback + start, TContext = Context>(params: RequestParams.SlmStart, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + stop, TContext = Context>(params?: RequestParams.SlmStop, options?: TransportRequestOptions): TransportRequestPromise> + stop, TContext = Context>(callback: callbackFn): TransportRequestCallback + stop, TContext = Context>(params: RequestParams.SlmStop, callback: callbackFn): TransportRequestCallback + stop, TContext = Context>(params: RequestParams.SlmStop, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + snapshot: { + cleanup_repository, TContext = Context>(params?: RequestParams.SnapshotCleanupRepository, options?: TransportRequestOptions): TransportRequestPromise> + cleanup_repository, TContext = Context>(callback: callbackFn): TransportRequestCallback + cleanup_repository, TContext = Context>(params: RequestParams.SnapshotCleanupRepository, callback: callbackFn): TransportRequestCallback + cleanup_repository, TContext = Context>(params: RequestParams.SnapshotCleanupRepository, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + cleanupRepository, TContext = Context>(params?: RequestParams.SnapshotCleanupRepository, options?: TransportRequestOptions): TransportRequestPromise> + cleanupRepository, TContext = Context>(callback: callbackFn): TransportRequestCallback + cleanupRepository, TContext = Context>(params: RequestParams.SnapshotCleanupRepository, callback: callbackFn): TransportRequestCallback + cleanupRepository, TContext = Context>(params: RequestParams.SnapshotCleanupRepository, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + clone, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SnapshotClone, options?: TransportRequestOptions): TransportRequestPromise> + clone, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + clone, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SnapshotClone, callback: callbackFn): TransportRequestCallback + clone, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SnapshotClone, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + create, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SnapshotCreate, options?: TransportRequestOptions): TransportRequestPromise> + create, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + create, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SnapshotCreate, callback: callbackFn): TransportRequestCallback + create, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SnapshotCreate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + create_repository, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SnapshotCreateRepository, options?: TransportRequestOptions): TransportRequestPromise> + create_repository, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + create_repository, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SnapshotCreateRepository, callback: callbackFn): TransportRequestCallback + create_repository, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SnapshotCreateRepository, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + createRepository, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SnapshotCreateRepository, options?: TransportRequestOptions): TransportRequestPromise> + createRepository, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + createRepository, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SnapshotCreateRepository, callback: callbackFn): TransportRequestCallback + createRepository, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SnapshotCreateRepository, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete, TContext = Context>(params?: RequestParams.SnapshotDelete, options?: TransportRequestOptions): TransportRequestPromise> + delete, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete, TContext = Context>(params: RequestParams.SnapshotDelete, callback: callbackFn): TransportRequestCallback + delete, TContext = Context>(params: RequestParams.SnapshotDelete, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete_repository, TContext = Context>(params?: RequestParams.SnapshotDeleteRepository, options?: TransportRequestOptions): TransportRequestPromise> + delete_repository, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_repository, TContext = Context>(params: RequestParams.SnapshotDeleteRepository, callback: callbackFn): TransportRequestCallback + delete_repository, TContext = Context>(params: RequestParams.SnapshotDeleteRepository, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteRepository, TContext = Context>(params?: RequestParams.SnapshotDeleteRepository, options?: TransportRequestOptions): TransportRequestPromise> + deleteRepository, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteRepository, TContext = Context>(params: RequestParams.SnapshotDeleteRepository, callback: callbackFn): TransportRequestCallback + deleteRepository, TContext = Context>(params: RequestParams.SnapshotDeleteRepository, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get, TContext = Context>(params?: RequestParams.SnapshotGet, options?: TransportRequestOptions): TransportRequestPromise> + get, TContext = Context>(callback: callbackFn): TransportRequestCallback + get, TContext = Context>(params: RequestParams.SnapshotGet, callback: callbackFn): TransportRequestCallback + get, TContext = Context>(params: RequestParams.SnapshotGet, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_repository, TContext = Context>(params?: RequestParams.SnapshotGetRepository, options?: TransportRequestOptions): TransportRequestPromise> + get_repository, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_repository, TContext = Context>(params: RequestParams.SnapshotGetRepository, callback: callbackFn): TransportRequestCallback + get_repository, TContext = Context>(params: RequestParams.SnapshotGetRepository, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getRepository, TContext = Context>(params?: RequestParams.SnapshotGetRepository, options?: TransportRequestOptions): TransportRequestPromise> + getRepository, TContext = Context>(callback: callbackFn): TransportRequestCallback + getRepository, TContext = Context>(params: RequestParams.SnapshotGetRepository, callback: callbackFn): TransportRequestCallback + getRepository, TContext = Context>(params: RequestParams.SnapshotGetRepository, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + restore, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SnapshotRestore, options?: TransportRequestOptions): TransportRequestPromise> + restore, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + restore, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SnapshotRestore, callback: callbackFn): TransportRequestCallback + restore, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SnapshotRestore, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + status, TContext = Context>(params?: RequestParams.SnapshotStatus, options?: TransportRequestOptions): TransportRequestPromise> + status, TContext = Context>(callback: callbackFn): TransportRequestCallback + status, TContext = Context>(params: RequestParams.SnapshotStatus, callback: callbackFn): TransportRequestCallback + status, TContext = Context>(params: RequestParams.SnapshotStatus, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + verify_repository, TContext = Context>(params?: RequestParams.SnapshotVerifyRepository, options?: TransportRequestOptions): TransportRequestPromise> + verify_repository, TContext = Context>(callback: callbackFn): TransportRequestCallback + verify_repository, TContext = Context>(params: RequestParams.SnapshotVerifyRepository, callback: callbackFn): TransportRequestCallback + verify_repository, TContext = Context>(params: RequestParams.SnapshotVerifyRepository, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + verifyRepository, TContext = Context>(params?: RequestParams.SnapshotVerifyRepository, options?: TransportRequestOptions): TransportRequestPromise> + verifyRepository, TContext = Context>(callback: callbackFn): TransportRequestCallback + verifyRepository, TContext = Context>(params: RequestParams.SnapshotVerifyRepository, callback: callbackFn): TransportRequestCallback + verifyRepository, TContext = Context>(params: RequestParams.SnapshotVerifyRepository, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + sql: { + clear_cursor, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SqlClearCursor, options?: TransportRequestOptions): TransportRequestPromise> + clear_cursor, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + clear_cursor, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SqlClearCursor, callback: callbackFn): TransportRequestCallback + clear_cursor, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SqlClearCursor, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + clearCursor, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SqlClearCursor, options?: TransportRequestOptions): TransportRequestPromise> + clearCursor, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + clearCursor, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SqlClearCursor, callback: callbackFn): TransportRequestCallback + clearCursor, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SqlClearCursor, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + query, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SqlQuery, options?: TransportRequestOptions): TransportRequestPromise> + query, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + query, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SqlQuery, callback: callbackFn): TransportRequestCallback + query, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SqlQuery, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + translate, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.SqlTranslate, options?: TransportRequestOptions): TransportRequestPromise> + translate, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + translate, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SqlTranslate, callback: callbackFn): TransportRequestCallback + translate, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.SqlTranslate, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + ssl: { + certificates, TContext = Context>(params?: RequestParams.SslCertificates, options?: TransportRequestOptions): TransportRequestPromise> + certificates, TContext = Context>(callback: callbackFn): TransportRequestCallback + certificates, TContext = Context>(params: RequestParams.SslCertificates, callback: callbackFn): TransportRequestCallback + certificates, TContext = Context>(params: RequestParams.SslCertificates, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + tasks: { + cancel, TContext = Context>(params?: RequestParams.TasksCancel, options?: TransportRequestOptions): TransportRequestPromise> + cancel, TContext = Context>(callback: callbackFn): TransportRequestCallback + cancel, TContext = Context>(params: RequestParams.TasksCancel, callback: callbackFn): TransportRequestCallback + cancel, TContext = Context>(params: RequestParams.TasksCancel, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get, TContext = Context>(params?: RequestParams.TasksGet, options?: TransportRequestOptions): TransportRequestPromise> + get, TContext = Context>(callback: callbackFn): TransportRequestCallback + get, TContext = Context>(params: RequestParams.TasksGet, callback: callbackFn): TransportRequestCallback + get, TContext = Context>(params: RequestParams.TasksGet, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + list, TContext = Context>(params?: RequestParams.TasksList, options?: TransportRequestOptions): TransportRequestPromise> + list, TContext = Context>(callback: callbackFn): TransportRequestCallback + list, TContext = Context>(params: RequestParams.TasksList, callback: callbackFn): TransportRequestCallback + list, TContext = Context>(params: RequestParams.TasksList, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + termvectors, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.Termvectors, options?: TransportRequestOptions): TransportRequestPromise> + termvectors, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + termvectors, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.Termvectors, callback: callbackFn): TransportRequestCallback + termvectors, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.Termvectors, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + text_structure: { + find_structure, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.TextStructureFindStructure, options?: TransportRequestOptions): TransportRequestPromise> + find_structure, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + find_structure, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.TextStructureFindStructure, callback: callbackFn): TransportRequestCallback + find_structure, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.TextStructureFindStructure, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + findStructure, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.TextStructureFindStructure, options?: TransportRequestOptions): TransportRequestPromise> + findStructure, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + findStructure, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.TextStructureFindStructure, callback: callbackFn): TransportRequestCallback + findStructure, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.TextStructureFindStructure, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + textStructure: { + find_structure, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.TextStructureFindStructure, options?: TransportRequestOptions): TransportRequestPromise> + find_structure, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + find_structure, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.TextStructureFindStructure, callback: callbackFn): TransportRequestCallback + find_structure, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.TextStructureFindStructure, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + findStructure, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.TextStructureFindStructure, options?: TransportRequestOptions): TransportRequestPromise> + findStructure, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + findStructure, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.TextStructureFindStructure, callback: callbackFn): TransportRequestCallback + findStructure, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.TextStructureFindStructure, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + transform: { + delete_transform, TContext = Context>(params?: RequestParams.TransformDeleteTransform, options?: TransportRequestOptions): TransportRequestPromise> + delete_transform, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_transform, TContext = Context>(params: RequestParams.TransformDeleteTransform, callback: callbackFn): TransportRequestCallback + delete_transform, TContext = Context>(params: RequestParams.TransformDeleteTransform, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteTransform, TContext = Context>(params?: RequestParams.TransformDeleteTransform, options?: TransportRequestOptions): TransportRequestPromise> + deleteTransform, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteTransform, TContext = Context>(params: RequestParams.TransformDeleteTransform, callback: callbackFn): TransportRequestCallback + deleteTransform, TContext = Context>(params: RequestParams.TransformDeleteTransform, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_transform, TContext = Context>(params?: RequestParams.TransformGetTransform, options?: TransportRequestOptions): TransportRequestPromise> + get_transform, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_transform, TContext = Context>(params: RequestParams.TransformGetTransform, callback: callbackFn): TransportRequestCallback + get_transform, TContext = Context>(params: RequestParams.TransformGetTransform, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getTransform, TContext = Context>(params?: RequestParams.TransformGetTransform, options?: TransportRequestOptions): TransportRequestPromise> + getTransform, TContext = Context>(callback: callbackFn): TransportRequestCallback + getTransform, TContext = Context>(params: RequestParams.TransformGetTransform, callback: callbackFn): TransportRequestCallback + getTransform, TContext = Context>(params: RequestParams.TransformGetTransform, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_transform_stats, TContext = Context>(params?: RequestParams.TransformGetTransformStats, options?: TransportRequestOptions): TransportRequestPromise> + get_transform_stats, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_transform_stats, TContext = Context>(params: RequestParams.TransformGetTransformStats, callback: callbackFn): TransportRequestCallback + get_transform_stats, TContext = Context>(params: RequestParams.TransformGetTransformStats, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getTransformStats, TContext = Context>(params?: RequestParams.TransformGetTransformStats, options?: TransportRequestOptions): TransportRequestPromise> + getTransformStats, TContext = Context>(callback: callbackFn): TransportRequestCallback + getTransformStats, TContext = Context>(params: RequestParams.TransformGetTransformStats, callback: callbackFn): TransportRequestCallback + getTransformStats, TContext = Context>(params: RequestParams.TransformGetTransformStats, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + preview_transform, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.TransformPreviewTransform, options?: TransportRequestOptions): TransportRequestPromise> + preview_transform, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + preview_transform, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.TransformPreviewTransform, callback: callbackFn): TransportRequestCallback + preview_transform, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.TransformPreviewTransform, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + previewTransform, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.TransformPreviewTransform, options?: TransportRequestOptions): TransportRequestPromise> + previewTransform, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + previewTransform, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.TransformPreviewTransform, callback: callbackFn): TransportRequestCallback + previewTransform, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.TransformPreviewTransform, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_transform, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.TransformPutTransform, options?: TransportRequestOptions): TransportRequestPromise> + put_transform, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_transform, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.TransformPutTransform, callback: callbackFn): TransportRequestCallback + put_transform, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.TransformPutTransform, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putTransform, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.TransformPutTransform, options?: TransportRequestOptions): TransportRequestPromise> + putTransform, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + putTransform, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.TransformPutTransform, callback: callbackFn): TransportRequestCallback + putTransform, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.TransformPutTransform, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + start_transform, TContext = Context>(params?: RequestParams.TransformStartTransform, options?: TransportRequestOptions): TransportRequestPromise> + start_transform, TContext = Context>(callback: callbackFn): TransportRequestCallback + start_transform, TContext = Context>(params: RequestParams.TransformStartTransform, callback: callbackFn): TransportRequestCallback + start_transform, TContext = Context>(params: RequestParams.TransformStartTransform, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + startTransform, TContext = Context>(params?: RequestParams.TransformStartTransform, options?: TransportRequestOptions): TransportRequestPromise> + startTransform, TContext = Context>(callback: callbackFn): TransportRequestCallback + startTransform, TContext = Context>(params: RequestParams.TransformStartTransform, callback: callbackFn): TransportRequestCallback + startTransform, TContext = Context>(params: RequestParams.TransformStartTransform, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + stop_transform, TContext = Context>(params?: RequestParams.TransformStopTransform, options?: TransportRequestOptions): TransportRequestPromise> + stop_transform, TContext = Context>(callback: callbackFn): TransportRequestCallback + stop_transform, TContext = Context>(params: RequestParams.TransformStopTransform, callback: callbackFn): TransportRequestCallback + stop_transform, TContext = Context>(params: RequestParams.TransformStopTransform, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + stopTransform, TContext = Context>(params?: RequestParams.TransformStopTransform, options?: TransportRequestOptions): TransportRequestPromise> + stopTransform, TContext = Context>(callback: callbackFn): TransportRequestCallback + stopTransform, TContext = Context>(params: RequestParams.TransformStopTransform, callback: callbackFn): TransportRequestCallback + stopTransform, TContext = Context>(params: RequestParams.TransformStopTransform, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + update_transform, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.TransformUpdateTransform, options?: TransportRequestOptions): TransportRequestPromise> + update_transform, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + update_transform, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.TransformUpdateTransform, callback: callbackFn): TransportRequestCallback + update_transform, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.TransformUpdateTransform, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + updateTransform, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.TransformUpdateTransform, options?: TransportRequestOptions): TransportRequestPromise> + updateTransform, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + updateTransform, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.TransformUpdateTransform, callback: callbackFn): TransportRequestCallback + updateTransform, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.TransformUpdateTransform, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + update, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.Update, options?: TransportRequestOptions): TransportRequestPromise> + update, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + update, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.Update, callback: callbackFn): TransportRequestCallback + update, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.Update, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + update_by_query, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.UpdateByQuery, options?: TransportRequestOptions): TransportRequestPromise> + update_by_query, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + update_by_query, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.UpdateByQuery, callback: callbackFn): TransportRequestCallback + update_by_query, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.UpdateByQuery, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + updateByQuery, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.UpdateByQuery, options?: TransportRequestOptions): TransportRequestPromise> + updateByQuery, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + updateByQuery, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.UpdateByQuery, callback: callbackFn): TransportRequestCallback + updateByQuery, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.UpdateByQuery, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + update_by_query_rethrottle, TContext = Context>(params?: RequestParams.UpdateByQueryRethrottle, options?: TransportRequestOptions): TransportRequestPromise> + update_by_query_rethrottle, TContext = Context>(callback: callbackFn): TransportRequestCallback + update_by_query_rethrottle, TContext = Context>(params: RequestParams.UpdateByQueryRethrottle, callback: callbackFn): TransportRequestCallback + update_by_query_rethrottle, TContext = Context>(params: RequestParams.UpdateByQueryRethrottle, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + updateByQueryRethrottle, TContext = Context>(params?: RequestParams.UpdateByQueryRethrottle, options?: TransportRequestOptions): TransportRequestPromise> + updateByQueryRethrottle, TContext = Context>(callback: callbackFn): TransportRequestCallback + updateByQueryRethrottle, TContext = Context>(params: RequestParams.UpdateByQueryRethrottle, callback: callbackFn): TransportRequestCallback + updateByQueryRethrottle, TContext = Context>(params: RequestParams.UpdateByQueryRethrottle, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + watcher: { + ack_watch, TContext = Context>(params?: RequestParams.WatcherAckWatch, options?: TransportRequestOptions): TransportRequestPromise> + ack_watch, TContext = Context>(callback: callbackFn): TransportRequestCallback + ack_watch, TContext = Context>(params: RequestParams.WatcherAckWatch, callback: callbackFn): TransportRequestCallback + ack_watch, TContext = Context>(params: RequestParams.WatcherAckWatch, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + ackWatch, TContext = Context>(params?: RequestParams.WatcherAckWatch, options?: TransportRequestOptions): TransportRequestPromise> + ackWatch, TContext = Context>(callback: callbackFn): TransportRequestCallback + ackWatch, TContext = Context>(params: RequestParams.WatcherAckWatch, callback: callbackFn): TransportRequestCallback + ackWatch, TContext = Context>(params: RequestParams.WatcherAckWatch, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + activate_watch, TContext = Context>(params?: RequestParams.WatcherActivateWatch, options?: TransportRequestOptions): TransportRequestPromise> + activate_watch, TContext = Context>(callback: callbackFn): TransportRequestCallback + activate_watch, TContext = Context>(params: RequestParams.WatcherActivateWatch, callback: callbackFn): TransportRequestCallback + activate_watch, TContext = Context>(params: RequestParams.WatcherActivateWatch, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + activateWatch, TContext = Context>(params?: RequestParams.WatcherActivateWatch, options?: TransportRequestOptions): TransportRequestPromise> + activateWatch, TContext = Context>(callback: callbackFn): TransportRequestCallback + activateWatch, TContext = Context>(params: RequestParams.WatcherActivateWatch, callback: callbackFn): TransportRequestCallback + activateWatch, TContext = Context>(params: RequestParams.WatcherActivateWatch, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deactivate_watch, TContext = Context>(params?: RequestParams.WatcherDeactivateWatch, options?: TransportRequestOptions): TransportRequestPromise> + deactivate_watch, TContext = Context>(callback: callbackFn): TransportRequestCallback + deactivate_watch, TContext = Context>(params: RequestParams.WatcherDeactivateWatch, callback: callbackFn): TransportRequestCallback + deactivate_watch, TContext = Context>(params: RequestParams.WatcherDeactivateWatch, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deactivateWatch, TContext = Context>(params?: RequestParams.WatcherDeactivateWatch, options?: TransportRequestOptions): TransportRequestPromise> + deactivateWatch, TContext = Context>(callback: callbackFn): TransportRequestCallback + deactivateWatch, TContext = Context>(params: RequestParams.WatcherDeactivateWatch, callback: callbackFn): TransportRequestCallback + deactivateWatch, TContext = Context>(params: RequestParams.WatcherDeactivateWatch, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + delete_watch, TContext = Context>(params?: RequestParams.WatcherDeleteWatch, options?: TransportRequestOptions): TransportRequestPromise> + delete_watch, TContext = Context>(callback: callbackFn): TransportRequestCallback + delete_watch, TContext = Context>(params: RequestParams.WatcherDeleteWatch, callback: callbackFn): TransportRequestCallback + delete_watch, TContext = Context>(params: RequestParams.WatcherDeleteWatch, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + deleteWatch, TContext = Context>(params?: RequestParams.WatcherDeleteWatch, options?: TransportRequestOptions): TransportRequestPromise> + deleteWatch, TContext = Context>(callback: callbackFn): TransportRequestCallback + deleteWatch, TContext = Context>(params: RequestParams.WatcherDeleteWatch, callback: callbackFn): TransportRequestCallback + deleteWatch, TContext = Context>(params: RequestParams.WatcherDeleteWatch, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + execute_watch, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.WatcherExecuteWatch, options?: TransportRequestOptions): TransportRequestPromise> + execute_watch, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + execute_watch, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.WatcherExecuteWatch, callback: callbackFn): TransportRequestCallback + execute_watch, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.WatcherExecuteWatch, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + executeWatch, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.WatcherExecuteWatch, options?: TransportRequestOptions): TransportRequestPromise> + executeWatch, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + executeWatch, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.WatcherExecuteWatch, callback: callbackFn): TransportRequestCallback + executeWatch, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.WatcherExecuteWatch, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + get_watch, TContext = Context>(params?: RequestParams.WatcherGetWatch, options?: TransportRequestOptions): TransportRequestPromise> + get_watch, TContext = Context>(callback: callbackFn): TransportRequestCallback + get_watch, TContext = Context>(params: RequestParams.WatcherGetWatch, callback: callbackFn): TransportRequestCallback + get_watch, TContext = Context>(params: RequestParams.WatcherGetWatch, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + getWatch, TContext = Context>(params?: RequestParams.WatcherGetWatch, options?: TransportRequestOptions): TransportRequestPromise> + getWatch, TContext = Context>(callback: callbackFn): TransportRequestCallback + getWatch, TContext = Context>(params: RequestParams.WatcherGetWatch, callback: callbackFn): TransportRequestCallback + getWatch, TContext = Context>(params: RequestParams.WatcherGetWatch, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + put_watch, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.WatcherPutWatch, options?: TransportRequestOptions): TransportRequestPromise> + put_watch, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + put_watch, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.WatcherPutWatch, callback: callbackFn): TransportRequestCallback + put_watch, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.WatcherPutWatch, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + putWatch, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.WatcherPutWatch, options?: TransportRequestOptions): TransportRequestPromise> + putWatch, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + putWatch, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.WatcherPutWatch, callback: callbackFn): TransportRequestCallback + putWatch, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.WatcherPutWatch, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + query_watches, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.WatcherQueryWatches, options?: TransportRequestOptions): TransportRequestPromise> + query_watches, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + query_watches, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.WatcherQueryWatches, callback: callbackFn): TransportRequestCallback + query_watches, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.WatcherQueryWatches, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + queryWatches, TRequestBody extends RequestBody = Record, TContext = Context>(params?: RequestParams.WatcherQueryWatches, options?: TransportRequestOptions): TransportRequestPromise> + queryWatches, TRequestBody extends RequestBody = Record, TContext = Context>(callback: callbackFn): TransportRequestCallback + queryWatches, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.WatcherQueryWatches, callback: callbackFn): TransportRequestCallback + queryWatches, TRequestBody extends RequestBody = Record, TContext = Context>(params: RequestParams.WatcherQueryWatches, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + start, TContext = Context>(params?: RequestParams.WatcherStart, options?: TransportRequestOptions): TransportRequestPromise> + start, TContext = Context>(callback: callbackFn): TransportRequestCallback + start, TContext = Context>(params: RequestParams.WatcherStart, callback: callbackFn): TransportRequestCallback + start, TContext = Context>(params: RequestParams.WatcherStart, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + stats, TContext = Context>(params?: RequestParams.WatcherStats, options?: TransportRequestOptions): TransportRequestPromise> + stats, TContext = Context>(callback: callbackFn): TransportRequestCallback + stats, TContext = Context>(params: RequestParams.WatcherStats, callback: callbackFn): TransportRequestCallback + stats, TContext = Context>(params: RequestParams.WatcherStats, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + stop, TContext = Context>(params?: RequestParams.WatcherStop, options?: TransportRequestOptions): TransportRequestPromise> + stop, TContext = Context>(callback: callbackFn): TransportRequestCallback + stop, TContext = Context>(params: RequestParams.WatcherStop, callback: callbackFn): TransportRequestCallback + stop, TContext = Context>(params: RequestParams.WatcherStop, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + xpack: { + info, TContext = Context>(params?: RequestParams.XpackInfo, options?: TransportRequestOptions): TransportRequestPromise> + info, TContext = Context>(callback: callbackFn): TransportRequestCallback + info, TContext = Context>(params: RequestParams.XpackInfo, callback: callbackFn): TransportRequestCallback + info, TContext = Context>(params: RequestParams.XpackInfo, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + usage, TContext = Context>(params?: RequestParams.XpackUsage, options?: TransportRequestOptions): TransportRequestPromise> + usage, TContext = Context>(callback: callbackFn): TransportRequestCallback + usage, TContext = Context>(params: RequestParams.XpackUsage, callback: callbackFn): TransportRequestCallback + usage, TContext = Context>(params: RequestParams.XpackUsage, options: TransportRequestOptions, callback: callbackFn): TransportRequestCallback + } + /* /GENERATED */ } declare const events: { @@ -165,6 +2720,7 @@ export { RequestEvent, ResurrectEvent, estypes, + RequestParams, ClientOptions, NodeOptions, ClientExtendsCallbackOptions From 3a0d5620baf3de83f463b316e4114f1bc250d9d5 Mon Sep 17 00:00:00 2001 From: delvedor Date: Fri, 2 Apr 2021 09:17:44 +0200 Subject: [PATCH 04/10] Updated canary package release script --- scripts/release-canary.js | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/scripts/release-canary.js b/scripts/release-canary.js index 3aa65879c..f9bda6c01 100644 --- a/scripts/release-canary.js +++ b/scripts/release-canary.js @@ -30,6 +30,7 @@ async function release (opts) { const originalName = packageJson.name const originalVersion = packageJson.version const currentCanaryVersion = packageJson.versionCanary + const originalTypes = packageJson.types const originalNpmIgnore = await readFile(join(__dirname, '..', '.npmignore'), 'utf8') const newCanaryInteger = opts.reset ? 1 : (Number(currentCanaryVersion.split('-')[1].split('.')[1]) + 1) @@ -39,12 +40,13 @@ async function release (opts) { packageJson.name = '@elastic/elasticsearch-canary' packageJson.version = newCanaryVersion packageJson.versionCanary = newCanaryVersion + packageJson.types = './api/new.d.ts' packageJson.commitHash = execSync('git log -1 --pretty=format:%h').toString() // update the package.json await writeFile( join(__dirname, '..', 'package.json'), - JSON.stringify(packageJson, null, 2), + JSON.stringify(packageJson, null, 2) + '\n', 'utf8' ) @@ -72,11 +74,12 @@ async function release (opts) { // restore the package.json to the original values packageJson.name = originalName packageJson.version = originalVersion + packageJson.types = originalTypes delete packageJson.commitHash await writeFile( join(__dirname, '..', 'package.json'), - JSON.stringify(packageJson, null, 2), + JSON.stringify(packageJson, null, 2) + '\n', 'utf8' ) From 8ebeab51b47c7462879529951257e7c8e92f5edb Mon Sep 17 00:00:00 2001 From: delvedor Date: Fri, 2 Apr 2021 10:19:57 +0200 Subject: [PATCH 05/10] Updated typescript docs --- docs/typescript.asciidoc | 90 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 90 insertions(+) diff --git a/docs/typescript.asciidoc b/docs/typescript.asciidoc index a2b29e6ce..7c1f1b269 100644 --- a/docs/typescript.asciidoc +++ b/docs/typescript.asciidoc @@ -7,6 +7,96 @@ definitions for every exposed API. NOTE: If you are using TypeScript you need to use _snake_case_ style to define the API parameters instead of _camelCase_. +Currently the client exposes two type definitions, the legacy one, which is the default +and the new one, which will be the default in the next major. +We storngly recommend to migrate to the new one as soon as possible. + +==== New type definitions + +The new type definition is more advanced compared to the legacy one. In the legacy +type definitions you were expected to configure via generics both request and response +bodies. The new type definitions comes with a complete type definition for every +Elasticsearch endpint. + +For example: + +[source,ts] +---- +// legacy definitions +const response = await client.search, SearchBody>({ + index: 'test', + body: { + query: { + match: { foo: 'bar' } + } + } +}) + +// new definitions +const response = await client.search({ + index: 'test', + body: { + query: { + match: { foo: 'bar' } + } + } +}) +---- + +The types are not 100% complete yet. Some APIs are missing (the newest ones, e.g. EQL), +and others may contain some errors, but we are continuously pushing fixes & improvements. + +Once you migrate to the new types, those are automatically integrated into the Elasticsearch client, you will get them out of the box. +If everything works, meaning that you won’t get compiler errors, you are good to go! +The types are already correct, and there is nothing more to do. + +If a type is incorrect, you should add a comment telling TypeScript that you know what you are doing +and not to bother you, we strongly recommend using `// @ts-expect-error @elastic/elasticsearch` +and continue to write your code as usual. +In this way, your code will compile until the type is fixed, and when it happens, you’ll only need to remove the +`// @ts-expect-error @elastic/elasticsearch` comment (TypeScript will let you know when it is time). +Finally, if the type you need is missing, you’ll see that the client method returns (or defines as a parameter) +a `TODO` type, which accepts any object. + +Open an issue in the client repository letting us know if you encounter any problem! + +===== How to migrate to the new type definitions + +Since the new type definitions can be considered a breaking change we couldn't add the directly to the client. +Following you will find a snippet that shows you how to override the default types with the new ones. + +[source,ts] +---- +import { Client } from '@elastic/elasticsearch' +import type { NewClientTypes } from '@elastic/elasticsearch/api/new' + +// @ts-expect-error @elastic/elasticsearch +const client = new Client({ + node: 'http://localhost:9200' +}) as NewClientTypes + +interface Source { + foo: string +} + +// try the new code completion when building a query! +const response = await client.search({ + index: 'test', + body: { + query: { + match_all: {} + } + } +}) + +// try the new code completion when traversing a response! +const results = response.body.hits.hits.map(hit => hit._source) +// results type will be `Source[]` +console.log(results) +---- + +==== Legacy type definitions + By default event API uses https://www.typescriptlang.org/docs/handbook/generics.html[generics] to specify the requests and response bodies and the `meta.context`. Currently, we can't From 5c6d63e39253d534254139be746e0041b571ba32 Mon Sep 17 00:00:00 2001 From: delvedor Date: Fri, 2 Apr 2021 15:34:08 +0200 Subject: [PATCH 06/10] Updated docs --- docs/typescript.asciidoc | 21 +++++++++++++-------- 1 file changed, 13 insertions(+), 8 deletions(-) diff --git a/docs/typescript.asciidoc b/docs/typescript.asciidoc index 7c1f1b269..678a87ecc 100644 --- a/docs/typescript.asciidoc +++ b/docs/typescript.asciidoc @@ -1,22 +1,26 @@ [[typescript]] === TypeScript support -The client offers a first-class support for TypeScript, since it ships the type -definitions for every exposed API. +The client offers a first-class support for TypeScript, shipping a complete set +of type definitions of Elasticsearch's API surface. + NOTE: If you are using TypeScript you need to use _snake_case_ style to define the API parameters instead of _camelCase_. Currently the client exposes two type definitions, the legacy one, which is the default and the new one, which will be the default in the next major. -We storngly recommend to migrate to the new one as soon as possible. +We strongly recommend to migrate to the new one as soon as possible, as the new types +are offering a vastly improved developer experience and guarantee you that your code +will always be in sync with the latest Elasticsearch features. +[discrete] ==== New type definitions The new type definition is more advanced compared to the legacy one. In the legacy type definitions you were expected to configure via generics both request and response bodies. The new type definitions comes with a complete type definition for every -Elasticsearch endpint. +Elasticsearch endpoint. For example: @@ -50,9 +54,8 @@ Once you migrate to the new types, those are automatically integrated into the E If everything works, meaning that you won’t get compiler errors, you are good to go! The types are already correct, and there is nothing more to do. -If a type is incorrect, you should add a comment telling TypeScript that you know what you are doing -and not to bother you, we strongly recommend using `// @ts-expect-error @elastic/elasticsearch` -and continue to write your code as usual. +If a type is incorrect, you should add a comment `// @ts-expect-error @elastic/elasticsearch` +telling TypeScript that you are aware of the warning and you would like to temporarily suppress it. In this way, your code will compile until the type is fixed, and when it happens, you’ll only need to remove the `// @ts-expect-error @elastic/elasticsearch` comment (TypeScript will let you know when it is time). Finally, if the type you need is missing, you’ll see that the client method returns (or defines as a parameter) @@ -60,6 +63,7 @@ a `TODO` type, which accepts any object. Open an issue in the client repository letting us know if you encounter any problem! +[discrete] ===== How to migrate to the new type definitions Since the new type definitions can be considered a breaking change we couldn't add the directly to the client. @@ -95,6 +99,7 @@ const results = response.body.hits.hits.map(hit => hit._source) console.log(results) ---- +[discrete] ==== Legacy type definitions By default event API uses @@ -135,7 +140,7 @@ You don't have to specify all the generics, but the order must be respected. [discrete] -==== A complete example +===== A complete example [source,ts] ---- From 6f789cecb34b42c92d67599120e5ffd0d8685c76 Mon Sep 17 00:00:00 2001 From: delvedor Date: Tue, 6 Apr 2021 10:53:19 +0200 Subject: [PATCH 07/10] Updated test --- test/types/api-response-body.test-d.ts | 175 +++++++++++++++++++++++-- test/types/api-response.test-d.ts | 36 +++-- test/types/client-options.test-d.ts | 2 +- test/types/client.test-d.ts | 36 ++--- test/types/connection-pool.test-d.ts | 2 +- test/types/connection.test-d.ts | 2 +- test/types/errors.test-d.ts | 2 +- test/types/helpers.test-d.ts | 2 +- test/types/kibana.test-d.ts | 3 +- test/types/new-types.test-d.ts | 108 +++++++++++++++ test/types/serializer.test-d.ts | 2 +- test/types/transport.test-d.ts | 2 +- 12 files changed, 324 insertions(+), 48 deletions(-) create mode 100644 test/types/new-types.test-d.ts diff --git a/test/types/api-response-body.test-d.ts b/test/types/api-response-body.test-d.ts index 2018d00d0..b3a124bf5 100644 --- a/test/types/api-response-body.test-d.ts +++ b/test/types/api-response-body.test-d.ts @@ -1,4 +1,4 @@ -/* + /* * 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 @@ -20,12 +20,57 @@ import { expectType, expectError } from 'tsd' import { Readable as ReadableStream } from 'stream'; import { TransportRequestCallback, Context } from '../../lib/Transport' -import { Client, ApiError, estypes } from '../../' +import { Client, ApiError } from '../../' const client = new Client({ node: 'http://localhost:9200' }) +interface SearchBody { + query: { + match: { foo: string } + } +} + +interface ShardsResponse { + total: number; + successful: number; + failed: number; + skipped: number; +} + +interface Explanation { + value: number; + description: string; + details: Explanation[]; +} + +interface SearchResponse { + took: number; + timed_out: boolean; + _scroll_id?: string; + _shards: ShardsResponse; + hits: { + total: number; + max_score: number; + hits: Array<{ + _index: string; + _type: string; + _id: string; + _score: number; + _source: T; + _version?: number; + _explanation?: Explanation; + fields?: any; + highlight?: any; + inner_hits?: any; + matched_queries?: string[]; + sort?: string[]; + }>; + }; + aggregations?: any; +} + interface Source { foo: string } @@ -49,13 +94,28 @@ expectError( } }) - expectType>(response.body) + expectType>(response.body) + expectType(response.meta.context) +} + +// Define only the response body (promise style) +{ + const response = await client.search>({ + index: 'test', + body: { + query: { + match: { foo: 'bar' } + } + } + }) + + expectType>(response.body) expectType(response.meta.context) } -// Define only the source (promise style) +// Define response body and request body (promise style) { - const response = await client.search({ + const response = await client.search, SearchBody>({ index: 'test', body: { query: { @@ -64,13 +124,13 @@ expectError( } }) - expectType>(response.body) + expectType>(response.body) expectType(response.meta.context) } // Define response body, request body and the context (promise style) { - const response = await client.search({ + const response = await client.search, SearchBody, Context>({ index: 'test', body: { query: { @@ -79,7 +139,40 @@ expectError( } }) - expectType>(response.body) + expectType>(response.body) + expectType(response.meta.context) +} + +// Send request body as string (promise style) +{ + const response = await client.search({ + index: 'test', + body: 'hello world' + }) + + expectType>(response.body) + expectType(response.meta.context) +} + +// Send request body as buffer (promise style) +{ + const response = await client.search({ + index: 'test', + body: Buffer.from('hello world') + }) + + expectType>(response.body) + expectType(response.meta.context) +} + +// Send request body as readable stream (promise style) +{ + const response = await client.search({ + index: 'test', + body: new ReadableStream() + }) + + expectType>(response.body) expectType(response.meta.context) } @@ -94,7 +187,7 @@ expectError( } }, (err, response) => { expectType(err) - expectType>(response.body) + expectType>(response.body) expectType(response.meta.context) }) expectType(result) @@ -102,7 +195,7 @@ expectError( // Define only the response body (callback style) { - const result = client.search({ + const result = client.search>({ index: 'test', body: { query: { @@ -111,7 +204,24 @@ expectError( } }, (err, response) => { expectType(err) - expectType>(response.body) + expectType>(response.body) + expectType(response.meta.context) + }) + expectType(result) +} + +// Define response body and request body (callback style) +{ + const result = client.search, SearchBody>({ + index: 'test', + body: { + query: { + match: { foo: 'bar' } + } + } + }, (err, response) => { + expectType(err) + expectType>(response.body) expectType(response.meta.context) }) expectType(result) @@ -119,7 +229,7 @@ expectError( // Define response body, request body and the context (callback style) { - const result = client.search({ + const result = client.search, SearchBody, Context>({ index: 'test', body: { query: { @@ -128,7 +238,46 @@ expectError( } }, (err, response) => { expectType(err) - expectType>(response.body) + expectType>(response.body) + expectType(response.meta.context) + }) + expectType(result) +} + +// Send request body as string (callback style) +{ + const result = client.search({ + index: 'test', + body: 'hello world' + }, (err, response) => { + expectType(err) + expectType>(response.body) + expectType(response.meta.context) + }) + expectType(result) +} + +// Send request body as buffer (callback style) +{ + const result = client.search({ + index: 'test', + body: Buffer.from('hello world') + }, (err, response) => { + expectType(err) + expectType>(response.body) + expectType(response.meta.context) + }) + expectType(result) +} + +// Send request body as readable stream (callback style) +{ + const result = client.search({ + index: 'test', + body: new ReadableStream() + }, (err, response) => { + expectType(err) + expectType>(response.body) expectType(response.meta.context) }) expectType(result) diff --git a/test/types/api-response.test-d.ts b/test/types/api-response.test-d.ts index 604a42860..a546f6a33 100644 --- a/test/types/api-response.test-d.ts +++ b/test/types/api-response.test-d.ts @@ -1,4 +1,4 @@ -/* + /* * 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 @@ -19,7 +19,7 @@ import { expectType } from 'tsd' import { TransportRequestCallback, Context } from '../../lib/Transport' -import { Client, ApiError, estypes } from '../../' +import { Client, ApiError } from '../../' const client = new Client({ node: 'http://localhost:9200' @@ -29,15 +29,23 @@ const client = new Client({ { const response = await client.cat.count({ index: 'test' }) - expectType(response.body) + expectType>(response.body) expectType(response.meta.context) } -// Define the context (promise style) +// Define only the response body (promise style) { const response = await client.cat.count({ index: 'test' }) - expectType(response.body) + expectType(response.body) + expectType(response.meta.context) +} + +// Define response body and the context (promise style) +{ + const response = await client.cat.count({ index: 'test' }) + + expectType(response.body) expectType(response.meta.context) } @@ -45,18 +53,28 @@ const client = new Client({ { const result = client.cat.count({ index: 'test' }, (err, response) => { expectType(err) - expectType(response.body) + expectType>(response.body) expectType(response.meta.context) }) expectType(result) } -// Define the context (callback style) +// Define only the response body (callback style) { const result = client.cat.count({ index: 'test' }, (err, response) => { expectType(err) - expectType(response.body) - expectType(response.meta.context) + expectType(response.body) + expectType(response.meta.context) + }) + expectType(result) +} + +// Define response body and the context (callback style) +{ + const result = client.cat.count({ index: 'test' }, (err, response) => { + expectType(err) + expectType(response.body) + expectType(response.meta.context) }) expectType(result) } diff --git a/test/types/client-options.test-d.ts b/test/types/client-options.test-d.ts index 814ba08df..24ca18743 100644 --- a/test/types/client-options.test-d.ts +++ b/test/types/client-options.test-d.ts @@ -1,4 +1,4 @@ -/* + /* * 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 diff --git a/test/types/client.test-d.ts b/test/types/client.test-d.ts index 98195c883..a37e16393 100644 --- a/test/types/client.test-d.ts +++ b/test/types/client.test-d.ts @@ -1,4 +1,4 @@ -/* + /* * 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 @@ -18,8 +18,8 @@ */ import { expectType } from 'tsd' -import { Client, ApiError, ApiResponse, RequestEvent, ResurrectEvent, estypes } from '../../' -import { TransportRequestCallback, TransportRequestPromise, Context } from '../../lib/Transport' +import { Client, ApiError, ApiResponse, RequestEvent, ResurrectEvent } from '../../' +import { TransportRequestCallback, TransportRequestPromise } from '../../lib/Transport' const client = new Client({ node: 'http://localhost:9200' @@ -51,7 +51,7 @@ client.on('resurrect', (err, meta) => { { const result = client.info((err, result) => { expectType(err) - expectType>(result) + expectType(result) }) expectType(result) expectType(result.abort()) @@ -60,7 +60,7 @@ client.on('resurrect', (err, meta) => { { const result = client.info({ pretty: true }, (err, result) => { expectType(err) - expectType>(result) + expectType(result) }) expectType(result) expectType(result.abort()) @@ -69,7 +69,7 @@ client.on('resurrect', (err, meta) => { { const result = client.info({ pretty: true }, { ignore: [404] }, (err, result) => { expectType(err) - expectType>(result) + expectType(result) }) expectType(result) expectType(result.abort()) @@ -78,27 +78,27 @@ client.on('resurrect', (err, meta) => { // Promise style { const promise = client.info() - expectType>>(promise) + expectType>(promise) promise - .then(result => expectType>(result)) + .then(result => expectType(result)) .catch((err: ApiError) => expectType(err)) expectType(promise.abort()) } { const promise = client.info({ pretty: true }) - expectType>>(promise) + expectType>(promise) promise - .then(result => expectType>(result)) + .then(result => expectType(result)) .catch((err: ApiError) => expectType(err)) expectType(promise.abort()) } { const promise = client.info({ pretty: true }, { ignore: [404] }) - expectType>>(promise) + expectType>(promise) promise - .then(result => expectType>(result)) + .then(result => expectType(result)) .catch((err: ApiError) => expectType(err)) expectType(promise.abort()) } @@ -106,10 +106,10 @@ client.on('resurrect', (err, meta) => { // Promise style with async await { const promise = client.info() - expectType>>(promise) + expectType>(promise) expectType(promise.abort()) try { - expectType>(await promise) + expectType(await promise) } catch (err) { expectType(err) } @@ -117,10 +117,10 @@ client.on('resurrect', (err, meta) => { { const promise = client.info({ pretty: true }) - expectType>>(promise) + expectType>(promise) expectType(promise.abort()) try { - expectType>(await promise) + expectType(await promise) } catch (err) { expectType(err) } @@ -128,10 +128,10 @@ client.on('resurrect', (err, meta) => { { const promise = client.info({ pretty: true }, { ignore: [404] }) - expectType>>(promise) + expectType>(promise) expectType(promise.abort()) try { - expectType>(await promise) + expectType(await promise) } catch (err) { expectType(err) } diff --git a/test/types/connection-pool.test-d.ts b/test/types/connection-pool.test-d.ts index f46f23e01..b2298f45e 100644 --- a/test/types/connection-pool.test-d.ts +++ b/test/types/connection-pool.test-d.ts @@ -1,4 +1,4 @@ -/* + /* * 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 diff --git a/test/types/connection.test-d.ts b/test/types/connection.test-d.ts index 66e9d257b..96c5b8919 100644 --- a/test/types/connection.test-d.ts +++ b/test/types/connection.test-d.ts @@ -1,4 +1,4 @@ -/* + /* * 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 diff --git a/test/types/errors.test-d.ts b/test/types/errors.test-d.ts index 2a0d4df1f..522ff63f3 100644 --- a/test/types/errors.test-d.ts +++ b/test/types/errors.test-d.ts @@ -1,4 +1,4 @@ -/* + /* * 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 diff --git a/test/types/helpers.test-d.ts b/test/types/helpers.test-d.ts index 202d4aa84..3610150c3 100644 --- a/test/types/helpers.test-d.ts +++ b/test/types/helpers.test-d.ts @@ -1,4 +1,4 @@ -/* + /* * 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 diff --git a/test/types/kibana.test-d.ts b/test/types/kibana.test-d.ts index 7c35228f5..139d21035 100644 --- a/test/types/kibana.test-d.ts +++ b/test/types/kibana.test-d.ts @@ -22,6 +22,7 @@ import { Client, RequestEvent, ResurrectEvent, ApiError, ApiResponse, estypes } import { KibanaClient } from '../../api/kibana' import { TransportRequestPromise, Context } from '../../lib/Transport' +// @ts-expect-error const client: KibanaClient = new Client({ node: 'http://localhost:9200' }) @@ -112,4 +113,4 @@ expectError(client.close(() => {})) // the child api should return a KibanaClient instance const child = client.child() expectType(child) -expectNotType(child) +expectNotType(child) \ No newline at end of file diff --git a/test/types/new-types.test-d.ts b/test/types/new-types.test-d.ts new file mode 100644 index 000000000..63a9f33ed --- /dev/null +++ b/test/types/new-types.test-d.ts @@ -0,0 +1,108 @@ +/* + * Licensed to Elasticsearch B.V. under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch B.V. licenses this file to you under + * the Apache License, Version 2.0 (the "License"); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +import { expectType, expectNotType, expectError } from 'tsd' +import { Client, RequestEvent, ResurrectEvent, ApiError, ApiResponse, estypes } from '../../' +import { NewClientTypes } from '../../api/new' +import { TransportRequestPromise, Context } from '../../lib/Transport' + +// @ts-expect-error +const client: NewClientTypes = new Client({ + node: 'http://localhost:9200' +}) + +client.on('request', (err, meta) => { + expectType(err) + expectType(meta) +}) + +client.on('response', (err, meta) => { + expectType(err) + expectType(meta) +}) + +client.on('sniff', (err, meta) => { + expectType(err) + expectType(meta) +}) + +client.on('resurrect', (err, meta) => { + expectType(err) + expectType(meta) +}) + +// No generics +{ + const response = await client.cat.count({ index: 'test' }) + + expectType(response.body) + expectType(response.meta.context) +} + +// Define only the context +{ + const response = await client.cat.count({ index: 'test' }) + + expectType(response.body) + expectType(response.meta.context) +} + +// Check API returned type and optional parameters +{ + const promise = client.info() + expectType>>(promise) + promise + .then(result => expectType>(result)) + .catch((err: ApiError) => expectType(err)) + expectType(promise.abort()) +} + +{ + const promise = client.info({ pretty: true }) + expectType>>(promise) + promise + .then(result => expectType>(result)) + .catch((err: ApiError) => expectType(err)) + expectType(promise.abort()) +} + +{ + const promise = client.info({ pretty: true }, { ignore: [404] }) + expectType>>(promise) + promise + .then(result => expectType>(result)) + .catch((err: ApiError) => expectType(err)) + expectType(promise.abort()) +} + +// body that does not respect the RequestBody constraint +expectError( + client.search({ + index: 'hello', + body: 42 + }).then(console.log) +) + +// @ts-expect-error +client.async_search.get() + +// the child api should return a KibanaClient instance +const child = client.child() +expectType(child) +expectNotType(child) \ No newline at end of file diff --git a/test/types/serializer.test-d.ts b/test/types/serializer.test-d.ts index 69c41ba46..fcb21f65f 100644 --- a/test/types/serializer.test-d.ts +++ b/test/types/serializer.test-d.ts @@ -1,4 +1,4 @@ -/* + /* * 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 diff --git a/test/types/transport.test-d.ts b/test/types/transport.test-d.ts index 5fa2573e0..53aff583f 100644 --- a/test/types/transport.test-d.ts +++ b/test/types/transport.test-d.ts @@ -1,4 +1,4 @@ -/* + /* * 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 From f692c5be095195484d680168613bb90715a66a05 Mon Sep 17 00:00:00 2001 From: delvedor Date: Tue, 6 Apr 2021 10:53:58 +0200 Subject: [PATCH 08/10] Fixed kibana types --- api/kibana.d.ts | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/api/kibana.d.ts b/api/kibana.d.ts index 996402ed5..005dbf9dc 100644 --- a/api/kibana.d.ts +++ b/api/kibana.d.ts @@ -127,7 +127,7 @@ interface KibanaClient { getAutoFollowPattern(params?: T.GetAutoFollowPatternRequest, options?: TransportRequestOptions): TransportRequestPromise> pauseAutoFollowPattern(params: T.PauseAutoFollowPatternRequest, options?: TransportRequestOptions): TransportRequestPromise> pauseFollow(params: T.PauseFollowIndexRequest, options?: TransportRequestOptions): TransportRequestPromise> - putAutoFollowPattern(params: T.CreateAutoFollowPatternRequest, options?: TransportRequestOptions): TransportRequestPromise> + putAutoFollowPattern(params: T.PutAutoFollowPatternRequest, options?: TransportRequestOptions): TransportRequestPromise> resumeAutoFollowPattern(params: T.ResumeAutoFollowPatternRequest, options?: TransportRequestOptions): TransportRequestPromise> resumeFollow(params: T.ResumeFollowIndexRequest, options?: TransportRequestOptions): TransportRequestPromise> stats(params?: T.CcrStatsRequest, options?: TransportRequestOptions): TransportRequestPromise> @@ -137,7 +137,7 @@ interface KibanaClient { closePointInTime(params?: T.ClosePointInTimeRequest, options?: TransportRequestOptions): TransportRequestPromise> cluster: { allocationExplain(params?: T.ClusterAllocationExplainRequest, options?: TransportRequestOptions): TransportRequestPromise> - deleteComponentTemplate(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> + deleteComponentTemplate(params: T.ClusterDeleteComponentTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise> deleteVotingConfigExclusions(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> existsComponentTemplate(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> getComponentTemplate(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> @@ -181,10 +181,10 @@ interface KibanaClient { stats(params?: T.EnrichStatsRequest, options?: TransportRequestOptions): TransportRequestPromise> } eql: { - delete(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> - get(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> - getStatus(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> - search(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> + delete(params: T.EqlDeleteRequest, options?: TransportRequestOptions): TransportRequestPromise> + get(params: T.EqlGetRequest, options?: TransportRequestOptions): TransportRequestPromise, TContext>> + getStatus(params: T.EqlGetStatusRequest, options?: TransportRequestOptions): TransportRequestPromise> + search(params: T.EqlSearchRequest, options?: TransportRequestOptions): TransportRequestPromise, TContext>> } exists(params: T.DocumentExistsRequest, options?: TransportRequestOptions): TransportRequestPromise> existsSource(params: T.SourceExistsRequest, options?: TransportRequestOptions): TransportRequestPromise> @@ -215,17 +215,17 @@ interface KibanaClient { } index(params: T.IndexRequest, options?: TransportRequestOptions): TransportRequestPromise> indices: { - addBlock(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> + addBlock(params: T.IndexAddBlockRequest, options?: TransportRequestOptions): TransportRequestPromise> analyze(params?: T.AnalyzeRequest, options?: TransportRequestOptions): TransportRequestPromise> clearCache(params?: T.ClearCacheRequest, options?: TransportRequestOptions): TransportRequestPromise> clone(params: T.CloneIndexRequest, options?: TransportRequestOptions): TransportRequestPromise> close(params: T.CloseIndexRequest, options?: TransportRequestOptions): TransportRequestPromise> create(params: T.CreateIndexRequest, options?: TransportRequestOptions): TransportRequestPromise> createDataStream(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> - dataStreamsStats(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> + dataStreamsStats(params?: T.IndicesDataStreamsStatsRequest, options?: TransportRequestOptions): TransportRequestPromise> delete(params: T.DeleteIndexRequest, options?: TransportRequestOptions): TransportRequestPromise> deleteAlias(params: T.DeleteAliasRequest, options?: TransportRequestOptions): TransportRequestPromise> - deleteDataStream(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> + deleteDataStream(params: T.IndicesDeleteDataStreamRequest, options?: TransportRequestOptions): TransportRequestPromise> deleteIndexTemplate(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> deleteTemplate(params: T.DeleteIndexTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise> exists(params: T.IndexExistsRequest, options?: TransportRequestOptions): TransportRequestPromise> @@ -246,7 +246,7 @@ interface KibanaClient { getSettings(params?: T.GetIndexSettingsRequest, options?: TransportRequestOptions): TransportRequestPromise> getTemplate(params?: T.GetIndexTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise> getUpgrade(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> - migrateToDataStream(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> + migrateToDataStream(params: T.IndicesMigrateToDataStreamRequest, options?: TransportRequestOptions): TransportRequestPromise> open(params: T.OpenIndexRequest, options?: TransportRequestOptions): TransportRequestPromise> promoteDataStream(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> putAlias(params: T.PutAliasRequest, options?: TransportRequestOptions): TransportRequestPromise> @@ -257,7 +257,7 @@ interface KibanaClient { recovery(params?: T.RecoveryStatusRequest, options?: TransportRequestOptions): TransportRequestPromise> refresh(params?: T.RefreshRequest, options?: TransportRequestOptions): TransportRequestPromise> reloadSearchAnalyzers(params: T.ReloadSearchAnalyzersRequest, options?: TransportRequestOptions): TransportRequestPromise> - resolveIndex(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> + resolveIndex(params: T.ResolveIndexRequest, options?: TransportRequestOptions): TransportRequestPromise> rollover(params: T.RolloverIndexRequest, options?: TransportRequestOptions): TransportRequestPromise> segments(params?: T.SegmentsRequest, options?: TransportRequestOptions): TransportRequestPromise> shardStores(params?: T.IndicesShardStoresRequest, options?: TransportRequestOptions): TransportRequestPromise> @@ -309,8 +309,8 @@ interface KibanaClient { deleteForecast(params: T.DeleteForecastRequest, options?: TransportRequestOptions): TransportRequestPromise> deleteJob(params: T.DeleteJobRequest, options?: TransportRequestOptions): TransportRequestPromise> deleteModelSnapshot(params: T.DeleteModelSnapshotRequest, options?: TransportRequestOptions): TransportRequestPromise> - deleteTrainedModel(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> - deleteTrainedModelAlias(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> + deleteTrainedModel(params: T.DeleteTrainedModelRequest, options?: TransportRequestOptions): TransportRequestPromise> + deleteTrainedModelAlias(params: T.DeleteTrainedModelAliasRequest, options?: TransportRequestOptions): TransportRequestPromise> estimateModelMemory(params?: T.EstimateModelMemoryRequest, options?: TransportRequestOptions): TransportRequestPromise> evaluateDataFrame(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> explainDataFrameAnalytics(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> @@ -400,7 +400,7 @@ interface KibanaClient { searchTemplate(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> searchableSnapshots: { clearCache(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> - mount(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> + mount(params: T.SearchableSnapshotsMountRequest, options?: TransportRequestOptions): TransportRequestPromise> repositoryStats(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> stats(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> } @@ -408,7 +408,7 @@ interface KibanaClient { authenticate(params?: T.AuthenticateRequest, options?: TransportRequestOptions): TransportRequestPromise> changePassword(params?: T.ChangePasswordRequest, options?: TransportRequestOptions): TransportRequestPromise> clearApiKeyCache(params?: T.ClearApiKeyCacheRequest, options?: TransportRequestOptions): TransportRequestPromise> - clearCachedPrivileges(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise> + clearCachedPrivileges(params: T.ClearCachedPrivilegesRequest, options?: TransportRequestOptions): TransportRequestPromise> clearCachedRealms(params: T.ClearCachedRealmsRequest, options?: TransportRequestOptions): TransportRequestPromise> clearCachedRoles(params: T.ClearCachedRolesRequest, options?: TransportRequestOptions): TransportRequestPromise> createApiKey(params?: T.CreateApiKeyRequest, options?: TransportRequestOptions): TransportRequestPromise> From f90a56e25133f7d7adab2d97c3485900d40bc828 Mon Sep 17 00:00:00 2001 From: delvedor Date: Tue, 6 Apr 2021 12:41:52 +0200 Subject: [PATCH 09/10] Fix comment --- test/types/api-response-body.test-d.ts | 2 +- test/types/api-response.test-d.ts | 2 +- test/types/client-options.test-d.ts | 2 +- test/types/client.test-d.ts | 2 +- test/types/connection-pool.test-d.ts | 2 +- test/types/connection.test-d.ts | 2 +- test/types/errors.test-d.ts | 4 ++-- test/types/helpers.test-d.ts | 2 +- test/types/serializer.test-d.ts | 2 +- test/types/transport.test-d.ts | 2 +- 10 files changed, 11 insertions(+), 11 deletions(-) diff --git a/test/types/api-response-body.test-d.ts b/test/types/api-response-body.test-d.ts index b3a124bf5..ccd236b8d 100644 --- a/test/types/api-response-body.test-d.ts +++ b/test/types/api-response-body.test-d.ts @@ -1,4 +1,4 @@ - /* +/* * 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 diff --git a/test/types/api-response.test-d.ts b/test/types/api-response.test-d.ts index a546f6a33..1765c2211 100644 --- a/test/types/api-response.test-d.ts +++ b/test/types/api-response.test-d.ts @@ -1,4 +1,4 @@ - /* +/* * 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 diff --git a/test/types/client-options.test-d.ts b/test/types/client-options.test-d.ts index 24ca18743..814ba08df 100644 --- a/test/types/client-options.test-d.ts +++ b/test/types/client-options.test-d.ts @@ -1,4 +1,4 @@ - /* +/* * 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 diff --git a/test/types/client.test-d.ts b/test/types/client.test-d.ts index a37e16393..49d7d03d8 100644 --- a/test/types/client.test-d.ts +++ b/test/types/client.test-d.ts @@ -1,4 +1,4 @@ - /* +/* * 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 diff --git a/test/types/connection-pool.test-d.ts b/test/types/connection-pool.test-d.ts index b2298f45e..f46f23e01 100644 --- a/test/types/connection-pool.test-d.ts +++ b/test/types/connection-pool.test-d.ts @@ -1,4 +1,4 @@ - /* +/* * 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 diff --git a/test/types/connection.test-d.ts b/test/types/connection.test-d.ts index 96c5b8919..66e9d257b 100644 --- a/test/types/connection.test-d.ts +++ b/test/types/connection.test-d.ts @@ -1,4 +1,4 @@ - /* +/* * 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 diff --git a/test/types/errors.test-d.ts b/test/types/errors.test-d.ts index 522ff63f3..e43cea39b 100644 --- a/test/types/errors.test-d.ts +++ b/test/types/errors.test-d.ts @@ -1,4 +1,4 @@ - /* +/* * 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 @@ -101,4 +101,4 @@ const response = { expectType(err.name) expectType(err.message) expectType(err.meta) -} \ No newline at end of file +} diff --git a/test/types/helpers.test-d.ts b/test/types/helpers.test-d.ts index 3610150c3..202d4aa84 100644 --- a/test/types/helpers.test-d.ts +++ b/test/types/helpers.test-d.ts @@ -1,4 +1,4 @@ - /* +/* * 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 diff --git a/test/types/serializer.test-d.ts b/test/types/serializer.test-d.ts index fcb21f65f..69c41ba46 100644 --- a/test/types/serializer.test-d.ts +++ b/test/types/serializer.test-d.ts @@ -1,4 +1,4 @@ - /* +/* * 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 diff --git a/test/types/transport.test-d.ts b/test/types/transport.test-d.ts index 53aff583f..5fa2573e0 100644 --- a/test/types/transport.test-d.ts +++ b/test/types/transport.test-d.ts @@ -1,4 +1,4 @@ - /* +/* * 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 From 623e8f57a2d85131804ae6764be5de92a07b3153 Mon Sep 17 00:00:00 2001 From: delvedor Date: Tue, 6 Apr 2021 12:43:02 +0200 Subject: [PATCH 10/10] Generate by hash as well --- scripts/generate.js | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/scripts/generate.js b/scripts/generate.js index 3b6be0dc4..ad6fc71cb 100644 --- a/scripts/generate.js +++ b/scripts/generate.js @@ -34,7 +34,7 @@ const { } = require('./utils') start(minimist(process.argv.slice(2), { - string: ['version'] + string: ['version', 'hash'] })) function start (opts) { @@ -51,7 +51,7 @@ function start (opts) { const requestParamsOutputFile = join(packageFolder, 'requestParams.d.ts') let log - downloadArtifacts({ version: opts.version }) + downloadArtifacts({ version: opts.version, hash: opts.hash }) .then(onArtifactsDownloaded) .catch(err => { console.log(err)