From ae615a0f2d20904ed21b726326ce9ee04a466bfb Mon Sep 17 00:00:00 2001 From: spalger Date: Thu, 19 May 2016 08:42:31 -0700 Subject: [PATCH] [apis] regenerate --- src/lib/apis/master.js | 251 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 251 insertions(+) diff --git a/src/lib/apis/master.js b/src/lib/apis/master.js index 17202f02e..7a58870e4 100644 --- a/src/lib/apis/master.js +++ b/src/lib/apis/master.js @@ -1661,6 +1661,257 @@ api['delete'] = ca({ method: 'DELETE' }); +/** + * Perform a [deleteByQuery](https://www.elastic.co/guide/en/elasticsearch/plugins/master/plugins-reindex.html) request + * + * @param {Object} params - An object with parameters used to carry out this action + * @param {String} params.analyzer - The analyzer to use for the query string + * @param {Boolean} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false) + * @param {String} [params.defaultOperator=OR] - The default operator for query string query (AND or OR) + * @param {String} params.df - The field to use as default where no field prefix is given in the query string + * @param {Boolean} params.explain - Specify whether to return detailed information about score computation as part of a hit + * @param {String, String[], Boolean} params.fields - A comma-separated list of fields to return as part of a hit + * @param {String, String[], Boolean} params.fielddataFields - A comma-separated list of fields to return as the field data representation of a field for each hit + * @param {Number} params.from - Starting offset (default: 0) + * @param {Boolean} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed) + * @param {Boolean} params.allowNoIndices - Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified) + * @param {String} [params.conflicts=abort] - What to do when the delete-by-query hits version conflicts? + * @param {String} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both. + * @param {Boolean} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored + * @param {Boolean} params.lowercaseExpandedTerms - Specify whether query terms should be lowercased + * @param {String} params.preference - Specify the node or shard the operation should be performed on (default: random) + * @param {String} params.q - Query in the Lucene query string syntax + * @param {String, String[], Boolean} params.routing - A comma-separated list of specific routing values + * @param {Duration} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search + * @param {String} params.searchType - Search operation type + * @param {Date, Number} params.searchTimeout - Explicit timeout for each search request. Defaults to no timeout. + * @param {Number} params.size - Number of hits to return (default: 10) + * @param {String, String[], Boolean} params.sort - A comma-separated list of : pairs + * @param {String, String[], Boolean} params._source - True or false to return the _source field or not, or a list of fields to return + * @param {String, String[], Boolean} params._sourceExclude - A list of fields to exclude from the returned _source field + * @param {String, String[], Boolean} params._sourceInclude - A list of fields to extract and return from the _source field + * @param {Number} params.terminateAfter - The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early. + * @param {String, String[], Boolean} params.stats - Specific 'tag' of the request for logging and statistical purposes + * @param {String} params.suggestField - Specify which field to use for suggestions + * @param {String} [params.suggestMode=missing] - Specify suggest mode + * @param {Number} params.suggestSize - How many suggestions to return in response + * @param {Text} params.suggestText - The source text for which the suggestions should be returned + * @param {Date, Number} [params.timeout=1m] - Time each individual bulk request should wait for shards that are unavailable. + * @param {Boolean} params.trackScores - Whether to calculate and return scores even if they are not used for sorting + * @param {Boolean} params.version - Specify whether to return document version as part of a hit + * @param {Boolean} params.requestCache - Specify if request cache should be used for this request or not, defaults to index level setting + * @param {Boolean} params.refresh - Should the effected indexes be refreshed? + * @param {String} params.consistency - Explicit write consistency setting for the operation + * @param {Integer} params.scrollSize - Size on the scroll request powering the update_by_query + * @param {Boolean} params.waitForCompletion - Should the request should block until the delete-by-query is complete. + * @param {Float} params.requestsPerSecond - The throttle for this request in sub-requests per second. 0 means set no throttle. + * @param {String, String[], Boolean} params.index - A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices + * @param {String, String[], Boolean} params.type - A comma-separated list of document types to search; leave empty to perform the operation on all types + */ +api.deleteByQuery = ca({ + params: { + analyzer: { + type: 'string' + }, + analyzeWildcard: { + type: 'boolean', + name: 'analyze_wildcard' + }, + defaultOperator: { + type: 'enum', + 'default': 'OR', + options: [ + 'AND', + 'OR' + ], + name: 'default_operator' + }, + df: { + type: 'string' + }, + explain: { + type: 'boolean' + }, + fields: { + type: 'list' + }, + fielddataFields: { + type: 'list', + name: 'fielddata_fields' + }, + from: { + type: 'number' + }, + ignoreUnavailable: { + type: 'boolean', + name: 'ignore_unavailable' + }, + allowNoIndices: { + type: 'boolean', + name: 'allow_no_indices' + }, + conflicts: { + type: 'enum', + 'default': 'abort', + options: [ + 'abort', + 'proceed' + ] + }, + expandWildcards: { + type: 'enum', + 'default': 'open', + options: [ + 'open', + 'closed', + 'none', + 'all' + ], + name: 'expand_wildcards' + }, + lenient: { + type: 'boolean' + }, + lowercaseExpandedTerms: { + type: 'boolean', + name: 'lowercase_expanded_terms' + }, + preference: { + type: 'string' + }, + q: { + type: 'string' + }, + routing: { + type: 'list' + }, + scroll: { + type: 'duration' + }, + searchType: { + type: 'enum', + options: [ + 'query_then_fetch', + 'dfs_query_then_fetch' + ], + name: 'search_type' + }, + searchTimeout: { + type: 'time', + name: 'search_timeout' + }, + size: { + type: 'number' + }, + sort: { + type: 'list' + }, + _source: { + type: 'list' + }, + _sourceExclude: { + type: 'list', + name: '_source_exclude' + }, + _sourceInclude: { + type: 'list', + name: '_source_include' + }, + terminateAfter: { + type: 'number', + name: 'terminate_after' + }, + stats: { + type: 'list' + }, + suggestField: { + type: 'string', + name: 'suggest_field' + }, + suggestMode: { + type: 'enum', + 'default': 'missing', + options: [ + 'missing', + 'popular', + 'always' + ], + name: 'suggest_mode' + }, + suggestSize: { + type: 'number', + name: 'suggest_size' + }, + suggestText: { + type: 'text', + name: 'suggest_text' + }, + timeout: { + type: 'time', + 'default': '1m' + }, + trackScores: { + type: 'boolean', + name: 'track_scores' + }, + version: { + type: 'boolean' + }, + requestCache: { + type: 'boolean', + name: 'request_cache' + }, + refresh: { + type: 'boolean' + }, + consistency: { + type: 'enum', + options: [ + 'one', + 'quorum', + 'all' + ] + }, + scrollSize: { + type: 'integer', + name: 'scroll_size' + }, + waitForCompletion: { + type: 'boolean', + 'default': false, + name: 'wait_for_completion' + }, + requestsPerSecond: { + type: 'float', + 'default': 0, + name: 'requests_per_second' + } + }, + urls: [ + { + fmt: '/<%=index%>/<%=type%>/_delete_by_query', + req: { + index: { + type: 'list' + }, + type: { + type: 'list' + } + } + }, + { + fmt: '/<%=index%>/_delete_by_query', + req: { + index: { + type: 'list' + } + } + } + ], + needBody: true, + method: 'POST' +}); + /** * Perform a [deleteScript](http://www.elastic.co/guide/en/elasticsearch/reference/master/modules-scripting.html) request *