API generation

2021-07-15 18:01:43 +02:00
parent 4073d60b97
commit cab8d8be38
9 changed files with 1192 additions and 14 deletions
--- a/api/api/ilm.js
+++ b/api/api/ilm.js
@ -23,8 +23,8 @@
 /* eslint no-unused-vars: 0 */

 const { handleError, snakeCaseKeys, normalizeArguments, kConfigurationError } = require('../utils')
-const acceptedQuerystring = ['pretty', 'human', 'error_trace', 'source', 'filter_path', 'only_managed', 'only_errors']
-const snakeCase = { errorTrace: 'error_trace', filterPath: 'filter_path', onlyManaged: 'only_managed', onlyErrors: 'only_errors' }
+const acceptedQuerystring = ['pretty', 'human', 'error_trace', 'source', 'filter_path', 'only_managed', 'only_errors', 'dry_run']
+const snakeCase = { errorTrace: 'error_trace', filterPath: 'filter_path', onlyManaged: 'only_managed', onlyErrors: 'only_errors', dryRun: 'dry_run' }

 function IlmApi (transport, ConfigurationError) {
  this.transport = transport
@ -132,6 +132,27 @@ IlmApi.prototype.getStatus = function ilmGetStatusApi (params, options, callback
  return this.transport.request(request, options, callback)
 }

+IlmApi.prototype.migrateToDataTiers = function ilmMigrateToDataTiersApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  let { method, body, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'POST'
+  path = '/' + '_ilm' + '/' + 'migrate_to_data_tiers'
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: body || '',
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
 IlmApi.prototype.moveToStep = function ilmMoveToStepApi (params, options, callback) {
  ;[params, options, callback] = normalizeArguments(params, options, callback)

@ -287,6 +308,7 @@ Object.defineProperties(IlmApi.prototype, {
  explain_lifecycle: { get () { return this.explainLifecycle } },
  get_lifecycle: { get () { return this.getLifecycle } },
  get_status: { get () { return this.getStatus } },
+  migrate_to_data_tiers: { get () { return this.migrateToDataTiers } },
  move_to_step: { get () { return this.moveToStep } },
  put_lifecycle: { get () { return this.putLifecycle } },
  remove_policy: { get () { return this.removePolicy } }
--- a/api/api/indices.js
+++ b/api/api/indices.js
@ -23,8 +23,8 @@
 /* eslint no-unused-vars: 0 */

 const { handleError, snakeCaseKeys, normalizeArguments, kConfigurationError } = require('../utils')
-const acceptedQuerystring = ['timeout', 'master_timeout', 'ignore_unavailable', 'allow_no_indices', 'expand_wildcards', 'pretty', 'human', 'error_trace', 'source', 'filter_path', 'index', 'fielddata', 'fields', 'query', 'request', 'wait_for_active_shards', 'local', 'flat_settings', 'include_defaults', 'force', 'wait_if_ongoing', 'flush', 'max_num_segments', 'only_expunge_deletes', 'create', 'cause', 'write_index_only', 'preserve_existing', 'order', 'detailed', 'active_only', 'dry_run', 'verbose', 'status', 'completion_fields', 'fielddata_fields', 'groups', 'level', 'types', 'include_segment_file_sizes', 'include_unloaded_segments', 'forbid_closed_indices', 'explain', 'q', 'analyzer', 'analyze_wildcard', 'default_operator', 'df', 'lenient', 'rewrite', 'all_shards']
-const snakeCase = { masterTimeout: 'master_timeout', ignoreUnavailable: 'ignore_unavailable', allowNoIndices: 'allow_no_indices', expandWildcards: 'expand_wildcards', errorTrace: 'error_trace', filterPath: 'filter_path', waitForActiveShards: 'wait_for_active_shards', flatSettings: 'flat_settings', includeDefaults: 'include_defaults', waitIfOngoing: 'wait_if_ongoing', maxNumSegments: 'max_num_segments', onlyExpungeDeletes: 'only_expunge_deletes', writeIndexOnly: 'write_index_only', preserveExisting: 'preserve_existing', activeOnly: 'active_only', dryRun: 'dry_run', completionFields: 'completion_fields', fielddataFields: 'fielddata_fields', includeSegmentFileSizes: 'include_segment_file_sizes', includeUnloadedSegments: 'include_unloaded_segments', forbidClosedIndices: 'forbid_closed_indices', analyzeWildcard: 'analyze_wildcard', defaultOperator: 'default_operator', allShards: 'all_shards' }
+const acceptedQuerystring = ['timeout', 'master_timeout', 'ignore_unavailable', 'allow_no_indices', 'expand_wildcards', 'pretty', 'human', 'error_trace', 'source', 'filter_path', 'index', 'fielddata', 'fields', 'query', 'request', 'wait_for_active_shards', 'run_expensive_tasks', 'flush', 'local', 'flat_settings', 'include_defaults', 'force', 'wait_if_ongoing', 'max_num_segments', 'only_expunge_deletes', 'create', 'cause', 'write_index_only', 'preserve_existing', 'order', 'detailed', 'active_only', 'dry_run', 'verbose', 'status', 'completion_fields', 'fielddata_fields', 'groups', 'level', 'types', 'include_segment_file_sizes', 'include_unloaded_segments', 'forbid_closed_indices', 'explain', 'q', 'analyzer', 'analyze_wildcard', 'default_operator', 'df', 'lenient', 'rewrite', 'all_shards']
+const snakeCase = { masterTimeout: 'master_timeout', ignoreUnavailable: 'ignore_unavailable', allowNoIndices: 'allow_no_indices', expandWildcards: 'expand_wildcards', errorTrace: 'error_trace', filterPath: 'filter_path', waitForActiveShards: 'wait_for_active_shards', runExpensiveTasks: 'run_expensive_tasks', flatSettings: 'flat_settings', includeDefaults: 'include_defaults', waitIfOngoing: 'wait_if_ongoing', maxNumSegments: 'max_num_segments', onlyExpungeDeletes: 'only_expunge_deletes', writeIndexOnly: 'write_index_only', preserveExisting: 'preserve_existing', activeOnly: 'active_only', dryRun: 'dry_run', completionFields: 'completion_fields', fielddataFields: 'fielddata_fields', includeSegmentFileSizes: 'include_segment_file_sizes', includeUnloadedSegments: 'include_unloaded_segments', forbidClosedIndices: 'forbid_closed_indices', analyzeWildcard: 'analyze_wildcard', defaultOperator: 'default_operator', allShards: 'all_shards' }

 function IndicesApi (transport, ConfigurationError) {
  this.transport = transport
@ -414,6 +414,33 @@ IndicesApi.prototype.deleteTemplate = function indicesDeleteTemplateApi (params,
  return this.transport.request(request, options, callback)
 }

+IndicesApi.prototype.diskUsage = function indicesDiskUsageApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  // check required parameters
+  if (params.index == null) {
+    const err = new this[kConfigurationError]('Missing required parameter: index')
+    return handleError(err, callback)
+  }
+
+  let { method, body, index, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'POST'
+  path = '/' + encodeURIComponent(index) + '/' + '_disk_usage'
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: body || '',
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
 IndicesApi.prototype.exists = function indicesExistsApi (params, options, callback) {
  ;[params, options, callback] = normalizeArguments(params, options, callback)

@ -564,6 +591,33 @@ IndicesApi.prototype.existsType = function indicesExistsTypeApi (params, options
  return this.transport.request(request, options, callback)
 }

+IndicesApi.prototype.fieldUsageStats = function indicesFieldUsageStatsApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  // check required parameters
+  if (params.index == null) {
+    const err = new this[kConfigurationError]('Missing required parameter: index')
+    return handleError(err, callback)
+  }
+
+  let { method, body, index, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'GET'
+  path = '/' + encodeURIComponent(index) + '/' + '_field_usage_stats'
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: null,
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
 IndicesApi.prototype.flush = function indicesFlushApi (params, options, callback) {
  ;[params, options, callback] = normalizeArguments(params, options, callback)

@ -1571,10 +1625,12 @@ Object.defineProperties(IndicesApi.prototype, {
  delete_data_stream: { get () { return this.deleteDataStream } },
  delete_index_template: { get () { return this.deleteIndexTemplate } },
  delete_template: { get () { return this.deleteTemplate } },
+  disk_usage: { get () { return this.diskUsage } },
  exists_alias: { get () { return this.existsAlias } },
  exists_index_template: { get () { return this.existsIndexTemplate } },
  exists_template: { get () { return this.existsTemplate } },
  exists_type: { get () { return this.existsType } },
+  field_usage_stats: { get () { return this.fieldUsageStats } },
  get_alias: { get () { return this.getAlias } },
  get_data_stream: { get () { return this.getDataStream } },
  get_field_mapping: { get () { return this.getFieldMapping } },
--- a/api/api/ml.js
+++ b/api/api/ml.js
@ -1048,6 +1048,33 @@ MlApi.prototype.getTrainedModelsStats = function mlGetTrainedModelsStatsApi (par
  return this.transport.request(request, options, callback)
 }

+MlApi.prototype.inferTrainedModelDeployment = function mlInferTrainedModelDeploymentApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  // check required parameters
+  if (params.model_id == null && params.modelId == null) {
+    const err = new this[kConfigurationError]('Missing required parameter: model_id or modelId')
+    return handleError(err, callback)
+  }
+
+  let { method, body, modelId, model_id, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'POST'
+  path = '/' + '_ml' + '/' + 'trained_models' + '/' + encodeURIComponent(model_id || modelId) + '/' + 'deployment' + '/' + '_infer'
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: body || '',
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
 MlApi.prototype.info = function mlInfoApi (params, options, callback) {
  ;[params, options, callback] = normalizeArguments(params, options, callback)

@ -1466,6 +1493,33 @@ MlApi.prototype.putTrainedModelAlias = function mlPutTrainedModelAliasApi (param
  return this.transport.request(request, options, callback)
 }

+MlApi.prototype.resetJob = function mlResetJobApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  // check required parameters
+  if (params.job_id == null && params.jobId == null) {
+    const err = new this[kConfigurationError]('Missing required parameter: job_id or jobId')
+    return handleError(err, callback)
+  }
+
+  let { method, body, jobId, job_id, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'POST'
+  path = '/' + '_ml' + '/' + 'anomaly_detectors' + '/' + encodeURIComponent(job_id || jobId) + '/' + '_reset'
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: body || '',
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
 MlApi.prototype.revertModelSnapshot = function mlRevertModelSnapshotApi (params, options, callback) {
  ;[params, options, callback] = normalizeArguments(params, options, callback)

@ -1578,6 +1632,33 @@ MlApi.prototype.startDatafeed = function mlStartDatafeedApi (params, options, ca
  return this.transport.request(request, options, callback)
 }

+MlApi.prototype.startTrainedModelDeployment = function mlStartTrainedModelDeploymentApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  // check required parameters
+  if (params.model_id == null && params.modelId == null) {
+    const err = new this[kConfigurationError]('Missing required parameter: model_id or modelId')
+    return handleError(err, callback)
+  }
+
+  let { method, body, modelId, model_id, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'POST'
+  path = '/' + '_ml' + '/' + 'trained_models' + '/' + encodeURIComponent(model_id || modelId) + '/' + 'deployment' + '/' + '_start'
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: body || '',
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
 MlApi.prototype.stopDataFrameAnalytics = function mlStopDataFrameAnalyticsApi (params, options, callback) {
  ;[params, options, callback] = normalizeArguments(params, options, callback)

@ -1632,6 +1713,33 @@ MlApi.prototype.stopDatafeed = function mlStopDatafeedApi (params, options, call
  return this.transport.request(request, options, callback)
 }

+MlApi.prototype.stopTrainedModelDeployment = function mlStopTrainedModelDeploymentApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  // check required parameters
+  if (params.model_id == null && params.modelId == null) {
+    const err = new this[kConfigurationError]('Missing required parameter: model_id or modelId')
+    return handleError(err, callback)
+  }
+
+  let { method, body, modelId, model_id, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'POST'
+  path = '/' + '_ml' + '/' + 'trained_models' + '/' + encodeURIComponent(model_id || modelId) + '/' + 'deployment' + '/' + '_stop'
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: body || '',
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
 MlApi.prototype.updateDataFrameAnalytics = function mlUpdateDataFrameAnalyticsApi (params, options, callback) {
  ;[params, options, callback] = normalizeArguments(params, options, callback)

@ -1923,6 +2031,7 @@ Object.defineProperties(MlApi.prototype, {
  get_records: { get () { return this.getRecords } },
  get_trained_models: { get () { return this.getTrainedModels } },
  get_trained_models_stats: { get () { return this.getTrainedModelsStats } },
+  infer_trained_model_deployment: { get () { return this.inferTrainedModelDeployment } },
  open_job: { get () { return this.openJob } },
  post_calendar_events: { get () { return this.postCalendarEvents } },
  post_data: { get () { return this.postData } },
@ -1936,12 +2045,15 @@ Object.defineProperties(MlApi.prototype, {
  put_job: { get () { return this.putJob } },
  put_trained_model: { get () { return this.putTrainedModel } },
  put_trained_model_alias: { get () { return this.putTrainedModelAlias } },
+  reset_job: { get () { return this.resetJob } },
  revert_model_snapshot: { get () { return this.revertModelSnapshot } },
  set_upgrade_mode: { get () { return this.setUpgradeMode } },
  start_data_frame_analytics: { get () { return this.startDataFrameAnalytics } },
  start_datafeed: { get () { return this.startDatafeed } },
+  start_trained_model_deployment: { get () { return this.startTrainedModelDeployment } },
  stop_data_frame_analytics: { get () { return this.stopDataFrameAnalytics } },
  stop_datafeed: { get () { return this.stopDatafeed } },
+  stop_trained_model_deployment: { get () { return this.stopTrainedModelDeployment } },
  update_data_frame_analytics: { get () { return this.updateDataFrameAnalytics } },
  update_datafeed: { get () { return this.updateDatafeed } },
  update_filter: { get () { return this.updateFilter } },
--- a/api/api/security.js
+++ b/api/api/security.js
@ -524,6 +524,27 @@ SecurityApi.prototype.enableUser = function securityEnableUserApi (params, optio
  return this.transport.request(request, options, callback)
 }

+SecurityApi.prototype.enrollKibana = function securityEnrollKibanaApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  let { method, body, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'GET'
+  path = '/' + '_security' + '/' + 'enroll' + '/' + 'kibana'
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: null,
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
 SecurityApi.prototype.enrollNode = function securityEnrollNodeApi (params, options, callback) {
  ;[params, options, callback] = normalizeArguments(params, options, callback)

@ -532,7 +553,7 @@ SecurityApi.prototype.enrollNode = function securityEnrollNodeApi (params, optio

  let path = ''
  if (method == null) method = 'GET'
-  path = '/' + '_security' + '/' + 'enroll_node'
+  path = '/' + '_security' + '/' + 'enroll' + '/' + 'node'

  // build request object
  const request = {
@ -1053,6 +1074,168 @@ SecurityApi.prototype.putUser = function securityPutUserApi (params, options, ca
  return this.transport.request(request, options, callback)
 }

+SecurityApi.prototype.samlAuthenticate = function securitySamlAuthenticateApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  // check required parameters
+  if (params.body == null) {
+    const err = new this[kConfigurationError]('Missing required parameter: body')
+    return handleError(err, callback)
+  }
+
+  let { method, body, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'POST'
+  path = '/' + '_security' + '/' + 'saml' + '/' + 'authenticate'
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: body || '',
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
+SecurityApi.prototype.samlCompleteLogout = function securitySamlCompleteLogoutApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  // check required parameters
+  if (params.body == null) {
+    const err = new this[kConfigurationError]('Missing required parameter: body')
+    return handleError(err, callback)
+  }
+
+  let { method, body, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'POST'
+  path = '/' + '_security' + '/' + 'saml' + '/' + 'complete_logout'
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: body || '',
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
+SecurityApi.prototype.samlInvalidate = function securitySamlInvalidateApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  // check required parameters
+  if (params.body == null) {
+    const err = new this[kConfigurationError]('Missing required parameter: body')
+    return handleError(err, callback)
+  }
+
+  let { method, body, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'POST'
+  path = '/' + '_security' + '/' + 'saml' + '/' + 'invalidate'
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: body || '',
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
+SecurityApi.prototype.samlLogout = function securitySamlLogoutApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  // check required parameters
+  if (params.body == null) {
+    const err = new this[kConfigurationError]('Missing required parameter: body')
+    return handleError(err, callback)
+  }
+
+  let { method, body, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'POST'
+  path = '/' + '_security' + '/' + 'saml' + '/' + 'logout'
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: body || '',
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
+SecurityApi.prototype.samlPrepareAuthentication = function securitySamlPrepareAuthenticationApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  // check required parameters
+  if (params.body == null) {
+    const err = new this[kConfigurationError]('Missing required parameter: body')
+    return handleError(err, callback)
+  }
+
+  let { method, body, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'POST'
+  path = '/' + '_security' + '/' + 'saml' + '/' + 'prepare'
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: body || '',
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
+SecurityApi.prototype.samlServiceProviderMetadata = function securitySamlServiceProviderMetadataApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  // check required parameters
+  if (params.realm_name == null && params.realmName == null) {
+    const err = new this[kConfigurationError]('Missing required parameter: realm_name or realmName')
+    return handleError(err, callback)
+  }
+
+  let { method, body, realmName, realm_name, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'GET'
+  path = '/' + '_security' + '/' + 'saml' + '/' + 'metadata' + '/' + encodeURIComponent(realm_name || realmName)
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: null,
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
 Object.defineProperties(SecurityApi.prototype, {
  change_password: { get () { return this.changePassword } },
  clear_api_key_cache: { get () { return this.clearApiKeyCache } },
@ -1069,6 +1252,7 @@ Object.defineProperties(SecurityApi.prototype, {
  delete_user: { get () { return this.deleteUser } },
  disable_user: { get () { return this.disableUser } },
  enable_user: { get () { return this.enableUser } },
+  enroll_kibana: { get () { return this.enrollKibana } },
  enroll_node: { get () { return this.enrollNode } },
  get_api_key: { get () { return this.getApiKey } },
  get_builtin_privileges: { get () { return this.getBuiltinPrivileges } },
@ -1087,7 +1271,13 @@ Object.defineProperties(SecurityApi.prototype, {
  put_privileges: { get () { return this.putPrivileges } },
  put_role: { get () { return this.putRole } },
  put_role_mapping: { get () { return this.putRoleMapping } },
-  put_user: { get () { return this.putUser } }
+  put_user: { get () { return this.putUser } },
+  saml_authenticate: { get () { return this.samlAuthenticate } },
+  saml_complete_logout: { get () { return this.samlCompleteLogout } },
+  saml_invalidate: { get () { return this.samlInvalidate } },
+  saml_logout: { get () { return this.samlLogout } },
+  saml_prepare_authentication: { get () { return this.samlPrepareAuthentication } },
+  saml_service_provider_metadata: { get () { return this.samlServiceProviderMetadata } }
 })

 module.exports = SecurityApi
--- a/api/api/snapshot.js
+++ b/api/api/snapshot.js
@ -23,8 +23,8 @@
 /* eslint no-unused-vars: 0 */

 const { handleError, snakeCaseKeys, normalizeArguments, kConfigurationError } = require('../utils')
-const acceptedQuerystring = ['master_timeout', 'timeout', 'pretty', 'human', 'error_trace', 'source', 'filter_path', 'wait_for_completion', 'verify', 'ignore_unavailable', 'index_details', 'verbose', 'local']
-const snakeCase = { masterTimeout: 'master_timeout', errorTrace: 'error_trace', filterPath: 'filter_path', waitForCompletion: 'wait_for_completion', ignoreUnavailable: 'ignore_unavailable', indexDetails: 'index_details' }
+const acceptedQuerystring = ['master_timeout', 'timeout', 'pretty', 'human', 'error_trace', 'source', 'filter_path', 'wait_for_completion', 'verify', 'ignore_unavailable', 'index_details', 'include_repository', 'verbose', 'local', 'blob_count', 'concurrency', 'read_node_count', 'early_read_node_count', 'seed', 'rare_action_probability', 'max_blob_size', 'max_total_data_size', 'detailed', 'rarely_abort_writes']
+const snakeCase = { masterTimeout: 'master_timeout', errorTrace: 'error_trace', filterPath: 'filter_path', waitForCompletion: 'wait_for_completion', ignoreUnavailable: 'ignore_unavailable', indexDetails: 'index_details', includeRepository: 'include_repository', blobCount: 'blob_count', readNodeCount: 'read_node_count', earlyReadNodeCount: 'early_read_node_count', rareActionProbability: 'rare_action_probability', maxBlobSize: 'max_blob_size', maxTotalDataSize: 'max_total_data_size', rarelyAbortWrites: 'rarely_abort_writes' }

 function SnapshotApi (transport, ConfigurationError) {
  this.transport = transport
@ -301,6 +301,33 @@ SnapshotApi.prototype.getRepository = function snapshotGetRepositoryApi (params,
  return this.transport.request(request, options, callback)
 }

+SnapshotApi.prototype.repositoryAnalyze = function snapshotRepositoryAnalyzeApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  // check required parameters
+  if (params.repository == null) {
+    const err = new this[kConfigurationError]('Missing required parameter: repository')
+    return handleError(err, callback)
+  }
+
+  let { method, body, repository, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'POST'
+  path = '/' + '_snapshot' + '/' + encodeURIComponent(repository) + '/' + '_analyze'
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: body || '',
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
 SnapshotApi.prototype.restore = function snapshotRestoreApi (params, options, callback) {
  ;[params, options, callback] = normalizeArguments(params, options, callback)

@ -405,6 +432,7 @@ Object.defineProperties(SnapshotApi.prototype, {
  create_repository: { get () { return this.createRepository } },
  delete_repository: { get () { return this.deleteRepository } },
  get_repository: { get () { return this.getRepository } },
+  repository_analyze: { get () { return this.repositoryAnalyze } },
  verify_repository: { get () { return this.verifyRepository } }
 })

--- a/api/api/sql.js
+++ b/api/api/sql.js
@ -23,8 +23,8 @@
 /* eslint no-unused-vars: 0 */

 const { handleError, snakeCaseKeys, normalizeArguments, kConfigurationError } = require('../utils')
-const acceptedQuerystring = ['pretty', 'human', 'error_trace', 'source', 'filter_path', 'format']
-const snakeCase = { errorTrace: 'error_trace', filterPath: 'filter_path' }
+const acceptedQuerystring = ['pretty', 'human', 'error_trace', 'source', 'filter_path', 'delimiter', 'format', 'keep_alive', 'wait_for_completion_timeout']
+const snakeCase = { errorTrace: 'error_trace', filterPath: 'filter_path', keepAlive: 'keep_alive', waitForCompletionTimeout: 'wait_for_completion_timeout' }

 function SqlApi (transport, ConfigurationError) {
  this.transport = transport
@ -58,6 +58,87 @@ SqlApi.prototype.clearCursor = function sqlClearCursorApi (params, options, call
  return this.transport.request(request, options, callback)
 }

+SqlApi.prototype.deleteAsync = function sqlDeleteAsyncApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  // check required parameters
+  if (params.id == null) {
+    const err = new this[kConfigurationError]('Missing required parameter: id')
+    return handleError(err, callback)
+  }
+
+  let { method, body, id, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'DELETE'
+  path = '/' + '_sql' + '/' + 'async' + '/' + 'delete' + '/' + encodeURIComponent(id)
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: body || '',
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
+SqlApi.prototype.getAsync = function sqlGetAsyncApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  // check required parameters
+  if (params.id == null) {
+    const err = new this[kConfigurationError]('Missing required parameter: id')
+    return handleError(err, callback)
+  }
+
+  let { method, body, id, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'GET'
+  path = '/' + '_sql' + '/' + 'async' + '/' + encodeURIComponent(id)
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: null,
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
+SqlApi.prototype.getAsyncStatus = function sqlGetAsyncStatusApi (params, options, callback) {
+  ;[params, options, callback] = normalizeArguments(params, options, callback)
+
+  // check required parameters
+  if (params.id == null) {
+    const err = new this[kConfigurationError]('Missing required parameter: id')
+    return handleError(err, callback)
+  }
+
+  let { method, body, id, ...querystring } = params
+  querystring = snakeCaseKeys(acceptedQuerystring, snakeCase, querystring)
+
+  let path = ''
+  if (method == null) method = 'GET'
+  path = '/' + '_sql' + '/' + 'async' + '/' + 'status' + '/' + encodeURIComponent(id)
+
+  // build request object
+  const request = {
+    method,
+    path,
+    body: null,
+    querystring
+  }
+
+  return this.transport.request(request, options, callback)
+}
+
 SqlApi.prototype.query = function sqlQueryApi (params, options, callback) {
  ;[params, options, callback] = normalizeArguments(params, options, callback)

@ -113,7 +194,10 @@ SqlApi.prototype.translate = function sqlTranslateApi (params, options, callback
 }

 Object.defineProperties(SqlApi.prototype, {
-  clear_cursor: { get () { return this.clearCursor } }
+  clear_cursor: { get () { return this.clearCursor } },
+  delete_async: { get () { return this.deleteAsync } },
+  get_async: { get () { return this.getAsync } },
+  get_async_status: { get () { return this.getAsyncStatus } }
 })

 module.exports = SqlApi
--- a/api/requestParams.d.ts
+++ b/api/requestParams.d.ts
@ -886,6 +886,11 @@ export interface IlmGetLifecycle extends Generic {
 export interface IlmGetStatus extends Generic {
 }

+export interface IlmMigrateToDataTiers<T = RequestBody> extends Generic {
+  dry_run?: boolean;
+  body?: T;
+}
+
 export interface IlmMoveToStep<T = RequestBody> extends Generic {
  index: string;
  body?: T;
@ -1021,6 +1026,15 @@ export interface IndicesDeleteTemplate extends Generic {
  master_timeout?: string;
 }

+export interface IndicesDiskUsage extends Generic {
+  index: string;
+  run_expensive_tasks?: boolean;
+  flush?: boolean;
+  ignore_unavailable?: boolean;
+  allow_no_indices?: boolean;
+  expand_wildcards?: 'open' | 'closed' | 'hidden' | 'none' | 'all';
+}
+
 export interface IndicesExists extends Generic {
  index: string | string[];
  local?: boolean;
@ -1063,6 +1077,14 @@ export interface IndicesExistsType extends Generic {
  local?: boolean;
 }

+export interface IndicesFieldUsageStats extends Generic {
+  index: string;
+  fields?: string | string[];
+  ignore_unavailable?: boolean;
+  allow_no_indices?: boolean;
+  expand_wildcards?: 'open' | 'closed' | 'hidden' | 'none' | 'all';
+}
+
 export interface IndicesFlush extends Generic {
  index?: string | string[];
  force?: boolean;
@ -1715,6 +1737,11 @@ export interface MlGetTrainedModelsStats extends Generic {
  size?: number;
 }

+export interface MlInferTrainedModelDeployment extends Generic {
+  model_id: string;
+  timeout?: string;
+}
+
 export interface MlInfo extends Generic {
 }

@ -1775,6 +1802,10 @@ export interface MlPutFilter<T = RequestBody> extends Generic {

 export interface MlPutJob<T = RequestBody> extends Generic {
  job_id: string;
+  ignore_unavailable?: boolean;
+  allow_no_indices?: boolean;
+  ignore_throttled?: boolean;
+  expand_wildcards?: 'open' | 'closed' | 'hidden' | 'none' | 'all';
  body: T;
 }

@ -1789,6 +1820,11 @@ export interface MlPutTrainedModelAlias extends Generic {
  reassign?: boolean;
 }

+export interface MlResetJob extends Generic {
+  job_id: string;
+  wait_for_completion?: boolean;
+}
+
 export interface MlRevertModelSnapshot<T = RequestBody> extends Generic {
  job_id: string;
  snapshot_id: string;
@ -1815,6 +1851,11 @@ export interface MlStartDatafeed<T = RequestBody> extends Generic {
  body?: T;
 }

+export interface MlStartTrainedModelDeployment extends Generic {
+  model_id: string;
+  timeout?: string;
+}
+
 export interface MlStopDataFrameAnalytics<T = RequestBody> extends Generic {
  id: string;
  allow_no_match?: boolean;
@ -1832,6 +1873,10 @@ export interface MlStopDatafeed<T = RequestBody> extends Generic {
  body?: T;
 }

+export interface MlStopTrainedModelDeployment extends Generic {
+  model_id: string;
+}
+
 export interface MlUpdateDataFrameAnalytics<T = RequestBody> extends Generic {
  id: string;
  body: T;
@ -2260,6 +2305,9 @@ export interface SecurityEnableUser extends Generic {
  refresh?: 'wait_for' | boolean;
 }

+export interface SecurityEnrollKibana extends Generic {
+}
+
 export interface SecurityEnrollNode extends Generic {
 }

@ -2349,6 +2397,30 @@ export interface SecurityPutUser<T = RequestBody> extends Generic {
  body: T;
 }

+export interface SecuritySamlAuthenticate<T = RequestBody> extends Generic {
+  body: T;
+}
+
+export interface SecuritySamlCompleteLogout<T = RequestBody> extends Generic {
+  body: T;
+}
+
+export interface SecuritySamlInvalidate<T = RequestBody> extends Generic {
+  body: T;
+}
+
+export interface SecuritySamlLogout<T = RequestBody> extends Generic {
+  body: T;
+}
+
+export interface SecuritySamlPrepareAuthentication<T = RequestBody> extends Generic {
+  body: T;
+}
+
+export interface SecuritySamlServiceProviderMetadata extends Generic {
+  realm_name: string;
+}
+
 export interface ShutdownDeleteNode extends Generic {
  node_id: string;
 }
@ -2442,6 +2514,7 @@ export interface SnapshotGet extends Generic {
  master_timeout?: string;
  ignore_unavailable?: boolean;
  index_details?: boolean;
+  include_repository?: boolean;
  verbose?: boolean;
 }

@ -2451,6 +2524,21 @@ export interface SnapshotGetRepository extends Generic {
  local?: boolean;
 }

+export interface SnapshotRepositoryAnalyze extends Generic {
+  repository: string;
+  blob_count?: number;
+  concurrency?: number;
+  read_node_count?: number;
+  early_read_node_count?: number;
+  seed?: number;
+  rare_action_probability?: number;
+  max_blob_size?: string;
+  max_total_data_size?: string;
+  timeout?: string;
+  detailed?: boolean;
+  rarely_abort_writes?: boolean;
+}
+
 export interface SnapshotRestore<T = RequestBody> extends Generic {
  repository: string;
  snapshot: string;
@ -2476,6 +2564,22 @@ export interface SqlClearCursor<T = RequestBody> extends Generic {
  body: T;
 }

+export interface SqlDeleteAsync extends Generic {
+  id: string;
+}
+
+export interface SqlGetAsync extends Generic {
+  id: string;
+  delimiter?: string;
+  format?: string;
+  keep_alive?: string;
+  wait_for_completion_timeout?: string;
+}
+
+export interface SqlGetAsyncStatus extends Generic {
+  id: string;
+}
+
 export interface SqlQuery<T = RequestBody> extends Generic {
  format?: string;
  body: T;