/*!
* Copyright (c) 2018 Elasticsearch BV
* http://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/index.html
* license: Apachelicence 2.0
* version: v15.0.0
*/
;(function () {
/* prevent lodash from detecting external amd loaders */var define;
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if(typeof define === 'function' && define.amd)
define([], factory);
else if(typeof exports === 'object')
exports["elasticsearch"] = factory();
else
root["elasticsearch"] = factory();
})(typeof self !== 'undefined' ? self : this, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, {
/******/ configurable: false,
/******/ enumerable: true,
/******/ get: getter
/******/ });
/******/ }
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = 26);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(global, module) {var __WEBPACK_AMD_DEFINE_RESULT__;/**
* @license
* Lodash <https://lodash.com/>
* Copyright JS Foundation and other contributors <https://js.foundation/>
* Released under MIT license <https://lodash.com/license>
* Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
* Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
*/
;(function() {
/** Used as a safe reference for `undefined` in pre-ES5 environments. */
var undefined;
/** Used as the semantic version number. */
var VERSION = '4.17.10';
/** Used as the size to enable large array optimizations. */
var LARGE_ARRAY_SIZE = 200;
/** Error message constants. */
var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://npms.io/search?q=ponyfill.',
FUNC_ERROR_TEXT = 'Expected a function';
/** Used to stand-in for `undefined` hash values. */
var HASH_UNDEFINED = '__lodash_hash_undefined__';
/** Used as the maximum memoize cache size. */
var MAX_MEMOIZE_SIZE = 500;
/** Used as the internal argument placeholder. */
var PLACEHOLDER = '__lodash_placeholder__';
/** Used to compose bitmasks for cloning. */
var CLONE_DEEP_FLAG = 1,
CLONE_FLAT_FLAG = 2,
CLONE_SYMBOLS_FLAG = 4;
/** Used to compose bitmasks for value comparisons. */
var COMPARE_PARTIAL_FLAG = 1,
COMPARE_UNORDERED_FLAG = 2;
/** Used to compose bitmasks for function metadata. */
var WRAP_BIND_FLAG = 1,
WRAP_BIND_KEY_FLAG = 2,
WRAP_CURRY_BOUND_FLAG = 4,
WRAP_CURRY_FLAG = 8,
WRAP_CURRY_RIGHT_FLAG = 16,
WRAP_PARTIAL_FLAG = 32,
WRAP_PARTIAL_RIGHT_FLAG = 64,
WRAP_ARY_FLAG = 128,
WRAP_REARG_FLAG = 256,
WRAP_FLIP_FLAG = 512;
/** Used as default options for `_.truncate`. */
var DEFAULT_TRUNC_LENGTH = 30,
DEFAULT_TRUNC_OMISSION = '...';
/** Used to detect hot functions by number of calls within a span of milliseconds. */
var HOT_COUNT = 800,
HOT_SPAN = 16;
/** Used to indicate the type of lazy iteratees. */
var LAZY_FILTER_FLAG = 1,
LAZY_MAP_FLAG = 2,
LAZY_WHILE_FLAG = 3;
/** Used as references for various `Number` constants. */
var INFINITY = 1 / 0,
MAX_SAFE_INTEGER = 9007199254740991,
MAX_INTEGER = 1.7976931348623157e+308,
NAN = 0 / 0;
/** Used as references for the maximum length and index of an array. */
var MAX_ARRAY_LENGTH = 4294967295,
MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1,
HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;
/** Used to associate wrap methods with their bit flags. */
var wrapFlags = [
['ary', WRAP_ARY_FLAG],
['bind', WRAP_BIND_FLAG],
['bindKey', WRAP_BIND_KEY_FLAG],
['curry', WRAP_CURRY_FLAG],
['curryRight', WRAP_CURRY_RIGHT_FLAG],
['flip', WRAP_FLIP_FLAG],
['partial', WRAP_PARTIAL_FLAG],
['partialRight', WRAP_PARTIAL_RIGHT_FLAG],
['rearg', WRAP_REARG_FLAG]
];
/** `Object#toString` result references. */
var argsTag = '[object Arguments]',
arrayTag = '[object Array]',
asyncTag = '[object AsyncFunction]',
boolTag = '[object Boolean]',
dateTag = '[object Date]',
domExcTag = '[object DOMException]',
errorTag = '[object Error]',
funcTag = '[object Function]',
genTag = '[object GeneratorFunction]',
mapTag = '[object Map]',
numberTag = '[object Number]',
nullTag = '[object Null]',
objectTag = '[object Object]',
promiseTag = '[object Promise]',
proxyTag = '[object Proxy]',
regexpTag = '[object RegExp]',
setTag = '[object Set]',
stringTag = '[object String]',
symbolTag = '[object Symbol]',
undefinedTag = '[object Undefined]',
weakMapTag = '[object WeakMap]',
weakSetTag = '[object WeakSet]';
var arrayBufferTag = '[object ArrayBuffer]',
dataViewTag = '[object DataView]',
float32Tag = '[object Float32Array]',
float64Tag = '[object Float64Array]',
int8Tag = '[object Int8Array]',
int16Tag = '[object Int16Array]',
int32Tag = '[object Int32Array]',
uint8Tag = '[object Uint8Array]',
uint8ClampedTag = '[object Uint8ClampedArray]',
uint16Tag = '[object Uint16Array]',
uint32Tag = '[object Uint32Array]';
/** Used to match empty string literals in compiled template source. */
var reEmptyStringLeading = /\b__p \+= '';/g,
reEmptyStringMiddle = /\b(__p \+=) '' \+/g,
reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;
/** Used to match HTML entities and HTML characters. */
var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g,
reUnescapedHtml = /[&<>"']/g,
reHasEscapedHtml = RegExp(reEscapedHtml.source),
reHasUnescapedHtml = RegExp(reUnescapedHtml.source);
/** Used to match template delimiters. */
var reEscape = /<%-([\s\S]+?)%>/g,
reEvaluate = /<%([\s\S]+?)%>/g,
reInterpolate = /<%=([\s\S]+?)%>/g;
/** Used to match property names within property paths. */
var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
reIsPlainProp = /^\w*$/,
rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
/**
* Used to match `RegExp`
* [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
*/
var reRegExpChar = /[\\^$.*+?()[\]{}|]/g,
reHasRegExpChar = RegExp(reRegExpChar.source);
/** Used to match leading and trailing whitespace. */
var reTrim = /^\s+|\s+$/g,
reTrimStart = /^\s+/,
reTrimEnd = /\s+$/;
/** Used to match wrap detail comments. */
var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,
reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/,
reSplitDetails = /,? & /;
/** Used to match words composed of alphanumeric characters. */
var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
/** Used to match backslashes in property paths. */
var reEscapeChar = /\\(\\)?/g;
/**
* Used to match
* [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components).
*/
var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;
/** Used to match `RegExp` flags from their coerced string values. */
var reFlags = /\w*$/;
/** Used to detect bad signed hexadecimal string values. */
var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
/** Used to detect binary string values. */
var reIsBinary = /^0b[01]+$/i;
/** Used to detect host constructors (Safari). */
var reIsHostCtor = /^\[object .+?Constructor\]$/;
/** Used to detect octal string values. */
var reIsOctal = /^0o[0-7]+$/i;
/** Used to detect unsigned integer values. */
var reIsUint = /^(?:0|[1-9]\d*)$/;
/** Used to match Latin Unicode letters (excluding mathematical operators). */
var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
/** Used to ensure capturing order of template delimiters. */
var reNoMatch = /($^)/;
/** Used to match unescaped characters in compiled string literals. */
var reUnescapedString = /['\n\r\u2028\u2029\\]/g;
/** Used to compose unicode character classes. */
var rsAstralRange = '\\ud800-\\udfff',
rsComboMarksRange = '\\u0300-\\u036f',
reComboHalfMarksRange = '\\ufe20-\\ufe2f',
rsComboSymbolsRange = '\\u20d0-\\u20ff',
rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,
rsDingbatRange = '\\u2700-\\u27bf',
rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff',
rsMathOpRange = '\\xac\\xb1\\xd7\\xf7',
rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf',
rsPunctuationRange = '\\u2000-\\u206f',
rsSpaceRange = ' \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000',
rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde',
rsVarRange = '\\ufe0e\\ufe0f',
rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
/** Used to compose unicode capture groups. */
var rsApos = "['\u2019]",
rsAstral = '[' + rsAstralRange + ']',
rsBreak = '[' + rsBreakRange + ']',
rsCombo = '[' + rsComboRange + ']',
rsDigits = '\\d+',
rsDingbat = '[' + rsDingbatRange + ']',
rsLower = '[' + rsLowerRange + ']',
rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',
rsFitz = '\\ud83c[\\udffb-\\udfff]',
rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',
rsNonAstral = '[^' + rsAstralRange + ']',
rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}',
rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]',
rsUpper = '[' + rsUpperRange + ']',
rsZWJ = '\\u200d';
/** Used to compose unicode regexes. */
var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')',
rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')',
rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?',
rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?',
reOptMod = rsModifier + '?',
rsOptVar = '[' + rsVarRange + ']?',
rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',
rsOrdLower = '\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])',
rsOrdUpper = '\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])',
rsSeq = rsOptVar + reOptMod + rsOptJoin,
rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq,
rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';
/** Used to match apostrophes. */
var reApos = RegExp(rsApos, 'g');
/**
* Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and
* [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).
*/
var reComboMark = RegExp(rsCombo, 'g');
/** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');
/** Used to match complex or compound words. */
var reUnicodeWord = RegExp([
rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',
rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')',
rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower,
rsUpper + '+' + rsOptContrUpper,
rsOrdUpper,
rsOrdLower,
rsDigits,
rsEmoji
].join('|'), 'g');
/** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */
var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + ']');
/** Used to detect strings that need a more robust regexp to match words. */
var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2,}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
/** Used to assign default `context` object properties. */
var contextProps = [
'Array', 'Buffer', 'DataView', 'Date', 'Error', 'Float32Array', 'Float64Array',
'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Map', 'Math', 'Object',
'Promise', 'RegExp', 'Set', 'String', 'Symbol', 'TypeError', 'Uint8Array',
'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap',
'_', 'clearTimeout', 'isFinite', 'parseInt', 'setTimeout'
];
/** Used to make template sourceURLs easier to identify. */
var templateCounter = -1;
/** Used to identify `toStringTag` values of typed arrays. */
var typedArrayTags = {};
typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
typedArrayTags[uint32Tag] = true;
typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
typedArrayTags[errorTag] = typedArrayTags[funcTag] =
typedArrayTags[mapTag] = typedArrayTags[numberTag] =
typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
typedArrayTags[setTag] = typedArrayTags[stringTag] =
typedArrayTags[weakMapTag] = false;
/** Used to identify `toStringTag` values supported by `_.clone`. */
var cloneableTags = {};
cloneableTags[argsTag] = cloneableTags[arrayTag] =
cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =
cloneableTags[boolTag] = cloneableTags[dateTag] =
cloneableTags[float32Tag] = cloneableTags[float64Tag] =
cloneableTags[int8Tag] = cloneableTags[int16Tag] =
cloneableTags[int32Tag] = cloneableTags[mapTag] =
cloneableTags[numberTag] = cloneableTags[objectTag] =
cloneableTags[regexpTag] = cloneableTags[setTag] =
cloneableTags[stringTag] = cloneableTags[symbolTag] =
cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
cloneableTags[errorTag] = cloneableTags[funcTag] =
cloneableTags[weakMapTag] = false;
/** Used to map Latin Unicode letters to basic Latin letters. */
var deburredLetters = {
// Latin-1 Supplement block.
'\xc0': 'A', '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A',
'\xe0': 'a', '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a',
'\xc7': 'C', '\xe7': 'c',
'\xd0': 'D', '\xf0': 'd',
'\xc8': 'E', '\xc9': 'E', '\xca': 'E', '\xcb': 'E',
'\xe8': 'e', '\xe9': 'e', '\xea': 'e', '\xeb': 'e',
'\xcc': 'I', '\xcd': 'I', '\xce': 'I', '\xcf': 'I',
'\xec': 'i', '\xed': 'i', '\xee': 'i', '\xef': 'i',
'\xd1': 'N', '\xf1': 'n',
'\xd2': 'O', '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O',
'\xf2': 'o', '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o',
'\xd9': 'U', '\xda': 'U', '\xdb': 'U', '\xdc': 'U',
'\xf9': 'u', '\xfa': 'u', '\xfb': 'u', '\xfc': 'u',
'\xdd': 'Y', '\xfd': 'y', '\xff': 'y',
'\xc6': 'Ae', '\xe6': 'ae',
'\xde': 'Th', '\xfe': 'th',
'\xdf': 'ss',
// Latin Extended-A block.
'\u0100': 'A', '\u0102': 'A', '\u0104': 'A',
'\u0101': 'a', '\u0103': 'a', '\u0105': 'a',
'\u0106': 'C', '\u0108': 'C', '\u010a': 'C', '\u010c': 'C',
'\u0107': 'c', '\u0109': 'c', '\u010b': 'c', '\u010d': 'c',
'\u010e': 'D', '\u0110': 'D', '\u010f': 'd', '\u0111': 'd',
'\u0112': 'E', '\u0114': 'E', '\u0116': 'E', '\u0118': 'E', '\u011a': 'E',
'\u0113': 'e', '\u0115': 'e', '\u0117': 'e', '\u0119': 'e', '\u011b': 'e',
'\u011c': 'G', '\u011e': 'G', '\u0120': 'G', '\u0122': 'G',
'\u011d': 'g', '\u011f': 'g', '\u0121': 'g', '\u0123': 'g',
'\u0124': 'H', '\u0126': 'H', '\u0125': 'h', '\u0127': 'h',
'\u0128': 'I', '\u012a': 'I', '\u012c': 'I', '\u012e': 'I', '\u0130': 'I',
'\u0129': 'i', '\u012b': 'i', '\u012d': 'i', '\u012f': 'i', '\u0131': 'i',
'\u0134': 'J', '\u0135': 'j',
'\u0136': 'K', '\u0137': 'k', '\u0138': 'k',
'\u0139': 'L', '\u013b': 'L', '\u013d': 'L', '\u013f': 'L', '\u0141': 'L',
'\u013a': 'l', '\u013c': 'l', '\u013e': 'l', '\u0140': 'l', '\u0142': 'l',
'\u0143': 'N', '\u0145': 'N', '\u0147': 'N', '\u014a': 'N',
'\u0144': 'n', '\u0146': 'n', '\u0148': 'n', '\u014b': 'n',
'\u014c': 'O', '\u014e': 'O', '\u0150': 'O',
'\u014d': 'o', '\u014f': 'o', '\u0151': 'o',
'\u0154': 'R', '\u0156': 'R', '\u0158': 'R',
'\u0155': 'r', '\u0157': 'r', '\u0159': 'r',
'\u015a': 'S', '\u015c': 'S', '\u015e': 'S', '\u0160': 'S',
'\u015b': 's', '\u015d': 's', '\u015f': 's', '\u0161': 's',
'\u0162': 'T', '\u0164': 'T', '\u0166': 'T',
'\u0163': 't', '\u0165': 't', '\u0167': 't',
'\u0168': 'U', '\u016a': 'U', '\u016c': 'U', '\u016e': 'U', '\u0170': 'U', '\u0172': 'U',
'\u0169': 'u', '\u016b': 'u', '\u016d': 'u', '\u016f': 'u', '\u0171': 'u', '\u0173': 'u',
'\u0174': 'W', '\u0175': 'w',
'\u0176': 'Y', '\u0177': 'y', '\u0178': 'Y',
'\u0179': 'Z', '\u017b': 'Z', '\u017d': 'Z',
'\u017a': 'z', '\u017c': 'z', '\u017e': 'z',
'\u0132': 'IJ', '\u0133': 'ij',
'\u0152': 'Oe', '\u0153': 'oe',
'\u0149': "'n", '\u017f': 's'
};
/** Used to map characters to HTML entities. */
var htmlEscapes = {
'&': '&',
'<': '<',
'>': '>',
'"': '"',
"'": '''
};
/** Used to map HTML entities to characters. */
var htmlUnescapes = {
'&': '&',
'<': '<',
'>': '>',
'"': '"',
''': "'"
};
/** Used to escape characters for inclusion in compiled string literals. */
var stringEscapes = {
'\\': '\\',
"'": "'",
'\n': 'n',
'\r': 'r',
'\u2028': 'u2028',
'\u2029': 'u2029'
};
/** Built-in method references without a dependency on `root`. */
var freeParseFloat = parseFloat,
freeParseInt = parseInt;
/** Detect free variable `global` from Node.js. */
var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
/** Detect free variable `self`. */
var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
/** Used as a reference to the global object. */
var root = freeGlobal || freeSelf || Function('return this')();
/** Detect free variable `exports`. */
var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
/** Detect free variable `module`. */
var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
/** Detect the popular CommonJS extension `module.exports`. */
var moduleExports = freeModule && freeModule.exports === freeExports;
/** Detect free variable `process` from Node.js. */
var freeProcess = moduleExports && freeGlobal.process;
/** Used to access faster Node.js helpers. */
var nodeUtil = (function() {
try {
// Use `util.types` for Node.js 10+.
var types = freeModule && freeModule.require && freeModule.require('util').types;
if (types) {
return types;
}
// Legacy `process.binding('util')` for Node.js < 10.
return freeProcess && freeProcess.binding && freeProcess.binding('util');
} catch (e) {}
}());
/* Node.js helper references. */
var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer,
nodeIsDate = nodeUtil && nodeUtil.isDate,
nodeIsMap = nodeUtil && nodeUtil.isMap,
nodeIsRegExp = nodeUtil && nodeUtil.isRegExp,
nodeIsSet = nodeUtil && nodeUtil.isSet,
nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
/*--------------------------------------------------------------------------*/
/**
* A faster alternative to `Function#apply`, this function invokes `func`
* with the `this` binding of `thisArg` and the arguments of `args`.
*
* @private
* @param {Function} func The function to invoke.
* @param {*} thisArg The `this` binding of `func`.
* @param {Array} args The arguments to invoke `func` with.
* @returns {*} Returns the result of `func`.
*/
function apply(func, thisArg, args) {
switch (args.length) {
case 0: return func.call(thisArg);
case 1: return func.call(thisArg, args[0]);
case 2: return func.call(thisArg, args[0], args[1]);
case 3: return func.call(thisArg, args[0], args[1], args[2]);
}
return func.apply(thisArg, args);
}
/**
* A specialized version of `baseAggregator` for arrays.
*
* @private
* @param {Array} [array] The array to iterate over.
* @param {Function} setter The function to set `accumulator` values.
* @param {Function} iteratee The iteratee to transform keys.
* @param {Object} accumulator The initial aggregated object.
* @returns {Function} Returns `accumulator`.
*/
function arrayAggregator(array, setter, iteratee, accumulator) {
var index = -1,
length = array == null ? 0 : array.length;
while (++index < length) {
var value = array[index];
setter(accumulator, value, iteratee(value), array);
}
return accumulator;
}
/**
* A specialized version of `_.forEach` for arrays without support for
* iteratee shorthands.
*
* @private
* @param {Array} [array] The array to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @returns {Array} Returns `array`.
*/
function arrayEach(array, iteratee) {
var index = -1,
length = array == null ? 0 : array.length;
while (++index < length) {
if (iteratee(array[index], index, array) === false) {
break;
}
}
return array;
}
/**
* A specialized version of `_.forEachRight` for arrays without support for
* iteratee shorthands.
*
* @private
* @param {Array} [array] The array to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @returns {Array} Returns `array`.
*/
function arrayEachRight(array, iteratee) {
var length = array == null ? 0 : array.length;
while (length--) {
if (iteratee(array[length], length, array) === false) {
break;
}
}
return array;
}
/**
* A specialized version of `_.every` for arrays without support for
* iteratee shorthands.
*
* @private
* @param {Array} [array] The array to iterate over.
* @param {Function} predicate The function invoked per iteration.
* @returns {boolean} Returns `true` if all elements pass the predicate check,
* else `false`.
*/
function arrayEvery(array, predicate) {
var index = -1,
length = array == null ? 0 : array.length;
while (++index < length) {
if (!predicate(array[index], index, array)) {
return false;
}
}
return true;
}
/**
* A specialized version of `_.filter` for arrays without support for
* iteratee shorthands.
*
* @private
* @param {Array} [array] The array to iterate over.
* @param {Function} predicate The function invoked per iteration.
* @returns {Array} Returns the new filtered array.
*/
function arrayFilter(array, predicate) {
var index = -1,
length = array == null ? 0 : array.length,
resIndex = 0,
result = [];
while (++index < length) {
var value = array[index];
if (predicate(value, index, array)) {
result[resIndex++] = value;
}
}
return result;
}
/**
* A specialized version of `_.includes` for arrays without support for
* specifying an index to search from.
*
* @private
* @param {Array} [array] The array to inspect.
* @param {*} target The value to search for.
* @returns {boolean} Returns `true` if `target` is found, else `false`.
*/
function arrayIncludes(array, value) {
var length = array == null ? 0 : array.length;
return !!length && baseIndexOf(array, value, 0) > -1;
}
/**
* This function is like `arrayIncludes` except that it accepts a comparator.
*
* @private
* @param {Array} [array] The array to inspect.
* @param {*} target The value to search for.
* @param {Function} comparator The comparator invoked per element.
* @returns {boolean} Returns `true` if `target` is found, else `false`.
*/
function arrayIncludesWith(array, value, comparator) {
var index = -1,
length = array == null ? 0 : array.length;
while (++index < length) {
if (comparator(value, array[index])) {
return true;
}
}
return false;
}
/**
* A specialized version of `_.map` for arrays without support for iteratee
* shorthands.
*
* @private
* @param {Array} [array] The array to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @returns {Array} Returns the new mapped array.
*/
function arrayMap(array, iteratee) {
var index = -1,
length = array == null ? 0 : array.length,
result = Array(length);
while (++index < length) {
result[index] = iteratee(array[index], index, array);
}
return result;
}
/**
* Appends the elements of `values` to `array`.
*
* @private
* @param {Array} array The array to modify.
* @param {Array} values The values to append.
* @returns {Array} Returns `array`.
*/
function arrayPush(array, values) {
var index = -1,
length = values.length,
offset = array.length;
while (++index < length) {
array[offset + index] = values[index];
}
return array;
}
/**
* A specialized version of `_.reduce` for arrays without support for
* iteratee shorthands.
*
* @private
* @param {Array} [array] The array to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @param {*} [accumulator] The initial value.
* @param {boolean} [initAccum] Specify using the first element of `array` as
* the initial value.
* @returns {*} Returns the accumulated value.
*/
function arrayReduce(array, iteratee, accumulator, initAccum) {
var index = -1,
length = array == null ? 0 : array.length;
if (initAccum && length) {
accumulator = array[++index];
}
while (++index < length) {
accumulator = iteratee(accumulator, array[index], index, array);
}
return accumulator;
}
/**
* A specialized version of `_.reduceRight` for arrays without support for
* iteratee shorthands.
*
* @private
* @param {Array} [array] The array to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @param {*} [accumulator] The initial value.
* @param {boolean} [initAccum] Specify using the last element of `array` as
* the initial value.
* @returns {*} Returns the accumulated value.
*/
function arrayReduceRight(array, iteratee, accumulator, initAccum) {
var length = array == null ? 0 : array.length;
if (initAccum && length) {
accumulator = array[--length];
}
while (length--) {
accumulator = iteratee(accumulator, array[length], length, array);
}
return accumulator;
}
/**
* A specialized version of `_.some` for arrays without support for iteratee
* shorthands.
*
* @private
* @param {Array} [array] The array to iterate over.
* @param {Function} predicate The function invoked per iteration.
* @returns {boolean} Returns `true` if any element passes the predicate check,
* else `false`.
*/
function arraySome(array, predicate) {
var index = -1,
length = array == null ? 0 : array.length;
while (++index < length) {
if (predicate(array[index], index, array)) {
return true;
}
}
return false;
}
/**
* Gets the size of an ASCII `string`.
*
* @private
* @param {string} string The string inspect.
* @returns {number} Returns the string size.
*/
var asciiSize = baseProperty('length');
/**
* Converts an ASCII `string` to an array.
*
* @private
* @param {string} string The string to convert.
* @returns {Array} Returns the converted array.
*/
function asciiToArray(string) {
return string.split('');
}
/**
* Splits an ASCII `string` into an array of its words.
*
* @private
* @param {string} The string to inspect.
* @returns {Array} Returns the words of `string`.
*/
function asciiWords(string) {
return string.match(reAsciiWord) || [];
}
/**
* The base implementation of methods like `_.findKey` and `_.findLastKey`,
* without support for iteratee shorthands, which iterates over `collection`
* using `eachFunc`.
*
* @private
* @param {Array|Object} collection The collection to inspect.
* @param {Function} predicate The function invoked per iteration.
* @param {Function} eachFunc The function to iterate over `collection`.
* @returns {*} Returns the found element or its key, else `undefined`.
*/
function baseFindKey(collection, predicate, eachFunc) {
var result;
eachFunc(collection, function(value, key, collection) {
if (predicate(value, key, collection)) {
result = key;
return false;
}
});
return result;
}
/**
* The base implementation of `_.findIndex` and `_.findLastIndex` without
* support for iteratee shorthands.
*
* @private
* @param {Array} array The array to inspect.
* @param {Function} predicate The function invoked per iteration.
* @param {number} fromIndex The index to search from.
* @param {boolean} [fromRight] Specify iterating from right to left.
* @returns {number} Returns the index of the matched value, else `-1`.
*/
function baseFindIndex(array, predicate, fromIndex, fromRight) {
var length = array.length,
index = fromIndex + (fromRight ? 1 : -1);
while ((fromRight ? index-- : ++index < length)) {
if (predicate(array[index], index, array)) {
return index;
}
}
return -1;
}
/**
* The base implementation of `_.indexOf` without `fromIndex` bounds checks.
*
* @private
* @param {Array} array The array to inspect.
* @param {*} value The value to search for.
* @param {number} fromIndex The index to search from.
* @returns {number} Returns the index of the matched value, else `-1`.
*/
function baseIndexOf(array, value, fromIndex) {
return value === value
? strictIndexOf(array, value, fromIndex)
: baseFindIndex(array, baseIsNaN, fromIndex);
}
/**
* This function is like `baseIndexOf` except that it accepts a comparator.
*
* @private
* @param {Array} array The array to inspect.
* @param {*} value The value to search for.
* @param {number} fromIndex The index to search from.
* @param {Function} comparator The comparator invoked per element.
* @returns {number} Returns the index of the matched value, else `-1`.
*/
function baseIndexOfWith(array, value, fromIndex, comparator) {
var index = fromIndex - 1,
length = array.length;
while (++index < length) {
if (comparator(array[index], value)) {
return index;
}
}
return -1;
}
/**
* The base implementation of `_.isNaN` without support for number objects.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
*/
function baseIsNaN(value) {
return value !== value;
}
/**
* The base implementation of `_.mean` and `_.meanBy` without support for
* iteratee shorthands.
*
* @private
* @param {Array} array The array to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @returns {number} Returns the mean.
*/
function baseMean(array, iteratee) {
var length = array == null ? 0 : array.length;
return length ? (baseSum(array, iteratee) / length) : NAN;
}
/**
* The base implementation of `_.property` without support for deep paths.
*
* @private
* @param {string} key The key of the property to get.
* @returns {Function} Returns the new accessor function.
*/
function baseProperty(key) {
return function(object) {
return object == null ? undefined : object[key];
};
}
/**
* The base implementation of `_.propertyOf` without support for deep paths.
*
* @private
* @param {Object} object The object to query.
* @returns {Function} Returns the new accessor function.
*/
function basePropertyOf(object) {
return function(key) {
return object == null ? undefined : object[key];
};
}
/**
* The base implementation of `_.reduce` and `_.reduceRight`, without support
* for iteratee shorthands, which iterates over `collection` using `eachFunc`.
*
* @private
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @param {*} accumulator The initial value.
* @param {boolean} initAccum Specify using the first or last element of
* `collection` as the initial value.
* @param {Function} eachFunc The function to iterate over `collection`.
* @returns {*} Returns the accumulated value.
*/
function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
eachFunc(collection, function(value, index, collection) {
accumulator = initAccum
? (initAccum = false, value)
: iteratee(accumulator, value, index, collection);
});
return accumulator;
}
/**
* The base implementation of `_.sortBy` which uses `comparer` to define the
* sort order of `array` and replaces criteria objects with their corresponding
* values.
*
* @private
* @param {Array} array The array to sort.
* @param {Function} comparer The function to define sort order.
* @returns {Array} Returns `array`.
*/
function baseSortBy(array, comparer) {
var length = array.length;
array.sort(comparer);
while (length--) {
array[length] = array[length].value;
}
return array;
}
/**
* The base implementation of `_.sum` and `_.sumBy` without support for
* iteratee shorthands.
*
* @private
* @param {Array} array The array to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @returns {number} Returns the sum.
*/
function baseSum(array, iteratee) {
var result,
index = -1,
length = array.length;
while (++index < length) {
var current = iteratee(array[index]);
if (current !== undefined) {
result = result === undefined ? current : (result + current);
}
}
return result;
}
/**
* The base implementation of `_.times` without support for iteratee shorthands
* or max array length checks.
*
* @private
* @param {number} n The number of times to invoke `iteratee`.
* @param {Function} iteratee The function invoked per iteration.
* @returns {Array} Returns the array of results.
*/
function baseTimes(n, iteratee) {
var index = -1,
result = Array(n);
while (++index < n) {
result[index] = iteratee(index);
}
return result;
}
/**
* The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array
* of key-value pairs for `object` corresponding to the property names of `props`.
*
* @private
* @param {Object} object The object to query.
* @param {Array} props The property names to get values for.
* @returns {Object} Returns the key-value pairs.
*/
function baseToPairs(object, props) {
return arrayMap(props, function(key) {
return [key, object[key]];
});
}
/**
* The base implementation of `_.unary` without support for storing metadata.
*
* @private
* @param {Function} func The function to cap arguments for.
* @returns {Function} Returns the new capped function.
*/
function baseUnary(func) {
return function(value) {
return func(value);
};
}
/**
* The base implementation of `_.values` and `_.valuesIn` which creates an
* array of `object` property values corresponding to the property names
* of `props`.
*
* @private
* @param {Object} object The object to query.
* @param {Array} props The property names to get values for.
* @returns {Object} Returns the array of property values.
*/
function baseValues(object, props) {
return arrayMap(props, function(key) {
return object[key];
});
}
/**
* Checks if a `cache` value for `key` exists.
*
* @private
* @param {Object} cache The cache to query.
* @param {string} key The key of the entry to check.
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
*/
function cacheHas(cache, key) {
return cache.has(key);
}
/**
* Used by `_.trim` and `_.trimStart` to get the index of the first string symbol
* that is not found in the character symbols.
*
* @private
* @param {Array} strSymbols The string symbols to inspect.
* @param {Array} chrSymbols The character symbols to find.
* @returns {number} Returns the index of the first unmatched string symbol.
*/
function charsStartIndex(strSymbols, chrSymbols) {
var index = -1,
length = strSymbols.length;
while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}
return index;
}
/**
* Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol
* that is not found in the character symbols.
*
* @private
* @param {Array} strSymbols The string symbols to inspect.
* @param {Array} chrSymbols The character symbols to find.
* @returns {number} Returns the index of the last unmatched string symbol.
*/
function charsEndIndex(strSymbols, chrSymbols) {
var index = strSymbols.length;
while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}
return index;
}
/**
* Gets the number of `placeholder` occurrences in `array`.
*
* @private
* @param {Array} array The array to inspect.
* @param {*} placeholder The placeholder to search for.
* @returns {number} Returns the placeholder count.
*/
function countHolders(array, placeholder) {
var length = array.length,
result = 0;
while (length--) {
if (array[length] === placeholder) {
++result;
}
}
return result;
}
/**
* Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A
* letters to basic Latin letters.
*
* @private
* @param {string} letter The matched letter to deburr.
* @returns {string} Returns the deburred letter.
*/
var deburrLetter = basePropertyOf(deburredLetters);
/**
* Used by `_.escape` to convert characters to HTML entities.
*
* @private
* @param {string} chr The matched character to escape.
* @returns {string} Returns the escaped character.
*/
var escapeHtmlChar = basePropertyOf(htmlEscapes);
/**
* Used by `_.template` to escape characters for inclusion in compiled string literals.
*
* @private
* @param {string} chr The matched character to escape.
* @returns {string} Returns the escaped character.
*/
function escapeStringChar(chr) {
return '\\' + stringEscapes[chr];
}
/**
* Gets the value at `key` of `object`.
*
* @private
* @param {Object} [object] The object to query.
* @param {string} key The key of the property to get.
* @returns {*} Returns the property value.
*/
function getValue(object, key) {
return object == null ? undefined : object[key];
}
/**
* Checks if `string` contains Unicode symbols.
*
* @private
* @param {string} string The string to inspect.
* @returns {boolean} Returns `true` if a symbol is found, else `false`.
*/
function hasUnicode(string) {
return reHasUnicode.test(string);
}
/**
* Checks if `string` contains a word composed of Unicode symbols.
*
* @private
* @param {string} string The string to inspect.
* @returns {boolean} Returns `true` if a word is found, else `false`.
*/
function hasUnicodeWord(string) {
return reHasUnicodeWord.test(string);
}
/**
* Converts `iterator` to an array.
*
* @private
* @param {Object} iterator The iterator to convert.
* @returns {Array} Returns the converted array.
*/
function iteratorToArray(iterator) {
var data,
result = [];
while (!(data = iterator.next()).done) {
result.push(data.value);
}
return result;
}
/**
* Converts `map` to its key-value pairs.
*
* @private
* @param {Object} map The map to convert.
* @returns {Array} Returns the key-value pairs.
*/
function mapToArray(map) {
var index = -1,
result = Array(map.size);
map.forEach(function(value, key) {
result[++index] = [key, value];
});
return result;
}
/**
* Creates a unary function that invokes `func` with its argument transformed.
*
* @private
* @param {Function} func The function to wrap.
* @param {Function} transform The argument transform.
* @returns {Function} Returns the new function.
*/
function overArg(func, transform) {
return function(arg) {
return func(transform(arg));
};
}
/**
* Replaces all `placeholder` elements in `array` with an internal placeholder
* and returns an array of their indexes.
*
* @private
* @param {Array} array The array to modify.
* @param {*} placeholder The placeholder to replace.
* @returns {Array} Returns the new array of placeholder indexes.
*/
function replaceHolders(array, placeholder) {
var index = -1,
length = array.length,
resIndex = 0,
result = [];
while (++index < length) {
var value = array[index];
if (value === placeholder || value === PLACEHOLDER) {
array[index] = PLACEHOLDER;
result[resIndex++] = index;
}
}
return result;
}
/**
* Gets the value at `key`, unless `key` is "__proto__".
*
* @private
* @param {Object} object The object to query.
* @param {string} key The key of the property to get.
* @returns {*} Returns the property value.
*/
function safeGet(object, key) {
return key == '__proto__'
? undefined
: object[key];
}
/**
* Converts `set` to an array of its values.
*
* @private
* @param {Object} set The set to convert.
* @returns {Array} Returns the values.
*/
function setToArray(set) {
var index = -1,
result = Array(set.size);
set.forEach(function(value) {
result[++index] = value;
});
return result;
}
/**
* Converts `set` to its value-value pairs.
*
* @private
* @param {Object} set The set to convert.
* @returns {Array} Returns the value-value pairs.
*/
function setToPairs(set) {
var index = -1,
result = Array(set.size);
set.forEach(function(value) {
result[++index] = [value, value];
});
return result;
}
/**
* A specialized version of `_.indexOf` which performs strict equality
* comparisons of values, i.e. `===`.
*
* @private
* @param {Array} array The array to inspect.
* @param {*} value The value to search for.
* @param {number} fromIndex The index to search from.
* @returns {number} Returns the index of the matched value, else `-1`.
*/
function strictIndexOf(array, value, fromIndex) {
var index = fromIndex - 1,
length = array.length;
while (++index < length) {
if (array[index] === value) {
return index;
}
}
return -1;
}
/**
* A specialized version of `_.lastIndexOf` which performs strict equality
* comparisons of values, i.e. `===`.
*
* @private
* @param {Array} array The array to inspect.
* @param {*} value The value to search for.
* @param {number} fromIndex The index to search from.
* @returns {number} Returns the index of the matched value, else `-1`.
*/
function strictLastIndexOf(array, value, fromIndex) {
var index = fromIndex + 1;
while (index--) {
if (array[index] === value) {
return index;
}
}
return index;
}
/**
* Gets the number of symbols in `string`.
*
* @private
* @param {string} string The string to inspect.
* @returns {number} Returns the string size.
*/
function stringSize(string) {
return hasUnicode(string)
? unicodeSize(string)
: asciiSize(string);
}
/**
* Converts `string` to an array.
*
* @private
* @param {string} string The string to convert.
* @returns {Array} Returns the converted array.
*/
function stringToArray(string) {
return hasUnicode(string)
? unicodeToArray(string)
: asciiToArray(string);
}
/**
* Used by `_.unescape` to convert HTML entities to characters.
*
* @private
* @param {string} chr The matched character to unescape.
* @returns {string} Returns the unescaped character.
*/
var unescapeHtmlChar = basePropertyOf(htmlUnescapes);
/**
* Gets the size of a Unicode `string`.
*
* @private
* @param {string} string The string inspect.
* @returns {number} Returns the string size.
*/
function unicodeSize(string) {
var result = reUnicode.lastIndex = 0;
while (reUnicode.test(string)) {
++result;
}
return result;
}
/**
* Converts a Unicode `string` to an array.
*
* @private
* @param {string} string The string to convert.
* @returns {Array} Returns the converted array.
*/
function unicodeToArray(string) {
return string.match(reUnicode) || [];
}
/**
* Splits a Unicode `string` into an array of its words.
*
* @private
* @param {string} The string to inspect.
* @returns {Array} Returns the words of `string`.
*/
function unicodeWords(string) {
return string.match(reUnicodeWord) || [];
}
/*--------------------------------------------------------------------------*/
/**
* Create a new pristine `lodash` function using the `context` object.
*
* @static
* @memberOf _
* @since 1.1.0
* @category Util
* @param {Object} [context=root] The context object.
* @returns {Function} Returns a new `lodash` function.
* @example
*
* _.mixin({ 'foo': _.constant('foo') });
*
* var lodash = _.runInContext();
* lodash.mixin({ 'bar': lodash.constant('bar') });
*
* _.isFunction(_.foo);
* // => true
* _.isFunction(_.bar);
* // => false
*
* lodash.isFunction(lodash.foo);
* // => false
* lodash.isFunction(lodash.bar);
* // => true
*
* // Create a suped-up `defer` in Node.js.
* var defer = _.runInContext({ 'setTimeout': setImmediate }).defer;
*/
var runInContext = (function runInContext(context) {
context = context == null ? root : _.defaults(root.Object(), context, _.pick(root, contextProps));
/** Built-in constructor references. */
var Array = context.Array,
Date = context.Date,
Error = context.Error,
Function = context.Function,
Math = context.Math,
Object = context.Object,
RegExp = context.RegExp,
String = context.String,
TypeError = context.TypeError;
/** Used for built-in method references. */
var arrayProto = Array.prototype,
funcProto = Function.prototype,
objectProto = Object.prototype;
/** Used to detect overreaching core-js shims. */
var coreJsData = context['__core-js_shared__'];
/** Used to resolve the decompiled source of functions. */
var funcToString = funcProto.toString;
/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;
/** Used to generate unique IDs. */
var idCounter = 0;
/** Used to detect methods masquerading as native. */
var maskSrcKey = (function() {
var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
return uid ? ('Symbol(src)_1.' + uid) : '';
}());
/**
* Used to resolve the
* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
* of values.
*/
var nativeObjectToString = objectProto.toString;
/** Used to infer the `Object` constructor. */
var objectCtorString = funcToString.call(Object);
/** Used to restore the original `_` reference in `_.noConflict`. */
var oldDash = root._;
/** Used to detect if a method is native. */
var reIsNative = RegExp('^' +
funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
.replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
);
/** Built-in value references. */
var Buffer = moduleExports ? context.Buffer : undefined,
Symbol = context.Symbol,
Uint8Array = context.Uint8Array,
allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined,
getPrototype = overArg(Object.getPrototypeOf, Object),
objectCreate = Object.create,
propertyIsEnumerable = objectProto.propertyIsEnumerable,
splice = arrayProto.splice,
spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined,
symIterator = Symbol ? Symbol.iterator : undefined,
symToStringTag = Symbol ? Symbol.toStringTag : undefined;
var defineProperty = (function() {
try {
var func = getNative(Object, 'defineProperty');
func({}, '', {});
return func;
} catch (e) {}
}());
/** Mocked built-ins. */
var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout,
ctxNow = Date && Date.now !== root.Date.now && Date.now,
ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout;
/* Built-in method references for those with the same name as other `lodash` methods. */
var nativeCeil = Math.ceil,
nativeFloor = Math.floor,
nativeGetSymbols = Object.getOwnPropertySymbols,
nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,
nativeIsFinite = context.isFinite,
nativeJoin = arrayProto.join,
nativeKeys = overArg(Object.keys, Object),
nativeMax = Math.max,
nativeMin = Math.min,
nativeNow = Date.now,
nativeParseInt = context.parseInt,
nativeRandom = Math.random,
nativeReverse = arrayProto.reverse;
/* Built-in method references that are verified to be native. */
var DataView = getNative(context, 'DataView'),
Map = getNative(context, 'Map'),
Promise = getNative(context, 'Promise'),
Set = getNative(context, 'Set'),
WeakMap = getNative(context, 'WeakMap'),
nativeCreate = getNative(Object, 'create');
/** Used to store function metadata. */
var metaMap = WeakMap && new WeakMap;
/** Used to lookup unminified function names. */
var realNames = {};
/** Used to detect maps, sets, and weakmaps. */
var dataViewCtorString = toSource(DataView),
mapCtorString = toSource(Map),
promiseCtorString = toSource(Promise),
setCtorString = toSource(Set),
weakMapCtorString = toSource(WeakMap);
/** Used to convert symbols to primitives and strings. */
var symbolProto = Symbol ? Symbol.prototype : undefined,
symbolValueOf = symbolProto ? symbolProto.valueOf : undefined,
symbolToString = symbolProto ? symbolProto.toString : undefined;
/*------------------------------------------------------------------------*/
/**
* Creates a `lodash` object which wraps `value` to enable implicit method
* chain sequences. Methods that operate on and return arrays, collections,
* and functions can be chained together. Methods that retrieve a single value
* or may return a primitive value will automatically end the chain sequence
* and return the unwrapped value. Otherwise, the value must be unwrapped
* with `_#value`.
*
* Explicit chain sequences, which must be unwrapped with `_#value`, may be
* enabled using `_.chain`.
*
* The execution of chained methods is lazy, that is, it's deferred until
* `_#value` is implicitly or explicitly called.
*
* Lazy evaluation allows several methods to support shortcut fusion.
* Shortcut fusion is an optimization to merge iteratee calls; this avoids
* the creation of intermediate arrays and can greatly reduce the number of
* iteratee executions. Sections of a chain sequence qualify for shortcut
* fusion if the section is applied to an array and iteratees accept only
* one argument. The heuristic for whether a section qualifies for shortcut
* fusion is subject to change.
*
* Chaining is supported in custom builds as long as the `_#value` method is
* directly or indirectly included in the build.
*
* In addition to lodash methods, wrappers have `Array` and `String` methods.
*
* The wrapper `Array` methods are:
* `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift`
*
* The wrapper `String` methods are:
* `replace` and `split`
*
* The wrapper methods that support shortcut fusion are:
* `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`,
* `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`,
* `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray`
*
* The chainable wrapper methods are:
* `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`,
* `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`,
* `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`,
* `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`,
* `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`,
* `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`,
* `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`,
* `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`,
* `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`,
* `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`,
* `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`,
* `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`,
* `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`,
* `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`,
* `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`,
* `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`,
* `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`,
* `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`,
* `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`,
* `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`,
* `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`,
* `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`,
* `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`,
* `zipObject`, `zipObjectDeep`, and `zipWith`
*
* The wrapper methods that are **not** chainable by default are:
* `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`,
* `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`,
* `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`,
* `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`,
* `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`,
* `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`,
* `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`,
* `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`,
* `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`,
* `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`,
* `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`,
* `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`,
* `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`,
* `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`,
* `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`,
* `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`,
* `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`,
* `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`,
* `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`,
* `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`,
* `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`,
* `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`,
* `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`,
* `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`,
* `upperFirst`, `value`, and `words`
*
* @name _
* @constructor
* @category Seq
* @param {*} value The value to wrap in a `lodash` instance.
* @returns {Object} Returns the new `lodash` wrapper instance.
* @example
*
* function square(n) {
* return n * n;
* }
*
* var wrapped = _([1, 2, 3]);
*
* // Returns an unwrapped value.
* wrapped.reduce(_.add);
* // => 6
*
* // Returns a wrapped value.
* var squares = wrapped.map(square);
*
* _.isArray(squares);
* // => false
*
* _.isArray(squares.value());
* // => true
*/
function lodash(value) {
if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {
if (value instanceof LodashWrapper) {
return value;
}
if (hasOwnProperty.call(value, '__wrapped__')) {
return wrapperClone(value);
}
}
return new LodashWrapper(value);
}
/**
* The base implementation of `_.create` without support for assigning
* properties to the created object.
*
* @private
* @param {Object} proto The object to inherit from.
* @returns {Object} Returns the new object.
*/
var baseCreate = (function() {
function object() {}
return function(proto) {
if (!isObject(proto)) {
return {};
}
if (objectCreate) {
return objectCreate(proto);
}
object.prototype = proto;
var result = new object;
object.prototype = undefined;
return result;
};
}());
/**
* The function whose prototype chain sequence wrappers inherit from.
*
* @private
*/
function baseLodash() {
// No operation performed.
}
/**
* The base constructor for creating `lodash` wrapper objects.
*
* @private
* @param {*} value The value to wrap.
* @param {boolean} [chainAll] Enable explicit method chain sequences.
*/
function LodashWrapper(value, chainAll) {
this.__wrapped__ = value;
this.__actions__ = [];
this.__chain__ = !!chainAll;
this.__index__ = 0;
this.__values__ = undefined;
}
/**
* By default, the template delimiters used by lodash are like those in
* embedded Ruby (ERB) as well as ES2015 template strings. Change the
* following template settings to use alternative delimiters.
*
* @static
* @memberOf _
* @type {Object}
*/
lodash.templateSettings = {
/**
* Used to detect `data` property values to be HTML-escaped.
*
* @memberOf _.templateSettings
* @type {RegExp}
*/
'escape': reEscape,
/**
* Used to detect code to be evaluated.
*
* @memberOf _.templateSettings
* @type {RegExp}
*/
'evaluate': reEvaluate,
/**
* Used to detect `data` property values to inject.
*
* @memberOf _.templateSettings
* @type {RegExp}
*/
'interpolate': reInterpolate,
/**
* Used to reference the data object in the template text.
*
* @memberOf _.templateSettings
* @type {string}
*/
'variable': '',
/**
* Used to import variables into the compiled template.
*
* @memberOf _.templateSettings
* @type {Object}
*/
'imports': {
/**
* A reference to the `lodash` function.
*
* @memberOf _.templateSettings.imports
* @type {Function}
*/
'_': lodash
}
};
// Ensure wrappers are instances of `baseLodash`.
lodash.prototype = baseLodash.prototype;
lodash.prototype.constructor = lodash;
LodashWrapper.prototype = baseCreate(baseLodash.prototype);
LodashWrapper.prototype.constructor = LodashWrapper;
/*------------------------------------------------------------------------*/
/**
* Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.
*
* @private
* @constructor
* @param {*} value The value to wrap.
*/
function LazyWrapper(value) {
this.__wrapped__ = value;
this.__actions__ = [];
this.__dir__ = 1;
this.__filtered__ = false;
this.__iteratees__ = [];
this.__takeCount__ = MAX_ARRAY_LENGTH;
this.__views__ = [];
}
/**
* Creates a clone of the lazy wrapper object.
*
* @private
* @name clone
* @memberOf LazyWrapper
* @returns {Object} Returns the cloned `LazyWrapper` object.
*/
function lazyClone() {
var result = new LazyWrapper(this.__wrapped__);
result.__actions__ = copyArray(this.__actions__);
result.__dir__ = this.__dir__;
result.__filtered__ = this.__filtered__;
result.__iteratees__ = copyArray(this.__iteratees__);
result.__takeCount__ = this.__takeCount__;
result.__views__ = copyArray(this.__views__);
return result;
}
/**
* Reverses the direction of lazy iteration.
*
* @private
* @name reverse
* @memberOf LazyWrapper
* @returns {Object} Returns the new reversed `LazyWrapper` object.
*/
function lazyReverse() {
if (this.__filtered__) {
var result = new LazyWrapper(this);
result.__dir__ = -1;
result.__filtered__ = true;
} else {
result = this.clone();
result.__dir__ *= -1;
}
return result;
}
/**
* Extracts the unwrapped value from its lazy wrapper.
*
* @private
* @name value
* @memberOf LazyWrapper
* @returns {*} Returns the unwrapped value.
*/
function lazyValue() {
var array = this.__wrapped__.value(),
dir = this.__dir__,
isArr = isArray(array),
isRight = dir < 0,
arrLength = isArr ? array.length : 0,
view = getView(0, arrLength, this.__views__),
start = view.start,
end = view.end,
length = end - start,
index = isRight ? end : (start - 1),
iteratees = this.__iteratees__,
iterLength = iteratees.length,
resIndex = 0,
takeCount = nativeMin(length, this.__takeCount__);
if (!isArr || (!isRight && arrLength == length && takeCount == length)) {
return baseWrapperValue(array, this.__actions__);
}
var result = [];
outer:
while (length-- && resIndex < takeCount) {
index += dir;
var iterIndex = -1,
value = array[index];
while (++iterIndex < iterLength) {
var data = iteratees[iterIndex],
iteratee = data.iteratee,
type = data.type,
computed = iteratee(value);
if (type == LAZY_MAP_FLAG) {
value = computed;
} else if (!computed) {
if (type == LAZY_FILTER_FLAG) {
continue outer;
} else {
break outer;
}
}
}
result[resIndex++] = value;
}
return result;
}
// Ensure `LazyWrapper` is an instance of `baseLodash`.
LazyWrapper.prototype = baseCreate(baseLodash.prototype);
LazyWrapper.prototype.constructor = LazyWrapper;
/*------------------------------------------------------------------------*/
/**
* Creates a hash object.
*
* @private
* @constructor
* @param {Array} [entries] The key-value pairs to cache.
*/
function Hash(entries) {
var index = -1,
length = entries == null ? 0 : entries.length;
this.clear();
while (++index < length) {
var entry = entries[index];
this.set(entry[0], entry[1]);
}
}
/**
* Removes all key-value entries from the hash.
*
* @private
* @name clear
* @memberOf Hash
*/
function hashClear() {
this.__data__ = nativeCreate ? nativeCreate(null) : {};
this.size = 0;
}
/**
* Removes `key` and its value from the hash.
*
* @private
* @name delete
* @memberOf Hash
* @param {Object} hash The hash to modify.
* @param {string} key The key of the value to remove.
* @returns {boolean} Returns `true` if the entry was removed, else `false`.
*/
function hashDelete(key) {
var result = this.has(key) && delete this.__data__[key];
this.size -= result ? 1 : 0;
return result;
}
/**
* Gets the hash value for `key`.
*
* @private
* @name get
* @memberOf Hash
* @param {string} key The key of the value to get.
* @returns {*} Returns the entry value.
*/
function hashGet(key) {
var data = this.__data__;
if (nativeCreate) {
var result = data[key];
return result === HASH_UNDEFINED ? undefined : result;
}
return hasOwnProperty.call(data, key) ? data[key] : undefined;
}
/**
* Checks if a hash value for `key` exists.
*
* @private
* @name has
* @memberOf Hash
* @param {string} key The key of the entry to check.
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
*/
function hashHas(key) {
var data = this.__data__;
return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);
}
/**
* Sets the hash `key` to `value`.
*
* @private
* @name set
* @memberOf Hash
* @param {string} key The key of the value to set.
* @param {*} value The value to set.
* @returns {Object} Returns the hash instance.
*/
function hashSet(key, value) {
var data = this.__data__;
this.size += this.has(key) ? 0 : 1;
data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
return this;
}
// Add methods to `Hash`.
Hash.prototype.clear = hashClear;
Hash.prototype['delete'] = hashDelete;
Hash.prototype.get = hashGet;
Hash.prototype.has = hashHas;
Hash.prototype.set = hashSet;
/*------------------------------------------------------------------------*/
/**
* Creates an list cache object.
*
* @private
* @constructor
* @param {Array} [entries] The key-value pairs to cache.
*/
function ListCache(entries) {
var index = -1,
length = entries == null ? 0 : entries.length;
this.clear();
while (++index < length) {
var entry = entries[index];
this.set(entry[0], entry[1]);
}
}
/**
* Removes all key-value entries from the list cache.
*
* @private
* @name clear
* @memberOf ListCache
*/
function listCacheClear() {
this.__data__ = [];
this.size = 0;
}
/**
* Removes `key` and its value from the list cache.
*
* @private
* @name delete
* @memberOf ListCache
* @param {string} key The key of the value to remove.
* @returns {boolean} Returns `true` if the entry was removed, else `false`.
*/
function listCacheDelete(key) {
var data = this.__data__,
index = assocIndexOf(data, key);
if (index < 0) {
return false;
}
var lastIndex = data.length - 1;
if (index == lastIndex) {
data.pop();
} else {
splice.call(data, index, 1);
}
--this.size;
return true;
}
/**
* Gets the list cache value for `key`.
*
* @private
* @name get
* @memberOf ListCache
* @param {string} key The key of the value to get.
* @returns {*} Returns the entry value.
*/
function listCacheGet(key) {
var data = this.__data__,
index = assocIndexOf(data, key);
return index < 0 ? undefined : data[index][1];
}
/**
* Checks if a list cache value for `key` exists.
*
* @private
* @name has
* @memberOf ListCache
* @param {string} key The key of the entry to check.
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
*/
function listCacheHas(key) {
return assocIndexOf(this.__data__, key) > -1;
}
/**
* Sets the list cache `key` to `value`.
*
* @private
* @name set
* @memberOf ListCache
* @param {string} key The key of the value to set.
* @param {*} value The value to set.
* @returns {Object} Returns the list cache instance.
*/
function listCacheSet(key, value) {
var data = this.__data__,
index = assocIndexOf(data, key);
if (index < 0) {
++this.size;
data.push([key, value]);
} else {
data[index][1] = value;
}
return this;
}
// Add methods to `ListCache`.
ListCache.prototype.clear = listCacheClear;
ListCache.prototype['delete'] = listCacheDelete;
ListCache.prototype.get = listCacheGet;
ListCache.prototype.has = listCacheHas;
ListCache.prototype.set = listCacheSet;
/*------------------------------------------------------------------------*/
/**
* Creates a map cache object to store key-value pairs.
*
* @private
* @constructor
* @param {Array} [entries] The key-value pairs to cache.
*/
function MapCache(entries) {
var index = -1,
length = entries == null ? 0 : entries.length;
this.clear();
while (++index < length) {
var entry = entries[index];
this.set(entry[0], entry[1]);
}
}
/**
* Removes all key-value entries from the map.
*
* @private
* @name clear
* @memberOf MapCache
*/
function mapCacheClear() {
this.size = 0;
this.__data__ = {
'hash': new Hash,
'map': new (Map || ListCache),
'string': new Hash
};
}
/**
* Removes `key` and its value from the map.
*
* @private
* @name delete
* @memberOf MapCache
* @param {string} key The key of the value to remove.
* @returns {boolean} Returns `true` if the entry was removed, else `false`.
*/
function mapCacheDelete(key) {
var result = getMapData(this, key)['delete'](key);
this.size -= result ? 1 : 0;
return result;
}
/**
* Gets the map value for `key`.
*
* @private
* @name get
* @memberOf MapCache
* @param {string} key The key of the value to get.
* @returns {*} Returns the entry value.
*/
function mapCacheGet(key) {
return getMapData(this, key).get(key);
}
/**
* Checks if a map value for `key` exists.
*
* @private
* @name has
* @memberOf MapCache
* @param {string} key The key of the entry to check.
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
*/
function mapCacheHas(key) {
return getMapData(this, key).has(key);
}
/**
* Sets the map `key` to `value`.
*
* @private
* @name set
* @memberOf MapCache
* @param {string} key The key of the value to set.
* @param {*} value The value to set.
* @returns {Object} Returns the map cache instance.
*/
function mapCacheSet(key, value) {
var data = getMapData(this, key),
size = data.size;
data.set(key, value);
this.size += data.size == size ? 0 : 1;
return this;
}
// Add methods to `MapCache`.
MapCache.prototype.clear = mapCacheClear;
MapCache.prototype['delete'] = mapCacheDelete;
MapCache.prototype.get = mapCacheGet;
MapCache.prototype.has = mapCacheHas;
MapCache.prototype.set = mapCacheSet;
/*------------------------------------------------------------------------*/
/**
*
* Creates an array cache object to store unique values.
*
* @private
* @constructor
* @param {Array} [values] The values to cache.
*/
function SetCache(values) {
var index = -1,
length = values == null ? 0 : values.length;
this.__data__ = new MapCache;
while (++index < length) {
this.add(values[index]);
}
}
/**
* Adds `value` to the array cache.
*
* @private
* @name add
* @memberOf SetCache
* @alias push
* @param {*} value The value to cache.
* @returns {Object} Returns the cache instance.
*/
function setCacheAdd(value) {
this.__data__.set(value, HASH_UNDEFINED);
return this;
}
/**
* Checks if `value` is in the array cache.
*
* @private
* @name has
* @memberOf SetCache
* @param {*} value The value to search for.
* @returns {number} Returns `true` if `value` is found, else `false`.
*/
function setCacheHas(value) {
return this.__data__.has(value);
}
// Add methods to `SetCache`.
SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
SetCache.prototype.has = setCacheHas;
/*------------------------------------------------------------------------*/
/**
* Creates a stack cache object to store key-value pairs.
*
* @private
* @constructor
* @param {Array} [entries] The key-value pairs to cache.
*/
function Stack(entries) {
var data = this.__data__ = new ListCache(entries);
this.size = data.size;
}
/**
* Removes all key-value entries from the stack.
*
* @private
* @name clear
* @memberOf Stack
*/
function stackClear() {
this.__data__ = new ListCache;
this.size = 0;
}
/**
* Removes `key` and its value from the stack.
*
* @private
* @name delete
* @memberOf Stack
* @param {string} key The key of the value to remove.
* @returns {boolean} Returns `true` if the entry was removed, else `false`.
*/
function stackDelete(key) {
var data = this.__data__,
result = data['delete'](key);
this.size = data.size;
return result;
}
/**
* Gets the stack value for `key`.
*
* @private
* @name get
* @memberOf Stack
* @param {string} key The key of the value to get.
* @returns {*} Returns the entry value.
*/
function stackGet(key) {
return this.__data__.get(key);
}
/**
* Checks if a stack value for `key` exists.
*
* @private
* @name has
* @memberOf Stack
* @param {string} key The key of the entry to check.
* @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
*/
function stackHas(key) {
return this.__data__.has(key);
}
/**
* Sets the stack `key` to `value`.
*
* @private
* @name set
* @memberOf Stack
* @param {string} key The key of the value to set.
* @param {*} value The value to set.
* @returns {Object} Returns the stack cache instance.
*/
function stackSet(key, value) {
var data = this.__data__;
if (data instanceof ListCache) {
var pairs = data.__data__;
if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
pairs.push([key, value]);
this.size = ++data.size;
return this;
}
data = this.__data__ = new MapCache(pairs);
}
data.set(key, value);
this.size = data.size;
return this;
}
// Add methods to `Stack`.
Stack.prototype.clear = stackClear;
Stack.prototype['delete'] = stackDelete;
Stack.prototype.get = stackGet;
Stack.prototype.has = stackHas;
Stack.prototype.set = stackSet;
/*------------------------------------------------------------------------*/
/**
* Creates an array of the enumerable property names of the array-like `value`.
*
* @private
* @param {*} value The value to query.
* @param {boolean} inherited Specify returning inherited property names.
* @returns {Array} Returns the array of property names.
*/
function arrayLikeKeys(value, inherited) {
var isArr = isArray(value),
isArg = !isArr && isArguments(value),
isBuff = !isArr && !isArg && isBuffer(value),
isType = !isArr && !isArg && !isBuff && isTypedArray(value),
skipIndexes = isArr || isArg || isBuff || isType,
result = skipIndexes ? baseTimes(value.length, String) : [],
length = result.length;
for (var key in value) {
if ((inherited || hasOwnProperty.call(value, key)) &&
!(skipIndexes && (
// Safari 9 has enumerable `arguments.length` in strict mode.
key == 'length' ||
// Node.js 0.10 has enumerable non-index properties on buffers.
(isBuff && (key == 'offset' || key == 'parent')) ||
// PhantomJS 2 has enumerable non-index properties on typed arrays.
(isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
// Skip index properties.
isIndex(key, length)
))) {
result.push(key);
}
}
return result;
}
/**
* A specialized version of `_.sample` for arrays.
*
* @private
* @param {Array} array The array to sample.
* @returns {*} Returns the random element.
*/
function arraySample(array) {
var length = array.length;
return length ? array[baseRandom(0, length - 1)] : undefined;
}
/**
* A specialized version of `_.sampleSize` for arrays.
*
* @private
* @param {Array} array The array to sample.
* @param {number} n The number of elements to sample.
* @returns {Array} Returns the random elements.
*/
function arraySampleSize(array, n) {
return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));
}
/**
* A specialized version of `_.shuffle` for arrays.
*
* @private
* @param {Array} array The array to shuffle.
* @returns {Array} Returns the new shuffled array.
*/
function arrayShuffle(array) {
return shuffleSelf(copyArray(array));
}
/**
* This function is like `assignValue` except that it doesn't assign
* `undefined` values.
*
* @private
* @param {Object} object The object to modify.
* @param {string} key The key of the property to assign.
* @param {*} value The value to assign.
*/
function assignMergeValue(object, key, value) {
if ((value !== undefined && !eq(object[key], value)) ||
(value === undefined && !(key in object))) {
baseAssignValue(object, key, value);
}
}
/**
* Assigns `value` to `key` of `object` if the existing value is not equivalent
* using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
* for equality comparisons.
*
* @private
* @param {Object} object The object to modify.
* @param {string} key The key of the property to assign.
* @param {*} value The value to assign.
*/
function assignValue(object, key, value) {
var objValue = object[key];
if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
(value === undefined && !(key in object))) {
baseAssignValue(object, key, value);
}
}
/**
* Gets the index at which the `key` is found in `array` of key-value pairs.
*
* @private
* @param {Array} array The array to inspect.
* @param {*} key The key to search for.
* @returns {number} Returns the index of the matched value, else `-1`.
*/
function assocIndexOf(array, key) {
var length = array.length;
while (length--) {
if (eq(array[length][0], key)) {
return length;
}
}
return -1;
}
/**
* Aggregates elements of `collection` on `accumulator` with keys transformed
* by `iteratee` and values set by `setter`.
*
* @private
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} setter The function to set `accumulator` values.
* @param {Function} iteratee The iteratee to transform keys.
* @param {Object} accumulator The initial aggregated object.
* @returns {Function} Returns `accumulator`.
*/
function baseAggregator(collection, setter, iteratee, accumulator) {
baseEach(collection, function(value, key, collection) {
setter(accumulator, value, iteratee(value), collection);
});
return accumulator;
}
/**
* The base implementation of `_.assign` without support for multiple sources
* or `customizer` functions.
*
* @private
* @param {Object} object The destination object.
* @param {Object} source The source object.
* @returns {Object} Returns `object`.
*/
function baseAssign(object, source) {
return object && copyObject(source, keys(source), object);
}
/**
* The base implementation of `_.assignIn` without support for multiple sources
* or `customizer` functions.
*
* @private
* @param {Object} object The destination object.
* @param {Object} source The source object.
* @returns {Object} Returns `object`.
*/
function baseAssignIn(object, source) {
return object && copyObject(source, keysIn(source), object);
}
/**
* The base implementation of `assignValue` and `assignMergeValue` without
* value checks.
*
* @private
* @param {Object} object The object to modify.
* @param {string} key The key of the property to assign.
* @param {*} value The value to assign.
*/
function baseAssignValue(object, key, value) {
if (key == '__proto__' && defineProperty) {
defineProperty(object, key, {
'configurable': true,
'enumerable': true,
'value': value,
'writable': true
});
} else {
object[key] = value;
}
}
/**
* The base implementation of `_.at` without support for individual paths.
*
* @private
* @param {Object} object The object to iterate over.
* @param {string[]} paths The property paths to pick.
* @returns {Array} Returns the picked elements.
*/
function baseAt(object, paths) {
var index = -1,
length = paths.length,
result = Array(length),
skip = object == null;
while (++index < length) {
result[index] = skip ? undefined : get(object, paths[index]);
}
return result;
}
/**
* The base implementation of `_.clamp` which doesn't coerce arguments.
*
* @private
* @param {number} number The number to clamp.
* @param {number} [lower] The lower bound.
* @param {number} upper The upper bound.
* @returns {number} Returns the clamped number.
*/
function baseClamp(number, lower, upper) {
if (number === number) {
if (upper !== undefined) {
number = number <= upper ? number : upper;
}
if (lower !== undefined) {
number = number >= lower ? number : lower;
}
}
return number;
}
/**
* The base implementation of `_.clone` and `_.cloneDeep` which tracks
* traversed objects.
*
* @private
* @param {*} value The value to clone.
* @param {boolean} bitmask The bitmask flags.
* 1 - Deep clone
* 2 - Flatten inherited properties
* 4 - Clone symbols
* @param {Function} [customizer] The function to customize cloning.
* @param {string} [key] The key of `value`.
* @param {Object} [object] The parent object of `value`.
* @param {Object} [stack] Tracks traversed objects and their clone counterparts.
* @returns {*} Returns the cloned value.
*/
function baseClone(value, bitmask, customizer, key, object, stack) {
var result,
isDeep = bitmask & CLONE_DEEP_FLAG,
isFlat = bitmask & CLONE_FLAT_FLAG,
isFull = bitmask & CLONE_SYMBOLS_FLAG;
if (customizer) {
result = object ? customizer(value, key, object, stack) : customizer(value);
}
if (result !== undefined) {
return result;
}
if (!isObject(value)) {
return value;
}
var isArr = isArray(value);
if (isArr) {
result = initCloneArray(value);
if (!isDeep) {
return copyArray(value, result);
}
} else {
var tag = getTag(value),
isFunc = tag == funcTag || tag == genTag;
if (isBuffer(value)) {
return cloneBuffer(value, isDeep);
}
if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
result = (isFlat || isFunc) ? {} : initCloneObject(value);
if (!isDeep) {
return isFlat
? copySymbolsIn(value, baseAssignIn(result, value))
: copySymbols(value, baseAssign(result, value));
}
} else {
if (!cloneableTags[tag]) {
return object ? value : {};
}
result = initCloneByTag(value, tag, isDeep);
}
}
// Check for circular references and return its corresponding clone.
stack || (stack = new Stack);
var stacked = stack.get(value);
if (stacked) {
return stacked;
}
stack.set(value, result);
if (isSet(value)) {
value.forEach(function(subValue) {
result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
});
return result;
}
if (isMap(value)) {
value.forEach(function(subValue, key) {
result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));
});
return result;
}
var keysFunc = isFull
? (isFlat ? getAllKeysIn : getAllKeys)
: (isFlat ? keysIn : keys);
var props = isArr ? undefined : keysFunc(value);
arrayEach(props || value, function(subValue, key) {
if (props) {
key = subValue;
subValue = value[key];
}
// Recursively populate clone (susceptible to call stack limits).
assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));
});
return result;
}
/**
* The base implementation of `_.conforms` which doesn't clone `source`.
*
* @private
* @param {Object} source The object of property predicates to conform to.
* @returns {Function} Returns the new spec function.
*/
function baseConforms(source) {
var props = keys(source);
return function(object) {
return baseConformsTo(object, source, props);
};
}
/**
* The base implementation of `_.conformsTo` which accepts `props` to check.
*
* @private
* @param {Object} object The object to inspect.
* @param {Object} source The object of property predicates to conform to.
* @returns {boolean} Returns `true` if `object` conforms, else `false`.
*/
function baseConformsTo(object, source, props) {
var length = props.length;
if (object == null) {
return !length;
}
object = Object(object);
while (length--) {
var key = props[length],
predicate = source[key],
value = object[key];
if ((value === undefined && !(key in object)) || !predicate(value)) {
return false;
}
}
return true;
}
/**
* The base implementation of `_.delay` and `_.defer` which accepts `args`
* to provide to `func`.
*
* @private
* @param {Function} func The function to delay.
* @param {number} wait The number of milliseconds to delay invocation.
* @param {Array} args The arguments to provide to `func`.
* @returns {number|Object} Returns the timer id or timeout object.
*/
function baseDelay(func, wait, args) {
if (typeof func != 'function') {
throw new TypeError(FUNC_ERROR_TEXT);
}
return setTimeout(function() { func.apply(undefined, args); }, wait);
}
/**
* The base implementation of methods like `_.difference` without support
* for excluding multiple arrays or iteratee shorthands.
*
* @private
* @param {Array} array The array to inspect.
* @param {Array} values The values to exclude.
* @param {Function} [iteratee] The iteratee invoked per element.
* @param {Function} [comparator] The comparator invoked per element.
* @returns {Array} Returns the new array of filtered values.
*/
function baseDifference(array, values, iteratee, comparator) {
var index = -1,
includes = arrayIncludes,
isCommon = true,
length = array.length,
result = [],
valuesLength = values.length;
if (!length) {
return result;
}
if (iteratee) {
values = arrayMap(values, baseUnary(iteratee));
}
if (comparator) {
includes = arrayIncludesWith;
isCommon = false;
}
else if (values.length >= LARGE_ARRAY_SIZE) {
includes = cacheHas;
isCommon = false;
values = new SetCache(values);
}
outer:
while (++index < length) {
var value = array[index],
computed = iteratee == null ? value : iteratee(value);
value = (comparator || value !== 0) ? value : 0;
if (isCommon && computed === computed) {
var valuesIndex = valuesLength;
while (valuesIndex--) {
if (values[valuesIndex] === computed) {
continue outer;
}
}
result.push(value);
}
else if (!includes(values, computed, comparator)) {
result.push(value);
}
}
return result;
}
/**
* The base implementation of `_.forEach` without support for iteratee shorthands.
*
* @private
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @returns {Array|Object} Returns `collection`.
*/
var baseEach = createBaseEach(baseForOwn);
/**
* The base implementation of `_.forEachRight` without support for iteratee shorthands.
*
* @private
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @returns {Array|Object} Returns `collection`.
*/
var baseEachRight = createBaseEach(baseForOwnRight, true);
/**
* The base implementation of `_.every` without support for iteratee shorthands.
*
* @private
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} predicate The function invoked per iteration.
* @returns {boolean} Returns `true` if all elements pass the predicate check,
* else `false`
*/
function baseEvery(collection, predicate) {
var result = true;
baseEach(collection, function(value, index, collection) {
result = !!predicate(value, index, collection);
return result;
});
return result;
}
/**
* The base implementation of methods like `_.max` and `_.min` which accepts a
* `comparator` to determine the extremum value.
*
* @private
* @param {Array} array The array to iterate over.
* @param {Function} iteratee The iteratee invoked per iteration.
* @param {Function} comparator The comparator used to compare values.
* @returns {*} Returns the extremum value.
*/
function baseExtremum(array, iteratee, comparator) {
var index = -1,
length = array.length;
while (++index < length) {
var value = array[index],
current = iteratee(value);
if (current != null && (computed === undefined
? (current === current && !isSymbol(current))
: comparator(current, computed)
)) {
var computed = current,
result = value;
}
}
return result;
}
/**
* The base implementation of `_.fill` without an iteratee call guard.
*
* @private
* @param {Array} array The array to fill.
* @param {*} value The value to fill `array` with.
* @param {number} [start=0] The start position.
* @param {number} [end=array.length] The end position.
* @returns {Array} Returns `array`.
*/
function baseFill(array, value, start, end) {
var length = array.length;
start = toInteger(start);
if (start < 0) {
start = -start > length ? 0 : (length + start);
}
end = (end === undefined || end > length) ? length : toInteger(end);
if (end < 0) {
end += length;
}
end = start > end ? 0 : toLength(end);
while (start < end) {
array[start++] = value;
}
return array;
}
/**
* The base implementation of `_.filter` without support for iteratee shorthands.
*
* @private
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} predicate The function invoked per iteration.
* @returns {Array} Returns the new filtered array.
*/
function baseFilter(collection, predicate) {
var result = [];
baseEach(collection, function(value, index, collection) {
if (predicate(value, index, collection)) {
result.push(value);
}
});
return result;
}
/**
* The base implementation of `_.flatten` with support for restricting flattening.
*
* @private
* @param {Array} array The array to flatten.
* @param {number} depth The maximum recursion depth.
* @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
* @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
* @param {Array} [result=[]] The initial result value.
* @returns {Array} Returns the new flattened array.
*/
function baseFlatten(array, depth, predicate, isStrict, result) {
var index = -1,
length = array.length;
predicate || (predicate = isFlattenable);
result || (result = []);
while (++index < length) {
var value = array[index];
if (depth > 0 && predicate(value)) {
if (depth > 1) {
// Recursively flatten arrays (susceptible to call stack limits).
baseFlatten(value, depth - 1, predicate, isStrict, result);
} else {
arrayPush(result, value);
}
} else if (!isStrict) {
result[result.length] = value;
}
}
return result;
}
/**
* The base implementation of `baseForOwn` which iterates over `object`
* properties returned by `keysFunc` and invokes `iteratee` for each property.
* Iteratee functions may exit iteration early by explicitly returning `false`.
*
* @private
* @param {Object} object The object to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @param {Function} keysFunc The function to get the keys of `object`.
* @returns {Object} Returns `object`.
*/
var baseFor = createBaseFor();
/**
* This function is like `baseFor` except that it iterates over properties
* in the opposite order.
*
* @private
* @param {Object} object The object to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @param {Function} keysFunc The function to get the keys of `object`.
* @returns {Object} Returns `object`.
*/
var baseForRight = createBaseFor(true);
/**
* The base implementation of `_.forOwn` without support for iteratee shorthands.
*
* @private
* @param {Object} object The object to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @returns {Object} Returns `object`.
*/
function baseForOwn(object, iteratee) {
return object && baseFor(object, iteratee, keys);
}
/**
* The base implementation of `_.forOwnRight` without support for iteratee shorthands.
*
* @private
* @param {Object} object The object to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @returns {Object} Returns `object`.
*/
function baseForOwnRight(object, iteratee) {
return object && baseForRight(object, iteratee, keys);
}
/**
* The base implementation of `_.functions` which creates an array of
* `object` function property names filtered from `props`.
*
* @private
* @param {Object} object The object to inspect.
* @param {Array} props The property names to filter.
* @returns {Array} Returns the function names.
*/
function baseFunctions(object, props) {
return arrayFilter(props, function(key) {
return isFunction(object[key]);
});
}
/**
* The base implementation of `_.get` without support for default values.
*
* @private
* @param {Object} object The object to query.
* @param {Array|string} path The path of the property to get.
* @returns {*} Returns the resolved value.
*/
function baseGet(object, path) {
path = castPath(path, object);
var index = 0,
length = path.length;
while (object != null && index < length) {
object = object[toKey(path[index++])];
}
return (index && index == length) ? object : undefined;
}
/**
* The base implementation of `getAllKeys` and `getAllKeysIn` which uses
* `keysFunc` and `symbolsFunc` to get the enumerable property names and
* symbols of `object`.
*
* @private
* @param {Object} object The object to query.
* @param {Function} keysFunc The function to get the keys of `object`.
* @param {Function} symbolsFunc The function to get the symbols of `object`.
* @returns {Array} Returns the array of property names and symbols.
*/
function baseGetAllKeys(object, keysFunc, symbolsFunc) {
var result = keysFunc(object);
return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
}
/**
* The base implementation of `getTag` without fallbacks for buggy environments.
*
* @private
* @param {*} value The value to query.
* @returns {string} Returns the `toStringTag`.
*/
function baseGetTag(value) {
if (value == null) {
return value === undefined ? undefinedTag : nullTag;
}
return (symToStringTag && symToStringTag in Object(value))
? getRawTag(value)
: objectToString(value);
}
/**
* The base implementation of `_.gt` which doesn't coerce arguments.
*
* @private
* @param {*} value The value to compare.
* @param {*} other The other value to compare.
* @returns {boolean} Returns `true` if `value` is greater than `other`,
* else `false`.
*/
function baseGt(value, other) {
return value > other;
}
/**
* The base implementation of `_.has` without support for deep paths.
*
* @private
* @param {Object} [object] The object to query.
* @param {Array|string} key The key to check.
* @returns {boolean} Returns `true` if `key` exists, else `false`.
*/
function baseHas(object, key) {
return object != null && hasOwnProperty.call(object, key);
}
/**
* The base implementation of `_.hasIn` without support for deep paths.
*
* @private
* @param {Object} [object] The object to query.
* @param {Array|string} key The key to check.
* @returns {boolean} Returns `true` if `key` exists, else `false`.
*/
function baseHasIn(object, key) {
return object != null && key in Object(object);
}
/**
* The base implementation of `_.inRange` which doesn't coerce arguments.
*
* @private
* @param {number} number The number to check.
* @param {number} start The start of the range.
* @param {number} end The end of the range.
* @returns {boolean} Returns `true` if `number` is in the range, else `false`.
*/
function baseInRange(number, start, end) {
return number >= nativeMin(start, end) && number < nativeMax(start, end);
}
/**
* The base implementation of methods like `_.intersection`, without support
* for iteratee shorthands, that accepts an array of arrays to inspect.
*
* @private
* @param {Array} arrays The arrays to inspect.
* @param {Function} [iteratee] The iteratee invoked per element.
* @param {Function} [comparator] The comparator invoked per element.
* @returns {Array} Returns the new array of shared values.
*/
function baseIntersection(arrays, iteratee, comparator) {
var includes = comparator ? arrayIncludesWith : arrayIncludes,
length = arrays[0].length,
othLength = arrays.length,
othIndex = othLength,
caches = Array(othLength),
maxLength = Infinity,
result = [];
while (othIndex--) {
var array = arrays[othIndex];
if (othIndex && iteratee) {
array = arrayMap(array, baseUnary(iteratee));
}
maxLength = nativeMin(array.length, maxLength);
caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120))
? new SetCache(othIndex && array)
: undefined;
}
array = arrays[0];
var index = -1,
seen = caches[0];
outer:
while (++index < length && result.length < maxLength) {
var value = array[index],
computed = iteratee ? iteratee(value) : value;
value = (comparator || value !== 0) ? value : 0;
if (!(seen
? cacheHas(seen, computed)
: includes(result, computed, comparator)
)) {
othIndex = othLength;
while (--othIndex) {
var cache = caches[othIndex];
if (!(cache
? cacheHas(cache, computed)
: includes(arrays[othIndex], computed, comparator))
) {
continue outer;
}
}
if (seen) {
seen.push(computed);
}
result.push(value);
}
}
return result;
}
/**
* The base implementation of `_.invert` and `_.invertBy` which inverts
* `object` with values transformed by `iteratee` and set by `setter`.
*
* @private
* @param {Object} object The object to iterate over.
* @param {Function} setter The function to set `accumulator` values.
* @param {Function} iteratee The iteratee to transform values.
* @param {Object} accumulator The initial inverted object.
* @returns {Function} Returns `accumulator`.
*/
function baseInverter(object, setter, iteratee, accumulator) {
baseForOwn(object, function(value, key, object) {
setter(accumulator, iteratee(value), key, object);
});
return accumulator;
}
/**
* The base implementation of `_.invoke` without support for individual
* method arguments.
*
* @private
* @param {Object} object The object to query.
* @param {Array|string} path The path of the method to invoke.
* @param {Array} args The arguments to invoke the method with.
* @returns {*} Returns the result of the invoked method.
*/
function baseInvoke(object, path, args) {
path = castPath(path, object);
object = parent(object, path);
var func = object == null ? object : object[toKey(last(path))];
return func == null ? undefined : apply(func, object, args);
}
/**
* The base implementation of `_.isArguments`.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is an `arguments` object,
*/
function baseIsArguments(value) {
return isObjectLike(value) && baseGetTag(value) == argsTag;
}
/**
* The base implementation of `_.isArrayBuffer` without Node.js optimizations.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.
*/
function baseIsArrayBuffer(value) {
return isObjectLike(value) && baseGetTag(value) == arrayBufferTag;
}
/**
* The base implementation of `_.isDate` without Node.js optimizations.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a date object, else `false`.
*/
function baseIsDate(value) {
return isObjectLike(value) && baseGetTag(value) == dateTag;
}
/**
* The base implementation of `_.isEqual` which supports partial comparisons
* and tracks traversed objects.
*
* @private
* @param {*} value The value to compare.
* @param {*} other The other value to compare.
* @param {boolean} bitmask The bitmask flags.
* 1 - Unordered comparison
* 2 - Partial comparison
* @param {Function} [customizer] The function to customize comparisons.
* @param {Object} [stack] Tracks traversed `value` and `other` objects.
* @returns {boolean} Returns `true` if the values are equivalent, else `false`.
*/
function baseIsEqual(value, other, bitmask, customizer, stack) {
if (value === other) {
return true;
}
if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {
return value !== value && other !== other;
}
return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
}
/**
* A specialized version of `baseIsEqual` for arrays and objects which performs
* deep comparisons and tracks traversed objects enabling objects with circular
* references to be compared.
*
* @private
* @param {Object} object The object to compare.
* @param {Object} other The other object to compare.
* @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
* @param {Function} customizer The function to customize comparisons.
* @param {Function} equalFunc The function to determine equivalents of values.
* @param {Object} [stack] Tracks traversed `object` and `other` objects.
* @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
*/
function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
var objIsArr = isArray(object),
othIsArr = isArray(other),
objTag = objIsArr ? arrayTag : getTag(object),
othTag = othIsArr ? arrayTag : getTag(other);
objTag = objTag == argsTag ? objectTag : objTag;
othTag = othTag == argsTag ? objectTag : othTag;
var objIsObj = objTag == objectTag,
othIsObj = othTag == objectTag,
isSameTag = objTag == othTag;
if (isSameTag && isBuffer(object)) {
if (!isBuffer(other)) {
return false;
}
objIsArr = true;
objIsObj = false;
}
if (isSameTag && !objIsObj) {
stack || (stack = new Stack);
return (objIsArr || isTypedArray(object))
? equalArrays(object, other, bitmask, customizer, equalFunc, stack)
: equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
}
if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
if (objIsWrapped || othIsWrapped) {
var objUnwrapped = objIsWrapped ? object.value() : object,
othUnwrapped = othIsWrapped ? other.value() : other;
stack || (stack = new Stack);
return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
}
}
if (!isSameTag) {
return false;
}
stack || (stack = new Stack);
return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
}
/**
* The base implementation of `_.isMap` without Node.js optimizations.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a map, else `false`.
*/
function baseIsMap(value) {
return isObjectLike(value) && getTag(value) == mapTag;
}
/**
* The base implementation of `_.isMatch` without support for iteratee shorthands.
*
* @private
* @param {Object} object The object to inspect.
* @param {Object} source The object of property values to match.
* @param {Array} matchData The property names, values, and compare flags to match.
* @param {Function} [customizer] The function to customize comparisons.
* @returns {boolean} Returns `true` if `object` is a match, else `false`.
*/
function baseIsMatch(object, source, matchData, customizer) {
var index = matchData.length,
length = index,
noCustomizer = !customizer;
if (object == null) {
return !length;
}
object = Object(object);
while (index--) {
var data = matchData[index];
if ((noCustomizer && data[2])
? data[1] !== object[data[0]]
: !(data[0] in object)
) {
return false;
}
}
while (++index < length) {
data = matchData[index];
var key = data[0],
objValue = object[key],
srcValue = data[1];
if (noCustomizer && data[2]) {
if (objValue === undefined && !(key in object)) {
return false;
}
} else {
var stack = new Stack;
if (customizer) {
var result = customizer(objValue, srcValue, key, object, source, stack);
}
if (!(result === undefined
? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)
: result
)) {
return false;
}
}
}
return true;
}
/**
* The base implementation of `_.isNative` without bad shim checks.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a native function,
* else `false`.
*/
function baseIsNative(value) {
if (!isObject(value) || isMasked(value)) {
return false;
}
var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
return pattern.test(toSource(value));
}
/**
* The base implementation of `_.isRegExp` without Node.js optimizations.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a regexp, else `false`.
*/
function baseIsRegExp(value) {
return isObjectLike(value) && baseGetTag(value) == regexpTag;
}
/**
* The base implementation of `_.isSet` without Node.js optimizations.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a set, else `false`.
*/
function baseIsSet(value) {
return isObjectLike(value) && getTag(value) == setTag;
}
/**
* The base implementation of `_.isTypedArray` without Node.js optimizations.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
*/
function baseIsTypedArray(value) {
return isObjectLike(value) &&
isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
}
/**
* The base implementation of `_.iteratee`.
*
* @private
* @param {*} [value=_.identity] The value to convert to an iteratee.
* @returns {Function} Returns the iteratee.
*/
function baseIteratee(value) {
// Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
// See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
if (typeof value == 'function') {
return value;
}
if (value == null) {
return identity;
}
if (typeof value == 'object') {
return isArray(value)
? baseMatchesProperty(value[0], value[1])
: baseMatches(value);
}
return property(value);
}
/**
* The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
*
* @private
* @param {Object} object The object to query.
* @returns {Array} Returns the array of property names.
*/
function baseKeys(object) {
if (!isPrototype(object)) {
return nativeKeys(object);
}
var result = [];
for (var key in Object(object)) {
if (hasOwnProperty.call(object, key) && key != 'constructor') {
result.push(key);
}
}
return result;
}
/**
* The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
*
* @private
* @param {Object} object The object to query.
* @returns {Array} Returns the array of property names.
*/
function baseKeysIn(object) {
if (!isObject(object)) {
return nativeKeysIn(object);
}
var isProto = isPrototype(object),
result = [];
for (var key in object) {
if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
result.push(key);
}
}
return result;
}
/**
* The base implementation of `_.lt` which doesn't coerce arguments.
*
* @private
* @param {*} value The value to compare.
* @param {*} other The other value to compare.
* @returns {boolean} Returns `true` if `value` is less than `other`,
* else `false`.
*/
function baseLt(value, other) {
return value < other;
}
/**
* The base implementation of `_.map` without support for iteratee shorthands.
*
* @private
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} iteratee The function invoked per iteration.
* @returns {Array} Returns the new mapped array.
*/
function baseMap(collection, iteratee) {
var index = -1,
result = isArrayLike(collection) ? Array(collection.length) : [];
baseEach(collection, function(value, key, collection) {
result[++index] = iteratee(value, key, collection);
});
return result;
}
/**
* The base implementation of `_.matches` which doesn't clone `source`.
*
* @private
* @param {Object} source The object of property values to match.
* @returns {Function} Returns the new spec function.
*/
function baseMatches(source) {
var matchData = getMatchData(source);
if (matchData.length == 1 && matchData[0][2]) {
return matchesStrictComparable(matchData[0][0], matchData[0][1]);
}
return function(object) {
return object === source || baseIsMatch(object, source, matchData);
};
}
/**
* The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.
*
* @private
* @param {string} path The path of the property to get.
* @param {*} srcValue The value to match.
* @returns {Function} Returns the new spec function.
*/
function baseMatchesProperty(path, srcValue) {
if (isKey(path) && isStrictComparable(srcValue)) {
return matchesStrictComparable(toKey(path), srcValue);
}
return function(object) {
var objValue = get(object, path);
return (objValue === undefined && objValue === srcValue)
? hasIn(object, path)
: baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
};
}
/**
* The base implementation of `_.merge` without support for multiple sources.
*
* @private
* @param {Object} object The destination object.
* @param {Object} source The source object.
* @param {number} srcIndex The index of `source`.
* @param {Function} [customizer] The function to customize merged values.
* @param {Object} [stack] Tracks traversed source values and their merged
* counterparts.
*/
function baseMerge(object, source, srcIndex, customizer, stack) {
if (object === source) {
return;
}
baseFor(source, function(srcValue, key) {
if (isObject(srcValue)) {
stack || (stack = new Stack);
baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
}
else {
var newValue = customizer
? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)
: undefined;
if (newValue === undefined) {
newValue = srcValue;
}
assignMergeValue(object, key, newValue);
}
}, keysIn);
}
/**
* A specialized version of `baseMerge` for arrays and objects which performs
* deep merges and tracks traversed objects enabling objects with circular
* references to be merged.
*
* @private
* @param {Object} object The destination object.
* @param {Object} source The source object.
* @param {string} key The key of the value to merge.
* @param {number} srcIndex The index of `source`.
* @param {Function} mergeFunc The function to merge values.
* @param {Function} [customizer] The function to customize assigned values.
* @param {Object} [stack] Tracks traversed source values and their merged
* counterparts.
*/
function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
var objValue = safeGet(object, key),
srcValue = safeGet(source, key),
stacked = stack.get(srcValue);
if (stacked) {
assignMergeValue(object, key, stacked);
return;
}
var newValue = customizer
? customizer(objValue, srcValue, (key + ''), object, source, stack)
: undefined;
var isCommon = newValue === undefined;
if (isCommon) {
var isArr = isArray(srcValue),
isBuff = !isArr && isBuffer(srcValue),
isTyped = !isArr && !isBuff && isTypedArray(srcValue);
newValue = srcValue;
if (isArr || isBuff || isTyped) {
if (isArray(objValue)) {
newValue = objValue;
}
else if (isArrayLikeObject(objValue)) {
newValue = copyArray(objValue);
}
else if (isBuff) {
isCommon = false;
newValue = cloneBuffer(srcValue, true);
}
else if (isTyped) {
isCommon = false;
newValue = cloneTypedArray(srcValue, true);
}
else {
newValue = [];
}
}
else if (isPlainObject(srcValue) || isArguments(srcValue)) {
newValue = objValue;
if (isArguments(objValue)) {
newValue = toPlainObject(objValue);
}
else if (!isObject(objValue) || (srcIndex && isFunction(objValue))) {
newValue = initCloneObject(srcValue);
}
}
else {
isCommon = false;
}
}
if (isCommon) {
// Recursively merge objects and arrays (susceptible to call stack limits).
stack.set(srcValue, newValue);
mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
stack['delete'](srcValue);
}
assignMergeValue(object, key, newValue);
}
/**
* The base implementation of `_.nth` which doesn't coerce arguments.
*
* @private
* @param {Array} array The array to query.
* @param {number} n The index of the element to return.
* @returns {*} Returns the nth element of `array`.
*/
function baseNth(array, n) {
var length = array.length;
if (!length) {
return;
}
n += n < 0 ? length : 0;
return isIndex(n, length) ? array[n] : undefined;
}
/**
* The base implementation of `_.orderBy` without param guards.
*
* @private
* @param {Array|Object} collection The collection to iterate over.
* @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.
* @param {string[]} orders The sort orders of `iteratees`.
* @returns {Array} Returns the new sorted array.
*/
function baseOrderBy(collection, iteratees, orders) {
var index = -1;
iteratees = arrayMap(iteratees.length ? iteratees : [identity], baseUnary(getIteratee()));
var result = baseMap(collection, function(value, key, collection) {
var criteria = arrayMap(iteratees, function(iteratee) {
return iteratee(value);
});
return { 'criteria': criteria, 'index': ++index, 'value': value };
});
return baseSortBy(result, function(object, other) {
return compareMultiple(object, other, orders);
});
}
/**
* The base implementation of `_.pick` without support for individual
* property identifiers.
*
* @private
* @param {Object} object The source object.
* @param {string[]} paths The property paths to pick.
* @returns {Object} Returns the new object.
*/
function basePick(object, paths) {
return basePickBy(object, paths, function(value, path) {
return hasIn(object, path);
});
}
/**
* The base implementation of `_.pickBy` without support for iteratee shorthands.
*
* @private
* @param {Object} object The source object.
* @param {string[]} paths The property paths to pick.
* @param {Function} predicate The function invoked per property.
* @returns {Object} Returns the new object.
*/
function basePickBy(object, paths, predicate) {
var index = -1,
length = paths.length,
result = {};
while (++index < length) {
var path = paths[index],
value = baseGet(object, path);
if (predicate(value, path)) {
baseSet(result, castPath(path, object), value);
}
}
return result;
}
/**
* A specialized version of `baseProperty` which supports deep paths.
*
* @private
* @param {Array|string} path The path of the property to get.
* @returns {Function} Returns the new accessor function.
*/
function basePropertyDeep(path) {
return function(object) {
return baseGet(object, path);
};
}
/**
* The base implementation of `_.pullAllBy` without support for iteratee
* shorthands.
*
* @private
* @param {Array} array The array to modify.
* @param {Array} values The values to remove.
* @param {Function} [iteratee] The iteratee invoked per element.
* @param {Function} [comparator] The comparator invoked per element.
* @returns {Array} Returns `array`.
*/
function basePullAll(array, values, iteratee, comparator) {
var indexOf = comparator ? baseIndexOfWith : baseIndexOf,
index = -1,
length = values.length,
seen = array;
if (array === values) {
values = copyArray(values);
}
if (iteratee) {
seen = arrayMap(array, baseUnary(iteratee));
}
while (++index < length) {
var fromIndex = 0,
value = values[index],
computed = iteratee ? iteratee(value) : value;
while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) {
if (seen !== array) {
splice.call(seen, fromIndex, 1);
}
splice.call(array, fromIndex, 1);
}
}
return array;
}
/**
* The base implementation of `_.pullAt` without support for individual
* indexes or capturing the removed elements.
*
* @private
* @param {Array} array The array to modify.
* @param {number[]} indexes The indexes of elements to remove.
* @returns {Array} Returns `array`.
*/
function basePullAt(array, indexes) {
var length = array ? indexes.length : 0,
lastIndex = length - 1;
while (length--) {
var index = indexes[length];
if (length == lastIndex || index !== previous) {
var previous = index;
if (isIndex(index)) {
splice.call(array, index, 1);
} else {
baseUnset(array, index);
}
}
}
return array;
}
/**
* The base implementation of `_.random` without support for returning
* floating-point numbers.
*
* @private
* @param {number} lower The lower bound.
* @param {number} upper The upper bound.
* @returns {number} Returns the random number.
*/
function baseRandom(lower, upper) {
return lower + nativeFloor(nativeRandom() * (upper - lower + 1));
}
/**
* The base implementation of `_.range` and `_.rangeRight` which doesn't
* coerce arguments.
*
* @private
* @param {number} start The start of the range.
* @param {number} end The end of the range.
* @param {number} step The value to increment or decrement by.
* @param {boolean} [fromRight] Specify iterating from right to left.
* @returns {Array} Returns the range of numbers.
*/
function baseRange(start, end, step, fromRight) {
var index = -1,
length = nativeMax(nativeCeil((end - start) / (step || 1)), 0),
result = Array(length);
while (length--) {
result[fromRight ? length : ++index] = start;
start += step;
}
return result;
}
/**
* The base implementation of `_.repeat` which doesn't coerce arguments.
*
* @private
* @param {string} string The string to repeat.
* @param {number} n The number of times to repeat the string.
* @returns {string} Returns the repeated string.
*/
function baseRepeat(string, n) {
var result = '';
if (!string || n < 1 || n > MAX_SAFE_INTEGER) {
return result;
}
// Leverage the exponentiation by squaring algorithm for a faster repeat.
// See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details.
do {
if (n % 2) {
result += string;
}
n = nativeFloor(n / 2);
if (n) {
string += string;
}
} while (n);
return result;
}
/**
* The base implementation of `_.rest` which doesn't validate or coerce arguments.
*
* @private
* @param {Function} func The function to apply a rest parameter to.
* @param {number} [start=func.length-1] The start position of the rest parameter.
* @returns {Function} Returns the new function.
*/
function baseRest(func, start) {
return setToString(overRest(func, start, identity), func + '');
}
/**
* The base implementation of `_.sample`.
*
* @private
* @param {Array|Object} collection The collection to sample.
* @returns {*} Returns the random element.
*/
function baseSample(collection) {
return arraySample(values(collection));
}
/**
* The base implementation of `_.sampleSize` without param guards.
*
* @private
* @param {Array|Object} collection The collection to sample.
* @param {number} n The number of elements to sample.
* @returns {Array} Returns the random elements.
*/
function baseSampleSize(collection, n) {
var array = values(collection);
return shuffleSelf(array, baseClamp(n, 0, array.length));
}
/**
* The base implementation of `_.set`.
*
* @private
* @param {Object} object The object to modify.
* @param {Array|string} path The path of the property to set.
* @param {*} value The value to set.
* @param {Function} [customizer] The function to customize path creation.
* @returns {Object} Returns `object`.
*/
function baseSet(object, path, value, customizer) {
if (!isObject(object)) {
return object;
}
path = castPath(path, object);
var index = -1,
length = path.length,
lastIndex = length - 1,
nested = object;
while (nested != null && ++index < length) {
var key = toKey(path[index]),
newValue = value;
if (index != lastIndex) {
var objValue = nested[key];
newValue = customizer ? customizer(objValue, key, nested) : undefined;
if (newValue === undefined) {
newValue = isObject(objValue)
? objValue
: (isIndex(path[index + 1]) ? [] : {});
}
}
assignValue(nested, key, newValue);
nested = nested[key];
}
return object;
}
/**
* The base implementation of `setData` without support for hot loop shorting.
*
* @private
* @param {Function} func The function to associate metadata with.
* @param {*} data The metadata.
* @returns {Function} Returns `func`.
*/
var baseSetData = !metaMap ? identity : function(func, data) {
metaMap.set(func, data);
return func;
};
/**
* The base implementation of `setToString` without support for hot loop shorting.
*
* @private
* @param {Function} func The function to modify.
* @param {Function} string The `toString` result.
* @returns {Function} Returns `func`.
*/
var baseSetToString = !defineProperty ? identity : function(func, string) {
return defineProperty(func, 'toString', {
'configurable': true,
'enumerable': false,
'value': constant(string),
'writable': true
});
};
/**
* The base implementation of `_.shuffle`.
*
* @private
* @param {Array|Object} collection The collection to shuffle.
* @returns {Array} Returns the new shuffled array.
*/
function baseShuffle(collection) {
return shuffleSelf(values(collection));
}
/**
* The base implementation of `_.slice` without an iteratee call guard.
*
* @private
* @param {Array} array The array to slice.
* @param {number} [start=0] The start position.
* @param {number} [end=array.length] The end position.
* @returns {Array} Returns the slice of `array`.
*/
function baseSlice(array, start, end) {
var index = -1,
length = array.length;
if (start < 0) {
start = -start > length ? 0 : (length + start);
}
end = end > length ? length : end;
if (end < 0) {
end += length;
}
length = start > end ? 0 : ((end - start) >>> 0);
start >>>= 0;
var result = Array(length);
while (++index < length) {
result[index] = array[index + start];
}
return result;
}
/**
* The base implementation of `_.some` without support for iteratee shorthands.
*
* @private
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} predicate The function invoked per iteration.
* @returns {boolean} Returns `true` if any element passes the predicate check,
* else `false`.
*/
function baseSome(collection, predicate) {
var result;
baseEach(collection, function(value, index, collection) {
result = predicate(value, index, collection);
return !result;
});
return !!result;
}
/**
* The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which
* performs a binary search of `array` to determine the index at which `value`
* should be inserted into `array` in order to maintain its sort order.
*
* @private
* @param {Array} array The sorted array to inspect.
* @param {*} value The value to evaluate.
* @param {boolean} [retHighest] Specify returning the highest qualified index.
* @returns {number} Returns the index at which `value` should be inserted
* into `array`.
*/
function baseSortedIndex(array, value, retHighest) {
var low = 0,
high = array == null ? low : array.length;
if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) {
while (low < high) {
var mid = (low + high) >>> 1,
computed = array[mid];
if (computed !== null && !isSymbol(computed) &&
(retHighest ? (computed <= value) : (computed < value))) {
low = mid + 1;
} else {
high = mid;
}
}
return high;
}
return baseSortedIndexBy(array, value, identity, retHighest);
}
/**
* The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy`
* which invokes `iteratee` for `value` and each element of `array` to compute
* their sort ranking. The iteratee is invoked with one argument; (value).
*
* @private
* @param {Array} array The sorted array to inspect.
* @param {*} value The value to evaluate.
* @param {Function} iteratee The iteratee invoked per element.
* @param {boolean} [retHighest] Specify returning the highest qualified index.
* @returns {number} Returns the index at which `value` should be inserted
* into `array`.
*/
function baseSortedIndexBy(array, value, iteratee, retHighest) {
value = iteratee(value);
var low = 0,
high = array == null ? 0 : array.length,
valIsNaN = value !== value,
valIsNull = value === null,
valIsSymbol = isSymbol(value),
valIsUndefined = value === undefined;
while (low < high) {
var mid = nativeFloor((low + high) / 2),
computed = iteratee(array[mid]),
othIsDefined = computed !== undefined,
othIsNull = computed === null,
othIsReflexive = computed === computed,
othIsSymbol = isSymbol(computed);
if (valIsNaN) {
var setLow = retHighest || othIsReflexive;
} else if (valIsUndefined) {
setLow = othIsReflexive && (retHighest || othIsDefined);
} else if (valIsNull) {
setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
} else if (valIsSymbol) {
setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
} else if (othIsNull || othIsSymbol) {
setLow = false;
} else {
setLow = retHighest ? (computed <= value) : (computed < value);
}
if (setLow) {
low = mid + 1;
} else {
high = mid;
}
}
return nativeMin(high, MAX_ARRAY_INDEX);
}
/**
* The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without
* support for iteratee shorthands.
*
* @private
* @param {Array} array The array to inspect.
* @param {Function} [iteratee] The iteratee invoked per element.
* @returns {Array} Returns the new duplicate free array.
*/
function baseSortedUniq(array, iteratee) {
var index = -1,
length = array.length,
resIndex = 0,
result = [];
while (++index < length) {
var value = array[index],
computed = iteratee ? iteratee(value) : value;
if (!index || !eq(computed, seen)) {
var seen = computed;
result[resIndex++] = value === 0 ? 0 : value;
}
}
return result;
}
/**
* The base implementation of `_.toNumber` which doesn't ensure correct
* conversions of binary, hexadecimal, or octal string values.
*
* @private
* @param {*} value The value to process.
* @returns {number} Returns the number.
*/
function baseToNumber(value) {
if (typeof value == 'number') {
return value;
}
if (isSymbol(value)) {
return NAN;
}
return +value;
}
/**
* The base implementation of `_.toString` which doesn't convert nullish
* values to empty strings.
*
* @private
* @param {*} value The value to process.
* @returns {string} Returns the string.
*/
function baseToString(value) {
// Exit early for strings to avoid a performance hit in some environments.
if (typeof value == 'string') {
return value;
}
if (isArray(value)) {
// Recursively convert values (susceptible to call stack limits).
return arrayMap(value, baseToString) + '';
}
if (isSymbol(value)) {
return symbolToString ? symbolToString.call(value) : '';
}
var result = (value + '');
return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
}
/**
* The base implementation of `_.uniqBy` without support for iteratee shorthands.
*
* @private
* @param {Array} array The array to inspect.
* @param {Function} [iteratee] The iteratee invoked per element.
* @param {Function} [comparator] The comparator invoked per element.
* @returns {Array} Returns the new duplicate free array.
*/
function baseUniq(array, iteratee, comparator) {
var index = -1,
includes = arrayIncludes,
length = array.length,
isCommon = true,
result = [],
seen = result;
if (comparator) {
isCommon = false;
includes = arrayIncludesWith;
}
else if (length >= LARGE_ARRAY_SIZE) {
var set = iteratee ? null : createSet(array);
if (set) {
return setToArray(set);
}
isCommon = false;
includes = cacheHas;
seen = new SetCache;
}
else {
seen = iteratee ? [] : result;
}
outer:
while (++index < length) {
var value = array[index],
computed = iteratee ? iteratee(value) : value;
value = (comparator || value !== 0) ? value : 0;
if (isCommon && computed === computed) {
var seenIndex = seen.length;
while (seenIndex--) {
if (seen[seenIndex] === computed) {
continue outer;
}
}
if (iteratee) {
seen.push(computed);
}
result.push(value);
}
else if (!includes(seen, computed, comparator)) {
if (seen !== result) {
seen.push(computed);
}
result.push(value);
}
}
return result;
}
/**
* The base implementation of `_.unset`.
*
* @private
* @param {Object} object The object to modify.
* @param {Array|string} path The property path to unset.
* @returns {boolean} Returns `true` if the property is deleted, else `false`.
*/
function baseUnset(object, path) {
path = castPath(path, object);
object = parent(object, path);
return object == null || delete object[toKey(last(path))];
}
/**
* The base implementation of `_.update`.
*
* @private
* @param {Object} object The object to modify.
* @param {Array|string} path The path of the property to update.
* @param {Function} updater The function to produce the updated value.
* @param {Function} [customizer] The function to customize path creation.
* @returns {Object} Returns `object`.
*/
function baseUpdate(object, path, updater, customizer) {
return baseSet(object, path, updater(baseGet(object, path)), customizer);
}
/**
* The base implementation of methods like `_.dropWhile` and `_.takeWhile`
* without support for iteratee shorthands.
*
* @private
* @param {Array} array The array to query.
* @param {Function} predicate The function invoked per iteration.
* @param {boolean} [isDrop] Specify dropping elements instead of taking them.
* @param {boolean} [fromRight] Specify iterating from right to left.
* @returns {Array} Returns the slice of `array`.
*/
function baseWhile(array, predicate, isDrop, fromRight) {
var length = array.length,
index = fromRight ? length : -1;
while ((fromRight ? index-- : ++index < length) &&
predicate(array[index], index, array)) {}
return isDrop
? baseSlice(array, (fromRight ? 0 : index), (fromRight ? index + 1 : length))
: baseSlice(array, (fromRight ? index + 1 : 0), (fromRight ? length : index));
}
/**
* The base implementation of `wrapperValue` which returns the result of
* performing a sequence of actions on the unwrapped `value`, where each
* successive action is supplied the return value of the previous.
*
* @private
* @param {*} value The unwrapped value.
* @param {Array} actions Actions to perform to resolve the unwrapped value.
* @returns {*} Returns the resolved value.
*/
function baseWrapperValue(value, actions) {
var result = value;
if (result instanceof LazyWrapper) {
result = result.value();
}
return arrayReduce(actions, function(result, action) {
return action.func.apply(action.thisArg, arrayPush([result], action.args));
}, result);
}
/**
* The base implementation of methods like `_.xor`, without support for
* iteratee shorthands, that accepts an array of arrays to inspect.
*
* @private
* @param {Array} arrays The arrays to inspect.
* @param {Function} [iteratee] The iteratee invoked per element.
* @param {Function} [comparator] The comparator invoked per element.
* @returns {Array} Returns the new array of values.
*/
function baseXor(arrays, iteratee, comparator) {
var length = arrays.length;
if (length < 2) {
return length ? baseUniq(arrays[0]) : [];
}
var index = -1,
result = Array(length);
while (++index < length) {
var array = arrays[index],
othIndex = -1;
while (++othIndex < length) {
if (othIndex != index) {
result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator);
}
}
}
return baseUniq(baseFlatten(result, 1), iteratee, comparator);
}
/**
* This base implementation of `_.zipObject` which assigns values using `assignFunc`.
*
* @private
* @param {Array} props The property identifiers.
* @param {Array} values The property values.
* @param {Function} assignFunc The function to assign values.
* @returns {Object} Returns the new object.
*/
function baseZipObject(props, values, assignFunc) {
var index = -1,
length = props.length,
valsLength = values.length,
result = {};
while (++index < length) {
var value = index < valsLength ? values[index] : undefined;
assignFunc(result, props[index], value);
}
return result;
}
/**
* Casts `value` to an empty array if it's not an array like object.
*
* @private
* @param {*} value The value to inspect.
* @returns {Array|Object} Returns the cast array-like object.
*/
function castArrayLikeObject(value) {
return isArrayLikeObject(value) ? value : [];
}
/**
* Casts `value` to `identity` if it's not a function.
*
* @private
* @param {*} value The value to inspect.
* @returns {Function} Returns cast function.
*/
function castFunction(value) {
return typeof value == 'function' ? value : identity;
}
/**
* Casts `value` to a path array if it's not one.
*
* @private
* @param {*} value The value to inspect.
* @param {Object} [object] The object to query keys on.
* @returns {Array} Returns the cast property path array.
*/
function castPath(value, object) {
if (isArray(value)) {
return value;
}
return isKey(value, object) ? [value] : stringToPath(toString(value));
}
/**
* A `baseRest` alias which can be replaced with `identity` by module
* replacement plugins.
*
* @private
* @type {Function}
* @param {Function} func The function to apply a rest parameter to.
* @returns {Function} Returns the new function.
*/
var castRest = baseRest;
/**
* Casts `array` to a slice if it's needed.
*
* @private
* @param {Array} array The array to inspect.
* @param {number} start The start position.
* @param {number} [end=array.length] The end position.
* @returns {Array} Returns the cast slice.
*/
function castSlice(array, start, end) {
var length = array.length;
end = end === undefined ? length : end;
return (!start && end >= length) ? array : baseSlice(array, start, end);
}
/**
* A simple wrapper around the global [`clearTimeout`](https://mdn.io/clearTimeout).
*
* @private
* @param {number|Object} id The timer id or timeout object of the timer to clear.
*/
var clearTimeout = ctxClearTimeout || function(id) {
return root.clearTimeout(id);
};
/**
* Creates a clone of `buffer`.
*
* @private
* @param {Buffer} buffer The buffer to clone.
* @param {boolean} [isDeep] Specify a deep clone.
* @returns {Buffer} Returns the cloned buffer.
*/
function cloneBuffer(buffer, isDeep) {
if (isDeep) {
return buffer.slice();
}
var length = buffer.length,
result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
buffer.copy(result);
return result;
}
/**
* Creates a clone of `arrayBuffer`.
*
* @private
* @param {ArrayBuffer} arrayBuffer The array buffer to clone.
* @returns {ArrayBuffer} Returns the cloned array buffer.
*/
function cloneArrayBuffer(arrayBuffer) {
var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
new Uint8Array(result).set(new Uint8Array(arrayBuffer));
return result;
}
/**
* Creates a clone of `dataView`.
*
* @private
* @param {Object} dataView The data view to clone.
* @param {boolean} [isDeep] Specify a deep clone.
* @returns {Object} Returns the cloned data view.
*/
function cloneDataView(dataView, isDeep) {
var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
}
/**
* Creates a clone of `regexp`.
*
* @private
* @param {Object} regexp The regexp to clone.
* @returns {Object} Returns the cloned regexp.
*/
function cloneRegExp(regexp) {
var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
result.lastIndex = regexp.lastIndex;
return result;
}
/**
* Creates a clone of the `symbol` object.
*
* @private
* @param {Object} symbol The symbol object to clone.
* @returns {Object} Returns the cloned symbol object.
*/
function cloneSymbol(symbol) {
return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
}
/**
* Creates a clone of `typedArray`.
*
* @private
* @param {Object} typedArray The typed array to clone.
* @param {boolean} [isDeep] Specify a deep clone.
* @returns {Object} Returns the cloned typed array.
*/
function cloneTypedArray(typedArray, isDeep) {
var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
}
/**
* Compares values to sort them in ascending order.
*
* @private
* @param {*} value The value to compare.
* @param {*} other The other value to compare.
* @returns {number} Returns the sort order indicator for `value`.
*/
function compareAscending(value, other) {
if (value !== other) {
var valIsDefined = value !== undefined,
valIsNull = value === null,
valIsReflexive = value === value,
valIsSymbol = isSymbol(value);
var othIsDefined = other !== undefined,
othIsNull = other === null,
othIsReflexive = other === other,
othIsSymbol = isSymbol(other);
if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) ||
(valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) ||
(valIsNull && othIsDefined && othIsReflexive) ||
(!valIsDefined && othIsReflexive) ||
!valIsReflexive) {
return 1;
}
if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) ||
(othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) ||
(othIsNull && valIsDefined && valIsReflexive) ||
(!othIsDefined && valIsReflexive) ||
!othIsReflexive) {
return -1;
}
}
return 0;
}
/**
* Used by `_.orderBy` to compare multiple properties of a value to another
* and stable sort them.
*
* If `orders` is unspecified, all values are sorted in ascending order. Otherwise,
* specify an order of "desc" for descending or "asc" for ascending sort order
* of corresponding values.
*
* @private
* @param {Object} object The object to compare.
* @param {Object} other The other object to compare.
* @param {boolean[]|string[]} orders The order to sort by for each property.
* @returns {number} Returns the sort order indicator for `object`.
*/
function compareMultiple(object, other, orders) {
var index = -1,
objCriteria = object.criteria,
othCriteria = other.criteria,
length = objCriteria.length,
ordersLength = orders.length;
while (++index < length) {
var result = compareAscending(objCriteria[index], othCriteria[index]);
if (result) {
if (index >= ordersLength) {
return result;
}
var order = orders[index];
return result * (order == 'desc' ? -1 : 1);
}
}
// Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications
// that causes it, under certain circumstances, to provide the same value for
// `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247
// for more details.
//
// This also ensures a stable sort in V8 and other engines.
// See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.
return object.index - other.index;
}
/**
* Creates an array that is the composition of partially applied arguments,
* placeholders, and provided arguments into a single array of arguments.
*
* @private
* @param {Array} args The provided arguments.
* @param {Array} partials The arguments to prepend to those provided.
* @param {Array} holders The `partials` placeholder indexes.
* @params {boolean} [isCurried] Specify composing for a curried function.
* @returns {Array} Returns the new array of composed arguments.
*/
function composeArgs(args, partials, holders, isCurried) {
var argsIndex = -1,
argsLength = args.length,
holdersLength = holders.length,
leftIndex = -1,
leftLength = partials.length,
rangeLength = nativeMax(argsLength - holdersLength, 0),
result = Array(leftLength + rangeLength),
isUncurried = !isCurried;
while (++leftIndex < leftLength) {
result[leftIndex] = partials[leftIndex];
}
while (++argsIndex < holdersLength) {
if (isUncurried || argsIndex < argsLength) {
result[holders[argsIndex]] = args[argsIndex];
}
}
while (rangeLength--) {
result[leftIndex++] = args[argsIndex++];
}
return result;
}
/**
* This function is like `composeArgs` except that the arguments composition
* is tailored for `_.partialRight`.
*
* @private
* @param {Array} args The provided arguments.
* @param {Array} partials The arguments to append to those provided.
* @param {Array} holders The `partials` placeholder indexes.
* @params {boolean} [isCurried] Specify composing for a curried function.
* @returns {Array} Returns the new array of composed arguments.
*/
function composeArgsRight(args, partials, holders, isCurried) {
var argsIndex = -1,
argsLength = args.length,
holdersIndex = -1,
holdersLength = holders.length,
rightIndex = -1,
rightLength = partials.length,
rangeLength = nativeMax(argsLength - holdersLength, 0),
result = Array(rangeLength + rightLength),
isUncurried = !isCurried;
while (++argsIndex < rangeLength) {
result[argsIndex] = args[argsIndex];
}
var offset = argsIndex;
while (++rightIndex < rightLength) {
result[offset + rightIndex] = partials[rightIndex];
}
while (++holdersIndex < holdersLength) {
if (isUncurried || argsIndex < argsLength) {
result[offset + holders[holdersIndex]] = args[argsIndex++];
}
}
return result;
}
/**
* Copies the values of `source` to `array`.
*
* @private
* @param {Array} source The array to copy values from.
* @param {Array} [array=[]] The array to copy values to.
* @returns {Array} Returns `array`.
*/
function copyArray(source, array) {
var index = -1,
length = source.length;
array || (array = Array(length));
while (++index < length) {
array[index] = source[index];
}
return array;
}
/**
* Copies properties of `source` to `object`.
*
* @private
* @param {Object} source The object to copy properties from.
* @param {Array} props The property identifiers to copy.
* @param {Object} [object={}] The object to copy properties to.
* @param {Function} [customizer] The function to customize copied values.
* @returns {Object} Returns `object`.
*/
function copyObject(source, props, object, customizer) {
var isNew = !object;
object || (object = {});
var index = -1,
length = props.length;
while (++index < length) {
var key = props[index];
var newValue = customizer
? customizer(object[key], source[key], key, object, source)
: undefined;
if (newValue === undefined) {
newValue = source[key];
}
if (isNew) {
baseAssignValue(object, key, newValue);
} else {
assignValue(object, key, newValue);
}
}
return object;
}
/**
* Copies own symbols of `source` to `object`.
*
* @private
* @param {Object} source The object to copy symbols from.
* @param {Object} [object={}] The object to copy symbols to.
* @returns {Object} Returns `object`.
*/
function copySymbols(source, object) {
return copyObject(source, getSymbols(source), object);
}
/**
* Copies own and inherited symbols of `source` to `object`.
*
* @private
* @param {Object} source The object to copy symbols from.
* @param {Object} [object={}] The object to copy symbols to.
* @returns {Object} Returns `object`.
*/
function copySymbolsIn(source, object) {
return copyObject(source, getSymbolsIn(source), object);
}
/**
* Creates a function like `_.groupBy`.
*
* @private
* @param {Function} setter The function to set accumulator values.
* @param {Function} [initializer] The accumulator object initializer.
* @returns {Function} Returns the new aggregator function.
*/
function createAggregator(setter, initializer) {
return function(collection, iteratee) {
var func = isArray(collection) ? arrayAggregator : baseAggregator,
accumulator = initializer ? initializer() : {};
return func(collection, setter, getIteratee(iteratee, 2), accumulator);
};
}
/**
* Creates a function like `_.assign`.
*
* @private
* @param {Function} assigner The function to assign values.
* @returns {Function} Returns the new assigner function.
*/
function createAssigner(assigner) {
return baseRest(function(object, sources) {
var index = -1,
length = sources.length,
customizer = length > 1 ? sources[length - 1] : undefined,
guard = length > 2 ? sources[2] : undefined;
customizer = (assigner.length > 3 && typeof customizer == 'function')
? (length--, customizer)
: undefined;
if (guard && isIterateeCall(sources[0], sources[1], guard)) {
customizer = length < 3 ? undefined : customizer;
length = 1;
}
object = Object(object);
while (++index < length) {
var source = sources[index];
if (source) {
assigner(object, source, index, customizer);
}
}
return object;
});
}
/**
* Creates a `baseEach` or `baseEachRight` function.
*
* @private
* @param {Function} eachFunc The function to iterate over a collection.
* @param {boolean} [fromRight] Specify iterating from right to left.
* @returns {Function} Returns the new base function.
*/
function createBaseEach(eachFunc, fromRight) {
return function(collection, iteratee) {
if (collection == null) {
return collection;
}
if (!isArrayLike(collection)) {
return eachFunc(collection, iteratee);
}
var length = collection.length,
index = fromRight ? length : -1,
iterable = Object(collection);
while ((fromRight ? index-- : ++index < length)) {
if (iteratee(iterable[index], index, iterable) === false) {
break;
}
}
return collection;
};
}
/**
* Creates a base function for methods like `_.forIn` and `_.forOwn`.
*
* @private
* @param {boolean} [fromRight] Specify iterating from right to left.
* @returns {Function} Returns the new base function.
*/
function createBaseFor(fromRight) {
return function(object, iteratee, keysFunc) {
var index = -1,
iterable = Object(object),
props = keysFunc(object),
length = props.length;
while (length--) {
var key = props[fromRight ? length : ++index];
if (iteratee(iterable[key], key, iterable) === false) {
break;
}
}
return object;
};
}
/**
* Creates a function that wraps `func` to invoke it with the optional `this`
* binding of `thisArg`.
*
* @private
* @param {Function} func The function to wrap.
* @param {number} bitmask The bitmask flags. See `createWrap` for more details.
* @param {*} [thisArg] The `this` binding of `func`.
* @returns {Function} Returns the new wrapped function.
*/
function createBind(func, bitmask, thisArg) {
var isBind = bitmask & WRAP_BIND_FLAG,
Ctor = createCtor(func);
function wrapper() {
var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
return fn.apply(isBind ? thisArg : this, arguments);
}
return wrapper;
}
/**
* Creates a function like `_.lowerFirst`.
*
* @private
* @param {string} methodName The name of the `String` case method to use.
* @returns {Function} Returns the new case function.
*/
function createCaseFirst(methodName) {
return function(string) {
string = toString(string);
var strSymbols = hasUnicode(string)
? stringToArray(string)
: undefined;
var chr = strSymbols
? strSymbols[0]
: string.charAt(0);
var trailing = strSymbols
? castSlice(strSymbols, 1).join('')
: string.slice(1);
return chr[methodName]() + trailing;
};
}
/**
* Creates a function like `_.camelCase`.
*
* @private
* @param {Function} callback The function to combine each word.
* @returns {Function} Returns the new compounder function.
*/
function createCompounder(callback) {
return function(string) {
return arrayReduce(words(deburr(string).replace(reApos, '')), callback, '');
};
}
/**
* Creates a function that produces an instance of `Ctor` regardless of
* whether it was invoked as part of a `new` expression or by `call` or `apply`.
*
* @private
* @param {Function} Ctor The constructor to wrap.
* @returns {Function} Returns the new wrapped function.
*/
function createCtor(Ctor) {
return function() {
// Use a `switch` statement to work with class constructors. See
// http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist
// for more details.
var args = arguments;
switch (args.length) {
case 0: return new Ctor;
case 1: return new Ctor(args[0]);
case 2: return new Ctor(args[0], args[1]);
case 3: return new Ctor(args[0], args[1], args[2]);
case 4: return new Ctor(args[0], args[1], args[2], args[3]);
case 5: return new Ctor(args[0], args[1], args[2], args[3], args[4]);
case 6: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);
case 7: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
}
var thisBinding = baseCreate(Ctor.prototype),
result = Ctor.apply(thisBinding, args);
// Mimic the constructor's `return` behavior.
// See https://es5.github.io/#x13.2.2 for more details.
return isObject(result) ? result : thisBinding;
};
}
/**
* Creates a function that wraps `func` to enable currying.
*
* @private
* @param {Function} func The function to wrap.
* @param {number} bitmask The bitmask flags. See `createWrap` for more details.
* @param {number} arity The arity of `func`.
* @returns {Function} Returns the new wrapped function.
*/
function createCurry(func, bitmask, arity) {
var Ctor = createCtor(func);
function wrapper() {
var length = arguments.length,
args = Array(length),
index = length,
placeholder = getHolder(wrapper);
while (index--) {
args[index] = arguments[index];
}
var holders = (length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder)
? []
: replaceHolders(args, placeholder);
length -= holders.length;
if (length < arity) {
return createRecurry(
func, bitmask, createHybrid, wrapper.placeholder, undefined,
args, holders, undefined, undefined, arity - length);
}
var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
return apply(fn, this, args);
}
return wrapper;
}
/**
* Creates a `_.find` or `_.findLast` function.
*
* @private
* @param {Function} findIndexFunc The function to find the collection index.
* @returns {Function} Returns the new find function.
*/
function createFind(findIndexFunc) {
return function(collection, predicate, fromIndex) {
var iterable = Object(collection);
if (!isArrayLike(collection)) {
var iteratee = getIteratee(predicate, 3);
collection = keys(collection);
predicate = function(key) { return iteratee(iterable[key], key, iterable); };
}
var index = findIndexFunc(collection, predicate, fromIndex);
return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;
};
}
/**
* Creates a `_.flow` or `_.flowRight` function.
*
* @private
* @param {boolean} [fromRight] Specify iterating from right to left.
* @returns {Function} Returns the new flow function.
*/
function createFlow(fromRight) {
return flatRest(function(funcs) {
var length = funcs.length,
index = length,
prereq = LodashWrapper.prototype.thru;
if (fromRight) {
funcs.reverse();
}
while (index--) {
var func = funcs[index];
if (typeof func != 'function') {
throw new TypeError(FUNC_ERROR_TEXT);
}
if (prereq && !wrapper && getFuncName(func) == 'wrapper') {
var wrapper = new LodashWrapper([], true);
}
}
index = wrapper ? index : length;
while (++index < length) {
func = funcs[index];
var funcName = getFuncName(func),
data = funcName == 'wrapper' ? getData(func) : undefined;
if (data && isLaziable(data[0]) &&
data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) &&
!data[4].length && data[9] == 1
) {
wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);
} else {
wrapper = (func.length == 1 && isLaziable(func))
? wrapper[funcName]()
: wrapper.thru(func);
}
}
return function() {
var args = arguments,
value = args[0];
if (wrapper && args.length == 1 && isArray(value)) {
return wrapper.plant(value).value();
}
var index = 0,
result = length ? funcs[index].apply(this, args) : value;
while (++index < length) {
result = funcs[index].call(this, result);
}
return result;
};
});
}
/**
* Creates a function that wraps `func` to invoke it with optional `this`
* binding of `thisArg`, partial application, and currying.
*
* @private
* @param {Function|string} func The function or method name to wrap.
* @param {number} bitmask The bitmask flags. See `createWrap` for more details.
* @param {*} [thisArg] The `this` binding of `func`.
* @param {Array} [partials] The arguments to prepend to those provided to
* the new function.
* @param {Array} [holders] The `partials` placeholder indexes.
* @param {Array} [partialsRight] The arguments to append to those provided
* to the new function.
* @param {Array} [holdersRight] The `partialsRight` placeholder indexes.
* @param {Array} [argPos] The argument positions of the new function.
* @param {number} [ary] The arity cap of `func`.
* @param {number} [arity] The arity of `func`.
* @returns {Function} Returns the new wrapped function.
*/
function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {
var isAry = bitmask & WRAP_ARY_FLAG,
isBind = bitmask & WRAP_BIND_FLAG,
isBindKey = bitmask & WRAP_BIND_KEY_FLAG,
isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG),
isFlip = bitmask & WRAP_FLIP_FLAG,
Ctor = isBindKey ? undefined : createCtor(func);
function wrapper() {
var length = arguments.length,
args = Array(length),
index = length;
while (index--) {
args[index] = arguments[index];
}
if (isCurried) {
var placeholder = getHolder(wrapper),
holdersCount = countHolders(args, placeholder);
}
if (partials) {
args = composeArgs(args, partials, holders, isCurried);
}
if (partialsRight) {
args = composeArgsRight(args, partialsRight, holdersRight, isCurried);
}
length -= holdersCount;
if (isCurried && length < arity) {
var newHolders = replaceHolders(args, placeholder);
return createRecurry(
func, bitmask, createHybrid, wrapper.placeholder, thisArg,
args, newHolders, argPos, ary, arity - length
);
}
var thisBinding = isBind ? thisArg : this,
fn = isBindKey ? thisBinding[func] : func;
length = args.length;
if (argPos) {
args = reorder(args, argPos);
} else if (isFlip && length > 1) {
args.reverse();
}
if (isAry && ary < length) {
args.length = ary;
}
if (this && this !== root && this instanceof wrapper) {
fn = Ctor || createCtor(fn);
}
return fn.apply(thisBinding, args);
}
return wrapper;
}
/**
* Creates a function like `_.invertBy`.
*
* @private
* @param {Function} setter The function to set accumulator values.
* @param {Function} toIteratee The function to resolve iteratees.
* @returns {Function} Returns the new inverter function.
*/
function createInverter(setter, toIteratee) {
return function(object, iteratee) {
return baseInverter(object, setter, toIteratee(iteratee), {});
};
}
/**
* Creates a function that performs a mathematical operation on two values.
*
* @private
* @param {Function} operator The function to perform the operation.
* @param {number} [defaultValue] The value used for `undefined` arguments.
* @returns {Function} Returns the new mathematical operation function.
*/
function createMathOperation(operator, defaultValue) {
return function(value, other) {
var result;
if (value === undefined && other === undefined) {
return defaultValue;
}
if (value !== undefined) {
result = value;
}
if (other !== undefined) {
if (result === undefined) {
return other;
}
if (typeof value == 'string' || typeof other == 'string') {
value = baseToString(value);
other = baseToString(other);
} else {
value = baseToNumber(value);
other = baseToNumber(other);
}
result = operator(value, other);
}
return result;
};
}
/**
* Creates a function like `_.over`.
*
* @private
* @param {Function} arrayFunc The function to iterate over iteratees.
* @returns {Function} Returns the new over function.
*/
function createOver(arrayFunc) {
return flatRest(function(iteratees) {
iteratees = arrayMap(iteratees, baseUnary(getIteratee()));
return baseRest(function(args) {
var thisArg = this;
return arrayFunc(iteratees, function(iteratee) {
return apply(iteratee, thisArg, args);
});
});
});
}
/**
* Creates the padding for `string` based on `length`. The `chars` string
* is truncated if the number of characters exceeds `length`.
*
* @private
* @param {number} length The padding length.
* @param {string} [chars=' '] The string used as padding.
* @returns {string} Returns the padding for `string`.
*/
function createPadding(length, chars) {
chars = chars === undefined ? ' ' : baseToString(chars);
var charsLength = chars.length;
if (charsLength < 2) {
return charsLength ? baseRepeat(chars, length) : chars;
}
var result = baseRepeat(chars, nativeCeil(length / stringSize(chars)));
return hasUnicode(chars)
? castSlice(stringToArray(result), 0, length).join('')
: result.slice(0, length);
}
/**
* Creates a function that wraps `func` to invoke it with the `this` binding
* of `thisArg` and `partials` prepended to the arguments it receives.
*
* @private
* @param {Function} func The function to wrap.
* @param {number} bitmask The bitmask flags. See `createWrap` for more details.
* @param {*} thisArg The `this` binding of `func`.
* @param {Array} partials The arguments to prepend to those provided to
* the new function.
* @returns {Function} Returns the new wrapped function.
*/
function createPartial(func, bitmask, thisArg, partials) {
var isBind = bitmask & WRAP_BIND_FLAG,
Ctor = createCtor(func);
function wrapper() {
var argsIndex = -1,
argsLength = arguments.length,
leftIndex = -1,
leftLength = partials.length,
args = Array(leftLength + argsLength),
fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
while (++leftIndex < leftLength) {
args[leftIndex] = partials[leftIndex];
}
while (argsLength--) {
args[leftIndex++] = arguments[++argsIndex];
}
return apply(fn, isBind ? thisArg : this, args);
}
return wrapper;
}
/**
* Creates a `_.range` or `_.rangeRight` function.
*
* @private
* @param {boolean} [fromRight] Specify iterating from right to left.
* @returns {Function} Returns the new range function.
*/
function createRange(fromRight) {
return function(start, end, step) {
if (step && typeof step != 'number' && isIterateeCall(start, end, step)) {
end = step = undefined;
}
// Ensure the sign of `-0` is preserved.
start = toFinite(start);
if (end === undefined) {
end = start;
start = 0;
} else {
end = toFinite(end);
}
step = step === undefined ? (start < end ? 1 : -1) : toFinite(step);
return baseRange(start, end, step, fromRight);
};
}
/**
* Creates a function that performs a relational operation on two values.
*
* @private
* @param {Function} operator The function to perform the operation.
* @returns {Function} Returns the new relational operation function.
*/
function createRelationalOperation(operator) {
return function(value, other) {
if (!(typeof value == 'string' && typeof other == 'string')) {
value = toNumber(value);
other = toNumber(other);
}
return operator(value, other);
};
}
/**
* Creates a function that wraps `func` to continue currying.
*
* @private
* @param {Function} func The function to wrap.
* @param {number} bitmask The bitmask flags. See `createWrap` for more details.
* @param {Function} wrapFunc The function to create the `func` wrapper.
* @param {*} placeholder The placeholder value.
* @param {*} [thisArg] The `this` binding of `func`.
* @param {Array} [partials] The arguments to prepend to those provided to
* the new function.
* @param {Array} [holders] The `partials` placeholder indexes.
* @param {Array} [argPos] The argument positions of the new function.
* @param {number} [ary] The arity cap of `func`.
* @param {number} [arity] The arity of `func`.
* @returns {Function} Returns the new wrapped function.
*/
function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {
var isCurry = bitmask & WRAP_CURRY_FLAG,
newHolders = isCurry ? holders : undefined,
newHoldersRight = isCurry ? undefined : holders,
newPartials = isCurry ? partials : undefined,
newPartialsRight = isCurry ? undefined : partials;
bitmask |= (isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG);
bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);
if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {
bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);
}
var newData = [
func, bitmask, thisArg, newPartials, newHolders, newPartialsRight,
newHoldersRight, argPos, ary, arity
];
var result = wrapFunc.apply(undefined, newData);
if (isLaziable(func)) {
setData(result, newData);
}
result.placeholder = placeholder;
return setWrapToString(result, func, bitmask);
}
/**
* Creates a function like `_.round`.
*
* @private
* @param {string} methodName The name of the `Math` method to use when rounding.
* @returns {Function} Returns the new round function.
*/
function createRound(methodName) {
var func = Math[methodName];
return function(number, precision) {
number = toNumber(number);
precision = precision == null ? 0 : nativeMin(toInteger(precision), 292);
if (precision) {
// Shift with exponential notation to avoid floating-point issues.
// See [MDN](https://mdn.io/round#Examples) for more details.
var pair = (toString(number) + 'e').split('e'),
value = func(pair[0] + 'e' + (+pair[1] + precision));
pair = (toString(value) + 'e').split('e');
return +(pair[0] + 'e' + (+pair[1] - precision));
}
return func(number);
};
}
/**
* Creates a set object of `values`.
*
* @private
* @param {Array} values The values to add to the set.
* @returns {Object} Returns the new set.
*/
var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) {
return new Set(values);
};
/**
* Creates a `_.toPairs` or `_.toPairsIn` function.
*
* @private
* @param {Function} keysFunc The function to get the keys of a given object.
* @returns {Function} Returns the new pairs function.
*/
function createToPairs(keysFunc) {
return function(object) {
var tag = getTag(object);
if (tag == mapTag) {
return mapToArray(object);
}
if (tag == setTag) {
return setToPairs(object);
}
return baseToPairs(object, keysFunc(object));
};
}
/**
* Creates a function that either curries or invokes `func` with optional
* `this` binding and partially applied arguments.
*
* @private
* @param {Function|string} func The function or method name to wrap.
* @param {number} bitmask The bitmask flags.
* 1 - `_.bind`
* 2 - `_.bindKey`
* 4 - `_.curry` or `_.curryRight` of a bound function
* 8 - `_.curry`
* 16 - `_.curryRight`
* 32 - `_.partial`
* 64 - `_.partialRight`
* 128 - `_.rearg`
* 256 - `_.ary`
* 512 - `_.flip`
* @param {*} [thisArg] The `this` binding of `func`.
* @param {Array} [partials] The arguments to be partially applied.
* @param {Array} [holders] The `partials` placeholder indexes.
* @param {Array} [argPos] The argument positions of the new function.
* @param {number} [ary] The arity cap of `func`.
* @param {number} [arity] The arity of `func`.
* @returns {Function} Returns the new wrapped function.
*/
function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {
var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;
if (!isBindKey && typeof func != 'function') {
throw new TypeError(FUNC_ERROR_TEXT);
}
var length = partials ? partials.length : 0;
if (!length) {
bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);
partials = holders = undefined;
}
ary = ary === undefined ? ary : nativeMax(toInteger(ary), 0);
arity = arity === undefined ? arity : toInteger(arity);
length -= holders ? holders.length : 0;
if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {
var partialsRight = partials,
holdersRight = holders;
partials = holders = undefined;
}
var data = isBindKey ? undefined : getData(func);
var newData = [
func, bitmask, thisArg, partials, holders, partialsRight, holdersRight,
argPos, ary, arity
];
if (data) {
mergeData(newData, data);
}
func = newData[0];
bitmask = newData[1];
thisArg = newData[2];
partials = newData[3];
holders = newData[4];
arity = newData[9] = newData[9] === undefined
? (isBindKey ? 0 : func.length)
: nativeMax(newData[9] - length, 0);
if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {
bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);
}
if (!bitmask || bitmask == WRAP_BIND_FLAG) {
var result = createBind(func, bitmask, thisArg);
} else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {
result = createCurry(func, bitmask, arity);
} else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {
result = createPartial(func, bitmask, thisArg, partials);
} else {
result = createHybrid.apply(undefined, newData);
}
var setter = data ? baseSetData : setData;
return setWrapToString(setter(result, newData), func, bitmask);
}
/**
* Used by `_.defaults` to customize its `_.assignIn` use to assign properties
* of source objects to the destination object for all destination properties
* that resolve to `undefined`.
*
* @private
* @param {*} objValue The destination value.
* @param {*} srcValue The source value.
* @param {string} key The key of the property to assign.
* @param {Object} object The parent object of `objValue`.
* @returns {*} Returns the value to assign.
*/
function customDefaultsAssignIn(objValue, srcValue, key, object) {
if (objValue === undefined ||
(eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) {
return srcValue;
}
return objValue;
}
/**
* Used by `_.defaultsDeep` to customize its `_.merge` use to merge source
* objects into destination objects that are passed thru.
*
* @private
* @param {*} objValue The destination value.
* @param {*} srcValue The source value.
* @param {string} key The key of the property to merge.
* @param {Object} object The parent object of `objValue`.
* @param {Object} source The parent object of `srcValue`.
* @param {Object} [stack] Tracks traversed source values and their merged
* counterparts.
* @returns {*} Returns the value to assign.
*/
function customDefaultsMerge(objValue, srcValue, key, object, source, stack) {
if (isObject(objValue) && isObject(srcValue)) {
// Recursively merge objects and arrays (susceptible to call stack limits).
stack.set(srcValue, objValue);
baseMerge(objValue, srcValue, undefined, customDefaultsMerge, stack);
stack['delete'](srcValue);
}
return objValue;
}
/**
* Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain
* objects.
*
* @private
* @param {*} value The value to inspect.
* @param {string} key The key of the property to inspect.
* @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`.
*/
function customOmitClone(value) {
return isPlainObject(value) ? undefined : value;
}
/**
* A specialized version of `baseIsEqualDeep` for arrays with support for
* partial deep comparisons.
*
* @private
* @param {Array} array The array to compare.
* @param {Array} other The other array to compare.
* @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
* @param {Function} customizer The function to customize comparisons.
* @param {Function} equalFunc The function to determine equivalents of values.
* @param {Object} stack Tracks traversed `array` and `other` objects.
* @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
*/
function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
arrLength = array.length,
othLength = other.length;
if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
return false;
}
// Assume cyclic values are equal.
var stacked = stack.get(array);
if (stacked && stack.get(other)) {
return stacked == other;
}
var index = -1,
result = true,
seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;
stack.set(array, other);
stack.set(other, array);
// Ignore non-index properties.
while (++index < arrLength) {
var arrValue = array[index],
othValue = other[index];
if (customizer) {
var compared = isPartial
? customizer(othValue, arrValue, index, other, array, stack)
: customizer(arrValue, othValue, index, array, other, stack);
}
if (compared !== undefined) {
if (compared) {
continue;
}
result = false;
break;
}
// Recursively compare arrays (susceptible to call stack limits).
if (seen) {
if (!arraySome(other, function(othValue, othIndex) {
if (!cacheHas(seen, othIndex) &&
(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
return seen.push(othIndex);
}
})) {
result = false;
break;
}
} else if (!(
arrValue === othValue ||
equalFunc(arrValue, othValue, bitmask, customizer, stack)
)) {
result = false;
break;
}
}
stack['delete'](array);
stack['delete'](other);
return result;
}
/**
* A specialized version of `baseIsEqualDeep` for comparing objects of
* the same `toStringTag`.
*
* **Note:** This function only supports comparing values with tags of
* `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
*
* @private
* @param {Object} object The object to compare.
* @param {Object} other The other object to compare.
* @param {string} tag The `toStringTag` of the objects to compare.
* @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
* @param {Function} customizer The function to customize comparisons.
* @param {Function} equalFunc The function to determine equivalents of values.
* @param {Object} stack Tracks traversed `object` and `other` objects.
* @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
*/
function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
switch (tag) {
case dataViewTag:
if ((object.byteLength != other.byteLength) ||
(object.byteOffset != other.byteOffset)) {
return false;
}
object = object.buffer;
other = other.buffer;
case arrayBufferTag:
if ((object.byteLength != other.byteLength) ||
!equalFunc(new Uint8Array(object), new Uint8Array(other))) {
return false;
}
return true;
case boolTag:
case dateTag:
case numberTag:
// Coerce booleans to `1` or `0` and dates to milliseconds.
// Invalid dates are coerced to `NaN`.
return eq(+object, +other);
case errorTag:
return object.name == other.name && object.message == other.message;
case regexpTag:
case stringTag:
// Coerce regexes to strings and treat strings, primitives and objects,
// as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
// for more details.
return object == (other + '');
case mapTag:
var convert = mapToArray;
case setTag:
var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
convert || (convert = setToArray);
if (object.size != other.size && !isPartial) {
return false;
}
// Assume cyclic values are equal.
var stacked = stack.get(object);
if (stacked) {
return stacked == other;
}
bitmask |= COMPARE_UNORDERED_FLAG;
// Recursively compare objects (susceptible to call stack limits).
stack.set(object, other);
var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
stack['delete'](object);
return result;
case symbolTag:
if (symbolValueOf) {
return symbolValueOf.call(object) == symbolValueOf.call(other);
}
}
return false;
}
/**
* A specialized version of `baseIsEqualDeep` for objects with support for
* partial deep comparisons.
*
* @private
* @param {Object} object The object to compare.
* @param {Object} other The other object to compare.
* @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
* @param {Function} customizer The function to customize comparisons.
* @param {Function} equalFunc The function to determine equivalents of values.
* @param {Object} stack Tracks traversed `object` and `other` objects.
* @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
*/
function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
objProps = getAllKeys(object),
objLength = objProps.length,
othProps = getAllKeys(other),
othLength = othProps.length;
if (objLength != othLength && !isPartial) {
return false;
}
var index = objLength;
while (index--) {
var key = objProps[index];
if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
return false;
}
}
// Assume cyclic values are equal.
var stacked = stack.get(object);
if (stacked && stack.get(other)) {
return stacked == other;
}
var result = true;
stack.set(object, other);
stack.set(other, object);
var skipCtor = isPartial;
while (++index < objLength) {
key = objProps[index];
var objValue = object[key],
othValue = other[key];
if (customizer) {
var compared = isPartial
? customizer(othValue, objValue, key, other, object, stack)
: customizer(objValue, othValue, key, object, other, stack);
}
// Recursively compare objects (susceptible to call stack limits).
if (!(compared === undefined
? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))
: compared
)) {
result = false;
break;
}
skipCtor || (skipCtor = key == 'constructor');
}
if (result && !skipCtor) {
var objCtor = object.constructor,
othCtor = other.constructor;
// Non `Object` object instances with different constructors are not equal.
if (objCtor != othCtor &&
('constructor' in object && 'constructor' in other) &&
!(typeof objCtor == 'function' && objCtor instanceof objCtor &&
typeof othCtor == 'function' && othCtor instanceof othCtor)) {
result = false;
}
}
stack['delete'](object);
stack['delete'](other);
return result;
}
/**
* A specialized version of `baseRest` which flattens the rest array.
*
* @private
* @param {Function} func The function to apply a rest parameter to.
* @returns {Function} Returns the new function.
*/
function flatRest(func) {
return setToString(overRest(func, undefined, flatten), func + '');
}
/**
* Creates an array of own enumerable property names and symbols of `object`.
*
* @private
* @param {Object} object The object to query.
* @returns {Array} Returns the array of property names and symbols.
*/
function getAllKeys(object) {
return baseGetAllKeys(object, keys, getSymbols);
}
/**
* Creates an array of own and inherited enumerable property names and
* symbols of `object`.
*
* @private
* @param {Object} object The object to query.
* @returns {Array} Returns the array of property names and symbols.
*/
function getAllKeysIn(object) {
return baseGetAllKeys(object, keysIn, getSymbolsIn);
}
/**
* Gets metadata for `func`.
*
* @private
* @param {Function} func The function to query.
* @returns {*} Returns the metadata for `func`.
*/
var getData = !metaMap ? noop : function(func) {
return metaMap.get(func);
};
/**
* Gets the name of `func`.
*
* @private
* @param {Function} func The function to query.
* @returns {string} Returns the function name.
*/
function getFuncName(func) {
var result = (func.name + ''),
array = realNames[result],
length = hasOwnProperty.call(realNames, result) ? array.length : 0;
while (length--) {
var data = array[length],
otherFunc = data.func;
if (otherFunc == null || otherFunc == func) {
return data.name;
}
}
return result;
}
/**
* Gets the argument placeholder value for `func`.
*
* @private
* @param {Function} func The function to inspect.
* @returns {*} Returns the placeholder value.
*/
function getHolder(func) {
var object = hasOwnProperty.call(lodash, 'placeholder') ? lodash : func;
return object.placeholder;
}
/**
* Gets the appropriate "iteratee" function. If `_.iteratee` is customized,
* this function returns the custom method, otherwise it returns `baseIteratee`.
* If arguments are provided, the chosen function is invoked with them and
* its result is returned.
*
* @private
* @param {*} [value] The value to convert to an iteratee.
* @param {number} [arity] The arity of the created iteratee.
* @returns {Function} Returns the chosen function or its result.
*/
function getIteratee() {
var result = lodash.iteratee || iteratee;
result = result === iteratee ? baseIteratee : result;
return arguments.length ? result(arguments[0], arguments[1]) : result;
}
/**
* Gets the data for `map`.
*
* @private
* @param {Object} map The map to query.
* @param {string} key The reference key.
* @returns {*} Returns the map data.
*/
function getMapData(map, key) {
var data = map.__data__;
return isKeyable(key)
? data[typeof key == 'string' ? 'string' : 'hash']
: data.map;
}
/**
* Gets the property names, values, and compare flags of `object`.
*
* @private
* @param {Object} object The object to query.
* @returns {Array} Returns the match data of `object`.
*/
function getMatchData(object) {
var result = keys(object),
length = result.length;
while (length--) {
var key = result[length],
value = object[key];
result[length] = [key, value, isStrictComparable(value)];
}
return result;
}
/**
* Gets the native function at `key` of `object`.
*
* @private
* @param {Object} object The object to query.
* @param {string} key The key of the method to get.
* @returns {*} Returns the function if it's native, else `undefined`.
*/
function getNative(object, key) {
var value = getValue(object, key);
return baseIsNative(value) ? value : undefined;
}
/**
* A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
*
* @private
* @param {*} value The value to query.
* @returns {string} Returns the raw `toStringTag`.
*/
function getRawTag(value) {
var isOwn = hasOwnProperty.call(value, symToStringTag),
tag = value[symToStringTag];
try {
value[symToStringTag] = undefined;
var unmasked = true;
} catch (e) {}
var result = nativeObjectToString.call(value);
if (unmasked) {
if (isOwn) {
value[symToStringTag] = tag;
} else {
delete value[symToStringTag];
}
}
return result;
}
/**
* Creates an array of the own enumerable symbols of `object`.
*
* @private
* @param {Object} object The object to query.
* @returns {Array} Returns the array of symbols.
*/
var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
if (object == null) {
return [];
}
object = Object(object);
return arrayFilter(nativeGetSymbols(object), function(symbol) {
return propertyIsEnumerable.call(object, symbol);
});
};
/**
* Creates an array of the own and inherited enumerable symbols of `object`.
*
* @private
* @param {Object} object The object to query.
* @returns {Array} Returns the array of symbols.
*/
var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
var result = [];
while (object) {
arrayPush(result, getSymbols(object));
object = getPrototype(object);
}
return result;
};
/**
* Gets the `toStringTag` of `value`.
*
* @private
* @param {*} value The value to query.
* @returns {string} Returns the `toStringTag`.
*/
var getTag = baseGetTag;
// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
(Map && getTag(new Map) != mapTag) ||
(Promise && getTag(Promise.resolve()) != promiseTag) ||
(Set && getTag(new Set) != setTag) ||
(WeakMap && getTag(new WeakMap) != weakMapTag)) {
getTag = function(value) {
var result = baseGetTag(value),
Ctor = result == objectTag ? value.constructor : undefined,
ctorString = Ctor ? toSource(Ctor) : '';
if (ctorString) {
switch (ctorString) {
case dataViewCtorString: return dataViewTag;
case mapCtorString: return mapTag;
case promiseCtorString: return promiseTag;
case setCtorString: return setTag;
case weakMapCtorString: return weakMapTag;
}
}
return result;
};
}
/**
* Gets the view, applying any `transforms` to the `start` and `end` positions.
*
* @private
* @param {number} start The start of the view.
* @param {number} end The end of the view.
* @param {Array} transforms The transformations to apply to the view.
* @returns {Object} Returns an object containing the `start` and `end`
* positions of the view.
*/
function getView(start, end, transforms) {
var index = -1,
length = transforms.length;
while (++index < length) {
var data = transforms[index],
size = data.size;
switch (data.type) {
case 'drop': start += size; break;
case 'dropRight': end -= size; break;
case 'take': end = nativeMin(end, start + size); break;
case 'takeRight': start = nativeMax(start, end - size); break;
}
}
return { 'start': start, 'end': end };
}
/**
* Extracts wrapper details from the `source` body comment.
*
* @private
* @param {string} source The source to inspect.
* @returns {Array} Returns the wrapper details.
*/
function getWrapDetails(source) {
var match = source.match(reWrapDetails);
return match ? match[1].split(reSplitDetails) : [];
}
/**
* Checks if `path` exists on `object`.
*
* @private
* @param {Object} object The object to query.
* @param {Array|string} path The path to check.
* @param {Function} hasFunc The function to check properties.
* @returns {boolean} Returns `true` if `path` exists, else `false`.
*/
function hasPath(object, path, hasFunc) {
path = castPath(path, object);
var index = -1,
length = path.length,
result = false;
while (++index < length) {
var key = toKey(path[index]);
if (!(result = object != null && hasFunc(object, key))) {
break;
}
object = object[key];
}
if (result || ++index != length) {
return result;
}
length = object == null ? 0 : object.length;
return !!length && isLength(length) && isIndex(key, length) &&
(isArray(object) || isArguments(object));
}
/**
* Initializes an array clone.
*
* @private
* @param {Array} array The array to clone.
* @returns {Array} Returns the initialized clone.
*/
function initCloneArray(array) {
var length = array.length,
result = new array.constructor(length);
// Add properties assigned by `RegExp#exec`.
if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {
result.index = array.index;
result.input = array.input;
}
return result;
}
/**
* Initializes an object clone.
*
* @private
* @param {Object} object The object to clone.
* @returns {Object} Returns the initialized clone.
*/
function initCloneObject(object) {
return (typeof object.constructor == 'function' && !isPrototype(object))
? baseCreate(getPrototype(object))
: {};
}
/**
* Initializes an object clone based on its `toStringTag`.
*
* **Note:** This function only supports cloning values with tags of
* `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.
*
* @private
* @param {Object} object The object to clone.
* @param {string} tag The `toStringTag` of the object to clone.
* @param {boolean} [isDeep] Specify a deep clone.
* @returns {Object} Returns the initialized clone.
*/
function initCloneByTag(object, tag, isDeep) {
var Ctor = object.constructor;
switch (tag) {
case arrayBufferTag:
return cloneArrayBuffer(object);
case boolTag:
case dateTag:
return new Ctor(+object);
case dataViewTag:
return cloneDataView(object, isDeep);
case float32Tag: case float64Tag:
case int8Tag: case int16Tag: case int32Tag:
case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:
return cloneTypedArray(object, isDeep);
case mapTag:
return new Ctor;
case numberTag:
case stringTag:
return new Ctor(object);
case regexpTag:
return cloneRegExp(object);
case setTag:
return new Ctor;
case symbolTag:
return cloneSymbol(object);
}
}
/**
* Inserts wrapper `details` in a comment at the top of the `source` body.
*
* @private
* @param {string} source The source to modify.
* @returns {Array} details The details to insert.
* @returns {string} Returns the modified source.
*/
function insertWrapDetails(source, details) {
var length = details.length;
if (!length) {
return source;
}
var lastIndex = length - 1;
details[lastIndex] = (length > 1 ? '& ' : '') + details[lastIndex];
details = details.join(length > 2 ? ', ' : ' ');
return source.replace(reWrapComment, '{\n/* [wrapped with ' + details + '] */\n');
}
/**
* Checks if `value` is a flattenable `arguments` object or array.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is flattenable, else `false`.
*/
function isFlattenable(value) {
return isArray(value) || isArguments(value) ||
!!(spreadableSymbol && value && value[spreadableSymbol]);
}
/**
* Checks if `value` is a valid array-like index.
*
* @private
* @param {*} value The value to check.
* @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
* @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
*/
function isIndex(value, length) {
var type = typeof value;
length = length == null ? MAX_SAFE_INTEGER : length;
return !!length &&
(type == 'number' ||
(type != 'symbol' && reIsUint.test(value))) &&
(value > -1 && value % 1 == 0 && value < length);
}
/**
* Checks if the given arguments are from an iteratee call.
*
* @private
* @param {*} value The potential iteratee value argument.
* @param {*} index The potential iteratee index or key argument.
* @param {*} object The potential iteratee object argument.
* @returns {boolean} Returns `true` if the arguments are from an iteratee call,
* else `false`.
*/
function isIterateeCall(value, index, object) {
if (!isObject(object)) {
return false;
}
var type = typeof index;
if (type == 'number'
? (isArrayLike(object) && isIndex(index, object.length))
: (type == 'string' && index in object)
) {
return eq(object[index], value);
}
return false;
}
/**
* Checks if `value` is a property name and not a property path.
*
* @private
* @param {*} value The value to check.
* @param {Object} [object] The object to query keys on.
* @returns {boolean} Returns `true` if `value` is a property name, else `false`.
*/
function isKey(value, object) {
if (isArray(value)) {
return false;
}
var type = typeof value;
if (type == 'number' || type == 'symbol' || type == 'boolean' ||
value == null || isSymbol(value)) {
return true;
}
return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
(object != null && value in Object(object));
}
/**
* Checks if `value` is suitable for use as unique object key.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is suitable, else `false`.
*/
function isKeyable(value) {
var type = typeof value;
return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
? (value !== '__proto__')
: (value === null);
}
/**
* Checks if `func` has a lazy counterpart.
*
* @private
* @param {Function} func The function to check.
* @returns {boolean} Returns `true` if `func` has a lazy counterpart,
* else `false`.
*/
function isLaziable(func) {
var funcName = getFuncName(func),
other = lodash[funcName];
if (typeof other != 'function' || !(funcName in LazyWrapper.prototype)) {
return false;
}
if (func === other) {
return true;
}
var data = getData(other);
return !!data && func === data[0];
}
/**
* Checks if `func` has its source masked.
*
* @private
* @param {Function} func The function to check.
* @returns {boolean} Returns `true` if `func` is masked, else `false`.
*/
function isMasked(func) {
return !!maskSrcKey && (maskSrcKey in func);
}
/**
* Checks if `func` is capable of being masked.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `func` is maskable, else `false`.
*/
var isMaskable = coreJsData ? isFunction : stubFalse;
/**
* Checks if `value` is likely a prototype object.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
*/
function isPrototype(value) {
var Ctor = value && value.constructor,
proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;
return value === proto;
}
/**
* Checks if `value` is suitable for strict equality comparisons, i.e. `===`.
*
* @private
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` if suitable for strict
* equality comparisons, else `false`.
*/
function isStrictComparable(value) {
return value === value && !isObject(value);
}
/**
* A specialized version of `matchesProperty` for source values suitable
* for strict equality comparisons, i.e. `===`.
*
* @private
* @param {string} key The key of the property to get.
* @param {*} srcValue The value to match.
* @returns {Function} Returns the new spec function.
*/
function matchesStrictComparable(key, srcValue) {
return function(object) {
if (object == null) {
return false;
}
return object[key] === srcValue &&
(srcValue !== undefined || (key in Object(object)));
};
}
/**
* A specialized version of `_.memoize` which clears the memoized function's
* cache when it exceeds `MAX_MEMOIZE_SIZE`.
*
* @private
* @param {Function} func The function to have its output memoized.
* @returns {Function} Returns the new memoized function.
*/
function memoizeCapped(func) {
var result = memoize(func, function(key) {
if (cache.size === MAX_MEMOIZE_SIZE) {
cache.clear();
}
return key;
});
var cache = result.cache;
return result;
}
/**
* Merges the function metadata of `source` into `data`.
*
* Merging metadata reduces the number of wrappers used to invoke a function.
* This is possible because methods like `_.bind`, `_.curry`, and `_.partial`
* may be applied regardless of execution order. Methods like `_.ary` and
* `_.rearg` modify function arguments, making the order in which they are
* executed important, preventing the merging of metadata. However, we make
* an exception for a safe combined case where curried functions have `_.ary`
* and or `_.rearg` applied.
*
* @private
* @param {Array} data The destination metadata.
* @param {Array} source The source metadata.
* @returns {Array} Returns `data`.
*/
function mergeData(data, source) {
var bitmask = data[1],
srcBitmask = source[1],
newBitmask = bitmask | srcBitmask,
isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG);
var isCombo =
((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_CURRY_FLAG)) ||
((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_REARG_FLAG) && (data[7].length <= source[8])) ||
((srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == WRAP_CURRY_FLAG));
// Exit early if metadata can't be merged.
if (!(isCommon || isCombo)) {
return data;
}
// Use source `thisArg` if available.
if (srcBitmask & WRAP_BIND_FLAG) {
data[2] = source[2];
// Set when currying a bound function.
newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;
}
// Compose partial arguments.
var value = source[3];
if (value) {
var partials = data[3];
data[3] = partials ? composeArgs(partials, value, source[4]) : value;
data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];
}
// Compose partial right arguments.
value = source[5];
if (value) {
partials = data[5];
data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;
data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];
}
// Use source `argPos` if available.
value = source[7];
if (value) {
data[7] = value;
}
// Use source `ary` if it's smaller.
if (srcBitmask & WRAP_ARY_FLAG) {
data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);
}
// Use source `arity` if one is not provided.
if (data[9] == null) {
data[9] = source[9];
}
// Use source `func` and merge bitmasks.
data[0] = source[0];
data[1] = newBitmask;
return data;
}
/**
* This function is like
* [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
* except that it includes inherited enumerable properties.
*
* @private
* @param {Object} object The object to query.
* @returns {Array} Returns the array of property names.
*/
function nativeKeysIn(object) {
var result = [];
if (object != null) {
for (var key in Object(object)) {
result.push(key);
}
}
return result;
}
/**
* Converts `value` to a string using `Object.prototype.toString`.
*
* @private
* @param {*} value The value to convert.
* @returns {string} Returns the converted string.
*/
function objectToString(value) {
return nativeObjectToString.call(value);
}
/**
* A specialized version of `baseRest` which transforms the rest array.
*
* @private
* @param {Function} func The function to apply a rest parameter to.
* @param {number} [start=func.length-1] The start position of the rest parameter.
* @param {Function} transform The rest array transform.
* @returns {Function} Returns the new function.
*/
function overRest(func, start, transform) {
start = nativeMax(start === undefined ? (func.length - 1) : start, 0);
return function() {
var args = arguments,
index = -1,
length = nativeMax(args.length - start, 0),
array = Array(length);
while (++index < length) {
array[index] = args[start + index];
}
index = -1;
var otherArgs = Array(start + 1);
while (++index < start) {
otherArgs[index] = args[index];
}
otherArgs[start] = transform(array);
return apply(func, this, otherArgs);
};
}
/**
* Gets the parent value at `path` of `object`.
*
* @private
* @param {Object} object The object to query.
* @param {Array} path The path to get the parent value of.
* @returns {*} Returns the parent value.
*/
function parent(object, path) {
return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
}
/**
* Reorder `array` according to the specified indexes where the element at
* the first index is assigned as the first element, the element at
* the second index is assigned as the second element, and so on.
*
* @private
* @param {Array} array The array to reorder.
* @param {Array} indexes The arranged array indexes.
* @returns {Array} Returns `array`.
*/
function reorder(array, indexes) {
var arrLength = array.length,
length = nativeMin(indexes.length, arrLength),
oldArray = copyArray(array);
while (length--) {
var index = indexes[length];
array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined;
}
return array;
}
/**
* Sets metadata for `func`.
*
* **Note:** If this function becomes hot, i.e. is invoked a lot in a short
* period of time, it will trip its breaker and transition to an identity
* function to avoid garbage collection pauses in V8. See
* [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070)
* for more details.
*
* @private
* @param {Function} func The function to associate metadata with.
* @param {*} data The metadata.
* @returns {Function} Returns `func`.
*/
var setData = shortOut(baseSetData);
/**
* A simple wrapper around the global [`setTimeout`](https://mdn.io/setTimeout).
*
* @private
* @param {Function} func The function to delay.
* @param {number} wait The number of milliseconds to delay invocation.
* @returns {number|Object} Returns the timer id or timeout object.
*/
var setTimeout = ctxSetTimeout || function(func, wait) {
return root.setTimeout(func, wait);
};
/**
* Sets the `toString` method of `func` to return `string`.
*
* @private
* @param {Function} func The function to modify.
* @param {Function} string The `toString` result.
* @returns {Function} Returns `func`.
*/
var setToString = shortOut(baseSetToString);
/**
* Sets the `toString` method of `wrapper` to mimic the source of `reference`
* with wrapper details in a comment at the top of the source body.
*
* @private
* @param {Function} wrapper The function to modify.
* @param {Function} reference The reference function.
* @param {number} bitmask The bitmask flags. See `createWrap` for more details.
* @returns {Function} Returns `wrapper`.
*/
function setWrapToString(wrapper, reference, bitmask) {
var source = (reference + '');
return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));
}
/**
* Creates a function that'll short out and invoke `identity` instead
* of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`
* milliseconds.
*
* @private
* @param {Function} func The function to restrict.
* @returns {Function} Returns the new shortable function.
*/
function shortOut(func) {
var count = 0,
lastCalled = 0;
return function() {
var stamp = nativeNow(),
remaining = HOT_SPAN - (stamp - lastCalled);
lastCalled = stamp;
if (remaining > 0) {
if (++count >= HOT_COUNT) {
return arguments[0];
}
} else {
count = 0;
}
return func.apply(undefined, arguments);
};
}
/**
* A specialized version of `_.shuffle` which mutates and sets the size of `array`.
*
* @private
* @param {Array} array The array to shuffle.
* @param {number} [size=array.length] The size of `array`.
* @returns {Array} Returns `array`.
*/
function shuffleSelf(array, size) {
var index = -1,
length = array.length,
lastIndex = length - 1;
size = size === undefined ? length : size;
while (++index < size) {
var rand = baseRandom(index, lastIndex),
value = array[rand];
array[rand] = array[index];
array[index] = value;
}
array.length = size;
return array;
}
/**
* Converts `string` to a property path array.
*
* @private
* @param {string} string The string to convert.
* @returns {Array} Returns the property path array.
*/
var stringToPath = memoizeCapped(function(string) {
var result = [];
if (string.charCodeAt(0) === 46 /* . */) {
result.push('');
}
string.replace(rePropName, function(match, number, quote, subString) {
result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));
});
return result;
});
/**
* Converts `value` to a string key if it's not a string or symbol.
*
* @private
* @param {*} value The value to inspect.
* @returns {string|symbol} Returns the key.
*/
function toKey(value) {
if (typeof value == 'string' || isSymbol(value)) {
return value;
}
var result = (value + '');
return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
}
/**
* Converts `func` to its source code.
*
* @private
* @param {Function} func The function to convert.
* @returns {string} Returns the source code.
*/
function toSource(func) {
if (func != null) {
try {
return funcToString.call(func);
} catch (e) {}
try {
return (func + '');
} catch (e) {}
}
return '';
}
/**
* Updates wrapper `details` based on `bitmask` flags.
*
* @private
* @returns {Array} details The details to modify.
* @param {number} bitmask The bitmask flags. See `createWrap` for more details.
* @returns {Array} Returns `details`.
*/
function updateWrapDetails(details, bitmask) {
arrayEach(wrapFlags, function(pair) {
var value = '_.' + pair[0];
if ((bitmask & pair[1]) && !arrayIncludes(details, value)) {
details.push(value);
}
});
return details.sort();
}
/**
* Creates a clone of `wrapper`.
*
* @private
* @param {Object} wrapper The wrapper to clone.
* @returns {Object} Returns the cloned wrapper.
*/
function wrapperClone(wrapper) {
if (wrapper instanceof LazyWrapper) {
return wrapper.clone();
}
var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);
result.__actions__ = copyArray(wrapper.__actions__);
result.__index__ = wrapper.__index__;
result.__values__ = wrapper.__values__;
return result;
}
/*------------------------------------------------------------------------*/
/**
* Creates an array of elements split into groups the length of `size`.
* If `array` can't be split evenly, the final chunk will be the remaining
* elements.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Array
* @param {Array} array The array to process.
* @param {number} [size=1] The length of each chunk
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
* @returns {Array} Returns the new array of chunks.
* @example
*
* _.chunk(['a', 'b', 'c', 'd'], 2);
* // => [['a', 'b'], ['c', 'd']]
*
* _.chunk(['a', 'b', 'c', 'd'], 3);
* // => [['a', 'b', 'c'], ['d']]
*/
function chunk(array, size, guard) {
if ((guard ? isIterateeCall(array, size, guard) : size === undefined)) {
size = 1;
} else {
size = nativeMax(toInteger(size), 0);
}
var length = array == null ? 0 : array.length;
if (!length || size < 1) {
return [];
}
var index = 0,
resIndex = 0,
result = Array(nativeCeil(length / size));
while (index < length) {
result[resIndex++] = baseSlice(array, index, (index += size));
}
return result;
}
/**
* Creates an array with all falsey values removed. The values `false`, `null`,
* `0`, `""`, `undefined`, and `NaN` are falsey.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Array
* @param {Array} array The array to compact.
* @returns {Array} Returns the new array of filtered values.
* @example
*
* _.compact([0, 1, false, 2, '', 3]);
* // => [1, 2, 3]
*/
function compact(array) {
var index = -1,
length = array == null ? 0 : array.length,
resIndex = 0,
result = [];
while (++index < length) {
var value = array[index];
if (value) {
result[resIndex++] = value;
}
}
return result;
}
/**
* Creates a new array concatenating `array` with any additional arrays
* and/or values.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Array
* @param {Array} array The array to concatenate.
* @param {...*} [values] The values to concatenate.
* @returns {Array} Returns the new concatenated array.
* @example
*
* var array = [1];
* var other = _.concat(array, 2, [3], [[4]]);
*
* console.log(other);
* // => [1, 2, 3, [4]]
*
* console.log(array);
* // => [1]
*/
function concat() {
var length = arguments.length;
if (!length) {
return [];
}
var args = Array(length - 1),
array = arguments[0],
index = length;
while (index--) {
args[index - 1] = arguments[index];
}
return arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1));
}
/**
* Creates an array of `array` values not included in the other given arrays
* using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
* for equality comparisons. The order and references of result values are
* determined by the first array.
*
* **Note:** Unlike `_.pullAll`, this method returns a new array.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Array
* @param {Array} array The array to inspect.
* @param {...Array} [values] The values to exclude.
* @returns {Array} Returns the new array of filtered values.
* @see _.without, _.xor
* @example
*
* _.difference([2, 1], [2, 3]);
* // => [1]
*/
var difference = baseRest(function(array, values) {
return isArrayLikeObject(array)
? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true))
: [];
});
/**
* This method is like `_.difference` except that it accepts `iteratee` which
* is invoked for each element of `array` and `values` to generate the criterion
* by which they're compared. The order and references of result values are
* determined by the first array. The iteratee is invoked with one argument:
* (value).
*
* **Note:** Unlike `_.pullAllBy`, this method returns a new array.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Array
* @param {Array} array The array to inspect.
* @param {...Array} [values] The values to exclude.
* @param {Function} [iteratee=_.identity] The iteratee invoked per element.
* @returns {Array} Returns the new array of filtered values.
* @example
*
* _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor);
* // => [1.2]
*
* // The `_.property` iteratee shorthand.
* _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');
* // => [{ 'x': 2 }]
*/
var differenceBy = baseRest(function(array, values) {
var iteratee = last(values);
if (isArrayLikeObject(iteratee)) {
iteratee = undefined;
}
return isArrayLikeObject(array)
? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), getIteratee(iteratee, 2))
: [];
});
/**
* This method is like `_.difference` except that it accepts `comparator`
* which is invoked to compare elements of `array` to `values`. The order and
* references of result values are determined by the first array. The comparator
* is invoked with two arguments: (arrVal, othVal).
*
* **Note:** Unlike `_.pullAllWith`, this method returns a new array.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Array
* @param {Array} array The array to inspect.
* @param {...Array} [values] The values to exclude.
* @param {Function} [comparator] The comparator invoked per element.
* @returns {Array} Returns the new array of filtered values.
* @example
*
* var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
*
* _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual);
* // => [{ 'x': 2, 'y': 1 }]
*/
var differenceWith = baseRest(function(array, values) {
var comparator = last(values);
if (isArrayLikeObject(comparator)) {
comparator = undefined;
}
return isArrayLikeObject(array)
? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), undefined, comparator)
: [];
});
/**
* Creates a slice of `array` with `n` elements dropped from the beginning.
*
* @static
* @memberOf _
* @since 0.5.0
* @category Array
* @param {Array} array The array to query.
* @param {number} [n=1] The number of elements to drop.
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
* @returns {Array} Returns the slice of `array`.
* @example
*
* _.drop([1, 2, 3]);
* // => [2, 3]
*
* _.drop([1, 2, 3], 2);
* // => [3]
*
* _.drop([1, 2, 3], 5);
* // => []
*
* _.drop([1, 2, 3], 0);
* // => [1, 2, 3]
*/
function drop(array, n, guard) {
var length = array == null ? 0 : array.length;
if (!length) {
return [];
}
n = (guard || n === undefined) ? 1 : toInteger(n);
return baseSlice(array, n < 0 ? 0 : n, length);
}
/**
* Creates a slice of `array` with `n` elements dropped from the end.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Array
* @param {Array} array The array to query.
* @param {number} [n=1] The number of elements to drop.
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
* @returns {Array} Returns the slice of `array`.
* @example
*
* _.dropRight([1, 2, 3]);
* // => [1, 2]
*
* _.dropRight([1, 2, 3], 2);
* // => [1]
*
* _.dropRight([1, 2, 3], 5);
* // => []
*
* _.dropRight([1, 2, 3], 0);
* // => [1, 2, 3]
*/
function dropRight(array, n, guard) {
var length = array == null ? 0 : array.length;
if (!length) {
return [];
}
n = (guard || n === undefined) ? 1 : toInteger(n);
n = length - n;
return baseSlice(array, 0, n < 0 ? 0 : n);
}
/**
* Creates a slice of `array` excluding elements dropped from the end.
* Elements are dropped until `predicate` returns falsey. The predicate is
* invoked with three arguments: (value, index, array).
*
* @static
* @memberOf _
* @since 3.0.0
* @category Array
* @param {Array} array The array to query.
* @param {Function} [predicate=_.identity] The function invoked per iteration.
* @returns {Array} Returns the slice of `array`.
* @example
*
* var users = [
* { 'user': 'barney', 'active': true },
* { 'user': 'fred', 'active': false },
* { 'user': 'pebbles', 'active': false }
* ];
*
* _.dropRightWhile(users, function(o) { return !o.active; });
* // => objects for ['barney']
*
* // The `_.matches` iteratee shorthand.
* _.dropRightWhile(users, { 'user': 'pebbles', 'active': false });
* // => objects for ['barney', 'fred']
*
* // The `_.matchesProperty` iteratee shorthand.
* _.dropRightWhile(users, ['active', false]);
* // => objects for ['barney']
*
* // The `_.property` iteratee shorthand.
* _.dropRightWhile(users, 'active');
* // => objects for ['barney', 'fred', 'pebbles']
*/
function dropRightWhile(array, predicate) {
return (array && array.length)
? baseWhile(array, getIteratee(predicate, 3), true, true)
: [];
}
/**
* Creates a slice of `array` excluding elements dropped from the beginning.
* Elements are dropped until `predicate` returns falsey. The predicate is
* invoked with three arguments: (value, index, array).
*
* @static
* @memberOf _
* @since 3.0.0
* @category Array
* @param {Array} array The array to query.
* @param {Function} [predicate=_.identity] The function invoked per iteration.
* @returns {Array} Returns the slice of `array`.
* @example
*
* var users = [
* { 'user': 'barney', 'active': false },
* { 'user': 'fred', 'active': false },
* { 'user': 'pebbles', 'active': true }
* ];
*
* _.dropWhile(users, function(o) { return !o.active; });
* // => objects for ['pebbles']
*
* // The `_.matches` iteratee shorthand.
* _.dropWhile(users, { 'user': 'barney', 'active': false });
* // => objects for ['fred', 'pebbles']
*
* // The `_.matchesProperty` iteratee shorthand.
* _.dropWhile(users, ['active', false]);
* // => objects for ['pebbles']
*
* // The `_.property` iteratee shorthand.
* _.dropWhile(users, 'active');
* // => objects for ['barney', 'fred', 'pebbles']
*/
function dropWhile(array, predicate) {
return (array && array.length)
? baseWhile(array, getIteratee(predicate, 3), true)
: [];
}
/**
* Fills elements of `array` with `value` from `start` up to, but not
* including, `end`.
*
* **Note:** This method mutates `array`.
*
* @static
* @memberOf _
* @since 3.2.0
* @category Array
* @param {Array} array The array to fill.
* @param {*} value The value to fill `array` with.
* @param {number} [start=0] The start position.
* @param {number} [end=array.length] The end position.
* @returns {Array} Returns `array`.
* @example
*
* var array = [1, 2, 3];
*
* _.fill(array, 'a');
* console.log(array);
* // => ['a', 'a', 'a']
*
* _.fill(Array(3), 2);
* // => [2, 2, 2]
*
* _.fill([4, 6, 8, 10], '*', 1, 3);
* // => [4, '*', '*', 10]
*/
function fill(array, value, start, end) {
var length = array == null ? 0 : array.length;
if (!length) {
return [];
}
if (start && typeof start != 'number' && isIterateeCall(array, value, start)) {
start = 0;
end = length;
}
return baseFill(array, value, start, end);
}
/**
* This method is like `_.find` except that it returns the index of the first
* element `predicate` returns truthy for instead of the element itself.
*
* @static
* @memberOf _
* @since 1.1.0
* @category Array
* @param {Array} array The array to inspect.
* @param {Function} [predicate=_.identity] The function invoked per iteration.
* @param {number} [fromIndex=0] The index to search from.
* @returns {number} Returns the index of the found element, else `-1`.
* @example
*
* var users = [
* { 'user': 'barney', 'active': false },
* { 'user': 'fred', 'active': false },
* { 'user': 'pebbles', 'active': true }
* ];
*
* _.findIndex(users, function(o) { return o.user == 'barney'; });
* // => 0
*
* // The `_.matches` iteratee shorthand.
* _.findIndex(users, { 'user': 'fred', 'active': false });
* // => 1
*
* // The `_.matchesProperty` iteratee shorthand.
* _.findIndex(users, ['active', false]);
* // => 0
*
* // The `_.property` iteratee shorthand.
* _.findIndex(users, 'active');
* // => 2
*/
function findIndex(array, predicate, fromIndex) {
var length = array == null ? 0 : array.length;
if (!length) {
return -1;
}
var index = fromIndex == null ? 0 : toInteger(fromIndex);
if (index < 0) {
index = nativeMax(length + index, 0);
}
return baseFindIndex(array, getIteratee(predicate, 3), index);
}
/**
* This method is like `_.findIndex` except that it iterates over elements
* of `collection` from right to left.
*
* @static
* @memberOf _
* @since 2.0.0
* @category Array
* @param {Array} array The array to inspect.
* @param {Function} [predicate=_.identity] The function invoked per iteration.
* @param {number} [fromIndex=array.length-1] The index to search from.
* @returns {number} Returns the index of the found element, else `-1`.
* @example
*
* var users = [
* { 'user': 'barney', 'active': true },
* { 'user': 'fred', 'active': false },
* { 'user': 'pebbles', 'active': false }
* ];
*
* _.findLastIndex(users, function(o) { return o.user == 'pebbles'; });
* // => 2
*
* // The `_.matches` iteratee shorthand.
* _.findLastIndex(users, { 'user': 'barney', 'active': true });
* // => 0
*
* // The `_.matchesProperty` iteratee shorthand.
* _.findLastIndex(users, ['active', false]);
* // => 2
*
* // The `_.property` iteratee shorthand.
* _.findLastIndex(users, 'active');
* // => 0
*/
function findLastIndex(array, predicate, fromIndex) {
var length = array == null ? 0 : array.length;
if (!length) {
return -1;
}
var index = length - 1;
if (fromIndex !== undefined) {
index = toInteger(fromIndex);
index = fromIndex < 0
? nativeMax(length + index, 0)
: nativeMin(index, length - 1);
}
return baseFindIndex(array, getIteratee(predicate, 3), index, true);
}
/**
* Flattens `array` a single level deep.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Array
* @param {Array} array The array to flatten.
* @returns {Array} Returns the new flattened array.
* @example
*
* _.flatten([1, [2, [3, [4]], 5]]);
* // => [1, 2, [3, [4]], 5]
*/
function flatten(array) {
var length = array == null ? 0 : array.length;
return length ? baseFlatten(array, 1) : [];
}
/**
* Recursively flattens `array`.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Array
* @param {Array} array The array to flatten.
* @returns {Array} Returns the new flattened array.
* @example
*
* _.flattenDeep([1, [2, [3, [4]], 5]]);
* // => [1, 2, 3, 4, 5]
*/
function flattenDeep(array) {
var length = array == null ? 0 : array.length;
return length ? baseFlatten(array, INFINITY) : [];
}
/**
* Recursively flatten `array` up to `depth` times.
*
* @static
* @memberOf _
* @since 4.4.0
* @category Array
* @param {Array} array The array to flatten.
* @param {number} [depth=1] The maximum recursion depth.
* @returns {Array} Returns the new flattened array.
* @example
*
* var array = [1, [2, [3, [4]], 5]];
*
* _.flattenDepth(array, 1);
* // => [1, 2, [3, [4]], 5]
*
* _.flattenDepth(array, 2);
* // => [1, 2, 3, [4], 5]
*/
function flattenDepth(array, depth) {
var length = array == null ? 0 : array.length;
if (!length) {
return [];
}
depth = depth === undefined ? 1 : toInteger(depth);
return baseFlatten(array, depth);
}
/**
* The inverse of `_.toPairs`; this method returns an object composed
* from key-value `pairs`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Array
* @param {Array} pairs The key-value pairs.
* @returns {Object} Returns the new object.
* @example
*
* _.fromPairs([['a', 1], ['b', 2]]);
* // => { 'a': 1, 'b': 2 }
*/
function fromPairs(pairs) {
var index = -1,
length = pairs == null ? 0 : pairs.length,
result = {};
while (++index < length) {
var pair = pairs[index];
result[pair[0]] = pair[1];
}
return result;
}
/**
* Gets the first element of `array`.
*
* @static
* @memberOf _
* @since 0.1.0
* @alias first
* @category Array
* @param {Array} array The array to query.
* @returns {*} Returns the first element of `array`.
* @example
*
* _.head([1, 2, 3]);
* // => 1
*
* _.head([]);
* // => undefined
*/
function head(array) {
return (array && array.length) ? array[0] : undefined;
}
/**
* Gets the index at which the first occurrence of `value` is found in `array`
* using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
* for equality comparisons. If `fromIndex` is negative, it's used as the
* offset from the end of `array`.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Array
* @param {Array} array The array to inspect.
* @param {*} value The value to search for.
* @param {number} [fromIndex=0] The index to search from.
* @returns {number} Returns the index of the matched value, else `-1`.
* @example
*
* _.indexOf([1, 2, 1, 2], 2);
* // => 1
*
* // Search from the `fromIndex`.
* _.indexOf([1, 2, 1, 2], 2, 2);
* // => 3
*/
function indexOf(array, value, fromIndex) {
var length = array == null ? 0 : array.length;
if (!length) {
return -1;
}
var index = fromIndex == null ? 0 : toInteger(fromIndex);
if (index < 0) {
index = nativeMax(length + index, 0);
}
return baseIndexOf(array, value, index);
}
/**
* Gets all but the last element of `array`.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Array
* @param {Array} array The array to query.
* @returns {Array} Returns the slice of `array`.
* @example
*
* _.initial([1, 2, 3]);
* // => [1, 2]
*/
function initial(array) {
var length = array == null ? 0 : array.length;
return length ? baseSlice(array, 0, -1) : [];
}
/**
* Creates an array of unique values that are included in all given arrays
* using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
* for equality comparisons. The order and references of result values are
* determined by the first array.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Array
* @param {...Array} [arrays] The arrays to inspect.
* @returns {Array} Returns the new array of intersecting values.
* @example
*
* _.intersection([2, 1], [2, 3]);
* // => [2]
*/
var intersection = baseRest(function(arrays) {
var mapped = arrayMap(arrays, castArrayLikeObject);
return (mapped.length && mapped[0] === arrays[0])
? baseIntersection(mapped)
: [];
});
/**
* This method is like `_.intersection` except that it accepts `iteratee`
* which is invoked for each element of each `arrays` to generate the criterion
* by which they're compared. The order and references of result values are
* determined by the first array. The iteratee is invoked with one argument:
* (value).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Array
* @param {...Array} [arrays] The arrays to inspect.
* @param {Function} [iteratee=_.identity] The iteratee invoked per element.
* @returns {Array} Returns the new array of intersecting values.
* @example
*
* _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor);
* // => [2.1]
*
* // The `_.property` iteratee shorthand.
* _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
* // => [{ 'x': 1 }]
*/
var intersectionBy = baseRest(function(arrays) {
var iteratee = last(arrays),
mapped = arrayMap(arrays, castArrayLikeObject);
if (iteratee === last(mapped)) {
iteratee = undefined;
} else {
mapped.pop();
}
return (mapped.length && mapped[0] === arrays[0])
? baseIntersection(mapped, getIteratee(iteratee, 2))
: [];
});
/**
* This method is like `_.intersection` except that it accepts `comparator`
* which is invoked to compare elements of `arrays`. The order and references
* of result values are determined by the first array. The comparator is
* invoked with two arguments: (arrVal, othVal).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Array
* @param {...Array} [arrays] The arrays to inspect.
* @param {Function} [comparator] The comparator invoked per element.
* @returns {Array} Returns the new array of intersecting values.
* @example
*
* var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
* var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
*
* _.intersectionWith(objects, others, _.isEqual);
* // => [{ 'x': 1, 'y': 2 }]
*/
var intersectionWith = baseRest(function(arrays) {
var comparator = last(arrays),
mapped = arrayMap(arrays, castArrayLikeObject);
comparator = typeof comparator == 'function' ? comparator : undefined;
if (comparator) {
mapped.pop();
}
return (mapped.length && mapped[0] === arrays[0])
? baseIntersection(mapped, undefined, comparator)
: [];
});
/**
* Converts all elements in `array` into a string separated by `separator`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Array
* @param {Array} array The array to convert.
* @param {string} [separator=','] The element separator.
* @returns {string} Returns the joined string.
* @example
*
* _.join(['a', 'b', 'c'], '~');
* // => 'a~b~c'
*/
function join(array, separator) {
return array == null ? '' : nativeJoin.call(array, separator);
}
/**
* Gets the last element of `array`.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Array
* @param {Array} array The array to query.
* @returns {*} Returns the last element of `array`.
* @example
*
* _.last([1, 2, 3]);
* // => 3
*/
function last(array) {
var length = array == null ? 0 : array.length;
return length ? array[length - 1] : undefined;
}
/**
* This method is like `_.indexOf` except that it iterates over elements of
* `array` from right to left.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Array
* @param {Array} array The array to inspect.
* @param {*} value The value to search for.
* @param {number} [fromIndex=array.length-1] The index to search from.
* @returns {number} Returns the index of the matched value, else `-1`.
* @example
*
* _.lastIndexOf([1, 2, 1, 2], 2);
* // => 3
*
* // Search from the `fromIndex`.
* _.lastIndexOf([1, 2, 1, 2], 2, 2);
* // => 1
*/
function lastIndexOf(array, value, fromIndex) {
var length = array == null ? 0 : array.length;
if (!length) {
return -1;
}
var index = length;
if (fromIndex !== undefined) {
index = toInteger(fromIndex);
index = index < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1);
}
return value === value
? strictLastIndexOf(array, value, index)
: baseFindIndex(array, baseIsNaN, index, true);
}
/**
* Gets the element at index `n` of `array`. If `n` is negative, the nth
* element from the end is returned.
*
* @static
* @memberOf _
* @since 4.11.0
* @category Array
* @param {Array} array The array to query.
* @param {number} [n=0] The index of the element to return.
* @returns {*} Returns the nth element of `array`.
* @example
*
* var array = ['a', 'b', 'c', 'd'];
*
* _.nth(array, 1);
* // => 'b'
*
* _.nth(array, -2);
* // => 'c';
*/
function nth(array, n) {
return (array && array.length) ? baseNth(array, toInteger(n)) : undefined;
}
/**
* Removes all given values from `array` using
* [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
* for equality comparisons.
*
* **Note:** Unlike `_.without`, this method mutates `array`. Use `_.remove`
* to remove elements from an array by predicate.
*
* @static
* @memberOf _
* @since 2.0.0
* @category Array
* @param {Array} array The array to modify.
* @param {...*} [values] The values to remove.
* @returns {Array} Returns `array`.
* @example
*
* var array = ['a', 'b', 'c', 'a', 'b', 'c'];
*
* _.pull(array, 'a', 'c');
* console.log(array);
* // => ['b', 'b']
*/
var pull = baseRest(pullAll);
/**
* This method is like `_.pull` except that it accepts an array of values to remove.
*
* **Note:** Unlike `_.difference`, this method mutates `array`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Array
* @param {Array} array The array to modify.
* @param {Array} values The values to remove.
* @returns {Array} Returns `array`.
* @example
*
* var array = ['a', 'b', 'c', 'a', 'b', 'c'];
*
* _.pullAll(array, ['a', 'c']);
* console.log(array);
* // => ['b', 'b']
*/
function pullAll(array, values) {
return (array && array.length && values && values.length)
? basePullAll(array, values)
: array;
}
/**
* This method is like `_.pullAll` except that it accepts `iteratee` which is
* invoked for each element of `array` and `values` to generate the criterion
* by which they're compared. The iteratee is invoked with one argument: (value).
*
* **Note:** Unlike `_.differenceBy`, this method mutates `array`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Array
* @param {Array} array The array to modify.
* @param {Array} values The values to remove.
* @param {Function} [iteratee=_.identity] The iteratee invoked per element.
* @returns {Array} Returns `array`.
* @example
*
* var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];
*
* _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');
* console.log(array);
* // => [{ 'x': 2 }]
*/
function pullAllBy(array, values, iteratee) {
return (array && array.length && values && values.length)
? basePullAll(array, values, getIteratee(iteratee, 2))
: array;
}
/**
* This method is like `_.pullAll` except that it accepts `comparator` which
* is invoked to compare elements of `array` to `values`. The comparator is
* invoked with two arguments: (arrVal, othVal).
*
* **Note:** Unlike `_.differenceWith`, this method mutates `array`.
*
* @static
* @memberOf _
* @since 4.6.0
* @category Array
* @param {Array} array The array to modify.
* @param {Array} values The values to remove.
* @param {Function} [comparator] The comparator invoked per element.
* @returns {Array} Returns `array`.
* @example
*
* var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];
*
* _.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);
* console.log(array);
* // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]
*/
function pullAllWith(array, values, comparator) {
return (array && array.length && values && values.length)
? basePullAll(array, values, undefined, comparator)
: array;
}
/**
* Removes elements from `array` corresponding to `indexes` and returns an
* array of removed elements.
*
* **Note:** Unlike `_.at`, this method mutates `array`.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Array
* @param {Array} array The array to modify.
* @param {...(number|number[])} [indexes] The indexes of elements to remove.
* @returns {Array} Returns the new array of removed elements.
* @example
*
* var array = ['a', 'b', 'c', 'd'];
* var pulled = _.pullAt(array, [1, 3]);
*
* console.log(array);
* // => ['a', 'c']
*
* console.log(pulled);
* // => ['b', 'd']
*/
var pullAt = flatRest(function(array, indexes) {
var length = array == null ? 0 : array.length,
result = baseAt(array, indexes);
basePullAt(array, arrayMap(indexes, function(index) {
return isIndex(index, length) ? +index : index;
}).sort(compareAscending));
return result;
});
/**
* Removes all elements from `array` that `predicate` returns truthy for
* and returns an array of the removed elements. The predicate is invoked
* with three arguments: (value, index, array).
*
* **Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull`
* to pull elements from an array by value.
*
* @static
* @memberOf _
* @since 2.0.0
* @category Array
* @param {Array} array The array to modify.
* @param {Function} [predicate=_.identity] The function invoked per iteration.
* @returns {Array} Returns the new array of removed elements.
* @example
*
* var array = [1, 2, 3, 4];
* var evens = _.remove(array, function(n) {
* return n % 2 == 0;
* });
*
* console.log(array);
* // => [1, 3]
*
* console.log(evens);
* // => [2, 4]
*/
function remove(array, predicate) {
var result = [];
if (!(array && array.length)) {
return result;
}
var index = -1,
indexes = [],
length = array.length;
predicate = getIteratee(predicate, 3);
while (++index < length) {
var value = array[index];
if (predicate(value, index, array)) {
result.push(value);
indexes.push(index);
}
}
basePullAt(array, indexes);
return result;
}
/**
* Reverses `array` so that the first element becomes the last, the second
* element becomes the second to last, and so on.
*
* **Note:** This method mutates `array` and is based on
* [`Array#reverse`](https://mdn.io/Array/reverse).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Array
* @param {Array} array The array to modify.
* @returns {Array} Returns `array`.
* @example
*
* var array = [1, 2, 3];
*
* _.reverse(array);
* // => [3, 2, 1]
*
* console.log(array);
* // => [3, 2, 1]
*/
function reverse(array) {
return array == null ? array : nativeReverse.call(array);
}
/**
* Creates a slice of `array` from `start` up to, but not including, `end`.
*
* **Note:** This method is used instead of
* [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are
* returned.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Array
* @param {Array} array The array to slice.
* @param {number} [start=0] The start position.
* @param {number} [end=array.length] The end position.
* @returns {Array} Returns the slice of `array`.
*/
function slice(array, start, end) {
var length = array == null ? 0 : array.length;
if (!length) {
return [];
}
if (end && typeof end != 'number' && isIterateeCall(array, start, end)) {
start = 0;
end = length;
}
else {
start = start == null ? 0 : toInteger(start);
end = end === undefined ? length : toInteger(end);
}
return baseSlice(array, start, end);
}
/**
* Uses a binary search to determine the lowest index at which `value`
* should be inserted into `array` in order to maintain its sort order.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Array
* @param {Array} array The sorted array to inspect.
* @param {*} value The value to evaluate.
* @returns {number} Returns the index at which `value` should be inserted
* into `array`.
* @example
*
* _.sortedIndex([30, 50], 40);
* // => 1
*/
function sortedIndex(array, value) {
return baseSortedIndex(array, value);
}
/**
* This method is like `_.sortedIndex` except that it accepts `iteratee`
* which is invoked for `value` and each element of `array` to compute their
* sort ranking. The iteratee is invoked with one argument: (value).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Array
* @param {Array} array The sorted array to inspect.
* @param {*} value The value to evaluate.
* @param {Function} [iteratee=_.identity] The iteratee invoked per element.
* @returns {number} Returns the index at which `value` should be inserted
* into `array`.
* @example
*
* var objects = [{ 'x': 4 }, { 'x': 5 }];
*
* _.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
* // => 0
*
* // The `_.property` iteratee shorthand.
* _.sortedIndexBy(objects, { 'x': 4 }, 'x');
* // => 0
*/
function sortedIndexBy(array, value, iteratee) {
return baseSortedIndexBy(array, value, getIteratee(iteratee, 2));
}
/**
* This method is like `_.indexOf` except that it performs a binary
* search on a sorted `array`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Array
* @param {Array} array The array to inspect.
* @param {*} value The value to search for.
* @returns {number} Returns the index of the matched value, else `-1`.
* @example
*
* _.sortedIndexOf([4, 5, 5, 5, 6], 5);
* // => 1
*/
function sortedIndexOf(array, value) {
var length = array == null ? 0 : array.length;
if (length) {
var index = baseSortedIndex(array, value);
if (index < length && eq(array[index], value)) {
return index;
}
}
return -1;
}
/**
* This method is like `_.sortedIndex` except that it returns the highest
* index at which `value` should be inserted into `array` in order to
* maintain its sort order.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Array
* @param {Array} array The sorted array to inspect.
* @param {*} value The value to evaluate.
* @returns {number} Returns the index at which `value` should be inserted
* into `array`.
* @example
*
* _.sortedLastIndex([4, 5, 5, 5, 6], 5);
* // => 4
*/
function sortedLastIndex(array, value) {
return baseSortedIndex(array, value, true);
}
/**
* This method is like `_.sortedLastIndex` except that it accepts `iteratee`
* which is invoked for `value` and each element of `array` to compute their
* sort ranking. The iteratee is invoked with one argument: (value).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Array
* @param {Array} array The sorted array to inspect.
* @param {*} value The value to evaluate.
* @param {Function} [iteratee=_.identity] The iteratee invoked per element.
* @returns {number} Returns the index at which `value` should be inserted
* into `array`.
* @example
*
* var objects = [{ 'x': 4 }, { 'x': 5 }];
*
* _.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
* // => 1
*
* // The `_.property` iteratee shorthand.
* _.sortedLastIndexBy(objects, { 'x': 4 }, 'x');
* // => 1
*/
function sortedLastIndexBy(array, value, iteratee) {
return baseSortedIndexBy(array, value, getIteratee(iteratee, 2), true);
}
/**
* This method is like `_.lastIndexOf` except that it performs a binary
* search on a sorted `array`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Array
* @param {Array} array The array to inspect.
* @param {*} value The value to search for.
* @returns {number} Returns the index of the matched value, else `-1`.
* @example
*
* _.sortedLastIndexOf([4, 5, 5, 5, 6], 5);
* // => 3
*/
function sortedLastIndexOf(array, value) {
var length = array == null ? 0 : array.length;
if (length) {
var index = baseSortedIndex(array, value, true) - 1;
if (eq(array[index], value)) {
return index;
}
}
return -1;
}
/**
* This method is like `_.uniq` except that it's designed and optimized
* for sorted arrays.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Array
* @param {Array} array The array to inspect.
* @returns {Array} Returns the new duplicate free array.
* @example
*
* _.sortedUniq([1, 1, 2]);
* // => [1, 2]
*/
function sortedUniq(array) {
return (array && array.length)
? baseSortedUniq(array)
: [];
}
/**
* This method is like `_.uniqBy` except that it's designed and optimized
* for sorted arrays.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Array
* @param {Array} array The array to inspect.
* @param {Function} [iteratee] The iteratee invoked per element.
* @returns {Array} Returns the new duplicate free array.
* @example
*
* _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);
* // => [1.1, 2.3]
*/
function sortedUniqBy(array, iteratee) {
return (array && array.length)
? baseSortedUniq(array, getIteratee(iteratee, 2))
: [];
}
/**
* Gets all but the first element of `array`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Array
* @param {Array} array The array to query.
* @returns {Array} Returns the slice of `array`.
* @example
*
* _.tail([1, 2, 3]);
* // => [2, 3]
*/
function tail(array) {
var length = array == null ? 0 : array.length;
return length ? baseSlice(array, 1, length) : [];
}
/**
* Creates a slice of `array` with `n` elements taken from the beginning.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Array
* @param {Array} array The array to query.
* @param {number} [n=1] The number of elements to take.
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
* @returns {Array} Returns the slice of `array`.
* @example
*
* _.take([1, 2, 3]);
* // => [1]
*
* _.take([1, 2, 3], 2);
* // => [1, 2]
*
* _.take([1, 2, 3], 5);
* // => [1, 2, 3]
*
* _.take([1, 2, 3], 0);
* // => []
*/
function take(array, n, guard) {
if (!(array && array.length)) {
return [];
}
n = (guard || n === undefined) ? 1 : toInteger(n);
return baseSlice(array, 0, n < 0 ? 0 : n);
}
/**
* Creates a slice of `array` with `n` elements taken from the end.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Array
* @param {Array} array The array to query.
* @param {number} [n=1] The number of elements to take.
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
* @returns {Array} Returns the slice of `array`.
* @example
*
* _.takeRight([1, 2, 3]);
* // => [3]
*
* _.takeRight([1, 2, 3], 2);
* // => [2, 3]
*
* _.takeRight([1, 2, 3], 5);
* // => [1, 2, 3]
*
* _.takeRight([1, 2, 3], 0);
* // => []
*/
function takeRight(array, n, guard) {
var length = array == null ? 0 : array.length;
if (!length) {
return [];
}
n = (guard || n === undefined) ? 1 : toInteger(n);
n = length - n;
return baseSlice(array, n < 0 ? 0 : n, length);
}
/**
* Creates a slice of `array` with elements taken from the end. Elements are
* taken until `predicate` returns falsey. The predicate is invoked with
* three arguments: (value, index, array).
*
* @static
* @memberOf _
* @since 3.0.0
* @category Array
* @param {Array} array The array to query.
* @param {Function} [predicate=_.identity] The function invoked per iteration.
* @returns {Array} Returns the slice of `array`.
* @example
*
* var users = [
* { 'user': 'barney', 'active': true },
* { 'user': 'fred', 'active': false },
* { 'user': 'pebbles', 'active': false }
* ];
*
* _.takeRightWhile(users, function(o) { return !o.active; });
* // => objects for ['fred', 'pebbles']
*
* // The `_.matches` iteratee shorthand.
* _.takeRightWhile(users, { 'user': 'pebbles', 'active': false });
* // => objects for ['pebbles']
*
* // The `_.matchesProperty` iteratee shorthand.
* _.takeRightWhile(users, ['active', false]);
* // => objects for ['fred', 'pebbles']
*
* // The `_.property` iteratee shorthand.
* _.takeRightWhile(users, 'active');
* // => []
*/
function takeRightWhile(array, predicate) {
return (array && array.length)
? baseWhile(array, getIteratee(predicate, 3), false, true)
: [];
}
/**
* Creates a slice of `array` with elements taken from the beginning. Elements
* are taken until `predicate` returns falsey. The predicate is invoked with
* three arguments: (value, index, array).
*
* @static
* @memberOf _
* @since 3.0.0
* @category Array
* @param {Array} array The array to query.
* @param {Function} [predicate=_.identity] The function invoked per iteration.
* @returns {Array} Returns the slice of `array`.
* @example
*
* var users = [
* { 'user': 'barney', 'active': false },
* { 'user': 'fred', 'active': false },
* { 'user': 'pebbles', 'active': true }
* ];
*
* _.takeWhile(users, function(o) { return !o.active; });
* // => objects for ['barney', 'fred']
*
* // The `_.matches` iteratee shorthand.
* _.takeWhile(users, { 'user': 'barney', 'active': false });
* // => objects for ['barney']
*
* // The `_.matchesProperty` iteratee shorthand.
* _.takeWhile(users, ['active', false]);
* // => objects for ['barney', 'fred']
*
* // The `_.property` iteratee shorthand.
* _.takeWhile(users, 'active');
* // => []
*/
function takeWhile(array, predicate) {
return (array && array.length)
? baseWhile(array, getIteratee(predicate, 3))
: [];
}
/**
* Creates an array of unique values, in order, from all given arrays using
* [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
* for equality comparisons.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Array
* @param {...Array} [arrays] The arrays to inspect.
* @returns {Array} Returns the new array of combined values.
* @example
*
* _.union([2], [1, 2]);
* // => [2, 1]
*/
var union = baseRest(function(arrays) {
return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));
});
/**
* This method is like `_.union` except that it accepts `iteratee` which is
* invoked for each element of each `arrays` to generate the criterion by
* which uniqueness is computed. Result values are chosen from the first
* array in which the value occurs. The iteratee is invoked with one argument:
* (value).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Array
* @param {...Array} [arrays] The arrays to inspect.
* @param {Function} [iteratee=_.identity] The iteratee invoked per element.
* @returns {Array} Returns the new array of combined values.
* @example
*
* _.unionBy([2.1], [1.2, 2.3], Math.floor);
* // => [2.1, 1.2]
*
* // The `_.property` iteratee shorthand.
* _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
* // => [{ 'x': 1 }, { 'x': 2 }]
*/
var unionBy = baseRest(function(arrays) {
var iteratee = last(arrays);
if (isArrayLikeObject(iteratee)) {
iteratee = undefined;
}
return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), getIteratee(iteratee, 2));
});
/**
* This method is like `_.union` except that it accepts `comparator` which
* is invoked to compare elements of `arrays`. Result values are chosen from
* the first array in which the value occurs. The comparator is invoked
* with two arguments: (arrVal, othVal).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Array
* @param {...Array} [arrays] The arrays to inspect.
* @param {Function} [comparator] The comparator invoked per element.
* @returns {Array} Returns the new array of combined values.
* @example
*
* var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
* var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
*
* _.unionWith(objects, others, _.isEqual);
* // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
*/
var unionWith = baseRest(function(arrays) {
var comparator = last(arrays);
comparator = typeof comparator == 'function' ? comparator : undefined;
return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined, comparator);
});
/**
* Creates a duplicate-free version of an array, using
* [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
* for equality comparisons, in which only the first occurrence of each element
* is kept. The order of result values is determined by the order they occur
* in the array.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Array
* @param {Array} array The array to inspect.
* @returns {Array} Returns the new duplicate free array.
* @example
*
* _.uniq([2, 1, 2]);
* // => [2, 1]
*/
function uniq(array) {
return (array && array.length) ? baseUniq(array) : [];
}
/**
* This method is like `_.uniq` except that it accepts `iteratee` which is
* invoked for each element in `array` to generate the criterion by which
* uniqueness is computed. The order of result values is determined by the
* order they occur in the array. The iteratee is invoked with one argument:
* (value).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Array
* @param {Array} array The array to inspect.
* @param {Function} [iteratee=_.identity] The iteratee invoked per element.
* @returns {Array} Returns the new duplicate free array.
* @example
*
* _.uniqBy([2.1, 1.2, 2.3], Math.floor);
* // => [2.1, 1.2]
*
* // The `_.property` iteratee shorthand.
* _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
* // => [{ 'x': 1 }, { 'x': 2 }]
*/
function uniqBy(array, iteratee) {
return (array && array.length) ? baseUniq(array, getIteratee(iteratee, 2)) : [];
}
/**
* This method is like `_.uniq` except that it accepts `comparator` which
* is invoked to compare elements of `array`. The order of result values is
* determined by the order they occur in the array.The comparator is invoked
* with two arguments: (arrVal, othVal).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Array
* @param {Array} array The array to inspect.
* @param {Function} [comparator] The comparator invoked per element.
* @returns {Array} Returns the new duplicate free array.
* @example
*
* var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];
*
* _.uniqWith(objects, _.isEqual);
* // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]
*/
function uniqWith(array, comparator) {
comparator = typeof comparator == 'function' ? comparator : undefined;
return (array && array.length) ? baseUniq(array, undefined, comparator) : [];
}
/**
* This method is like `_.zip` except that it accepts an array of grouped
* elements and creates an array regrouping the elements to their pre-zip
* configuration.
*
* @static
* @memberOf _
* @since 1.2.0
* @category Array
* @param {Array} array The array of grouped elements to process.
* @returns {Array} Returns the new array of regrouped elements.
* @example
*
* var zipped = _.zip(['a', 'b'], [1, 2], [true, false]);
* // => [['a', 1, true], ['b', 2, false]]
*
* _.unzip(zipped);
* // => [['a', 'b'], [1, 2], [true, false]]
*/
function unzip(array) {
if (!(array && array.length)) {
return [];
}
var length = 0;
array = arrayFilter(array, function(group) {
if (isArrayLikeObject(group)) {
length = nativeMax(group.length, length);
return true;
}
});
return baseTimes(length, function(index) {
return arrayMap(array, baseProperty(index));
});
}
/**
* This method is like `_.unzip` except that it accepts `iteratee` to specify
* how regrouped values should be combined. The iteratee is invoked with the
* elements of each group: (...group).
*
* @static
* @memberOf _
* @since 3.8.0
* @category Array
* @param {Array} array The array of grouped elements to process.
* @param {Function} [iteratee=_.identity] The function to combine
* regrouped values.
* @returns {Array} Returns the new array of regrouped elements.
* @example
*
* var zipped = _.zip([1, 2], [10, 20], [100, 200]);
* // => [[1, 10, 100], [2, 20, 200]]
*
* _.unzipWith(zipped, _.add);
* // => [3, 30, 300]
*/
function unzipWith(array, iteratee) {
if (!(array && array.length)) {
return [];
}
var result = unzip(array);
if (iteratee == null) {
return result;
}
return arrayMap(result, function(group) {
return apply(iteratee, undefined, group);
});
}
/**
* Creates an array excluding all given values using
* [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
* for equality comparisons.
*
* **Note:** Unlike `_.pull`, this method returns a new array.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Array
* @param {Array} array The array to inspect.
* @param {...*} [values] The values to exclude.
* @returns {Array} Returns the new array of filtered values.
* @see _.difference, _.xor
* @example
*
* _.without([2, 1, 2, 3], 1, 2);
* // => [3]
*/
var without = baseRest(function(array, values) {
return isArrayLikeObject(array)
? baseDifference(array, values)
: [];
});
/**
* Creates an array of unique values that is the
* [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference)
* of the given arrays. The order of result values is determined by the order
* they occur in the arrays.
*
* @static
* @memberOf _
* @since 2.4.0
* @category Array
* @param {...Array} [arrays] The arrays to inspect.
* @returns {Array} Returns the new array of filtered values.
* @see _.difference, _.without
* @example
*
* _.xor([2, 1], [2, 3]);
* // => [1, 3]
*/
var xor = baseRest(function(arrays) {
return baseXor(arrayFilter(arrays, isArrayLikeObject));
});
/**
* This method is like `_.xor` except that it accepts `iteratee` which is
* invoked for each element of each `arrays` to generate the criterion by
* which by which they're compared. The order of result values is determined
* by the order they occur in the arrays. The iteratee is invoked with one
* argument: (value).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Array
* @param {...Array} [arrays] The arrays to inspect.
* @param {Function} [iteratee=_.identity] The iteratee invoked per element.
* @returns {Array} Returns the new array of filtered values.
* @example
*
* _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);
* // => [1.2, 3.4]
*
* // The `_.property` iteratee shorthand.
* _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
* // => [{ 'x': 2 }]
*/
var xorBy = baseRest(function(arrays) {
var iteratee = last(arrays);
if (isArrayLikeObject(iteratee)) {
iteratee = undefined;
}
return baseXor(arrayFilter(arrays, isArrayLikeObject), getIteratee(iteratee, 2));
});
/**
* This method is like `_.xor` except that it accepts `comparator` which is
* invoked to compare elements of `arrays`. The order of result values is
* determined by the order they occur in the arrays. The comparator is invoked
* with two arguments: (arrVal, othVal).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Array
* @param {...Array} [arrays] The arrays to inspect.
* @param {Function} [comparator] The comparator invoked per element.
* @returns {Array} Returns the new array of filtered values.
* @example
*
* var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
* var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
*
* _.xorWith(objects, others, _.isEqual);
* // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
*/
var xorWith = baseRest(function(arrays) {
var comparator = last(arrays);
comparator = typeof comparator == 'function' ? comparator : undefined;
return baseXor(arrayFilter(arrays, isArrayLikeObject), undefined, comparator);
});
/**
* Creates an array of grouped elements, the first of which contains the
* first elements of the given arrays, the second of which contains the
* second elements of the given arrays, and so on.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Array
* @param {...Array} [arrays] The arrays to process.
* @returns {Array} Returns the new array of grouped elements.
* @example
*
* _.zip(['a', 'b'], [1, 2], [true, false]);
* // => [['a', 1, true], ['b', 2, false]]
*/
var zip = baseRest(unzip);
/**
* This method is like `_.fromPairs` except that it accepts two arrays,
* one of property identifiers and one of corresponding values.
*
* @static
* @memberOf _
* @since 0.4.0
* @category Array
* @param {Array} [props=[]] The property identifiers.
* @param {Array} [values=[]] The property values.
* @returns {Object} Returns the new object.
* @example
*
* _.zipObject(['a', 'b'], [1, 2]);
* // => { 'a': 1, 'b': 2 }
*/
function zipObject(props, values) {
return baseZipObject(props || [], values || [], assignValue);
}
/**
* This method is like `_.zipObject` except that it supports property paths.
*
* @static
* @memberOf _
* @since 4.1.0
* @category Array
* @param {Array} [props=[]] The property identifiers.
* @param {Array} [values=[]] The property values.
* @returns {Object} Returns the new object.
* @example
*
* _.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]);
* // => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }
*/
function zipObjectDeep(props, values) {
return baseZipObject(props || [], values || [], baseSet);
}
/**
* This method is like `_.zip` except that it accepts `iteratee` to specify
* how grouped values should be combined. The iteratee is invoked with the
* elements of each group: (...group).
*
* @static
* @memberOf _
* @since 3.8.0
* @category Array
* @param {...Array} [arrays] The arrays to process.
* @param {Function} [iteratee=_.identity] The function to combine
* grouped values.
* @returns {Array} Returns the new array of grouped elements.
* @example
*
* _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {
* return a + b + c;
* });
* // => [111, 222]
*/
var zipWith = baseRest(function(arrays) {
var length = arrays.length,
iteratee = length > 1 ? arrays[length - 1] : undefined;
iteratee = typeof iteratee == 'function' ? (arrays.pop(), iteratee) : undefined;
return unzipWith(arrays, iteratee);
});
/*------------------------------------------------------------------------*/
/**
* Creates a `lodash` wrapper instance that wraps `value` with explicit method
* chain sequences enabled. The result of such sequences must be unwrapped
* with `_#value`.
*
* @static
* @memberOf _
* @since 1.3.0
* @category Seq
* @param {*} value The value to wrap.
* @returns {Object} Returns the new `lodash` wrapper instance.
* @example
*
* var users = [
* { 'user': 'barney', 'age': 36 },
* { 'user': 'fred', 'age': 40 },
* { 'user': 'pebbles', 'age': 1 }
* ];
*
* var youngest = _
* .chain(users)
* .sortBy('age')
* .map(function(o) {
* return o.user + ' is ' + o.age;
* })
* .head()
* .value();
* // => 'pebbles is 1'
*/
function chain(value) {
var result = lodash(value);
result.__chain__ = true;
return result;
}
/**
* This method invokes `interceptor` and returns `value`. The interceptor
* is invoked with one argument; (value). The purpose of this method is to
* "tap into" a method chain sequence in order to modify intermediate results.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Seq
* @param {*} value The value to provide to `interceptor`.
* @param {Function} interceptor The function to invoke.
* @returns {*} Returns `value`.
* @example
*
* _([1, 2, 3])
* .tap(function(array) {
* // Mutate input array.
* array.pop();
* })
* .reverse()
* .value();
* // => [2, 1]
*/
function tap(value, interceptor) {
interceptor(value);
return value;
}
/**
* This method is like `_.tap` except that it returns the result of `interceptor`.
* The purpose of this method is to "pass thru" values replacing intermediate
* results in a method chain sequence.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Seq
* @param {*} value The value to provide to `interceptor`.
* @param {Function} interceptor The function to invoke.
* @returns {*} Returns the result of `interceptor`.
* @example
*
* _(' abc ')
* .chain()
* .trim()
* .thru(function(value) {
* return [value];
* })
* .value();
* // => ['abc']
*/
function thru(value, interceptor) {
return interceptor(value);
}
/**
* This method is the wrapper version of `_.at`.
*
* @name at
* @memberOf _
* @since 1.0.0
* @category Seq
* @param {...(string|string[])} [paths] The property paths to pick.
* @returns {Object} Returns the new `lodash` wrapper instance.
* @example
*
* var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };
*
* _(object).at(['a[0].b.c', 'a[1]']).value();
* // => [3, 4]
*/
var wrapperAt = flatRest(function(paths) {
var length = paths.length,
start = length ? paths[0] : 0,
value = this.__wrapped__,
interceptor = function(object) { return baseAt(object, paths); };
if (length > 1 || this.__actions__.length ||
!(value instanceof LazyWrapper) || !isIndex(start)) {
return this.thru(interceptor);
}
value = value.slice(start, +start + (length ? 1 : 0));
value.__actions__.push({
'func': thru,
'args': [interceptor],
'thisArg': undefined
});
return new LodashWrapper(value, this.__chain__).thru(function(array) {
if (length && !array.length) {
array.push(undefined);
}
return array;
});
});
/**
* Creates a `lodash` wrapper instance with explicit method chain sequences enabled.
*
* @name chain
* @memberOf _
* @since 0.1.0
* @category Seq
* @returns {Object} Returns the new `lodash` wrapper instance.
* @example
*
* var users = [
* { 'user': 'barney', 'age': 36 },
* { 'user': 'fred', 'age': 40 }
* ];
*
* // A sequence without explicit chaining.
* _(users).head();
* // => { 'user': 'barney', 'age': 36 }
*
* // A sequence with explicit chaining.
* _(users)
* .chain()
* .head()
* .pick('user')
* .value();
* // => { 'user': 'barney' }
*/
function wrapperChain() {
return chain(this);
}
/**
* Executes the chain sequence and returns the wrapped result.
*
* @name commit
* @memberOf _
* @since 3.2.0
* @category Seq
* @returns {Object} Returns the new `lodash` wrapper instance.
* @example
*
* var array = [1, 2];
* var wrapped = _(array).push(3);
*
* console.log(array);
* // => [1, 2]
*
* wrapped = wrapped.commit();
* console.log(array);
* // => [1, 2, 3]
*
* wrapped.last();
* // => 3
*
* console.log(array);
* // => [1, 2, 3]
*/
function wrapperCommit() {
return new LodashWrapper(this.value(), this.__chain__);
}
/**
* Gets the next value on a wrapped object following the
* [iterator protocol](https://mdn.io/iteration_protocols#iterator).
*
* @name next
* @memberOf _
* @since 4.0.0
* @category Seq
* @returns {Object} Returns the next iterator value.
* @example
*
* var wrapped = _([1, 2]);
*
* wrapped.next();
* // => { 'done': false, 'value': 1 }
*
* wrapped.next();
* // => { 'done': false, 'value': 2 }
*
* wrapped.next();
* // => { 'done': true, 'value': undefined }
*/
function wrapperNext() {
if (this.__values__ === undefined) {
this.__values__ = toArray(this.value());
}
var done = this.__index__ >= this.__values__.length,
value = done ? undefined : this.__values__[this.__index__++];
return { 'done': done, 'value': value };
}
/**
* Enables the wrapper to be iterable.
*
* @name Symbol.iterator
* @memberOf _
* @since 4.0.0
* @category Seq
* @returns {Object} Returns the wrapper object.
* @example
*
* var wrapped = _([1, 2]);
*
* wrapped[Symbol.iterator]() === wrapped;
* // => true
*
* Array.from(wrapped);
* // => [1, 2]
*/
function wrapperToIterator() {
return this;
}
/**
* Creates a clone of the chain sequence planting `value` as the wrapped value.
*
* @name plant
* @memberOf _
* @since 3.2.0
* @category Seq
* @param {*} value The value to plant.
* @returns {Object} Returns the new `lodash` wrapper instance.
* @example
*
* function square(n) {
* return n * n;
* }
*
* var wrapped = _([1, 2]).map(square);
* var other = wrapped.plant([3, 4]);
*
* other.value();
* // => [9, 16]
*
* wrapped.value();
* // => [1, 4]
*/
function wrapperPlant(value) {
var result,
parent = this;
while (parent instanceof baseLodash) {
var clone = wrapperClone(parent);
clone.__index__ = 0;
clone.__values__ = undefined;
if (result) {
previous.__wrapped__ = clone;
} else {
result = clone;
}
var previous = clone;
parent = parent.__wrapped__;
}
previous.__wrapped__ = value;
return result;
}
/**
* This method is the wrapper version of `_.reverse`.
*
* **Note:** This method mutates the wrapped array.
*
* @name reverse
* @memberOf _
* @since 0.1.0
* @category Seq
* @returns {Object} Returns the new `lodash` wrapper instance.
* @example
*
* var array = [1, 2, 3];
*
* _(array).reverse().value()
* // => [3, 2, 1]
*
* console.log(array);
* // => [3, 2, 1]
*/
function wrapperReverse() {
var value = this.__wrapped__;
if (value instanceof LazyWrapper) {
var wrapped = value;
if (this.__actions__.length) {
wrapped = new LazyWrapper(this);
}
wrapped = wrapped.reverse();
wrapped.__actions__.push({
'func': thru,
'args': [reverse],
'thisArg': undefined
});
return new LodashWrapper(wrapped, this.__chain__);
}
return this.thru(reverse);
}
/**
* Executes the chain sequence to resolve the unwrapped value.
*
* @name value
* @memberOf _
* @since 0.1.0
* @alias toJSON, valueOf
* @category Seq
* @returns {*} Returns the resolved unwrapped value.
* @example
*
* _([1, 2, 3]).value();
* // => [1, 2, 3]
*/
function wrapperValue() {
return baseWrapperValue(this.__wrapped__, this.__actions__);
}
/*------------------------------------------------------------------------*/
/**
* Creates an object composed of keys generated from the results of running
* each element of `collection` thru `iteratee`. The corresponding value of
* each key is the number of times the key was returned by `iteratee`. The
* iteratee is invoked with one argument: (value).
*
* @static
* @memberOf _
* @since 0.5.0
* @category Collection
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} [iteratee=_.identity] The iteratee to transform keys.
* @returns {Object} Returns the composed aggregate object.
* @example
*
* _.countBy([6.1, 4.2, 6.3], Math.floor);
* // => { '4': 1, '6': 2 }
*
* // The `_.property` iteratee shorthand.
* _.countBy(['one', 'two', 'three'], 'length');
* // => { '3': 2, '5': 1 }
*/
var countBy = createAggregator(function(result, value, key) {
if (hasOwnProperty.call(result, key)) {
++result[key];
} else {
baseAssignValue(result, key, 1);
}
});
/**
* Checks if `predicate` returns truthy for **all** elements of `collection`.
* Iteration is stopped once `predicate` returns falsey. The predicate is
* invoked with three arguments: (value, index|key, collection).
*
* **Note:** This method returns `true` for
* [empty collections](https://en.wikipedia.org/wiki/Empty_set) because
* [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of
* elements of empty collections.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Collection
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} [predicate=_.identity] The function invoked per iteration.
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
* @returns {boolean} Returns `true` if all elements pass the predicate check,
* else `false`.
* @example
*
* _.every([true, 1, null, 'yes'], Boolean);
* // => false
*
* var users = [
* { 'user': 'barney', 'age': 36, 'active': false },
* { 'user': 'fred', 'age': 40, 'active': false }
* ];
*
* // The `_.matches` iteratee shorthand.
* _.every(users, { 'user': 'barney', 'active': false });
* // => false
*
* // The `_.matchesProperty` iteratee shorthand.
* _.every(users, ['active', false]);
* // => true
*
* // The `_.property` iteratee shorthand.
* _.every(users, 'active');
* // => false
*/
function every(collection, predicate, guard) {
var func = isArray(collection) ? arrayEvery : baseEvery;
if (guard && isIterateeCall(collection, predicate, guard)) {
predicate = undefined;
}
return func(collection, getIteratee(predicate, 3));
}
/**
* Iterates over elements of `collection`, returning an array of all elements
* `predicate` returns truthy for. The predicate is invoked with three
* arguments: (value, index|key, collection).
*
* **Note:** Unlike `_.remove`, this method returns a new array.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Collection
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} [predicate=_.identity] The function invoked per iteration.
* @returns {Array} Returns the new filtered array.
* @see _.reject
* @example
*
* var users = [
* { 'user': 'barney', 'age': 36, 'active': true },
* { 'user': 'fred', 'age': 40, 'active': false }
* ];
*
* _.filter(users, function(o) { return !o.active; });
* // => objects for ['fred']
*
* // The `_.matches` iteratee shorthand.
* _.filter(users, { 'age': 36, 'active': true });
* // => objects for ['barney']
*
* // The `_.matchesProperty` iteratee shorthand.
* _.filter(users, ['active', false]);
* // => objects for ['fred']
*
* // The `_.property` iteratee shorthand.
* _.filter(users, 'active');
* // => objects for ['barney']
*/
function filter(collection, predicate) {
var func = isArray(collection) ? arrayFilter : baseFilter;
return func(collection, getIteratee(predicate, 3));
}
/**
* Iterates over elements of `collection`, returning the first element
* `predicate` returns truthy for. The predicate is invoked with three
* arguments: (value, index|key, collection).
*
* @static
* @memberOf _
* @since 0.1.0
* @category Collection
* @param {Array|Object} collection The collection to inspect.
* @param {Function} [predicate=_.identity] The function invoked per iteration.
* @param {number} [fromIndex=0] The index to search from.
* @returns {*} Returns the matched element, else `undefined`.
* @example
*
* var users = [
* { 'user': 'barney', 'age': 36, 'active': true },
* { 'user': 'fred', 'age': 40, 'active': false },
* { 'user': 'pebbles', 'age': 1, 'active': true }
* ];
*
* _.find(users, function(o) { return o.age < 40; });
* // => object for 'barney'
*
* // The `_.matches` iteratee shorthand.
* _.find(users, { 'age': 1, 'active': true });
* // => object for 'pebbles'
*
* // The `_.matchesProperty` iteratee shorthand.
* _.find(users, ['active', false]);
* // => object for 'fred'
*
* // The `_.property` iteratee shorthand.
* _.find(users, 'active');
* // => object for 'barney'
*/
var find = createFind(findIndex);
/**
* This method is like `_.find` except that it iterates over elements of
* `collection` from right to left.
*
* @static
* @memberOf _
* @since 2.0.0
* @category Collection
* @param {Array|Object} collection The collection to inspect.
* @param {Function} [predicate=_.identity] The function invoked per iteration.
* @param {number} [fromIndex=collection.length-1] The index to search from.
* @returns {*} Returns the matched element, else `undefined`.
* @example
*
* _.findLast([1, 2, 3, 4], function(n) {
* return n % 2 == 1;
* });
* // => 3
*/
var findLast = createFind(findLastIndex);
/**
* Creates a flattened array of values by running each element in `collection`
* thru `iteratee` and flattening the mapped results. The iteratee is invoked
* with three arguments: (value, index|key, collection).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Collection
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} [iteratee=_.identity] The function invoked per iteration.
* @returns {Array} Returns the new flattened array.
* @example
*
* function duplicate(n) {
* return [n, n];
* }
*
* _.flatMap([1, 2], duplicate);
* // => [1, 1, 2, 2]
*/
function flatMap(collection, iteratee) {
return baseFlatten(map(collection, iteratee), 1);
}
/**
* This method is like `_.flatMap` except that it recursively flattens the
* mapped results.
*
* @static
* @memberOf _
* @since 4.7.0
* @category Collection
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} [iteratee=_.identity] The function invoked per iteration.
* @returns {Array} Returns the new flattened array.
* @example
*
* function duplicate(n) {
* return [[[n, n]]];
* }
*
* _.flatMapDeep([1, 2], duplicate);
* // => [1, 1, 2, 2]
*/
function flatMapDeep(collection, iteratee) {
return baseFlatten(map(collection, iteratee), INFINITY);
}
/**
* This method is like `_.flatMap` except that it recursively flattens the
* mapped results up to `depth` times.
*
* @static
* @memberOf _
* @since 4.7.0
* @category Collection
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} [iteratee=_.identity] The function invoked per iteration.
* @param {number} [depth=1] The maximum recursion depth.
* @returns {Array} Returns the new flattened array.
* @example
*
* function duplicate(n) {
* return [[[n, n]]];
* }
*
* _.flatMapDepth([1, 2], duplicate, 2);
* // => [[1, 1], [2, 2]]
*/
function flatMapDepth(collection, iteratee, depth) {
depth = depth === undefined ? 1 : toInteger(depth);
return baseFlatten(map(collection, iteratee), depth);
}
/**
* Iterates over elements of `collection` and invokes `iteratee` for each element.
* The iteratee is invoked with three arguments: (value, index|key, collection).
* Iteratee functions may exit iteration early by explicitly returning `false`.
*
* **Note:** As with other "Collections" methods, objects with a "length"
* property are iterated like arrays. To avoid this behavior use `_.forIn`
* or `_.forOwn` for object iteration.
*
* @static
* @memberOf _
* @since 0.1.0
* @alias each
* @category Collection
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} [iteratee=_.identity] The function invoked per iteration.
* @returns {Array|Object} Returns `collection`.
* @see _.forEachRight
* @example
*
* _.forEach([1, 2], function(value) {
* console.log(value);
* });
* // => Logs `1` then `2`.
*
* _.forEach({ 'a': 1, 'b': 2 }, function(value, key) {
* console.log(key);
* });
* // => Logs 'a' then 'b' (iteration order is not guaranteed).
*/
function forEach(collection, iteratee) {
var func = isArray(collection) ? arrayEach : baseEach;
return func(collection, getIteratee(iteratee, 3));
}
/**
* This method is like `_.forEach` except that it iterates over elements of
* `collection` from right to left.
*
* @static
* @memberOf _
* @since 2.0.0
* @alias eachRight
* @category Collection
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} [iteratee=_.identity] The function invoked per iteration.
* @returns {Array|Object} Returns `collection`.
* @see _.forEach
* @example
*
* _.forEachRight([1, 2], function(value) {
* console.log(value);
* });
* // => Logs `2` then `1`.
*/
function forEachRight(collection, iteratee) {
var func = isArray(collection) ? arrayEachRight : baseEachRight;
return func(collection, getIteratee(iteratee, 3));
}
/**
* Creates an object composed of keys generated from the results of running
* each element of `collection` thru `iteratee`. The order of grouped values
* is determined by the order they occur in `collection`. The corresponding
* value of each key is an array of elements responsible for generating the
* key. The iteratee is invoked with one argument: (value).
*
* @static
* @memberOf _
* @since 0.1.0
* @category Collection
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} [iteratee=_.identity] The iteratee to transform keys.
* @returns {Object} Returns the composed aggregate object.
* @example
*
* _.groupBy([6.1, 4.2, 6.3], Math.floor);
* // => { '4': [4.2], '6': [6.1, 6.3] }
*
* // The `_.property` iteratee shorthand.
* _.groupBy(['one', 'two', 'three'], 'length');
* // => { '3': ['one', 'two'], '5': ['three'] }
*/
var groupBy = createAggregator(function(result, value, key) {
if (hasOwnProperty.call(result, key)) {
result[key].push(value);
} else {
baseAssignValue(result, key, [value]);
}
});
/**
* Checks if `value` is in `collection`. If `collection` is a string, it's
* checked for a substring of `value`, otherwise
* [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
* is used for equality comparisons. If `fromIndex` is negative, it's used as
* the offset from the end of `collection`.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Collection
* @param {Array|Object|string} collection The collection to inspect.
* @param {*} value The value to search for.
* @param {number} [fromIndex=0] The index to search from.
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.
* @returns {boolean} Returns `true` if `value` is found, else `false`.
* @example
*
* _.includes([1, 2, 3], 1);
* // => true
*
* _.includes([1, 2, 3], 1, 2);
* // => false
*
* _.includes({ 'a': 1, 'b': 2 }, 1);
* // => true
*
* _.includes('abcd', 'bc');
* // => true
*/
function includes(collection, value, fromIndex, guard) {
collection = isArrayLike(collection) ? collection : values(collection);
fromIndex = (fromIndex && !guard) ? toInteger(fromIndex) : 0;
var length = collection.length;
if (fromIndex < 0) {
fromIndex = nativeMax(length + fromIndex, 0);
}
return isString(collection)
? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1)
: (!!length && baseIndexOf(collection, value, fromIndex) > -1);
}
/**
* Invokes the method at `path` of each element in `collection`, returning
* an array of the results of each invoked method. Any additional arguments
* are provided to each invoked method. If `path` is a function, it's invoked
* for, and `this` bound to, each element in `collection`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Collection
* @param {Array|Object} collection The collection to iterate over.
* @param {Array|Function|string} path The path of the method to invoke or
* the function invoked per iteration.
* @param {...*} [args] The arguments to invoke each method with.
* @returns {Array} Returns the array of results.
* @example
*
* _.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort');
* // => [[1, 5, 7], [1, 2, 3]]
*
* _.invokeMap([123, 456], String.prototype.split, '');
* // => [['1', '2', '3'], ['4', '5', '6']]
*/
var invokeMap = baseRest(function(collection, path, args) {
var index = -1,
isFunc = typeof path == 'function',
result = isArrayLike(collection) ? Array(collection.length) : [];
baseEach(collection, function(value) {
result[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args);
});
return result;
});
/**
* Creates an object composed of keys generated from the results of running
* each element of `collection` thru `iteratee`. The corresponding value of
* each key is the last element responsible for generating the key. The
* iteratee is invoked with one argument: (value).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Collection
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} [iteratee=_.identity] The iteratee to transform keys.
* @returns {Object} Returns the composed aggregate object.
* @example
*
* var array = [
* { 'dir': 'left', 'code': 97 },
* { 'dir': 'right', 'code': 100 }
* ];
*
* _.keyBy(array, function(o) {
* return String.fromCharCode(o.code);
* });
* // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
*
* _.keyBy(array, 'dir');
* // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }
*/
var keyBy = createAggregator(function(result, value, key) {
baseAssignValue(result, key, value);
});
/**
* Creates an array of values by running each element in `collection` thru
* `iteratee`. The iteratee is invoked with three arguments:
* (value, index|key, collection).
*
* Many lodash methods are guarded to work as iteratees for methods like
* `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.
*
* The guarded methods are:
* `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,
* `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,
* `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,
* `template`, `trim`, `trimEnd`, `trimStart`, and `words`
*
* @static
* @memberOf _
* @since 0.1.0
* @category Collection
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} [iteratee=_.identity] The function invoked per iteration.
* @returns {Array} Returns the new mapped array.
* @example
*
* function square(n) {
* return n * n;
* }
*
* _.map([4, 8], square);
* // => [16, 64]
*
* _.map({ 'a': 4, 'b': 8 }, square);
* // => [16, 64] (iteration order is not guaranteed)
*
* var users = [
* { 'user': 'barney' },
* { 'user': 'fred' }
* ];
*
* // The `_.property` iteratee shorthand.
* _.map(users, 'user');
* // => ['barney', 'fred']
*/
function map(collection, iteratee) {
var func = isArray(collection) ? arrayMap : baseMap;
return func(collection, getIteratee(iteratee, 3));
}
/**
* This method is like `_.sortBy` except that it allows specifying the sort
* orders of the iteratees to sort by. If `orders` is unspecified, all values
* are sorted in ascending order. Otherwise, specify an order of "desc" for
* descending or "asc" for ascending sort order of corresponding values.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Collection
* @param {Array|Object} collection The collection to iterate over.
* @param {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]]
* The iteratees to sort by.
* @param {string[]} [orders] The sort orders of `iteratees`.
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.
* @returns {Array} Returns the new sorted array.
* @example
*
* var users = [
* { 'user': 'fred', 'age': 48 },
* { 'user': 'barney', 'age': 34 },
* { 'user': 'fred', 'age': 40 },
* { 'user': 'barney', 'age': 36 }
* ];
*
* // Sort by `user` in ascending order and by `age` in descending order.
* _.orderBy(users, ['user', 'age'], ['asc', 'desc']);
* // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]
*/
function orderBy(collection, iteratees, orders, guard) {
if (collection == null) {
return [];
}
if (!isArray(iteratees)) {
iteratees = iteratees == null ? [] : [iteratees];
}
orders = guard ? undefined : orders;
if (!isArray(orders)) {
orders = orders == null ? [] : [orders];
}
return baseOrderBy(collection, iteratees, orders);
}
/**
* Creates an array of elements split into two groups, the first of which
* contains elements `predicate` returns truthy for, the second of which
* contains elements `predicate` returns falsey for. The predicate is
* invoked with one argument: (value).
*
* @static
* @memberOf _
* @since 3.0.0
* @category Collection
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} [predicate=_.identity] The function invoked per iteration.
* @returns {Array} Returns the array of grouped elements.
* @example
*
* var users = [
* { 'user': 'barney', 'age': 36, 'active': false },
* { 'user': 'fred', 'age': 40, 'active': true },
* { 'user': 'pebbles', 'age': 1, 'active': false }
* ];
*
* _.partition(users, function(o) { return o.active; });
* // => objects for [['fred'], ['barney', 'pebbles']]
*
* // The `_.matches` iteratee shorthand.
* _.partition(users, { 'age': 1, 'active': false });
* // => objects for [['pebbles'], ['barney', 'fred']]
*
* // The `_.matchesProperty` iteratee shorthand.
* _.partition(users, ['active', false]);
* // => objects for [['barney', 'pebbles'], ['fred']]
*
* // The `_.property` iteratee shorthand.
* _.partition(users, 'active');
* // => objects for [['fred'], ['barney', 'pebbles']]
*/
var partition = createAggregator(function(result, value, key) {
result[key ? 0 : 1].push(value);
}, function() { return [[], []]; });
/**
* Reduces `collection` to a value which is the accumulated result of running
* each element in `collection` thru `iteratee`, where each successive
* invocation is supplied the return value of the previous. If `accumulator`
* is not given, the first element of `collection` is used as the initial
* value. The iteratee is invoked with four arguments:
* (accumulator, value, index|key, collection).
*
* Many lodash methods are guarded to work as iteratees for methods like
* `_.reduce`, `_.reduceRight`, and `_.transform`.
*
* The guarded methods are:
* `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`,
* and `sortBy`
*
* @static
* @memberOf _
* @since 0.1.0
* @category Collection
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} [iteratee=_.identity] The function invoked per iteration.
* @param {*} [accumulator] The initial value.
* @returns {*} Returns the accumulated value.
* @see _.reduceRight
* @example
*
* _.reduce([1, 2], function(sum, n) {
* return sum + n;
* }, 0);
* // => 3
*
* _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
* (result[value] || (result[value] = [])).push(key);
* return result;
* }, {});
* // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed)
*/
function reduce(collection, iteratee, accumulator) {
var func = isArray(collection) ? arrayReduce : baseReduce,
initAccum = arguments.length < 3;
return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEach);
}
/**
* This method is like `_.reduce` except that it iterates over elements of
* `collection` from right to left.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Collection
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} [iteratee=_.identity] The function invoked per iteration.
* @param {*} [accumulator] The initial value.
* @returns {*} Returns the accumulated value.
* @see _.reduce
* @example
*
* var array = [[0, 1], [2, 3], [4, 5]];
*
* _.reduceRight(array, function(flattened, other) {
* return flattened.concat(other);
* }, []);
* // => [4, 5, 2, 3, 0, 1]
*/
function reduceRight(collection, iteratee, accumulator) {
var func = isArray(collection) ? arrayReduceRight : baseReduce,
initAccum = arguments.length < 3;
return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEachRight);
}
/**
* The opposite of `_.filter`; this method returns the elements of `collection`
* that `predicate` does **not** return truthy for.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Collection
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} [predicate=_.identity] The function invoked per iteration.
* @returns {Array} Returns the new filtered array.
* @see _.filter
* @example
*
* var users = [
* { 'user': 'barney', 'age': 36, 'active': false },
* { 'user': 'fred', 'age': 40, 'active': true }
* ];
*
* _.reject(users, function(o) { return !o.active; });
* // => objects for ['fred']
*
* // The `_.matches` iteratee shorthand.
* _.reject(users, { 'age': 40, 'active': true });
* // => objects for ['barney']
*
* // The `_.matchesProperty` iteratee shorthand.
* _.reject(users, ['active', false]);
* // => objects for ['fred']
*
* // The `_.property` iteratee shorthand.
* _.reject(users, 'active');
* // => objects for ['barney']
*/
function reject(collection, predicate) {
var func = isArray(collection) ? arrayFilter : baseFilter;
return func(collection, negate(getIteratee(predicate, 3)));
}
/**
* Gets a random element from `collection`.
*
* @static
* @memberOf _
* @since 2.0.0
* @category Collection
* @param {Array|Object} collection The collection to sample.
* @returns {*} Returns the random element.
* @example
*
* _.sample([1, 2, 3, 4]);
* // => 2
*/
function sample(collection) {
var func = isArray(collection) ? arraySample : baseSample;
return func(collection);
}
/**
* Gets `n` random elements at unique keys from `collection` up to the
* size of `collection`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Collection
* @param {Array|Object} collection The collection to sample.
* @param {number} [n=1] The number of elements to sample.
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
* @returns {Array} Returns the random elements.
* @example
*
* _.sampleSize([1, 2, 3], 2);
* // => [3, 1]
*
* _.sampleSize([1, 2, 3], 4);
* // => [2, 3, 1]
*/
function sampleSize(collection, n, guard) {
if ((guard ? isIterateeCall(collection, n, guard) : n === undefined)) {
n = 1;
} else {
n = toInteger(n);
}
var func = isArray(collection) ? arraySampleSize : baseSampleSize;
return func(collection, n);
}
/**
* Creates an array of shuffled values, using a version of the
* [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle).
*
* @static
* @memberOf _
* @since 0.1.0
* @category Collection
* @param {Array|Object} collection The collection to shuffle.
* @returns {Array} Returns the new shuffled array.
* @example
*
* _.shuffle([1, 2, 3, 4]);
* // => [4, 1, 3, 2]
*/
function shuffle(collection) {
var func = isArray(collection) ? arrayShuffle : baseShuffle;
return func(collection);
}
/**
* Gets the size of `collection` by returning its length for array-like
* values or the number of own enumerable string keyed properties for objects.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Collection
* @param {Array|Object|string} collection The collection to inspect.
* @returns {number} Returns the collection size.
* @example
*
* _.size([1, 2, 3]);
* // => 3
*
* _.size({ 'a': 1, 'b': 2 });
* // => 2
*
* _.size('pebbles');
* // => 7
*/
function size(collection) {
if (collection == null) {
return 0;
}
if (isArrayLike(collection)) {
return isString(collection) ? stringSize(collection) : collection.length;
}
var tag = getTag(collection);
if (tag == mapTag || tag == setTag) {
return collection.size;
}
return baseKeys(collection).length;
}
/**
* Checks if `predicate` returns truthy for **any** element of `collection`.
* Iteration is stopped once `predicate` returns truthy. The predicate is
* invoked with three arguments: (value, index|key, collection).
*
* @static
* @memberOf _
* @since 0.1.0
* @category Collection
* @param {Array|Object} collection The collection to iterate over.
* @param {Function} [predicate=_.identity] The function invoked per iteration.
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
* @returns {boolean} Returns `true` if any element passes the predicate check,
* else `false`.
* @example
*
* _.some([null, 0, 'yes', false], Boolean);
* // => true
*
* var users = [
* { 'user': 'barney', 'active': true },
* { 'user': 'fred', 'active': false }
* ];
*
* // The `_.matches` iteratee shorthand.
* _.some(users, { 'user': 'barney', 'active': false });
* // => false
*
* // The `_.matchesProperty` iteratee shorthand.
* _.some(users, ['active', false]);
* // => true
*
* // The `_.property` iteratee shorthand.
* _.some(users, 'active');
* // => true
*/
function some(collection, predicate, guard) {
var func = isArray(collection) ? arraySome : baseSome;
if (guard && isIterateeCall(collection, predicate, guard)) {
predicate = undefined;
}
return func(collection, getIteratee(predicate, 3));
}
/**
* Creates an array of elements, sorted in ascending order by the results of
* running each element in a collection thru each iteratee. This method
* performs a stable sort, that is, it preserves the original sort order of
* equal elements. The iteratees are invoked with one argument: (value).
*
* @static
* @memberOf _
* @since 0.1.0
* @category Collection
* @param {Array|Object} collection The collection to iterate over.
* @param {...(Function|Function[])} [iteratees=[_.identity]]
* The iteratees to sort by.
* @returns {Array} Returns the new sorted array.
* @example
*
* var users = [
* { 'user': 'fred', 'age': 48 },
* { 'user': 'barney', 'age': 36 },
* { 'user': 'fred', 'age': 40 },
* { 'user': 'barney', 'age': 34 }
* ];
*
* _.sortBy(users, [function(o) { return o.user; }]);
* // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]
*
* _.sortBy(users, ['user', 'age']);
* // => objects for [['barney', 34], ['barney', 36], ['fred', 40], ['fred', 48]]
*/
var sortBy = baseRest(function(collection, iteratees) {
if (collection == null) {
return [];
}
var length = iteratees.length;
if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {
iteratees = [];
} else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {
iteratees = [iteratees[0]];
}
return baseOrderBy(collection, baseFlatten(iteratees, 1), []);
});
/*------------------------------------------------------------------------*/
/**
* Gets the timestamp of the number of milliseconds that have elapsed since
* the Unix epoch (1 January 1970 00:00:00 UTC).
*
* @static
* @memberOf _
* @since 2.4.0
* @category Date
* @returns {number} Returns the timestamp.
* @example
*
* _.defer(function(stamp) {
* console.log(_.now() - stamp);
* }, _.now());
* // => Logs the number of milliseconds it took for the deferred invocation.
*/
var now = ctxNow || function() {
return root.Date.now();
};
/*------------------------------------------------------------------------*/
/**
* The opposite of `_.before`; this method creates a function that invokes
* `func` once it's called `n` or more times.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Function
* @param {number} n The number of calls before `func` is invoked.
* @param {Function} func The function to restrict.
* @returns {Function} Returns the new restricted function.
* @example
*
* var saves = ['profile', 'settings'];
*
* var done = _.after(saves.length, function() {
* console.log('done saving!');
* });
*
* _.forEach(saves, function(type) {
* asyncSave({ 'type': type, 'complete': done });
* });
* // => Logs 'done saving!' after the two async saves have completed.
*/
function after(n, func) {
if (typeof func != 'function') {
throw new TypeError(FUNC_ERROR_TEXT);
}
n = toInteger(n);
return function() {
if (--n < 1) {
return func.apply(this, arguments);
}
};
}
/**
* Creates a function that invokes `func`, with up to `n` arguments,
* ignoring any additional arguments.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Function
* @param {Function} func The function to cap arguments for.
* @param {number} [n=func.length] The arity cap.
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
* @returns {Function} Returns the new capped function.
* @example
*
* _.map(['6', '8', '10'], _.ary(parseInt, 1));
* // => [6, 8, 10]
*/
function ary(func, n, guard) {
n = guard ? undefined : n;
n = (func && n == null) ? func.length : n;
return createWrap(func, WRAP_ARY_FLAG, undefined, undefined, undefined, undefined, n);
}
/**
* Creates a function that invokes `func`, with the `this` binding and arguments
* of the created function, while it's called less than `n` times. Subsequent
* calls to the created function return the result of the last `func` invocation.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Function
* @param {number} n The number of calls at which `func` is no longer invoked.
* @param {Function} func The function to restrict.
* @returns {Function} Returns the new restricted function.
* @example
*
* jQuery(element).on('click', _.before(5, addContactToList));
* // => Allows adding up to 4 contacts to the list.
*/
function before(n, func) {
var result;
if (typeof func != 'function') {
throw new TypeError(FUNC_ERROR_TEXT);
}
n = toInteger(n);
return function() {
if (--n > 0) {
result = func.apply(this, arguments);
}
if (n <= 1) {
func = undefined;
}
return result;
};
}
/**
* Creates a function that invokes `func` with the `this` binding of `thisArg`
* and `partials` prepended to the arguments it receives.
*
* The `_.bind.placeholder` value, which defaults to `_` in monolithic builds,
* may be used as a placeholder for partially applied arguments.
*
* **Note:** Unlike native `Function#bind`, this method doesn't set the "length"
* property of bound functions.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Function
* @param {Function} func The function to bind.
* @param {*} thisArg The `this` binding of `func`.
* @param {...*} [partials] The arguments to be partially applied.
* @returns {Function} Returns the new bound function.
* @example
*
* function greet(greeting, punctuation) {
* return greeting + ' ' + this.user + punctuation;
* }
*
* var object = { 'user': 'fred' };
*
* var bound = _.bind(greet, object, 'hi');
* bound('!');
* // => 'hi fred!'
*
* // Bound with placeholders.
* var bound = _.bind(greet, object, _, '!');
* bound('hi');
* // => 'hi fred!'
*/
var bind = baseRest(function(func, thisArg, partials) {
var bitmask = WRAP_BIND_FLAG;
if (partials.length) {
var holders = replaceHolders(partials, getHolder(bind));
bitmask |= WRAP_PARTIAL_FLAG;
}
return createWrap(func, bitmask, thisArg, partials, holders);
});
/**
* Creates a function that invokes the method at `object[key]` with `partials`
* prepended to the arguments it receives.
*
* This method differs from `_.bind` by allowing bound functions to reference
* methods that may be redefined or don't yet exist. See
* [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern)
* for more details.
*
* The `_.bindKey.placeholder` value, which defaults to `_` in monolithic
* builds, may be used as a placeholder for partially applied arguments.
*
* @static
* @memberOf _
* @since 0.10.0
* @category Function
* @param {Object} object The object to invoke the method on.
* @param {string} key The key of the method.
* @param {...*} [partials] The arguments to be partially applied.
* @returns {Function} Returns the new bound function.
* @example
*
* var object = {
* 'user': 'fred',
* 'greet': function(greeting, punctuation) {
* return greeting + ' ' + this.user + punctuation;
* }
* };
*
* var bound = _.bindKey(object, 'greet', 'hi');
* bound('!');
* // => 'hi fred!'
*
* object.greet = function(greeting, punctuation) {
* return greeting + 'ya ' + this.user + punctuation;
* };
*
* bound('!');
* // => 'hiya fred!'
*
* // Bound with placeholders.
* var bound = _.bindKey(object, 'greet', _, '!');
* bound('hi');
* // => 'hiya fred!'
*/
var bindKey = baseRest(function(object, key, partials) {
var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG;
if (partials.length) {
var holders = replaceHolders(partials, getHolder(bindKey));
bitmask |= WRAP_PARTIAL_FLAG;
}
return createWrap(key, bitmask, object, partials, holders);
});
/**
* Creates a function that accepts arguments of `func` and either invokes
* `func` returning its result, if at least `arity` number of arguments have
* been provided, or returns a function that accepts the remaining `func`
* arguments, and so on. The arity of `func` may be specified if `func.length`
* is not sufficient.
*
* The `_.curry.placeholder` value, which defaults to `_` in monolithic builds,
* may be used as a placeholder for provided arguments.
*
* **Note:** This method doesn't set the "length" property of curried functions.
*
* @static
* @memberOf _
* @since 2.0.0
* @category Function
* @param {Function} func The function to curry.
* @param {number} [arity=func.length] The arity of `func`.
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
* @returns {Function} Returns the new curried function.
* @example
*
* var abc = function(a, b, c) {
* return [a, b, c];
* };
*
* var curried = _.curry(abc);
*
* curried(1)(2)(3);
* // => [1, 2, 3]
*
* curried(1, 2)(3);
* // => [1, 2, 3]
*
* curried(1, 2, 3);
* // => [1, 2, 3]
*
* // Curried with placeholders.
* curried(1)(_, 3)(2);
* // => [1, 2, 3]
*/
function curry(func, arity, guard) {
arity = guard ? undefined : arity;
var result = createWrap(func, WRAP_CURRY_FLAG, undefined, undefined, undefined, undefined, undefined, arity);
result.placeholder = curry.placeholder;
return result;
}
/**
* This method is like `_.curry` except that arguments are applied to `func`
* in the manner of `_.partialRight` instead of `_.partial`.
*
* The `_.curryRight.placeholder` value, which defaults to `_` in monolithic
* builds, may be used as a placeholder for provided arguments.
*
* **Note:** This method doesn't set the "length" property of curried functions.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Function
* @param {Function} func The function to curry.
* @param {number} [arity=func.length] The arity of `func`.
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
* @returns {Function} Returns the new curried function.
* @example
*
* var abc = function(a, b, c) {
* return [a, b, c];
* };
*
* var curried = _.curryRight(abc);
*
* curried(3)(2)(1);
* // => [1, 2, 3]
*
* curried(2, 3)(1);
* // => [1, 2, 3]
*
* curried(1, 2, 3);
* // => [1, 2, 3]
*
* // Curried with placeholders.
* curried(3)(1, _)(2);
* // => [1, 2, 3]
*/
function curryRight(func, arity, guard) {
arity = guard ? undefined : arity;
var result = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined, undefined, undefined, undefined, undefined, arity);
result.placeholder = curryRight.placeholder;
return result;
}
/**
* Creates a debounced function that delays invoking `func` until after `wait`
* milliseconds have elapsed since the last time the debounced function was
* invoked. The debounced function comes with a `cancel` method to cancel
* delayed `func` invocations and a `flush` method to immediately invoke them.
* Provide `options` to indicate whether `func` should be invoked on the
* leading and/or trailing edge of the `wait` timeout. The `func` is invoked
* with the last arguments provided to the debounced function. Subsequent
* calls to the debounced function return the result of the last `func`
* invocation.
*
* **Note:** If `leading` and `trailing` options are `true`, `func` is
* invoked on the trailing edge of the timeout only if the debounced function
* is invoked more than once during the `wait` timeout.
*
* If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
* until to the next tick, similar to `setTimeout` with a timeout of `0`.
*
* See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
* for details over the differences between `_.debounce` and `_.throttle`.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Function
* @param {Function} func The function to debounce.
* @param {number} [wait=0] The number of milliseconds to delay.
* @param {Object} [options={}] The options object.
* @param {boolean} [options.leading=false]
* Specify invoking on the leading edge of the timeout.
* @param {number} [options.maxWait]
* The maximum time `func` is allowed to be delayed before it's invoked.
* @param {boolean} [options.trailing=true]
* Specify invoking on the trailing edge of the timeout.
* @returns {Function} Returns the new debounced function.
* @example
*
* // Avoid costly calculations while the window size is in flux.
* jQuery(window).on('resize', _.debounce(calculateLayout, 150));
*
* // Invoke `sendMail` when clicked, debouncing subsequent calls.
* jQuery(element).on('click', _.debounce(sendMail, 300, {
* 'leading': true,
* 'trailing': false
* }));
*
* // Ensure `batchLog` is invoked once after 1 second of debounced calls.
* var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
* var source = new EventSource('/stream');
* jQuery(source).on('message', debounced);
*
* // Cancel the trailing debounced invocation.
* jQuery(window).on('popstate', debounced.cancel);
*/
function debounce(func, wait, options) {
var lastArgs,
lastThis,
maxWait,
result,
timerId,
lastCallTime,
lastInvokeTime = 0,
leading = false,
maxing = false,
trailing = true;
if (typeof func != 'function') {
throw new TypeError(FUNC_ERROR_TEXT);
}
wait = toNumber(wait) || 0;
if (isObject(options)) {
leading = !!options.leading;
maxing = 'maxWait' in options;
maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
trailing = 'trailing' in options ? !!options.trailing : trailing;
}
function invokeFunc(time) {
var args = lastArgs,
thisArg = lastThis;
lastArgs = lastThis = undefined;
lastInvokeTime = time;
result = func.apply(thisArg, args);
return result;
}
function leadingEdge(time) {
// Reset any `maxWait` timer.
lastInvokeTime = time;
// Start the timer for the trailing edge.
timerId = setTimeout(timerExpired, wait);
// Invoke the leading edge.
return leading ? invokeFunc(time) : result;
}
function remainingWait(time) {
var timeSinceLastCall = time - lastCallTime,
timeSinceLastInvoke = time - lastInvokeTime,
timeWaiting = wait - timeSinceLastCall;
return maxing
? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)
: timeWaiting;
}
function shouldInvoke(time) {
var timeSinceLastCall = time - lastCallTime,
timeSinceLastInvoke = time - lastInvokeTime;
// Either this is the first call, activity has stopped and we're at the
// trailing edge, the system time has gone backwards and we're treating
// it as the trailing edge, or we've hit the `maxWait` limit.
return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||
(timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
}
function timerExpired() {
var time = now();
if (shouldInvoke(time)) {
return trailingEdge(time);
}
// Restart the timer.
timerId = setTimeout(timerExpired, remainingWait(time));
}
function trailingEdge(time) {
timerId = undefined;
// Only invoke if we have `lastArgs` which means `func` has been
// debounced at least once.
if (trailing && lastArgs) {
return invokeFunc(time);
}
lastArgs = lastThis = undefined;
return result;
}
function cancel() {
if (timerId !== undefined) {
clearTimeout(timerId);
}
lastInvokeTime = 0;
lastArgs = lastCallTime = lastThis = timerId = undefined;
}
function flush() {
return timerId === undefined ? result : trailingEdge(now());
}
function debounced() {
var time = now(),
isInvoking = shouldInvoke(time);
lastArgs = arguments;
lastThis = this;
lastCallTime = time;
if (isInvoking) {
if (timerId === undefined) {
return leadingEdge(lastCallTime);
}
if (maxing) {
// Handle invocations in a tight loop.
timerId = setTimeout(timerExpired, wait);
return invokeFunc(lastCallTime);
}
}
if (timerId === undefined) {
timerId = setTimeout(timerExpired, wait);
}
return result;
}
debounced.cancel = cancel;
debounced.flush = flush;
return debounced;
}
/**
* Defers invoking the `func` until the current call stack has cleared. Any
* additional arguments are provided to `func` when it's invoked.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Function
* @param {Function} func The function to defer.
* @param {...*} [args] The arguments to invoke `func` with.
* @returns {number} Returns the timer id.
* @example
*
* _.defer(function(text) {
* console.log(text);
* }, 'deferred');
* // => Logs 'deferred' after one millisecond.
*/
var defer = baseRest(function(func, args) {
return baseDelay(func, 1, args);
});
/**
* Invokes `func` after `wait` milliseconds. Any additional arguments are
* provided to `func` when it's invoked.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Function
* @param {Function} func The function to delay.
* @param {number} wait The number of milliseconds to delay invocation.
* @param {...*} [args] The arguments to invoke `func` with.
* @returns {number} Returns the timer id.
* @example
*
* _.delay(function(text) {
* console.log(text);
* }, 1000, 'later');
* // => Logs 'later' after one second.
*/
var delay = baseRest(function(func, wait, args) {
return baseDelay(func, toNumber(wait) || 0, args);
});
/**
* Creates a function that invokes `func` with arguments reversed.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Function
* @param {Function} func The function to flip arguments for.
* @returns {Function} Returns the new flipped function.
* @example
*
* var flipped = _.flip(function() {
* return _.toArray(arguments);
* });
*
* flipped('a', 'b', 'c', 'd');
* // => ['d', 'c', 'b', 'a']
*/
function flip(func) {
return createWrap(func, WRAP_FLIP_FLAG);
}
/**
* Creates a function that memoizes the result of `func`. If `resolver` is
* provided, it determines the cache key for storing the result based on the
* arguments provided to the memoized function. By default, the first argument
* provided to the memoized function is used as the map cache key. The `func`
* is invoked with the `this` binding of the memoized function.
*
* **Note:** The cache is exposed as the `cache` property on the memoized
* function. Its creation may be customized by replacing the `_.memoize.Cache`
* constructor with one whose instances implement the
* [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
* method interface of `clear`, `delete`, `get`, `has`, and `set`.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Function
* @param {Function} func The function to have its output memoized.
* @param {Function} [resolver] The function to resolve the cache key.
* @returns {Function} Returns the new memoized function.
* @example
*
* var object = { 'a': 1, 'b': 2 };
* var other = { 'c': 3, 'd': 4 };
*
* var values = _.memoize(_.values);
* values(object);
* // => [1, 2]
*
* values(other);
* // => [3, 4]
*
* object.a = 2;
* values(object);
* // => [1, 2]
*
* // Modify the result cache.
* values.cache.set(object, ['a', 'b']);
* values(object);
* // => ['a', 'b']
*
* // Replace `_.memoize.Cache`.
* _.memoize.Cache = WeakMap;
*/
function memoize(func, resolver) {
if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {
throw new TypeError(FUNC_ERROR_TEXT);
}
var memoized = function() {
var args = arguments,
key = resolver ? resolver.apply(this, args) : args[0],
cache = memoized.cache;
if (cache.has(key)) {
return cache.get(key);
}
var result = func.apply(this, args);
memoized.cache = cache.set(key, result) || cache;
return result;
};
memoized.cache = new (memoize.Cache || MapCache);
return memoized;
}
// Expose `MapCache`.
memoize.Cache = MapCache;
/**
* Creates a function that negates the result of the predicate `func`. The
* `func` predicate is invoked with the `this` binding and arguments of the
* created function.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Function
* @param {Function} predicate The predicate to negate.
* @returns {Function} Returns the new negated function.
* @example
*
* function isEven(n) {
* return n % 2 == 0;
* }
*
* _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));
* // => [1, 3, 5]
*/
function negate(predicate) {
if (typeof predicate != 'function') {
throw new TypeError(FUNC_ERROR_TEXT);
}
return function() {
var args = arguments;
switch (args.length) {
case 0: return !predicate.call(this);
case 1: return !predicate.call(this, args[0]);
case 2: return !predicate.call(this, args[0], args[1]);
case 3: return !predicate.call(this, args[0], args[1], args[2]);
}
return !predicate.apply(this, args);
};
}
/**
* Creates a function that is restricted to invoking `func` once. Repeat calls
* to the function return the value of the first invocation. The `func` is
* invoked with the `this` binding and arguments of the created function.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Function
* @param {Function} func The function to restrict.
* @returns {Function} Returns the new restricted function.
* @example
*
* var initialize = _.once(createApplication);
* initialize();
* initialize();
* // => `createApplication` is invoked once
*/
function once(func) {
return before(2, func);
}
/**
* Creates a function that invokes `func` with its arguments transformed.
*
* @static
* @since 4.0.0
* @memberOf _
* @category Function
* @param {Function} func The function to wrap.
* @param {...(Function|Function[])} [transforms=[_.identity]]
* The argument transforms.
* @returns {Function} Returns the new function.
* @example
*
* function doubled(n) {
* return n * 2;
* }
*
* function square(n) {
* return n * n;
* }
*
* var func = _.overArgs(function(x, y) {
* return [x, y];
* }, [square, doubled]);
*
* func(9, 3);
* // => [81, 6]
*
* func(10, 5);
* // => [100, 10]
*/
var overArgs = castRest(function(func, transforms) {
transforms = (transforms.length == 1 && isArray(transforms[0]))
? arrayMap(transforms[0], baseUnary(getIteratee()))
: arrayMap(baseFlatten(transforms, 1), baseUnary(getIteratee()));
var funcsLength = transforms.length;
return baseRest(function(args) {
var index = -1,
length = nativeMin(args.length, funcsLength);
while (++index < length) {
args[index] = transforms[index].call(this, args[index]);
}
return apply(func, this, args);
});
});
/**
* Creates a function that invokes `func` with `partials` prepended to the
* arguments it receives. This method is like `_.bind` except it does **not**
* alter the `this` binding.
*
* The `_.partial.placeholder` value, which defaults to `_` in monolithic
* builds, may be used as a placeholder for partially applied arguments.
*
* **Note:** This method doesn't set the "length" property of partially
* applied functions.
*
* @static
* @memberOf _
* @since 0.2.0
* @category Function
* @param {Function} func The function to partially apply arguments to.
* @param {...*} [partials] The arguments to be partially applied.
* @returns {Function} Returns the new partially applied function.
* @example
*
* function greet(greeting, name) {
* return greeting + ' ' + name;
* }
*
* var sayHelloTo = _.partial(greet, 'hello');
* sayHelloTo('fred');
* // => 'hello fred'
*
* // Partially applied with placeholders.
* var greetFred = _.partial(greet, _, 'fred');
* greetFred('hi');
* // => 'hi fred'
*/
var partial = baseRest(function(func, partials) {
var holders = replaceHolders(partials, getHolder(partial));
return createWrap(func, WRAP_PARTIAL_FLAG, undefined, partials, holders);
});
/**
* This method is like `_.partial` except that partially applied arguments
* are appended to the arguments it receives.
*
* The `_.partialRight.placeholder` value, which defaults to `_` in monolithic
* builds, may be used as a placeholder for partially applied arguments.
*
* **Note:** This method doesn't set the "length" property of partially
* applied functions.
*
* @static
* @memberOf _
* @since 1.0.0
* @category Function
* @param {Function} func The function to partially apply arguments to.
* @param {...*} [partials] The arguments to be partially applied.
* @returns {Function} Returns the new partially applied function.
* @example
*
* function greet(greeting, name) {
* return greeting + ' ' + name;
* }
*
* var greetFred = _.partialRight(greet, 'fred');
* greetFred('hi');
* // => 'hi fred'
*
* // Partially applied with placeholders.
* var sayHelloTo = _.partialRight(greet, 'hello', _);
* sayHelloTo('fred');
* // => 'hello fred'
*/
var partialRight = baseRest(function(func, partials) {
var holders = replaceHolders(partials, getHolder(partialRight));
return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, undefined, partials, holders);
});
/**
* Creates a function that invokes `func` with arguments arranged according
* to the specified `indexes` where the argument value at the first index is
* provided as the first argument, the argument value at the second index is
* provided as the second argument, and so on.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Function
* @param {Function} func The function to rearrange arguments for.
* @param {...(number|number[])} indexes The arranged argument indexes.
* @returns {Function} Returns the new function.
* @example
*
* var rearged = _.rearg(function(a, b, c) {
* return [a, b, c];
* }, [2, 0, 1]);
*
* rearged('b', 'c', 'a')
* // => ['a', 'b', 'c']
*/
var rearg = flatRest(function(func, indexes) {
return createWrap(func, WRAP_REARG_FLAG, undefined, undefined, undefined, indexes);
});
/**
* Creates a function that invokes `func` with the `this` binding of the
* created function and arguments from `start` and beyond provided as
* an array.
*
* **Note:** This method is based on the
* [rest parameter](https://mdn.io/rest_parameters).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Function
* @param {Function} func The function to apply a rest parameter to.
* @param {number} [start=func.length-1] The start position of the rest parameter.
* @returns {Function} Returns the new function.
* @example
*
* var say = _.rest(function(what, names) {
* return what + ' ' + _.initial(names).join(', ') +
* (_.size(names) > 1 ? ', & ' : '') + _.last(names);
* });
*
* say('hello', 'fred', 'barney', 'pebbles');
* // => 'hello fred, barney, & pebbles'
*/
function rest(func, start) {
if (typeof func != 'function') {
throw new TypeError(FUNC_ERROR_TEXT);
}
start = start === undefined ? start : toInteger(start);
return baseRest(func, start);
}
/**
* Creates a function that invokes `func` with the `this` binding of the
* create function and an array of arguments much like
* [`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply).
*
* **Note:** This method is based on the
* [spread operator](https://mdn.io/spread_operator).
*
* @static
* @memberOf _
* @since 3.2.0
* @category Function
* @param {Function} func The function to spread arguments over.
* @param {number} [start=0] The start position of the spread.
* @returns {Function} Returns the new function.
* @example
*
* var say = _.spread(function(who, what) {
* return who + ' says ' + what;
* });
*
* say(['fred', 'hello']);
* // => 'fred says hello'
*
* var numbers = Promise.all([
* Promise.resolve(40),
* Promise.resolve(36)
* ]);
*
* numbers.then(_.spread(function(x, y) {
* return x + y;
* }));
* // => a Promise of 76
*/
function spread(func, start) {
if (typeof func != 'function') {
throw new TypeError(FUNC_ERROR_TEXT);
}
start = start == null ? 0 : nativeMax(toInteger(start), 0);
return baseRest(function(args) {
var array = args[start],
otherArgs = castSlice(args, 0, start);
if (array) {
arrayPush(otherArgs, array);
}
return apply(func, this, otherArgs);
});
}
/**
* Creates a throttled function that only invokes `func` at most once per
* every `wait` milliseconds. The throttled function comes with a `cancel`
* method to cancel delayed `func` invocations and a `flush` method to
* immediately invoke them. Provide `options` to indicate whether `func`
* should be invoked on the leading and/or trailing edge of the `wait`
* timeout. The `func` is invoked with the last arguments provided to the
* throttled function. Subsequent calls to the throttled function return the
* result of the last `func` invocation.
*
* **Note:** If `leading` and `trailing` options are `true`, `func` is
* invoked on the trailing edge of the timeout only if the throttled function
* is invoked more than once during the `wait` timeout.
*
* If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
* until to the next tick, similar to `setTimeout` with a timeout of `0`.
*
* See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
* for details over the differences between `_.throttle` and `_.debounce`.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Function
* @param {Function} func The function to throttle.
* @param {number} [wait=0] The number of milliseconds to throttle invocations to.
* @param {Object} [options={}] The options object.
* @param {boolean} [options.leading=true]
* Specify invoking on the leading edge of the timeout.
* @param {boolean} [options.trailing=true]
* Specify invoking on the trailing edge of the timeout.
* @returns {Function} Returns the new throttled function.
* @example
*
* // Avoid excessively updating the position while scrolling.
* jQuery(window).on('scroll', _.throttle(updatePosition, 100));
*
* // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.
* var throttled = _.throttle(renewToken, 300000, { 'trailing': false });
* jQuery(element).on('click', throttled);
*
* // Cancel the trailing throttled invocation.
* jQuery(window).on('popstate', throttled.cancel);
*/
function throttle(func, wait, options) {
var leading = true,
trailing = true;
if (typeof func != 'function') {
throw new TypeError(FUNC_ERROR_TEXT);
}
if (isObject(options)) {
leading = 'leading' in options ? !!options.leading : leading;
trailing = 'trailing' in options ? !!options.trailing : trailing;
}
return debounce(func, wait, {
'leading': leading,
'maxWait': wait,
'trailing': trailing
});
}
/**
* Creates a function that accepts up to one argument, ignoring any
* additional arguments.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Function
* @param {Function} func The function to cap arguments for.
* @returns {Function} Returns the new capped function.
* @example
*
* _.map(['6', '8', '10'], _.unary(parseInt));
* // => [6, 8, 10]
*/
function unary(func) {
return ary(func, 1);
}
/**
* Creates a function that provides `value` to `wrapper` as its first
* argument. Any additional arguments provided to the function are appended
* to those provided to the `wrapper`. The wrapper is invoked with the `this`
* binding of the created function.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Function
* @param {*} value The value to wrap.
* @param {Function} [wrapper=identity] The wrapper function.
* @returns {Function} Returns the new function.
* @example
*
* var p = _.wrap(_.escape, function(func, text) {
* return '<p>' + func(text) + '</p>';
* });
*
* p('fred, barney, & pebbles');
* // => '<p>fred, barney, & pebbles</p>'
*/
function wrap(value, wrapper) {
return partial(castFunction(wrapper), value);
}
/*------------------------------------------------------------------------*/
/**
* Casts `value` as an array if it's not one.
*
* @static
* @memberOf _
* @since 4.4.0
* @category Lang
* @param {*} value The value to inspect.
* @returns {Array} Returns the cast array.
* @example
*
* _.castArray(1);
* // => [1]
*
* _.castArray({ 'a': 1 });
* // => [{ 'a': 1 }]
*
* _.castArray('abc');
* // => ['abc']
*
* _.castArray(null);
* // => [null]
*
* _.castArray(undefined);
* // => [undefined]
*
* _.castArray();
* // => []
*
* var array = [1, 2, 3];
* console.log(_.castArray(array) === array);
* // => true
*/
function castArray() {
if (!arguments.length) {
return [];
}
var value = arguments[0];
return isArray(value) ? value : [value];
}
/**
* Creates a shallow clone of `value`.
*
* **Note:** This method is loosely based on the
* [structured clone algorithm](https://mdn.io/Structured_clone_algorithm)
* and supports cloning arrays, array buffers, booleans, date objects, maps,
* numbers, `Object` objects, regexes, sets, strings, symbols, and typed
* arrays. The own enumerable properties of `arguments` objects are cloned
* as plain objects. An empty object is returned for uncloneable values such
* as error objects, functions, DOM nodes, and WeakMaps.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Lang
* @param {*} value The value to clone.
* @returns {*} Returns the cloned value.
* @see _.cloneDeep
* @example
*
* var objects = [{ 'a': 1 }, { 'b': 2 }];
*
* var shallow = _.clone(objects);
* console.log(shallow[0] === objects[0]);
* // => true
*/
function clone(value) {
return baseClone(value, CLONE_SYMBOLS_FLAG);
}
/**
* This method is like `_.clone` except that it accepts `customizer` which
* is invoked to produce the cloned value. If `customizer` returns `undefined`,
* cloning is handled by the method instead. The `customizer` is invoked with
* up to four arguments; (value [, index|key, object, stack]).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to clone.
* @param {Function} [customizer] The function to customize cloning.
* @returns {*} Returns the cloned value.
* @see _.cloneDeepWith
* @example
*
* function customizer(value) {
* if (_.isElement(value)) {
* return value.cloneNode(false);
* }
* }
*
* var el = _.cloneWith(document.body, customizer);
*
* console.log(el === document.body);
* // => false
* console.log(el.nodeName);
* // => 'BODY'
* console.log(el.childNodes.length);
* // => 0
*/
function cloneWith(value, customizer) {
customizer = typeof customizer == 'function' ? customizer : undefined;
return baseClone(value, CLONE_SYMBOLS_FLAG, customizer);
}
/**
* This method is like `_.clone` except that it recursively clones `value`.
*
* @static
* @memberOf _
* @since 1.0.0
* @category Lang
* @param {*} value The value to recursively clone.
* @returns {*} Returns the deep cloned value.
* @see _.clone
* @example
*
* var objects = [{ 'a': 1 }, { 'b': 2 }];
*
* var deep = _.cloneDeep(objects);
* console.log(deep[0] === objects[0]);
* // => false
*/
function cloneDeep(value) {
return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
}
/**
* This method is like `_.cloneWith` except that it recursively clones `value`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to recursively clone.
* @param {Function} [customizer] The function to customize cloning.
* @returns {*} Returns the deep cloned value.
* @see _.cloneWith
* @example
*
* function customizer(value) {
* if (_.isElement(value)) {
* return value.cloneNode(true);
* }
* }
*
* var el = _.cloneDeepWith(document.body, customizer);
*
* console.log(el === document.body);
* // => false
* console.log(el.nodeName);
* // => 'BODY'
* console.log(el.childNodes.length);
* // => 20
*/
function cloneDeepWith(value, customizer) {
customizer = typeof customizer == 'function' ? customizer : undefined;
return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);
}
/**
* Checks if `object` conforms to `source` by invoking the predicate
* properties of `source` with the corresponding property values of `object`.
*
* **Note:** This method is equivalent to `_.conforms` when `source` is
* partially applied.
*
* @static
* @memberOf _
* @since 4.14.0
* @category Lang
* @param {Object} object The object to inspect.
* @param {Object} source The object of property predicates to conform to.
* @returns {boolean} Returns `true` if `object` conforms, else `false`.
* @example
*
* var object = { 'a': 1, 'b': 2 };
*
* _.conformsTo(object, { 'b': function(n) { return n > 1; } });
* // => true
*
* _.conformsTo(object, { 'b': function(n) { return n > 2; } });
* // => false
*/
function conformsTo(object, source) {
return source == null || baseConformsTo(object, source, keys(source));
}
/**
* Performs a
* [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
* comparison between two values to determine if they are equivalent.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to compare.
* @param {*} other The other value to compare.
* @returns {boolean} Returns `true` if the values are equivalent, else `false`.
* @example
*
* var object = { 'a': 1 };
* var other = { 'a': 1 };
*
* _.eq(object, object);
* // => true
*
* _.eq(object, other);
* // => false
*
* _.eq('a', 'a');
* // => true
*
* _.eq('a', Object('a'));
* // => false
*
* _.eq(NaN, NaN);
* // => true
*/
function eq(value, other) {
return value === other || (value !== value && other !== other);
}
/**
* Checks if `value` is greater than `other`.
*
* @static
* @memberOf _
* @since 3.9.0
* @category Lang
* @param {*} value The value to compare.
* @param {*} other The other value to compare.
* @returns {boolean} Returns `true` if `value` is greater than `other`,
* else `false`.
* @see _.lt
* @example
*
* _.gt(3, 1);
* // => true
*
* _.gt(3, 3);
* // => false
*
* _.gt(1, 3);
* // => false
*/
var gt = createRelationalOperation(baseGt);
/**
* Checks if `value` is greater than or equal to `other`.
*
* @static
* @memberOf _
* @since 3.9.0
* @category Lang
* @param {*} value The value to compare.
* @param {*} other The other value to compare.
* @returns {boolean} Returns `true` if `value` is greater than or equal to
* `other`, else `false`.
* @see _.lte
* @example
*
* _.gte(3, 1);
* // => true
*
* _.gte(3, 3);
* // => true
*
* _.gte(1, 3);
* // => false
*/
var gte = createRelationalOperation(function(value, other) {
return value >= other;
});
/**
* Checks if `value` is likely an `arguments` object.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is an `arguments` object,
* else `false`.
* @example
*
* _.isArguments(function() { return arguments; }());
* // => true
*
* _.isArguments([1, 2, 3]);
* // => false
*/
var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&
!propertyIsEnumerable.call(value, 'callee');
};
/**
* Checks if `value` is classified as an `Array` object.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is an array, else `false`.
* @example
*
* _.isArray([1, 2, 3]);
* // => true
*
* _.isArray(document.body.children);
* // => false
*
* _.isArray('abc');
* // => false
*
* _.isArray(_.noop);
* // => false
*/
var isArray = Array.isArray;
/**
* Checks if `value` is classified as an `ArrayBuffer` object.
*
* @static
* @memberOf _
* @since 4.3.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.
* @example
*
* _.isArrayBuffer(new ArrayBuffer(2));
* // => true
*
* _.isArrayBuffer(new Array(2));
* // => false
*/
var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer;
/**
* Checks if `value` is array-like. A value is considered array-like if it's
* not a function and has a `value.length` that's an integer greater than or
* equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is array-like, else `false`.
* @example
*
* _.isArrayLike([1, 2, 3]);
* // => true
*
* _.isArrayLike(document.body.children);
* // => true
*
* _.isArrayLike('abc');
* // => true
*
* _.isArrayLike(_.noop);
* // => false
*/
function isArrayLike(value) {
return value != null && isLength(value.length) && !isFunction(value);
}
/**
* This method is like `_.isArrayLike` except that it also checks if `value`
* is an object.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is an array-like object,
* else `false`.
* @example
*
* _.isArrayLikeObject([1, 2, 3]);
* // => true
*
* _.isArrayLikeObject(document.body.children);
* // => true
*
* _.isArrayLikeObject('abc');
* // => false
*
* _.isArrayLikeObject(_.noop);
* // => false
*/
function isArrayLikeObject(value) {
return isObjectLike(value) && isArrayLike(value);
}
/**
* Checks if `value` is classified as a boolean primitive or object.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a boolean, else `false`.
* @example
*
* _.isBoolean(false);
* // => true
*
* _.isBoolean(null);
* // => false
*/
function isBoolean(value) {
return value === true || value === false ||
(isObjectLike(value) && baseGetTag(value) == boolTag);
}
/**
* Checks if `value` is a buffer.
*
* @static
* @memberOf _
* @since 4.3.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
* @example
*
* _.isBuffer(new Buffer(2));
* // => true
*
* _.isBuffer(new Uint8Array(2));
* // => false
*/
var isBuffer = nativeIsBuffer || stubFalse;
/**
* Checks if `value` is classified as a `Date` object.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a date object, else `false`.
* @example
*
* _.isDate(new Date);
* // => true
*
* _.isDate('Mon April 23 2012');
* // => false
*/
var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate;
/**
* Checks if `value` is likely a DOM element.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a DOM element, else `false`.
* @example
*
* _.isElement(document.body);
* // => true
*
* _.isElement('<body>');
* // => false
*/
function isElement(value) {
return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value);
}
/**
* Checks if `value` is an empty object, collection, map, or set.
*
* Objects are considered empty if they have no own enumerable string keyed
* properties.
*
* Array-like values such as `arguments` objects, arrays, buffers, strings, or
* jQuery-like collections are considered empty if they have a `length` of `0`.
* Similarly, maps and sets are considered empty if they have a `size` of `0`.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is empty, else `false`.
* @example
*
* _.isEmpty(null);
* // => true
*
* _.isEmpty(true);
* // => true
*
* _.isEmpty(1);
* // => true
*
* _.isEmpty([1, 2, 3]);
* // => false
*
* _.isEmpty({ 'a': 1 });
* // => false
*/
function isEmpty(value) {
if (value == null) {
return true;
}
if (isArrayLike(value) &&
(isArray(value) || typeof value == 'string' || typeof value.splice == 'function' ||
isBuffer(value) || isTypedArray(value) || isArguments(value))) {
return !value.length;
}
var tag = getTag(value);
if (tag == mapTag || tag == setTag) {
return !value.size;
}
if (isPrototype(value)) {
return !baseKeys(value).length;
}
for (var key in value) {
if (hasOwnProperty.call(value, key)) {
return false;
}
}
return true;
}
/**
* Performs a deep comparison between two values to determine if they are
* equivalent.
*
* **Note:** This method supports comparing arrays, array buffers, booleans,
* date objects, error objects, maps, numbers, `Object` objects, regexes,
* sets, strings, symbols, and typed arrays. `Object` objects are compared
* by their own, not inherited, enumerable properties. Functions and DOM
* nodes are compared by strict equality, i.e. `===`.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Lang
* @param {*} value The value to compare.
* @param {*} other The other value to compare.
* @returns {boolean} Returns `true` if the values are equivalent, else `false`.
* @example
*
* var object = { 'a': 1 };
* var other = { 'a': 1 };
*
* _.isEqual(object, other);
* // => true
*
* object === other;
* // => false
*/
function isEqual(value, other) {
return baseIsEqual(value, other);
}
/**
* This method is like `_.isEqual` except that it accepts `customizer` which
* is invoked to compare values. If `customizer` returns `undefined`, comparisons
* are handled by the method instead. The `customizer` is invoked with up to
* six arguments: (objValue, othValue [, index|key, object, other, stack]).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to compare.
* @param {*} other The other value to compare.
* @param {Function} [customizer] The function to customize comparisons.
* @returns {boolean} Returns `true` if the values are equivalent, else `false`.
* @example
*
* function isGreeting(value) {
* return /^h(?:i|ello)$/.test(value);
* }
*
* function customizer(objValue, othValue) {
* if (isGreeting(objValue) && isGreeting(othValue)) {
* return true;
* }
* }
*
* var array = ['hello', 'goodbye'];
* var other = ['hi', 'goodbye'];
*
* _.isEqualWith(array, other, customizer);
* // => true
*/
function isEqualWith(value, other, customizer) {
customizer = typeof customizer == 'function' ? customizer : undefined;
var result = customizer ? customizer(value, other) : undefined;
return result === undefined ? baseIsEqual(value, other, undefined, customizer) : !!result;
}
/**
* Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`,
* `SyntaxError`, `TypeError`, or `URIError` object.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is an error object, else `false`.
* @example
*
* _.isError(new Error);
* // => true
*
* _.isError(Error);
* // => false
*/
function isError(value) {
if (!isObjectLike(value)) {
return false;
}
var tag = baseGetTag(value);
return tag == errorTag || tag == domExcTag ||
(typeof value.message == 'string' && typeof value.name == 'string' && !isPlainObject(value));
}
/**
* Checks if `value` is a finite primitive number.
*
* **Note:** This method is based on
* [`Number.isFinite`](https://mdn.io/Number/isFinite).
*
* @static
* @memberOf _
* @since 0.1.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a finite number, else `false`.
* @example
*
* _.isFinite(3);
* // => true
*
* _.isFinite(Number.MIN_VALUE);
* // => true
*
* _.isFinite(Infinity);
* // => false
*
* _.isFinite('3');
* // => false
*/
function isFinite(value) {
return typeof value == 'number' && nativeIsFinite(value);
}
/**
* Checks if `value` is classified as a `Function` object.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a function, else `false`.
* @example
*
* _.isFunction(_);
* // => true
*
* _.isFunction(/abc/);
* // => false
*/
function isFunction(value) {
if (!isObject(value)) {
return false;
}
// The use of `Object#toString` avoids issues with the `typeof` operator
// in Safari 9 which returns 'object' for typed arrays and other constructors.
var tag = baseGetTag(value);
return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
}
/**
* Checks if `value` is an integer.
*
* **Note:** This method is based on
* [`Number.isInteger`](https://mdn.io/Number/isInteger).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is an integer, else `false`.
* @example
*
* _.isInteger(3);
* // => true
*
* _.isInteger(Number.MIN_VALUE);
* // => false
*
* _.isInteger(Infinity);
* // => false
*
* _.isInteger('3');
* // => false
*/
function isInteger(value) {
return typeof value == 'number' && value == toInteger(value);
}
/**
* Checks if `value` is a valid array-like length.
*
* **Note:** This method is loosely based on
* [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
* @example
*
* _.isLength(3);
* // => true
*
* _.isLength(Number.MIN_VALUE);
* // => false
*
* _.isLength(Infinity);
* // => false
*
* _.isLength('3');
* // => false
*/
function isLength(value) {
return typeof value == 'number' &&
value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
}
/**
* Checks if `value` is the
* [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
* of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
*
* @static
* @memberOf _
* @since 0.1.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is an object, else `false`.
* @example
*
* _.isObject({});
* // => true
*
* _.isObject([1, 2, 3]);
* // => true
*
* _.isObject(_.noop);
* // => true
*
* _.isObject(null);
* // => false
*/
function isObject(value) {
var type = typeof value;
return value != null && (type == 'object' || type == 'function');
}
/**
* Checks if `value` is object-like. A value is object-like if it's not `null`
* and has a `typeof` result of "object".
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
* @example
*
* _.isObjectLike({});
* // => true
*
* _.isObjectLike([1, 2, 3]);
* // => true
*
* _.isObjectLike(_.noop);
* // => false
*
* _.isObjectLike(null);
* // => false
*/
function isObjectLike(value) {
return value != null && typeof value == 'object';
}
/**
* Checks if `value` is classified as a `Map` object.
*
* @static
* @memberOf _
* @since 4.3.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a map, else `false`.
* @example
*
* _.isMap(new Map);
* // => true
*
* _.isMap(new WeakMap);
* // => false
*/
var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;
/**
* Performs a partial deep comparison between `object` and `source` to
* determine if `object` contains equivalent property values.
*
* **Note:** This method is equivalent to `_.matches` when `source` is
* partially applied.
*
* Partial comparisons will match empty array and empty object `source`
* values against any array or object value, respectively. See `_.isEqual`
* for a list of supported value comparisons.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Lang
* @param {Object} object The object to inspect.
* @param {Object} source The object of property values to match.
* @returns {boolean} Returns `true` if `object` is a match, else `false`.
* @example
*
* var object = { 'a': 1, 'b': 2 };
*
* _.isMatch(object, { 'b': 2 });
* // => true
*
* _.isMatch(object, { 'b': 1 });
* // => false
*/
function isMatch(object, source) {
return object === source || baseIsMatch(object, source, getMatchData(source));
}
/**
* This method is like `_.isMatch` except that it accepts `customizer` which
* is invoked to compare values. If `customizer` returns `undefined`, comparisons
* are handled by the method instead. The `customizer` is invoked with five
* arguments: (objValue, srcValue, index|key, object, source).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {Object} object The object to inspect.
* @param {Object} source The object of property values to match.
* @param {Function} [customizer] The function to customize comparisons.
* @returns {boolean} Returns `true` if `object` is a match, else `false`.
* @example
*
* function isGreeting(value) {
* return /^h(?:i|ello)$/.test(value);
* }
*
* function customizer(objValue, srcValue) {
* if (isGreeting(objValue) && isGreeting(srcValue)) {
* return true;
* }
* }
*
* var object = { 'greeting': 'hello' };
* var source = { 'greeting': 'hi' };
*
* _.isMatchWith(object, source, customizer);
* // => true
*/
function isMatchWith(object, source, customizer) {
customizer = typeof customizer == 'function' ? customizer : undefined;
return baseIsMatch(object, source, getMatchData(source), customizer);
}
/**
* Checks if `value` is `NaN`.
*
* **Note:** This method is based on
* [`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as
* global [`isNaN`](https://mdn.io/isNaN) which returns `true` for
* `undefined` and other non-number values.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
* @example
*
* _.isNaN(NaN);
* // => true
*
* _.isNaN(new Number(NaN));
* // => true
*
* isNaN(undefined);
* // => true
*
* _.isNaN(undefined);
* // => false
*/
function isNaN(value) {
// An `NaN` primitive is the only value that is not equal to itself.
// Perform the `toStringTag` check first to avoid errors with some
// ActiveX objects in IE.
return isNumber(value) && value != +value;
}
/**
* Checks if `value` is a pristine native function.
*
* **Note:** This method can't reliably detect native functions in the presence
* of the core-js package because core-js circumvents this kind of detection.
* Despite multiple requests, the core-js maintainer has made it clear: any
* attempt to fix the detection will be obstructed. As a result, we're left
* with little choice but to throw an error. Unfortunately, this also affects
* packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill),
* which rely on core-js.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a native function,
* else `false`.
* @example
*
* _.isNative(Array.prototype.push);
* // => true
*
* _.isNative(_);
* // => false
*/
function isNative(value) {
if (isMaskable(value)) {
throw new Error(CORE_ERROR_TEXT);
}
return baseIsNative(value);
}
/**
* Checks if `value` is `null`.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is `null`, else `false`.
* @example
*
* _.isNull(null);
* // => true
*
* _.isNull(void 0);
* // => false
*/
function isNull(value) {
return value === null;
}
/**
* Checks if `value` is `null` or `undefined`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is nullish, else `false`.
* @example
*
* _.isNil(null);
* // => true
*
* _.isNil(void 0);
* // => true
*
* _.isNil(NaN);
* // => false
*/
function isNil(value) {
return value == null;
}
/**
* Checks if `value` is classified as a `Number` primitive or object.
*
* **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are
* classified as numbers, use the `_.isFinite` method.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a number, else `false`.
* @example
*
* _.isNumber(3);
* // => true
*
* _.isNumber(Number.MIN_VALUE);
* // => true
*
* _.isNumber(Infinity);
* // => true
*
* _.isNumber('3');
* // => false
*/
function isNumber(value) {
return typeof value == 'number' ||
(isObjectLike(value) && baseGetTag(value) == numberTag);
}
/**
* Checks if `value` is a plain object, that is, an object created by the
* `Object` constructor or one with a `[[Prototype]]` of `null`.
*
* @static
* @memberOf _
* @since 0.8.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
* @example
*
* function Foo() {
* this.a = 1;
* }
*
* _.isPlainObject(new Foo);
* // => false
*
* _.isPlainObject([1, 2, 3]);
* // => false
*
* _.isPlainObject({ 'x': 0, 'y': 0 });
* // => true
*
* _.isPlainObject(Object.create(null));
* // => true
*/
function isPlainObject(value) {
if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
return false;
}
var proto = getPrototype(value);
if (proto === null) {
return true;
}
var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
return typeof Ctor == 'function' && Ctor instanceof Ctor &&
funcToString.call(Ctor) == objectCtorString;
}
/**
* Checks if `value` is classified as a `RegExp` object.
*
* @static
* @memberOf _
* @since 0.1.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a regexp, else `false`.
* @example
*
* _.isRegExp(/abc/);
* // => true
*
* _.isRegExp('/abc/');
* // => false
*/
var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;
/**
* Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754
* double precision number which isn't the result of a rounded unsafe integer.
*
* **Note:** This method is based on
* [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a safe integer, else `false`.
* @example
*
* _.isSafeInteger(3);
* // => true
*
* _.isSafeInteger(Number.MIN_VALUE);
* // => false
*
* _.isSafeInteger(Infinity);
* // => false
*
* _.isSafeInteger('3');
* // => false
*/
function isSafeInteger(value) {
return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER;
}
/**
* Checks if `value` is classified as a `Set` object.
*
* @static
* @memberOf _
* @since 4.3.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a set, else `false`.
* @example
*
* _.isSet(new Set);
* // => true
*
* _.isSet(new WeakSet);
* // => false
*/
var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;
/**
* Checks if `value` is classified as a `String` primitive or object.
*
* @static
* @since 0.1.0
* @memberOf _
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a string, else `false`.
* @example
*
* _.isString('abc');
* // => true
*
* _.isString(1);
* // => false
*/
function isString(value) {
return typeof value == 'string' ||
(!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);
}
/**
* Checks if `value` is classified as a `Symbol` primitive or object.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
* @example
*
* _.isSymbol(Symbol.iterator);
* // => true
*
* _.isSymbol('abc');
* // => false
*/
function isSymbol(value) {
return typeof value == 'symbol' ||
(isObjectLike(value) && baseGetTag(value) == symbolTag);
}
/**
* Checks if `value` is classified as a typed array.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
* @example
*
* _.isTypedArray(new Uint8Array);
* // => true
*
* _.isTypedArray([]);
* // => false
*/
var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
/**
* Checks if `value` is `undefined`.
*
* @static
* @since 0.1.0
* @memberOf _
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.
* @example
*
* _.isUndefined(void 0);
* // => true
*
* _.isUndefined(null);
* // => false
*/
function isUndefined(value) {
return value === undefined;
}
/**
* Checks if `value` is classified as a `WeakMap` object.
*
* @static
* @memberOf _
* @since 4.3.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a weak map, else `false`.
* @example
*
* _.isWeakMap(new WeakMap);
* // => true
*
* _.isWeakMap(new Map);
* // => false
*/
function isWeakMap(value) {
return isObjectLike(value) && getTag(value) == weakMapTag;
}
/**
* Checks if `value` is classified as a `WeakSet` object.
*
* @static
* @memberOf _
* @since 4.3.0
* @category Lang
* @param {*} value The value to check.
* @returns {boolean} Returns `true` if `value` is a weak set, else `false`.
* @example
*
* _.isWeakSet(new WeakSet);
* // => true
*
* _.isWeakSet(new Set);
* // => false
*/
function isWeakSet(value) {
return isObjectLike(value) && baseGetTag(value) == weakSetTag;
}
/**
* Checks if `value` is less than `other`.
*
* @static
* @memberOf _
* @since 3.9.0
* @category Lang
* @param {*} value The value to compare.
* @param {*} other The other value to compare.
* @returns {boolean} Returns `true` if `value` is less than `other`,
* else `false`.
* @see _.gt
* @example
*
* _.lt(1, 3);
* // => true
*
* _.lt(3, 3);
* // => false
*
* _.lt(3, 1);
* // => false
*/
var lt = createRelationalOperation(baseLt);
/**
* Checks if `value` is less than or equal to `other`.
*
* @static
* @memberOf _
* @since 3.9.0
* @category Lang
* @param {*} value The value to compare.
* @param {*} other The other value to compare.
* @returns {boolean} Returns `true` if `value` is less than or equal to
* `other`, else `false`.
* @see _.gte
* @example
*
* _.lte(1, 3);
* // => true
*
* _.lte(3, 3);
* // => true
*
* _.lte(3, 1);
* // => false
*/
var lte = createRelationalOperation(function(value, other) {
return value <= other;
});
/**
* Converts `value` to an array.
*
* @static
* @since 0.1.0
* @memberOf _
* @category Lang
* @param {*} value The value to convert.
* @returns {Array} Returns the converted array.
* @example
*
* _.toArray({ 'a': 1, 'b': 2 });
* // => [1, 2]
*
* _.toArray('abc');
* // => ['a', 'b', 'c']
*
* _.toArray(1);
* // => []
*
* _.toArray(null);
* // => []
*/
function toArray(value) {
if (!value) {
return [];
}
if (isArrayLike(value)) {
return isString(value) ? stringToArray(value) : copyArray(value);
}
if (symIterator && value[symIterator]) {
return iteratorToArray(value[symIterator]());
}
var tag = getTag(value),
func = tag == mapTag ? mapToArray : (tag == setTag ? setToArray : values);
return func(value);
}
/**
* Converts `value` to a finite number.
*
* @static
* @memberOf _
* @since 4.12.0
* @category Lang
* @param {*} value The value to convert.
* @returns {number} Returns the converted number.
* @example
*
* _.toFinite(3.2);
* // => 3.2
*
* _.toFinite(Number.MIN_VALUE);
* // => 5e-324
*
* _.toFinite(Infinity);
* // => 1.7976931348623157e+308
*
* _.toFinite('3.2');
* // => 3.2
*/
function toFinite(value) {
if (!value) {
return value === 0 ? value : 0;
}
value = toNumber(value);
if (value === INFINITY || value === -INFINITY) {
var sign = (value < 0 ? -1 : 1);
return sign * MAX_INTEGER;
}
return value === value ? value : 0;
}
/**
* Converts `value` to an integer.
*
* **Note:** This method is loosely based on
* [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to convert.
* @returns {number} Returns the converted integer.
* @example
*
* _.toInteger(3.2);
* // => 3
*
* _.toInteger(Number.MIN_VALUE);
* // => 0
*
* _.toInteger(Infinity);
* // => 1.7976931348623157e+308
*
* _.toInteger('3.2');
* // => 3
*/
function toInteger(value) {
var result = toFinite(value),
remainder = result % 1;
return result === result ? (remainder ? result - remainder : result) : 0;
}
/**
* Converts `value` to an integer suitable for use as the length of an
* array-like object.
*
* **Note:** This method is based on
* [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to convert.
* @returns {number} Returns the converted integer.
* @example
*
* _.toLength(3.2);
* // => 3
*
* _.toLength(Number.MIN_VALUE);
* // => 0
*
* _.toLength(Infinity);
* // => 4294967295
*
* _.toLength('3.2');
* // => 3
*/
function toLength(value) {
return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0;
}
/**
* Converts `value` to a number.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to process.
* @returns {number} Returns the number.
* @example
*
* _.toNumber(3.2);
* // => 3.2
*
* _.toNumber(Number.MIN_VALUE);
* // => 5e-324
*
* _.toNumber(Infinity);
* // => Infinity
*
* _.toNumber('3.2');
* // => 3.2
*/
function toNumber(value) {
if (typeof value == 'number') {
return value;
}
if (isSymbol(value)) {
return NAN;
}
if (isObject(value)) {
var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
value = isObject(other) ? (other + '') : other;
}
if (typeof value != 'string') {
return value === 0 ? value : +value;
}
value = value.replace(reTrim, '');
var isBinary = reIsBinary.test(value);
return (isBinary || reIsOctal.test(value))
? freeParseInt(value.slice(2), isBinary ? 2 : 8)
: (reIsBadHex.test(value) ? NAN : +value);
}
/**
* Converts `value` to a plain object flattening inherited enumerable string
* keyed properties of `value` to own properties of the plain object.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Lang
* @param {*} value The value to convert.
* @returns {Object} Returns the converted plain object.
* @example
*
* function Foo() {
* this.b = 2;
* }
*
* Foo.prototype.c = 3;
*
* _.assign({ 'a': 1 }, new Foo);
* // => { 'a': 1, 'b': 2 }
*
* _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
* // => { 'a': 1, 'b': 2, 'c': 3 }
*/
function toPlainObject(value) {
return copyObject(value, keysIn(value));
}
/**
* Converts `value` to a safe integer. A safe integer can be compared and
* represented correctly.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to convert.
* @returns {number} Returns the converted integer.
* @example
*
* _.toSafeInteger(3.2);
* // => 3
*
* _.toSafeInteger(Number.MIN_VALUE);
* // => 0
*
* _.toSafeInteger(Infinity);
* // => 9007199254740991
*
* _.toSafeInteger('3.2');
* // => 3
*/
function toSafeInteger(value) {
return value
? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER)
: (value === 0 ? value : 0);
}
/**
* Converts `value` to a string. An empty string is returned for `null`
* and `undefined` values. The sign of `-0` is preserved.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Lang
* @param {*} value The value to convert.
* @returns {string} Returns the converted string.
* @example
*
* _.toString(null);
* // => ''
*
* _.toString(-0);
* // => '-0'
*
* _.toString([1, 2, 3]);
* // => '1,2,3'
*/
function toString(value) {
return value == null ? '' : baseToString(value);
}
/*------------------------------------------------------------------------*/
/**
* Assigns own enumerable string keyed properties of source objects to the
* destination object. Source objects are applied from left to right.
* Subsequent sources overwrite property assignments of previous sources.
*
* **Note:** This method mutates `object` and is loosely based on
* [`Object.assign`](https://mdn.io/Object/assign).
*
* @static
* @memberOf _
* @since 0.10.0
* @category Object
* @param {Object} object The destination object.
* @param {...Object} [sources] The source objects.
* @returns {Object} Returns `object`.
* @see _.assignIn
* @example
*
* function Foo() {
* this.a = 1;
* }
*
* function Bar() {
* this.c = 3;
* }
*
* Foo.prototype.b = 2;
* Bar.prototype.d = 4;
*
* _.assign({ 'a': 0 }, new Foo, new Bar);
* // => { 'a': 1, 'c': 3 }
*/
var assign = createAssigner(function(object, source) {
if (isPrototype(source) || isArrayLike(source)) {
copyObject(source, keys(source), object);
return;
}
for (var key in source) {
if (hasOwnProperty.call(source, key)) {
assignValue(object, key, source[key]);
}
}
});
/**
* This method is like `_.assign` except that it iterates over own and
* inherited source properties.
*
* **Note:** This method mutates `object`.
*
* @static
* @memberOf _
* @since 4.0.0
* @alias extend
* @category Object
* @param {Object} object The destination object.
* @param {...Object} [sources] The source objects.
* @returns {Object} Returns `object`.
* @see _.assign
* @example
*
* function Foo() {
* this.a = 1;
* }
*
* function Bar() {
* this.c = 3;
* }
*
* Foo.prototype.b = 2;
* Bar.prototype.d = 4;
*
* _.assignIn({ 'a': 0 }, new Foo, new Bar);
* // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }
*/
var assignIn = createAssigner(function(object, source) {
copyObject(source, keysIn(source), object);
});
/**
* This method is like `_.assignIn` except that it accepts `customizer`
* which is invoked to produce the assigned values. If `customizer` returns
* `undefined`, assignment is handled by the method instead. The `customizer`
* is invoked with five arguments: (objValue, srcValue, key, object, source).
*
* **Note:** This method mutates `object`.
*
* @static
* @memberOf _
* @since 4.0.0
* @alias extendWith
* @category Object
* @param {Object} object The destination object.
* @param {...Object} sources The source objects.
* @param {Function} [customizer] The function to customize assigned values.
* @returns {Object} Returns `object`.
* @see _.assignWith
* @example
*
* function customizer(objValue, srcValue) {
* return _.isUndefined(objValue) ? srcValue : objValue;
* }
*
* var defaults = _.partialRight(_.assignInWith, customizer);
*
* defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
* // => { 'a': 1, 'b': 2 }
*/
var assignInWith = createAssigner(function(object, source, srcIndex, customizer) {
copyObject(source, keysIn(source), object, customizer);
});
/**
* This method is like `_.assign` except that it accepts `customizer`
* which is invoked to produce the assigned values. If `customizer` returns
* `undefined`, assignment is handled by the method instead. The `customizer`
* is invoked with five arguments: (objValue, srcValue, key, object, source).
*
* **Note:** This method mutates `object`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Object
* @param {Object} object The destination object.
* @param {...Object} sources The source objects.
* @param {Function} [customizer] The function to customize assigned values.
* @returns {Object} Returns `object`.
* @see _.assignInWith
* @example
*
* function customizer(objValue, srcValue) {
* return _.isUndefined(objValue) ? srcValue : objValue;
* }
*
* var defaults = _.partialRight(_.assignWith, customizer);
*
* defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
* // => { 'a': 1, 'b': 2 }
*/
var assignWith = createAssigner(function(object, source, srcIndex, customizer) {
copyObject(source, keys(source), object, customizer);
});
/**
* Creates an array of values corresponding to `paths` of `object`.
*
* @static
* @memberOf _
* @since 1.0.0
* @category Object
* @param {Object} object The object to iterate over.
* @param {...(string|string[])} [paths] The property paths to pick.
* @returns {Array} Returns the picked values.
* @example
*
* var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };
*
* _.at(object, ['a[0].b.c', 'a[1]']);
* // => [3, 4]
*/
var at = flatRest(baseAt);
/**
* Creates an object that inherits from the `prototype` object. If a
* `properties` object is given, its own enumerable string keyed properties
* are assigned to the created object.
*
* @static
* @memberOf _
* @since 2.3.0
* @category Object
* @param {Object} prototype The object to inherit from.
* @param {Object} [properties] The properties to assign to the object.
* @returns {Object} Returns the new object.
* @example
*
* function Shape() {
* this.x = 0;
* this.y = 0;
* }
*
* function Circle() {
* Shape.call(this);
* }
*
* Circle.prototype = _.create(Shape.prototype, {
* 'constructor': Circle
* });
*
* var circle = new Circle;
* circle instanceof Circle;
* // => true
*
* circle instanceof Shape;
* // => true
*/
function create(prototype, properties) {
var result = baseCreate(prototype);
return properties == null ? result : baseAssign(result, properties);
}
/**
* Assigns own and inherited enumerable string keyed properties of source
* objects to the destination object for all destination properties that
* resolve to `undefined`. Source objects are applied from left to right.
* Once a property is set, additional values of the same property are ignored.
*
* **Note:** This method mutates `object`.
*
* @static
* @since 0.1.0
* @memberOf _
* @category Object
* @param {Object} object The destination object.
* @param {...Object} [sources] The source objects.
* @returns {Object} Returns `object`.
* @see _.defaultsDeep
* @example
*
* _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
* // => { 'a': 1, 'b': 2 }
*/
var defaults = baseRest(function(object, sources) {
object = Object(object);
var index = -1;
var length = sources.length;
var guard = length > 2 ? sources[2] : undefined;
if (guard && isIterateeCall(sources[0], sources[1], guard)) {
length = 1;
}
while (++index < length) {
var source = sources[index];
var props = keysIn(source);
var propsIndex = -1;
var propsLength = props.length;
while (++propsIndex < propsLength) {
var key = props[propsIndex];
var value = object[key];
if (value === undefined ||
(eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) {
object[key] = source[key];
}
}
}
return object;
});
/**
* This method is like `_.defaults` except that it recursively assigns
* default properties.
*
* **Note:** This method mutates `object`.
*
* @static
* @memberOf _
* @since 3.10.0
* @category Object
* @param {Object} object The destination object.
* @param {...Object} [sources] The source objects.
* @returns {Object} Returns `object`.
* @see _.defaults
* @example
*
* _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } });
* // => { 'a': { 'b': 2, 'c': 3 } }
*/
var defaultsDeep = baseRest(function(args) {
args.push(undefined, customDefaultsMerge);
return apply(mergeWith, undefined, args);
});
/**
* This method is like `_.find` except that it returns the key of the first
* element `predicate` returns truthy for instead of the element itself.
*
* @static
* @memberOf _
* @since 1.1.0
* @category Object
* @param {Object} object The object to inspect.
* @param {Function} [predicate=_.identity] The function invoked per iteration.
* @returns {string|undefined} Returns the key of the matched element,
* else `undefined`.
* @example
*
* var users = {
* 'barney': { 'age': 36, 'active': true },
* 'fred': { 'age': 40, 'active': false },
* 'pebbles': { 'age': 1, 'active': true }
* };
*
* _.findKey(users, function(o) { return o.age < 40; });
* // => 'barney' (iteration order is not guaranteed)
*
* // The `_.matches` iteratee shorthand.
* _.findKey(users, { 'age': 1, 'active': true });
* // => 'pebbles'
*
* // The `_.matchesProperty` iteratee shorthand.
* _.findKey(users, ['active', false]);
* // => 'fred'
*
* // The `_.property` iteratee shorthand.
* _.findKey(users, 'active');
* // => 'barney'
*/
function findKey(object, predicate) {
return baseFindKey(object, getIteratee(predicate, 3), baseForOwn);
}
/**
* This method is like `_.findKey` except that it iterates over elements of
* a collection in the opposite order.
*
* @static
* @memberOf _
* @since 2.0.0
* @category Object
* @param {Object} object The object to inspect.
* @param {Function} [predicate=_.identity] The function invoked per iteration.
* @returns {string|undefined} Returns the key of the matched element,
* else `undefined`.
* @example
*
* var users = {
* 'barney': { 'age': 36, 'active': true },
* 'fred': { 'age': 40, 'active': false },
* 'pebbles': { 'age': 1, 'active': true }
* };
*
* _.findLastKey(users, function(o) { return o.age < 40; });
* // => returns 'pebbles' assuming `_.findKey` returns 'barney'
*
* // The `_.matches` iteratee shorthand.
* _.findLastKey(users, { 'age': 36, 'active': true });
* // => 'barney'
*
* // The `_.matchesProperty` iteratee shorthand.
* _.findLastKey(users, ['active', false]);
* // => 'fred'
*
* // The `_.property` iteratee shorthand.
* _.findLastKey(users, 'active');
* // => 'pebbles'
*/
function findLastKey(object, predicate) {
return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight);
}
/**
* Iterates over own and inherited enumerable string keyed properties of an
* object and invokes `iteratee` for each property. The iteratee is invoked
* with three arguments: (value, key, object). Iteratee functions may exit
* iteration early by explicitly returning `false`.
*
* @static
* @memberOf _
* @since 0.3.0
* @category Object
* @param {Object} object The object to iterate over.
* @param {Function} [iteratee=_.identity] The function invoked per iteration.
* @returns {Object} Returns `object`.
* @see _.forInRight
* @example
*
* function Foo() {
* this.a = 1;
* this.b = 2;
* }
*
* Foo.prototype.c = 3;
*
* _.forIn(new Foo, function(value, key) {
* console.log(key);
* });
* // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed).
*/
function forIn(object, iteratee) {
return object == null
? object
: baseFor(object, getIteratee(iteratee, 3), keysIn);
}
/**
* This method is like `_.forIn` except that it iterates over properties of
* `object` in the opposite order.
*
* @static
* @memberOf _
* @since 2.0.0
* @category Object
* @param {Object} object The object to iterate over.
* @param {Function} [iteratee=_.identity] The function invoked per iteration.
* @returns {Object} Returns `object`.
* @see _.forIn
* @example
*
* function Foo() {
* this.a = 1;
* this.b = 2;
* }
*
* Foo.prototype.c = 3;
*
* _.forInRight(new Foo, function(value, key) {
* console.log(key);
* });
* // => Logs 'c', 'b', then 'a' assuming `_.forIn` logs 'a', 'b', then 'c'.
*/
function forInRight(object, iteratee) {
return object == null
? object
: baseForRight(object, getIteratee(iteratee, 3), keysIn);
}
/**
* Iterates over own enumerable string keyed properties of an object and
* invokes `iteratee` for each property. The iteratee is invoked with three
* arguments: (value, key, object). Iteratee functions may exit iteration
* early by explicitly returning `false`.
*
* @static
* @memberOf _
* @since 0.3.0
* @category Object
* @param {Object} object The object to iterate over.
* @param {Function} [iteratee=_.identity] The function invoked per iteration.
* @returns {Object} Returns `object`.
* @see _.forOwnRight
* @example
*
* function Foo() {
* this.a = 1;
* this.b = 2;
* }
*
* Foo.prototype.c = 3;
*
* _.forOwn(new Foo, function(value, key) {
* console.log(key);
* });
* // => Logs 'a' then 'b' (iteration order is not guaranteed).
*/
function forOwn(object, iteratee) {
return object && baseForOwn(object, getIteratee(iteratee, 3));
}
/**
* This method is like `_.forOwn` except that it iterates over properties of
* `object` in the opposite order.
*
* @static
* @memberOf _
* @since 2.0.0
* @category Object
* @param {Object} object The object to iterate over.
* @param {Function} [iteratee=_.identity] The function invoked per iteration.
* @returns {Object} Returns `object`.
* @see _.forOwn
* @example
*
* function Foo() {
* this.a = 1;
* this.b = 2;
* }
*
* Foo.prototype.c = 3;
*
* _.forOwnRight(new Foo, function(value, key) {
* console.log(key);
* });
* // => Logs 'b' then 'a' assuming `_.forOwn` logs 'a' then 'b'.
*/
function forOwnRight(object, iteratee) {
return object && baseForOwnRight(object, getIteratee(iteratee, 3));
}
/**
* Creates an array of function property names from own enumerable properties
* of `object`.
*
* @static
* @since 0.1.0
* @memberOf _
* @category Object
* @param {Object} object The object to inspect.
* @returns {Array} Returns the function names.
* @see _.functionsIn
* @example
*
* function Foo() {
* this.a = _.constant('a');
* this.b = _.constant('b');
* }
*
* Foo.prototype.c = _.constant('c');
*
* _.functions(new Foo);
* // => ['a', 'b']
*/
function functions(object) {
return object == null ? [] : baseFunctions(object, keys(object));
}
/**
* Creates an array of function property names from own and inherited
* enumerable properties of `object`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Object
* @param {Object} object The object to inspect.
* @returns {Array} Returns the function names.
* @see _.functions
* @example
*
* function Foo() {
* this.a = _.constant('a');
* this.b = _.constant('b');
* }
*
* Foo.prototype.c = _.constant('c');
*
* _.functionsIn(new Foo);
* // => ['a', 'b', 'c']
*/
function functionsIn(object) {
return object == null ? [] : baseFunctions(object, keysIn(object));
}
/**
* Gets the value at `path` of `object`. If the resolved value is
* `undefined`, the `defaultValue` is returned in its place.
*
* @static
* @memberOf _
* @since 3.7.0
* @category Object
* @param {Object} object The object to query.
* @param {Array|string} path The path of the property to get.
* @param {*} [defaultValue] The value returned for `undefined` resolved values.
* @returns {*} Returns the resolved value.
* @example
*
* var object = { 'a': [{ 'b': { 'c': 3 } }] };
*
* _.get(object, 'a[0].b.c');
* // => 3
*
* _.get(object, ['a', '0', 'b', 'c']);
* // => 3
*
* _.get(object, 'a.b.c', 'default');
* // => 'default'
*/
function get(object, path, defaultValue) {
var result = object == null ? undefined : baseGet(object, path);
return result === undefined ? defaultValue : result;
}
/**
* Checks if `path` is a direct property of `object`.
*
* @static
* @since 0.1.0
* @memberOf _
* @category Object
* @param {Object} object The object to query.
* @param {Array|string} path The path to check.
* @returns {boolean} Returns `true` if `path` exists, else `false`.
* @example
*
* var object = { 'a': { 'b': 2 } };
* var other = _.create({ 'a': _.create({ 'b': 2 }) });
*
* _.has(object, 'a');
* // => true
*
* _.has(object, 'a.b');
* // => true
*
* _.has(object, ['a', 'b']);
* // => true
*
* _.has(other, 'a');
* // => false
*/
function has(object, path) {
return object != null && hasPath(object, path, baseHas);
}
/**
* Checks if `path` is a direct or inherited property of `object`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Object
* @param {Object} object The object to query.
* @param {Array|string} path The path to check.
* @returns {boolean} Returns `true` if `path` exists, else `false`.
* @example
*
* var object = _.create({ 'a': _.create({ 'b': 2 }) });
*
* _.hasIn(object, 'a');
* // => true
*
* _.hasIn(object, 'a.b');
* // => true
*
* _.hasIn(object, ['a', 'b']);
* // => true
*
* _.hasIn(object, 'b');
* // => false
*/
function hasIn(object, path) {
return object != null && hasPath(object, path, baseHasIn);
}
/**
* Creates an object composed of the inverted keys and values of `object`.
* If `object` contains duplicate values, subsequent values overwrite
* property assignments of previous values.
*
* @static
* @memberOf _
* @since 0.7.0
* @category Object
* @param {Object} object The object to invert.
* @returns {Object} Returns the new inverted object.
* @example
*
* var object = { 'a': 1, 'b': 2, 'c': 1 };
*
* _.invert(object);
* // => { '1': 'c', '2': 'b' }
*/
var invert = createInverter(function(result, value, key) {
if (value != null &&
typeof value.toString != 'function') {
value = nativeObjectToString.call(value);
}
result[value] = key;
}, constant(identity));
/**
* This method is like `_.invert` except that the inverted object is generated
* from the results of running each element of `object` thru `iteratee`. The
* corresponding inverted value of each inverted key is an array of keys
* responsible for generating the inverted value. The iteratee is invoked
* with one argument: (value).
*
* @static
* @memberOf _
* @since 4.1.0
* @category Object
* @param {Object} object The object to invert.
* @param {Function} [iteratee=_.identity] The iteratee invoked per element.
* @returns {Object} Returns the new inverted object.
* @example
*
* var object = { 'a': 1, 'b': 2, 'c': 1 };
*
* _.invertBy(object);
* // => { '1': ['a', 'c'], '2': ['b'] }
*
* _.invertBy(object, function(value) {
* return 'group' + value;
* });
* // => { 'group1': ['a', 'c'], 'group2': ['b'] }
*/
var invertBy = createInverter(function(result, value, key) {
if (value != null &&
typeof value.toString != 'function') {
value = nativeObjectToString.call(value);
}
if (hasOwnProperty.call(result, value)) {
result[value].push(key);
} else {
result[value] = [key];
}
}, getIteratee);
/**
* Invokes the method at `path` of `object`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Object
* @param {Object} object The object to query.
* @param {Array|string} path The path of the method to invoke.
* @param {...*} [args] The arguments to invoke the method with.
* @returns {*} Returns the result of the invoked method.
* @example
*
* var object = { 'a': [{ 'b': { 'c': [1, 2, 3, 4] } }] };
*
* _.invoke(object, 'a[0].b.c.slice', 1, 3);
* // => [2, 3]
*/
var invoke = baseRest(baseInvoke);
/**
* Creates an array of the own enumerable property names of `object`.
*
* **Note:** Non-object values are coerced to objects. See the
* [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
* for more details.
*
* @static
* @since 0.1.0
* @memberOf _
* @category Object
* @param {Object} object The object to query.
* @returns {Array} Returns the array of property names.
* @example
*
* function Foo() {
* this.a = 1;
* this.b = 2;
* }
*
* Foo.prototype.c = 3;
*
* _.keys(new Foo);
* // => ['a', 'b'] (iteration order is not guaranteed)
*
* _.keys('hi');
* // => ['0', '1']
*/
function keys(object) {
return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
}
/**
* Creates an array of the own and inherited enumerable property names of `object`.
*
* **Note:** Non-object values are coerced to objects.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Object
* @param {Object} object The object to query.
* @returns {Array} Returns the array of property names.
* @example
*
* function Foo() {
* this.a = 1;
* this.b = 2;
* }
*
* Foo.prototype.c = 3;
*
* _.keysIn(new Foo);
* // => ['a', 'b', 'c'] (iteration order is not guaranteed)
*/
function keysIn(object) {
return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
}
/**
* The opposite of `_.mapValues`; this method creates an object with the
* same values as `object` and keys generated by running each own enumerable
* string keyed property of `object` thru `iteratee`. The iteratee is invoked
* with three arguments: (value, key, object).
*
* @static
* @memberOf _
* @since 3.8.0
* @category Object
* @param {Object} object The object to iterate over.
* @param {Function} [iteratee=_.identity] The function invoked per iteration.
* @returns {Object} Returns the new mapped object.
* @see _.mapValues
* @example
*
* _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) {
* return key + value;
* });
* // => { 'a1': 1, 'b2': 2 }
*/
function mapKeys(object, iteratee) {
var result = {};
iteratee = getIteratee(iteratee, 3);
baseForOwn(object, function(value, key, object) {
baseAssignValue(result, iteratee(value, key, object), value);
});
return result;
}
/**
* Creates an object with the same keys as `object` and values generated
* by running each own enumerable string keyed property of `object` thru
* `iteratee`. The iteratee is invoked with three arguments:
* (value, key, object).
*
* @static
* @memberOf _
* @since 2.4.0
* @category Object
* @param {Object} object The object to iterate over.
* @param {Function} [iteratee=_.identity] The function invoked per iteration.
* @returns {Object} Returns the new mapped object.
* @see _.mapKeys
* @example
*
* var users = {
* 'fred': { 'user': 'fred', 'age': 40 },
* 'pebbles': { 'user': 'pebbles', 'age': 1 }
* };
*
* _.mapValues(users, function(o) { return o.age; });
* // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
*
* // The `_.property` iteratee shorthand.
* _.mapValues(users, 'age');
* // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
*/
function mapValues(object, iteratee) {
var result = {};
iteratee = getIteratee(iteratee, 3);
baseForOwn(object, function(value, key, object) {
baseAssignValue(result, key, iteratee(value, key, object));
});
return result;
}
/**
* This method is like `_.assign` except that it recursively merges own and
* inherited enumerable string keyed properties of source objects into the
* destination object. Source properties that resolve to `undefined` are
* skipped if a destination value exists. Array and plain object properties
* are merged recursively. Other objects and value types are overridden by
* assignment. Source objects are applied from left to right. Subsequent
* sources overwrite property assignments of previous sources.
*
* **Note:** This method mutates `object`.
*
* @static
* @memberOf _
* @since 0.5.0
* @category Object
* @param {Object} object The destination object.
* @param {...Object} [sources] The source objects.
* @returns {Object} Returns `object`.
* @example
*
* var object = {
* 'a': [{ 'b': 2 }, { 'd': 4 }]
* };
*
* var other = {
* 'a': [{ 'c': 3 }, { 'e': 5 }]
* };
*
* _.merge(object, other);
* // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }
*/
var merge = createAssigner(function(object, source, srcIndex) {
baseMerge(object, source, srcIndex);
});
/**
* This method is like `_.merge` except that it accepts `customizer` which
* is invoked to produce the merged values of the destination and source
* properties. If `customizer` returns `undefined`, merging is handled by the
* method instead. The `customizer` is invoked with six arguments:
* (objValue, srcValue, key, object, source, stack).
*
* **Note:** This method mutates `object`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Object
* @param {Object} object The destination object.
* @param {...Object} sources The source objects.
* @param {Function} customizer The function to customize assigned values.
* @returns {Object} Returns `object`.
* @example
*
* function customizer(objValue, srcValue) {
* if (_.isArray(objValue)) {
* return objValue.concat(srcValue);
* }
* }
*
* var object = { 'a': [1], 'b': [2] };
* var other = { 'a': [3], 'b': [4] };
*
* _.mergeWith(object, other, customizer);
* // => { 'a': [1, 3], 'b': [2, 4] }
*/
var mergeWith = createAssigner(function(object, source, srcIndex, customizer) {
baseMerge(object, source, srcIndex, customizer);
});
/**
* The opposite of `_.pick`; this method creates an object composed of the
* own and inherited enumerable property paths of `object` that are not omitted.
*
* **Note:** This method is considerably slower than `_.pick`.
*
* @static
* @since 0.1.0
* @memberOf _
* @category Object
* @param {Object} object The source object.
* @param {...(string|string[])} [paths] The property paths to omit.
* @returns {Object} Returns the new object.
* @example
*
* var object = { 'a': 1, 'b': '2', 'c': 3 };
*
* _.omit(object, ['a', 'c']);
* // => { 'b': '2' }
*/
var omit = flatRest(function(object, paths) {
var result = {};
if (object == null) {
return result;
}
var isDeep = false;
paths = arrayMap(paths, function(path) {
path = castPath(path, object);
isDeep || (isDeep = path.length > 1);
return path;
});
copyObject(object, getAllKeysIn(object), result);
if (isDeep) {
result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);
}
var length = paths.length;
while (length--) {
baseUnset(result, paths[length]);
}
return result;
});
/**
* The opposite of `_.pickBy`; this method creates an object composed of
* the own and inherited enumerable string keyed properties of `object` that
* `predicate` doesn't return truthy for. The predicate is invoked with two
* arguments: (value, key).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Object
* @param {Object} object The source object.
* @param {Function} [predicate=_.identity] The function invoked per property.
* @returns {Object} Returns the new object.
* @example
*
* var object = { 'a': 1, 'b': '2', 'c': 3 };
*
* _.omitBy(object, _.isNumber);
* // => { 'b': '2' }
*/
function omitBy(object, predicate) {
return pickBy(object, negate(getIteratee(predicate)));
}
/**
* Creates an object composed of the picked `object` properties.
*
* @static
* @since 0.1.0
* @memberOf _
* @category Object
* @param {Object} object The source object.
* @param {...(string|string[])} [paths] The property paths to pick.
* @returns {Object} Returns the new object.
* @example
*
* var object = { 'a': 1, 'b': '2', 'c': 3 };
*
* _.pick(object, ['a', 'c']);
* // => { 'a': 1, 'c': 3 }
*/
var pick = flatRest(function(object, paths) {
return object == null ? {} : basePick(object, paths);
});
/**
* Creates an object composed of the `object` properties `predicate` returns
* truthy for. The predicate is invoked with two arguments: (value, key).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Object
* @param {Object} object The source object.
* @param {Function} [predicate=_.identity] The function invoked per property.
* @returns {Object} Returns the new object.
* @example
*
* var object = { 'a': 1, 'b': '2', 'c': 3 };
*
* _.pickBy(object, _.isNumber);
* // => { 'a': 1, 'c': 3 }
*/
function pickBy(object, predicate) {
if (object == null) {
return {};
}
var props = arrayMap(getAllKeysIn(object), function(prop) {
return [prop];
});
predicate = getIteratee(predicate);
return basePickBy(object, props, function(value, path) {
return predicate(value, path[0]);
});
}
/**
* This method is like `_.get` except that if the resolved value is a
* function it's invoked with the `this` binding of its parent object and
* its result is returned.
*
* @static
* @since 0.1.0
* @memberOf _
* @category Object
* @param {Object} object The object to query.
* @param {Array|string} path The path of the property to resolve.
* @param {*} [defaultValue] The value returned for `undefined` resolved values.
* @returns {*} Returns the resolved value.
* @example
*
* var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] };
*
* _.result(object, 'a[0].b.c1');
* // => 3
*
* _.result(object, 'a[0].b.c2');
* // => 4
*
* _.result(object, 'a[0].b.c3', 'default');
* // => 'default'
*
* _.result(object, 'a[0].b.c3', _.constant('default'));
* // => 'default'
*/
function result(object, path, defaultValue) {
path = castPath(path, object);
var index = -1,
length = path.length;
// Ensure the loop is entered when path is empty.
if (!length) {
length = 1;
object = undefined;
}
while (++index < length) {
var value = object == null ? undefined : object[toKey(path[index])];
if (value === undefined) {
index = length;
value = defaultValue;
}
object = isFunction(value) ? value.call(object) : value;
}
return object;
}
/**
* Sets the value at `path` of `object`. If a portion of `path` doesn't exist,
* it's created. Arrays are created for missing index properties while objects
* are created for all other missing properties. Use `_.setWith` to customize
* `path` creation.
*
* **Note:** This method mutates `object`.
*
* @static
* @memberOf _
* @since 3.7.0
* @category Object
* @param {Object} object The object to modify.
* @param {Array|string} path The path of the property to set.
* @param {*} value The value to set.
* @returns {Object} Returns `object`.
* @example
*
* var object = { 'a': [{ 'b': { 'c': 3 } }] };
*
* _.set(object, 'a[0].b.c', 4);
* console.log(object.a[0].b.c);
* // => 4
*
* _.set(object, ['x', '0', 'y', 'z'], 5);
* console.log(object.x[0].y.z);
* // => 5
*/
function set(object, path, value) {
return object == null ? object : baseSet(object, path, value);
}
/**
* This method is like `_.set` except that it accepts `customizer` which is
* invoked to produce the objects of `path`. If `customizer` returns `undefined`
* path creation is handled by the method instead. The `customizer` is invoked
* with three arguments: (nsValue, key, nsObject).
*
* **Note:** This method mutates `object`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Object
* @param {Object} object The object to modify.
* @param {Array|string} path The path of the property to set.
* @param {*} value The value to set.
* @param {Function} [customizer] The function to customize assigned values.
* @returns {Object} Returns `object`.
* @example
*
* var object = {};
*
* _.setWith(object, '[0][1]', 'a', Object);
* // => { '0': { '1': 'a' } }
*/
function setWith(object, path, value, customizer) {
customizer = typeof customizer == 'function' ? customizer : undefined;
return object == null ? object : baseSet(object, path, value, customizer);
}
/**
* Creates an array of own enumerable string keyed-value pairs for `object`
* which can be consumed by `_.fromPairs`. If `object` is a map or set, its
* entries are returned.
*
* @static
* @memberOf _
* @since 4.0.0
* @alias entries
* @category Object
* @param {Object} object The object to query.
* @returns {Array} Returns the key-value pairs.
* @example
*
* function Foo() {
* this.a = 1;
* this.b = 2;
* }
*
* Foo.prototype.c = 3;
*
* _.toPairs(new Foo);
* // => [['a', 1], ['b', 2]] (iteration order is not guaranteed)
*/
var toPairs = createToPairs(keys);
/**
* Creates an array of own and inherited enumerable string keyed-value pairs
* for `object` which can be consumed by `_.fromPairs`. If `object` is a map
* or set, its entries are returned.
*
* @static
* @memberOf _
* @since 4.0.0
* @alias entriesIn
* @category Object
* @param {Object} object The object to query.
* @returns {Array} Returns the key-value pairs.
* @example
*
* function Foo() {
* this.a = 1;
* this.b = 2;
* }
*
* Foo.prototype.c = 3;
*
* _.toPairsIn(new Foo);
* // => [['a', 1], ['b', 2], ['c', 3]] (iteration order is not guaranteed)
*/
var toPairsIn = createToPairs(keysIn);
/**
* An alternative to `_.reduce`; this method transforms `object` to a new
* `accumulator` object which is the result of running each of its own
* enumerable string keyed properties thru `iteratee`, with each invocation
* potentially mutating the `accumulator` object. If `accumulator` is not
* provided, a new object with the same `[[Prototype]]` will be used. The
* iteratee is invoked with four arguments: (accumulator, value, key, object).
* Iteratee functions may exit iteration early by explicitly returning `false`.
*
* @static
* @memberOf _
* @since 1.3.0
* @category Object
* @param {Object} object The object to iterate over.
* @param {Function} [iteratee=_.identity] The function invoked per iteration.
* @param {*} [accumulator] The custom accumulator value.
* @returns {*} Returns the accumulated value.
* @example
*
* _.transform([2, 3, 4], function(result, n) {
* result.push(n *= n);
* return n % 2 == 0;
* }, []);
* // => [4, 9]
*
* _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
* (result[value] || (result[value] = [])).push(key);
* }, {});
* // => { '1': ['a', 'c'], '2': ['b'] }
*/
function transform(object, iteratee, accumulator) {
var isArr = isArray(object),
isArrLike = isArr || isBuffer(object) || isTypedArray(object);
iteratee = getIteratee(iteratee, 4);
if (accumulator == null) {
var Ctor = object && object.constructor;
if (isArrLike) {
accumulator = isArr ? new Ctor : [];
}
else if (isObject(object)) {
accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {};
}
else {
accumulator = {};
}
}
(isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object) {
return iteratee(accumulator, value, index, object);
});
return accumulator;
}
/**
* Removes the property at `path` of `object`.
*
* **Note:** This method mutates `object`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Object
* @param {Object} object The object to modify.
* @param {Array|string} path The path of the property to unset.
* @returns {boolean} Returns `true` if the property is deleted, else `false`.
* @example
*
* var object = { 'a': [{ 'b': { 'c': 7 } }] };
* _.unset(object, 'a[0].b.c');
* // => true
*
* console.log(object);
* // => { 'a': [{ 'b': {} }] };
*
* _.unset(object, ['a', '0', 'b', 'c']);
* // => true
*
* console.log(object);
* // => { 'a': [{ 'b': {} }] };
*/
function unset(object, path) {
return object == null ? true : baseUnset(object, path);
}
/**
* This method is like `_.set` except that accepts `updater` to produce the
* value to set. Use `_.updateWith` to customize `path` creation. The `updater`
* is invoked with one argument: (value).
*
* **Note:** This method mutates `object`.
*
* @static
* @memberOf _
* @since 4.6.0
* @category Object
* @param {Object} object The object to modify.
* @param {Array|string} path The path of the property to set.
* @param {Function} updater The function to produce the updated value.
* @returns {Object} Returns `object`.
* @example
*
* var object = { 'a': [{ 'b': { 'c': 3 } }] };
*
* _.update(object, 'a[0].b.c', function(n) { return n * n; });
* console.log(object.a[0].b.c);
* // => 9
*
* _.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; });
* console.log(object.x[0].y.z);
* // => 0
*/
function update(object, path, updater) {
return object == null ? object : baseUpdate(object, path, castFunction(updater));
}
/**
* This method is like `_.update` except that it accepts `customizer` which is
* invoked to produce the objects of `path`. If `customizer` returns `undefined`
* path creation is handled by the method instead. The `customizer` is invoked
* with three arguments: (nsValue, key, nsObject).
*
* **Note:** This method mutates `object`.
*
* @static
* @memberOf _
* @since 4.6.0
* @category Object
* @param {Object} object The object to modify.
* @param {Array|string} path The path of the property to set.
* @param {Function} updater The function to produce the updated value.
* @param {Function} [customizer] The function to customize assigned values.
* @returns {Object} Returns `object`.
* @example
*
* var object = {};
*
* _.updateWith(object, '[0][1]', _.constant('a'), Object);
* // => { '0': { '1': 'a' } }
*/
function updateWith(object, path, updater, customizer) {
customizer = typeof customizer == 'function' ? customizer : undefined;
return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer);
}
/**
* Creates an array of the own enumerable string keyed property values of `object`.
*
* **Note:** Non-object values are coerced to objects.
*
* @static
* @since 0.1.0
* @memberOf _
* @category Object
* @param {Object} object The object to query.
* @returns {Array} Returns the array of property values.
* @example
*
* function Foo() {
* this.a = 1;
* this.b = 2;
* }
*
* Foo.prototype.c = 3;
*
* _.values(new Foo);
* // => [1, 2] (iteration order is not guaranteed)
*
* _.values('hi');
* // => ['h', 'i']
*/
function values(object) {
return object == null ? [] : baseValues(object, keys(object));
}
/**
* Creates an array of the own and inherited enumerable string keyed property
* values of `object`.
*
* **Note:** Non-object values are coerced to objects.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Object
* @param {Object} object The object to query.
* @returns {Array} Returns the array of property values.
* @example
*
* function Foo() {
* this.a = 1;
* this.b = 2;
* }
*
* Foo.prototype.c = 3;
*
* _.valuesIn(new Foo);
* // => [1, 2, 3] (iteration order is not guaranteed)
*/
function valuesIn(object) {
return object == null ? [] : baseValues(object, keysIn(object));
}
/*------------------------------------------------------------------------*/
/**
* Clamps `number` within the inclusive `lower` and `upper` bounds.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Number
* @param {number} number The number to clamp.
* @param {number} [lower] The lower bound.
* @param {number} upper The upper bound.
* @returns {number} Returns the clamped number.
* @example
*
* _.clamp(-10, -5, 5);
* // => -5
*
* _.clamp(10, -5, 5);
* // => 5
*/
function clamp(number, lower, upper) {
if (upper === undefined) {
upper = lower;
lower = undefined;
}
if (upper !== undefined) {
upper = toNumber(upper);
upper = upper === upper ? upper : 0;
}
if (lower !== undefined) {
lower = toNumber(lower);
lower = lower === lower ? lower : 0;
}
return baseClamp(toNumber(number), lower, upper);
}
/**
* Checks if `n` is between `start` and up to, but not including, `end`. If
* `end` is not specified, it's set to `start` with `start` then set to `0`.
* If `start` is greater than `end` the params are swapped to support
* negative ranges.
*
* @static
* @memberOf _
* @since 3.3.0
* @category Number
* @param {number} number The number to check.
* @param {number} [start=0] The start of the range.
* @param {number} end The end of the range.
* @returns {boolean} Returns `true` if `number` is in the range, else `false`.
* @see _.range, _.rangeRight
* @example
*
* _.inRange(3, 2, 4);
* // => true
*
* _.inRange(4, 8);
* // => true
*
* _.inRange(4, 2);
* // => false
*
* _.inRange(2, 2);
* // => false
*
* _.inRange(1.2, 2);
* // => true
*
* _.inRange(5.2, 4);
* // => false
*
* _.inRange(-3, -2, -6);
* // => true
*/
function inRange(number, start, end) {
start = toFinite(start);
if (end === undefined) {
end = start;
start = 0;
} else {
end = toFinite(end);
}
number = toNumber(number);
return baseInRange(number, start, end);
}
/**
* Produces a random number between the inclusive `lower` and `upper` bounds.
* If only one argument is provided a number between `0` and the given number
* is returned. If `floating` is `true`, or either `lower` or `upper` are
* floats, a floating-point number is returned instead of an integer.
*
* **Note:** JavaScript follows the IEEE-754 standard for resolving
* floating-point values which can produce unexpected results.
*
* @static
* @memberOf _
* @since 0.7.0
* @category Number
* @param {number} [lower=0] The lower bound.
* @param {number} [upper=1] The upper bound.
* @param {boolean} [floating] Specify returning a floating-point number.
* @returns {number} Returns the random number.
* @example
*
* _.random(0, 5);
* // => an integer between 0 and 5
*
* _.random(5);
* // => also an integer between 0 and 5
*
* _.random(5, true);
* // => a floating-point number between 0 and 5
*
* _.random(1.2, 5.2);
* // => a floating-point number between 1.2 and 5.2
*/
function random(lower, upper, floating) {
if (floating && typeof floating != 'boolean' && isIterateeCall(lower, upper, floating)) {
upper = floating = undefined;
}
if (floating === undefined) {
if (typeof upper == 'boolean') {
floating = upper;
upper = undefined;
}
else if (typeof lower == 'boolean') {
floating = lower;
lower = undefined;
}
}
if (lower === undefined && upper === undefined) {
lower = 0;
upper = 1;
}
else {
lower = toFinite(lower);
if (upper === undefined) {
upper = lower;
lower = 0;
} else {
upper = toFinite(upper);
}
}
if (lower > upper) {
var temp = lower;
lower = upper;
upper = temp;
}
if (floating || lower % 1 || upper % 1) {
var rand = nativeRandom();
return nativeMin(lower + (rand * (upper - lower + freeParseFloat('1e-' + ((rand + '').length - 1)))), upper);
}
return baseRandom(lower, upper);
}
/*------------------------------------------------------------------------*/
/**
* Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).
*
* @static
* @memberOf _
* @since 3.0.0
* @category String
* @param {string} [string=''] The string to convert.
* @returns {string} Returns the camel cased string.
* @example
*
* _.camelCase('Foo Bar');
* // => 'fooBar'
*
* _.camelCase('--foo-bar--');
* // => 'fooBar'
*
* _.camelCase('__FOO_BAR__');
* // => 'fooBar'
*/
var camelCase = createCompounder(function(result, word, index) {
word = word.toLowerCase();
return result + (index ? capitalize(word) : word);
});
/**
* Converts the first character of `string` to upper case and the remaining
* to lower case.
*
* @static
* @memberOf _
* @since 3.0.0
* @category String
* @param {string} [string=''] The string to capitalize.
* @returns {string} Returns the capitalized string.
* @example
*
* _.capitalize('FRED');
* // => 'Fred'
*/
function capitalize(string) {
return upperFirst(toString(string).toLowerCase());
}
/**
* Deburrs `string` by converting
* [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)
* and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)
* letters to basic Latin letters and removing
* [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).
*
* @static
* @memberOf _
* @since 3.0.0
* @category String
* @param {string} [string=''] The string to deburr.
* @returns {string} Returns the deburred string.
* @example
*
* _.deburr('déjà vu');
* // => 'deja vu'
*/
function deburr(string) {
string = toString(string);
return string && string.replace(reLatin, deburrLetter).replace(reComboMark, '');
}
/**
* Checks if `string` ends with the given target string.
*
* @static
* @memberOf _
* @since 3.0.0
* @category String
* @param {string} [string=''] The string to inspect.
* @param {string} [target] The string to search for.
* @param {number} [position=string.length] The position to search up to.
* @returns {boolean} Returns `true` if `string` ends with `target`,
* else `false`.
* @example
*
* _.endsWith('abc', 'c');
* // => true
*
* _.endsWith('abc', 'b');
* // => false
*
* _.endsWith('abc', 'b', 2);
* // => true
*/
function endsWith(string, target, position) {
string = toString(string);
target = baseToString(target);
var length = string.length;
position = position === undefined
? length
: baseClamp(toInteger(position), 0, length);
var end = position;
position -= target.length;
return position >= 0 && string.slice(position, end) == target;
}
/**
* Converts the characters "&", "<", ">", '"', and "'" in `string` to their
* corresponding HTML entities.
*
* **Note:** No other characters are escaped. To escape additional
* characters use a third-party library like [_he_](https://mths.be/he).
*
* Though the ">" character is escaped for symmetry, characters like
* ">" and "/" don't need escaping in HTML and have no special meaning
* unless they're part of a tag or unquoted attribute value. See
* [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands)
* (under "semi-related fun fact") for more details.
*
* When working with HTML you should always
* [quote attribute values](http://wonko.com/post/html-escaping) to reduce
* XSS vectors.
*
* @static
* @since 0.1.0
* @memberOf _
* @category String
* @param {string} [string=''] The string to escape.
* @returns {string} Returns the escaped string.
* @example
*
* _.escape('fred, barney, & pebbles');
* // => 'fred, barney, & pebbles'
*/
function escape(string) {
string = toString(string);
return (string && reHasUnescapedHtml.test(string))
? string.replace(reUnescapedHtml, escapeHtmlChar)
: string;
}
/**
* Escapes the `RegExp` special characters "^", "$", "\", ".", "*", "+",
* "?", "(", ")", "[", "]", "{", "}", and "|" in `string`.
*
* @static
* @memberOf _
* @since 3.0.0
* @category String
* @param {string} [string=''] The string to escape.
* @returns {string} Returns the escaped string.
* @example
*
* _.escapeRegExp('[lodash](https://lodash.com/)');
* // => '\[lodash\]\(https://lodash\.com/\)'
*/
function escapeRegExp(string) {
string = toString(string);
return (string && reHasRegExpChar.test(string))
? string.replace(reRegExpChar, '\\$&')
: string;
}
/**
* Converts `string` to
* [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles).
*
* @static
* @memberOf _
* @since 3.0.0
* @category String
* @param {string} [string=''] The string to convert.
* @returns {string} Returns the kebab cased string.
* @example
*
* _.kebabCase('Foo Bar');
* // => 'foo-bar'
*
* _.kebabCase('fooBar');
* // => 'foo-bar'
*
* _.kebabCase('__FOO_BAR__');
* // => 'foo-bar'
*/
var kebabCase = createCompounder(function(result, word, index) {
return result + (index ? '-' : '') + word.toLowerCase();
});
/**
* Converts `string`, as space separated words, to lower case.
*
* @static
* @memberOf _
* @since 4.0.0
* @category String
* @param {string} [string=''] The string to convert.
* @returns {string} Returns the lower cased string.
* @example
*
* _.lowerCase('--Foo-Bar--');
* // => 'foo bar'
*
* _.lowerCase('fooBar');
* // => 'foo bar'
*
* _.lowerCase('__FOO_BAR__');
* // => 'foo bar'
*/
var lowerCase = createCompounder(function(result, word, index) {
return result + (index ? ' ' : '') + word.toLowerCase();
});
/**
* Converts the first character of `string` to lower case.
*
* @static
* @memberOf _
* @since 4.0.0
* @category String
* @param {string} [string=''] The string to convert.
* @returns {string} Returns the converted string.
* @example
*
* _.lowerFirst('Fred');
* // => 'fred'
*
* _.lowerFirst('FRED');
* // => 'fRED'
*/
var lowerFirst = createCaseFirst('toLowerCase');
/**
* Pads `string` on the left and right sides if it's shorter than `length`.
* Padding characters are truncated if they can't be evenly divided by `length`.
*
* @static
* @memberOf _
* @since 3.0.0
* @category String
* @param {string} [string=''] The string to pad.
* @param {number} [length=0] The padding length.
* @param {string} [chars=' '] The string used as padding.
* @returns {string} Returns the padded string.
* @example
*
* _.pad('abc', 8);
* // => ' abc '
*
* _.pad('abc', 8, '_-');
* // => '_-abc_-_'
*
* _.pad('abc', 3);
* // => 'abc'
*/
function pad(string, length, chars) {
string = toString(string);
length = toInteger(length);
var strLength = length ? stringSize(string) : 0;
if (!length || strLength >= length) {
return string;
}
var mid = (length - strLength) / 2;
return (
createPadding(nativeFloor(mid), chars) +
string +
createPadding(nativeCeil(mid), chars)
);
}
/**
* Pads `string` on the right side if it's shorter than `length`. Padding
* characters are truncated if they exceed `length`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category String
* @param {string} [string=''] The string to pad.
* @param {number} [length=0] The padding length.
* @param {string} [chars=' '] The string used as padding.
* @returns {string} Returns the padded string.
* @example
*
* _.padEnd('abc', 6);
* // => 'abc '
*
* _.padEnd('abc', 6, '_-');
* // => 'abc_-_'
*
* _.padEnd('abc', 3);
* // => 'abc'
*/
function padEnd(string, length, chars) {
string = toString(string);
length = toInteger(length);
var strLength = length ? stringSize(string) : 0;
return (length && strLength < length)
? (string + createPadding(length - strLength, chars))
: string;
}
/**
* Pads `string` on the left side if it's shorter than `length`. Padding
* characters are truncated if they exceed `length`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category String
* @param {string} [string=''] The string to pad.
* @param {number} [length=0] The padding length.
* @param {string} [chars=' '] The string used as padding.
* @returns {string} Returns the padded string.
* @example
*
* _.padStart('abc', 6);
* // => ' abc'
*
* _.padStart('abc', 6, '_-');
* // => '_-_abc'
*
* _.padStart('abc', 3);
* // => 'abc'
*/
function padStart(string, length, chars) {
string = toString(string);
length = toInteger(length);
var strLength = length ? stringSize(string) : 0;
return (length && strLength < length)
? (createPadding(length - strLength, chars) + string)
: string;
}
/**
* Converts `string` to an integer of the specified radix. If `radix` is
* `undefined` or `0`, a `radix` of `10` is used unless `value` is a
* hexadecimal, in which case a `radix` of `16` is used.
*
* **Note:** This method aligns with the
* [ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`.
*
* @static
* @memberOf _
* @since 1.1.0
* @category String
* @param {string} string The string to convert.
* @param {number} [radix=10] The radix to interpret `value` by.
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
* @returns {number} Returns the converted integer.
* @example
*
* _.parseInt('08');
* // => 8
*
* _.map(['6', '08', '10'], _.parseInt);
* // => [6, 8, 10]
*/
function parseInt(string, radix, guard) {
if (guard || radix == null) {
radix = 0;
} else if (radix) {
radix = +radix;
}
return nativeParseInt(toString(string).replace(reTrimStart, ''), radix || 0);
}
/**
* Repeats the given string `n` times.
*
* @static
* @memberOf _
* @since 3.0.0
* @category String
* @param {string} [string=''] The string to repeat.
* @param {number} [n=1] The number of times to repeat the string.
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
* @returns {string} Returns the repeated string.
* @example
*
* _.repeat('*', 3);
* // => '***'
*
* _.repeat('abc', 2);
* // => 'abcabc'
*
* _.repeat('abc', 0);
* // => ''
*/
function repeat(string, n, guard) {
if ((guard ? isIterateeCall(string, n, guard) : n === undefined)) {
n = 1;
} else {
n = toInteger(n);
}
return baseRepeat(toString(string), n);
}
/**
* Replaces matches for `pattern` in `string` with `replacement`.
*
* **Note:** This method is based on
* [`String#replace`](https://mdn.io/String/replace).
*
* @static
* @memberOf _
* @since 4.0.0
* @category String
* @param {string} [string=''] The string to modify.
* @param {RegExp|string} pattern The pattern to replace.
* @param {Function|string} replacement The match replacement.
* @returns {string} Returns the modified string.
* @example
*
* _.replace('Hi Fred', 'Fred', 'Barney');
* // => 'Hi Barney'
*/
function replace() {
var args = arguments,
string = toString(args[0]);
return args.length < 3 ? string : string.replace(args[1], args[2]);
}
/**
* Converts `string` to
* [snake case](https://en.wikipedia.org/wiki/Snake_case).
*
* @static
* @memberOf _
* @since 3.0.0
* @category String
* @param {string} [string=''] The string to convert.
* @returns {string} Returns the snake cased string.
* @example
*
* _.snakeCase('Foo Bar');
* // => 'foo_bar'
*
* _.snakeCase('fooBar');
* // => 'foo_bar'
*
* _.snakeCase('--FOO-BAR--');
* // => 'foo_bar'
*/
var snakeCase = createCompounder(function(result, word, index) {
return result + (index ? '_' : '') + word.toLowerCase();
});
/**
* Splits `string` by `separator`.
*
* **Note:** This method is based on
* [`String#split`](https://mdn.io/String/split).
*
* @static
* @memberOf _
* @since 4.0.0
* @category String
* @param {string} [string=''] The string to split.
* @param {RegExp|string} separator The separator pattern to split by.
* @param {number} [limit] The length to truncate results to.
* @returns {Array} Returns the string segments.
* @example
*
* _.split('a-b-c', '-', 2);
* // => ['a', 'b']
*/
function split(string, separator, limit) {
if (limit && typeof limit != 'number' && isIterateeCall(string, separator, limit)) {
separator = limit = undefined;
}
limit = limit === undefined ? MAX_ARRAY_LENGTH : limit >>> 0;
if (!limit) {
return [];
}
string = toString(string);
if (string && (
typeof separator == 'string' ||
(separator != null && !isRegExp(separator))
)) {
separator = baseToString(separator);
if (!separator && hasUnicode(string)) {
return castSlice(stringToArray(string), 0, limit);
}
}
return string.split(separator, limit);
}
/**
* Converts `string` to
* [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage).
*
* @static
* @memberOf _
* @since 3.1.0
* @category String
* @param {string} [string=''] The string to convert.
* @returns {string} Returns the start cased string.
* @example
*
* _.startCase('--foo-bar--');
* // => 'Foo Bar'
*
* _.startCase('fooBar');
* // => 'Foo Bar'
*
* _.startCase('__FOO_BAR__');
* // => 'FOO BAR'
*/
var startCase = createCompounder(function(result, word, index) {
return result + (index ? ' ' : '') + upperFirst(word);
});
/**
* Checks if `string` starts with the given target string.
*
* @static
* @memberOf _
* @since 3.0.0
* @category String
* @param {string} [string=''] The string to inspect.
* @param {string} [target] The string to search for.
* @param {number} [position=0] The position to search from.
* @returns {boolean} Returns `true` if `string` starts with `target`,
* else `false`.
* @example
*
* _.startsWith('abc', 'a');
* // => true
*
* _.startsWith('abc', 'b');
* // => false
*
* _.startsWith('abc', 'b', 1);
* // => true
*/
function startsWith(string, target, position) {
string = toString(string);
position = position == null
? 0
: baseClamp(toInteger(position), 0, string.length);
target = baseToString(target);
return string.slice(position, position + target.length) == target;
}
/**
* Creates a compiled template function that can interpolate data properties
* in "interpolate" delimiters, HTML-escape interpolated data properties in
* "escape" delimiters, and execute JavaScript in "evaluate" delimiters. Data
* properties may be accessed as free variables in the template. If a setting
* object is given, it takes precedence over `_.templateSettings` values.
*
* **Note:** In the development build `_.template` utilizes
* [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl)
* for easier debugging.
*
* For more information on precompiling templates see
* [lodash's custom builds documentation](https://lodash.com/custom-builds).
*
* For more information on Chrome extension sandboxes see
* [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval).
*
* @static
* @since 0.1.0
* @memberOf _
* @category String
* @param {string} [string=''] The template string.
* @param {Object} [options={}] The options object.
* @param {RegExp} [options.escape=_.templateSettings.escape]
* The HTML "escape" delimiter.
* @param {RegExp} [options.evaluate=_.templateSettings.evaluate]
* The "evaluate" delimiter.
* @param {Object} [options.imports=_.templateSettings.imports]
* An object to import into the template as free variables.
* @param {RegExp} [options.interpolate=_.templateSettings.interpolate]
* The "interpolate" delimiter.
* @param {string} [options.sourceURL='lodash.templateSources[n]']
* The sourceURL of the compiled template.
* @param {string} [options.variable='obj']
* The data object variable name.
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
* @returns {Function} Returns the compiled template function.
* @example
*
* // Use the "interpolate" delimiter to create a compiled template.
* var compiled = _.template('hello <%= user %>!');
* compiled({ 'user': 'fred' });
* // => 'hello fred!'
*
* // Use the HTML "escape" delimiter to escape data property values.
* var compiled = _.template('<b><%- value %></b>');
* compiled({ 'value': '<script>' });
* // => '<b><script></b>'
*
* // Use the "evaluate" delimiter to execute JavaScript and generate HTML.
* var compiled = _.template('<% _.forEach(users, function(user) { %><li><%- user %></li><% }); %>');
* compiled({ 'users': ['fred', 'barney'] });
* // => '<li>fred</li><li>barney</li>'
*
* // Use the internal `print` function in "evaluate" delimiters.
* var compiled = _.template('<% print("hello " + user); %>!');
* compiled({ 'user': 'barney' });
* // => 'hello barney!'
*
* // Use the ES template literal delimiter as an "interpolate" delimiter.
* // Disable support by replacing the "interpolate" delimiter.
* var compiled = _.template('hello ${ user }!');
* compiled({ 'user': 'pebbles' });
* // => 'hello pebbles!'
*
* // Use backslashes to treat delimiters as plain text.
* var compiled = _.template('<%= "\\<%- value %\\>" %>');
* compiled({ 'value': 'ignored' });
* // => '<%- value %>'
*
* // Use the `imports` option to import `jQuery` as `jq`.
* var text = '<% jq.each(users, function(user) { %><li><%- user %></li><% }); %>';
* var compiled = _.template(text, { 'imports': { 'jq': jQuery } });
* compiled({ 'users': ['fred', 'barney'] });
* // => '<li>fred</li><li>barney</li>'
*
* // Use the `sourceURL` option to specify a custom sourceURL for the template.
* var compiled = _.template('hello <%= user %>!', { 'sourceURL': '/basic/greeting.jst' });
* compiled(data);
* // => Find the source of "greeting.jst" under the Sources tab or Resources panel of the web inspector.
*
* // Use the `variable` option to ensure a with-statement isn't used in the compiled template.
* var compiled = _.template('hi <%= data.user %>!', { 'variable': 'data' });
* compiled.source;
* // => function(data) {
* // var __t, __p = '';
* // __p += 'hi ' + ((__t = ( data.user )) == null ? '' : __t) + '!';
* // return __p;
* // }
*
* // Use custom template delimiters.
* _.templateSettings.interpolate = /{{([\s\S]+?)}}/g;
* var compiled = _.template('hello {{ user }}!');
* compiled({ 'user': 'mustache' });
* // => 'hello mustache!'
*
* // Use the `source` property to inline compiled templates for meaningful
* // line numbers in error messages and stack traces.
* fs.writeFileSync(path.join(process.cwd(), 'jst.js'), '\
* var JST = {\
* "main": ' + _.template(mainText).source + '\
* };\
* ');
*/
function template(string, options, guard) {
// Based on John Resig's `tmpl` implementation
// (http://ejohn.org/blog/javascript-micro-templating/)
// and Laura Doktorova's doT.js (https://github.com/olado/doT).
var settings = lodash.templateSettings;
if (guard && isIterateeCall(string, options, guard)) {
options = undefined;
}
string = toString(string);
options = assignInWith({}, options, settings, customDefaultsAssignIn);
var imports = assignInWith({}, options.imports, settings.imports, customDefaultsAssignIn),
importsKeys = keys(imports),
importsValues = baseValues(imports, importsKeys);
var isEscaping,
isEvaluating,
index = 0,
interpolate = options.interpolate || reNoMatch,
source = "__p += '";
// Compile the regexp to match each delimiter.
var reDelimiters = RegExp(
(options.escape || reNoMatch).source + '|' +
interpolate.source + '|' +
(interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + '|' +
(options.evaluate || reNoMatch).source + '|$'
, 'g');
// Use a sourceURL for easier debugging.
var sourceURL = '//# sourceURL=' +
('sourceURL' in options
? options.sourceURL
: ('lodash.templateSources[' + (++templateCounter) + ']')
) + '\n';
string.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {
interpolateValue || (interpolateValue = esTemplateValue);
// Escape characters that can't be included in string literals.
source += string.slice(index, offset).replace(reUnescapedString, escapeStringChar);
// Replace delimiters with snippets.
if (escapeValue) {
isEscaping = true;
source += "' +\n__e(" + escapeValue + ") +\n'";
}
if (evaluateValue) {
isEvaluating = true;
source += "';\n" + evaluateValue + ";\n__p += '";
}
if (interpolateValue) {
source += "' +\n((__t = (" + interpolateValue + ")) == null ? '' : __t) +\n'";
}
index = offset + match.length;
// The JS engine embedded in Adobe products needs `match` returned in
// order to produce the correct `offset` value.
return match;
});
source += "';\n";
// If `variable` is not specified wrap a with-statement around the generated
// code to add the data object to the top of the scope chain.
var variable = options.variable;
if (!variable) {
source = 'with (obj) {\n' + source + '\n}\n';
}
// Cleanup code by stripping empty strings.
source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source)
.replace(reEmptyStringMiddle, '$1')
.replace(reEmptyStringTrailing, '$1;');
// Frame code as the function body.
source = 'function(' + (variable || 'obj') + ') {\n' +
(variable
? ''
: 'obj || (obj = {});\n'
) +
"var __t, __p = ''" +
(isEscaping
? ', __e = _.escape'
: ''
) +
(isEvaluating
? ', __j = Array.prototype.join;\n' +
"function print() { __p += __j.call(arguments, '') }\n"
: ';\n'
) +
source +
'return __p\n}';
var result = attempt(function() {
return Function(importsKeys, sourceURL + 'return ' + source)
.apply(undefined, importsValues);
});
// Provide the compiled function's source by its `toString` method or
// the `source` property as a convenience for inlining compiled templates.
result.source = source;
if (isError(result)) {
throw result;
}
return result;
}
/**
* Converts `string`, as a whole, to lower case just like
* [String#toLowerCase](https://mdn.io/toLowerCase).
*
* @static
* @memberOf _
* @since 4.0.0
* @category String
* @param {string} [string=''] The string to convert.
* @returns {string} Returns the lower cased string.
* @example
*
* _.toLower('--Foo-Bar--');
* // => '--foo-bar--'
*
* _.toLower('fooBar');
* // => 'foobar'
*
* _.toLower('__FOO_BAR__');
* // => '__foo_bar__'
*/
function toLower(value) {
return toString(value).toLowerCase();
}
/**
* Converts `string`, as a whole, to upper case just like
* [String#toUpperCase](https://mdn.io/toUpperCase).
*
* @static
* @memberOf _
* @since 4.0.0
* @category String
* @param {string} [string=''] The string to convert.
* @returns {string} Returns the upper cased string.
* @example
*
* _.toUpper('--foo-bar--');
* // => '--FOO-BAR--'
*
* _.toUpper('fooBar');
* // => 'FOOBAR'
*
* _.toUpper('__foo_bar__');
* // => '__FOO_BAR__'
*/
function toUpper(value) {
return toString(value).toUpperCase();
}
/**
* Removes leading and trailing whitespace or specified characters from `string`.
*
* @static
* @memberOf _
* @since 3.0.0
* @category String
* @param {string} [string=''] The string to trim.
* @param {string} [chars=whitespace] The characters to trim.
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
* @returns {string} Returns the trimmed string.
* @example
*
* _.trim(' abc ');
* // => 'abc'
*
* _.trim('-_-abc-_-', '_-');
* // => 'abc'
*
* _.map([' foo ', ' bar '], _.trim);
* // => ['foo', 'bar']
*/
function trim(string, chars, guard) {
string = toString(string);
if (string && (guard || chars === undefined)) {
return string.replace(reTrim, '');
}
if (!string || !(chars = baseToString(chars))) {
return string;
}
var strSymbols = stringToArray(string),
chrSymbols = stringToArray(chars),
start = charsStartIndex(strSymbols, chrSymbols),
end = charsEndIndex(strSymbols, chrSymbols) + 1;
return castSlice(strSymbols, start, end).join('');
}
/**
* Removes trailing whitespace or specified characters from `string`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category String
* @param {string} [string=''] The string to trim.
* @param {string} [chars=whitespace] The characters to trim.
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
* @returns {string} Returns the trimmed string.
* @example
*
* _.trimEnd(' abc ');
* // => ' abc'
*
* _.trimEnd('-_-abc-_-', '_-');
* // => '-_-abc'
*/
function trimEnd(string, chars, guard) {
string = toString(string);
if (string && (guard || chars === undefined)) {
return string.replace(reTrimEnd, '');
}
if (!string || !(chars = baseToString(chars))) {
return string;
}
var strSymbols = stringToArray(string),
end = charsEndIndex(strSymbols, stringToArray(chars)) + 1;
return castSlice(strSymbols, 0, end).join('');
}
/**
* Removes leading whitespace or specified characters from `string`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category String
* @param {string} [string=''] The string to trim.
* @param {string} [chars=whitespace] The characters to trim.
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
* @returns {string} Returns the trimmed string.
* @example
*
* _.trimStart(' abc ');
* // => 'abc '
*
* _.trimStart('-_-abc-_-', '_-');
* // => 'abc-_-'
*/
function trimStart(string, chars, guard) {
string = toString(string);
if (string && (guard || chars === undefined)) {
return string.replace(reTrimStart, '');
}
if (!string || !(chars = baseToString(chars))) {
return string;
}
var strSymbols = stringToArray(string),
start = charsStartIndex(strSymbols, stringToArray(chars));
return castSlice(strSymbols, start).join('');
}
/**
* Truncates `string` if it's longer than the given maximum string length.
* The last characters of the truncated string are replaced with the omission
* string which defaults to "...".
*
* @static
* @memberOf _
* @since 4.0.0
* @category String
* @param {string} [string=''] The string to truncate.
* @param {Object} [options={}] The options object.
* @param {number} [options.length=30] The maximum string length.
* @param {string} [options.omission='...'] The string to indicate text is omitted.
* @param {RegExp|string} [options.separator] The separator pattern to truncate to.
* @returns {string} Returns the truncated string.
* @example
*
* _.truncate('hi-diddly-ho there, neighborino');
* // => 'hi-diddly-ho there, neighbo...'
*
* _.truncate('hi-diddly-ho there, neighborino', {
* 'length': 24,
* 'separator': ' '
* });
* // => 'hi-diddly-ho there,...'
*
* _.truncate('hi-diddly-ho there, neighborino', {
* 'length': 24,
* 'separator': /,? +/
* });
* // => 'hi-diddly-ho there...'
*
* _.truncate('hi-diddly-ho there, neighborino', {
* 'omission': ' [...]'
* });
* // => 'hi-diddly-ho there, neig [...]'
*/
function truncate(string, options) {
var length = DEFAULT_TRUNC_LENGTH,
omission = DEFAULT_TRUNC_OMISSION;
if (isObject(options)) {
var separator = 'separator' in options ? options.separator : separator;
length = 'length' in options ? toInteger(options.length) : length;
omission = 'omission' in options ? baseToString(options.omission) : omission;
}
string = toString(string);
var strLength = string.length;
if (hasUnicode(string)) {
var strSymbols = stringToArray(string);
strLength = strSymbols.length;
}
if (length >= strLength) {
return string;
}
var end = length - stringSize(omission);
if (end < 1) {
return omission;
}
var result = strSymbols
? castSlice(strSymbols, 0, end).join('')
: string.slice(0, end);
if (separator === undefined) {
return result + omission;
}
if (strSymbols) {
end += (result.length - end);
}
if (isRegExp(separator)) {
if (string.slice(end).search(separator)) {
var match,
substring = result;
if (!separator.global) {
separator = RegExp(separator.source, toString(reFlags.exec(separator)) + 'g');
}
separator.lastIndex = 0;
while ((match = separator.exec(substring))) {
var newEnd = match.index;
}
result = result.slice(0, newEnd === undefined ? end : newEnd);
}
} else if (string.indexOf(baseToString(separator), end) != end) {
var index = result.lastIndexOf(separator);
if (index > -1) {
result = result.slice(0, index);
}
}
return result + omission;
}
/**
* The inverse of `_.escape`; this method converts the HTML entities
* `&`, `<`, `>`, `"`, and `'` in `string` to
* their corresponding characters.
*
* **Note:** No other HTML entities are unescaped. To unescape additional
* HTML entities use a third-party library like [_he_](https://mths.be/he).
*
* @static
* @memberOf _
* @since 0.6.0
* @category String
* @param {string} [string=''] The string to unescape.
* @returns {string} Returns the unescaped string.
* @example
*
* _.unescape('fred, barney, & pebbles');
* // => 'fred, barney, & pebbles'
*/
function unescape(string) {
string = toString(string);
return (string && reHasEscapedHtml.test(string))
? string.replace(reEscapedHtml, unescapeHtmlChar)
: string;
}
/**
* Converts `string`, as space separated words, to upper case.
*
* @static
* @memberOf _
* @since 4.0.0
* @category String
* @param {string} [string=''] The string to convert.
* @returns {string} Returns the upper cased string.
* @example
*
* _.upperCase('--foo-bar');
* // => 'FOO BAR'
*
* _.upperCase('fooBar');
* // => 'FOO BAR'
*
* _.upperCase('__foo_bar__');
* // => 'FOO BAR'
*/
var upperCase = createCompounder(function(result, word, index) {
return result + (index ? ' ' : '') + word.toUpperCase();
});
/**
* Converts the first character of `string` to upper case.
*
* @static
* @memberOf _
* @since 4.0.0
* @category String
* @param {string} [string=''] The string to convert.
* @returns {string} Returns the converted string.
* @example
*
* _.upperFirst('fred');
* // => 'Fred'
*
* _.upperFirst('FRED');
* // => 'FRED'
*/
var upperFirst = createCaseFirst('toUpperCase');
/**
* Splits `string` into an array of its words.
*
* @static
* @memberOf _
* @since 3.0.0
* @category String
* @param {string} [string=''] The string to inspect.
* @param {RegExp|string} [pattern] The pattern to match words.
* @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
* @returns {Array} Returns the words of `string`.
* @example
*
* _.words('fred, barney, & pebbles');
* // => ['fred', 'barney', 'pebbles']
*
* _.words('fred, barney, & pebbles', /[^, ]+/g);
* // => ['fred', 'barney', '&', 'pebbles']
*/
function words(string, pattern, guard) {
string = toString(string);
pattern = guard ? undefined : pattern;
if (pattern === undefined) {
return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);
}
return string.match(pattern) || [];
}
/*------------------------------------------------------------------------*/
/**
* Attempts to invoke `func`, returning either the result or the caught error
* object. Any additional arguments are provided to `func` when it's invoked.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Util
* @param {Function} func The function to attempt.
* @param {...*} [args] The arguments to invoke `func` with.
* @returns {*} Returns the `func` result or error object.
* @example
*
* // Avoid throwing errors for invalid selectors.
* var elements = _.attempt(function(selector) {
* return document.querySelectorAll(selector);
* }, '>_>');
*
* if (_.isError(elements)) {
* elements = [];
* }
*/
var attempt = baseRest(function(func, args) {
try {
return apply(func, undefined, args);
} catch (e) {
return isError(e) ? e : new Error(e);
}
});
/**
* Binds methods of an object to the object itself, overwriting the existing
* method.
*
* **Note:** This method doesn't set the "length" property of bound functions.
*
* @static
* @since 0.1.0
* @memberOf _
* @category Util
* @param {Object} object The object to bind and assign the bound methods to.
* @param {...(string|string[])} methodNames The object method names to bind.
* @returns {Object} Returns `object`.
* @example
*
* var view = {
* 'label': 'docs',
* 'click': function() {
* console.log('clicked ' + this.label);
* }
* };
*
* _.bindAll(view, ['click']);
* jQuery(element).on('click', view.click);
* // => Logs 'clicked docs' when clicked.
*/
var bindAll = flatRest(function(object, methodNames) {
arrayEach(methodNames, function(key) {
key = toKey(key);
baseAssignValue(object, key, bind(object[key], object));
});
return object;
});
/**
* Creates a function that iterates over `pairs` and invokes the corresponding
* function of the first predicate to return truthy. The predicate-function
* pairs are invoked with the `this` binding and arguments of the created
* function.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Util
* @param {Array} pairs The predicate-function pairs.
* @returns {Function} Returns the new composite function.
* @example
*
* var func = _.cond([
* [_.matches({ 'a': 1 }), _.constant('matches A')],
* [_.conforms({ 'b': _.isNumber }), _.constant('matches B')],
* [_.stubTrue, _.constant('no match')]
* ]);
*
* func({ 'a': 1, 'b': 2 });
* // => 'matches A'
*
* func({ 'a': 0, 'b': 1 });
* // => 'matches B'
*
* func({ 'a': '1', 'b': '2' });
* // => 'no match'
*/
function cond(pairs) {
var length = pairs == null ? 0 : pairs.length,
toIteratee = getIteratee();
pairs = !length ? [] : arrayMap(pairs, function(pair) {
if (typeof pair[1] != 'function') {
throw new TypeError(FUNC_ERROR_TEXT);
}
return [toIteratee(pair[0]), pair[1]];
});
return baseRest(function(args) {
var index = -1;
while (++index < length) {
var pair = pairs[index];
if (apply(pair[0], this, args)) {
return apply(pair[1], this, args);
}
}
});
}
/**
* Creates a function that invokes the predicate properties of `source` with
* the corresponding property values of a given object, returning `true` if
* all predicates return truthy, else `false`.
*
* **Note:** The created function is equivalent to `_.conformsTo` with
* `source` partially applied.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Util
* @param {Object} source The object of property predicates to conform to.
* @returns {Function} Returns the new spec function.
* @example
*
* var objects = [
* { 'a': 2, 'b': 1 },
* { 'a': 1, 'b': 2 }
* ];
*
* _.filter(objects, _.conforms({ 'b': function(n) { return n > 1; } }));
* // => [{ 'a': 1, 'b': 2 }]
*/
function conforms(source) {
return baseConforms(baseClone(source, CLONE_DEEP_FLAG));
}
/**
* Creates a function that returns `value`.
*
* @static
* @memberOf _
* @since 2.4.0
* @category Util
* @param {*} value The value to return from the new function.
* @returns {Function} Returns the new constant function.
* @example
*
* var objects = _.times(2, _.constant({ 'a': 1 }));
*
* console.log(objects);
* // => [{ 'a': 1 }, { 'a': 1 }]
*
* console.log(objects[0] === objects[1]);
* // => true
*/
function constant(value) {
return function() {
return value;
};
}
/**
* Checks `value` to determine whether a default value should be returned in
* its place. The `defaultValue` is returned if `value` is `NaN`, `null`,
* or `undefined`.
*
* @static
* @memberOf _
* @since 4.14.0
* @category Util
* @param {*} value The value to check.
* @param {*} defaultValue The default value.
* @returns {*} Returns the resolved value.
* @example
*
* _.defaultTo(1, 10);
* // => 1
*
* _.defaultTo(undefined, 10);
* // => 10
*/
function defaultTo(value, defaultValue) {
return (value == null || value !== value) ? defaultValue : value;
}
/**
* Creates a function that returns the result of invoking the given functions
* with the `this` binding of the created function, where each successive
* invocation is supplied the return value of the previous.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Util
* @param {...(Function|Function[])} [funcs] The functions to invoke.
* @returns {Function} Returns the new composite function.
* @see _.flowRight
* @example
*
* function square(n) {
* return n * n;
* }
*
* var addSquare = _.flow([_.add, square]);
* addSquare(1, 2);
* // => 9
*/
var flow = createFlow();
/**
* This method is like `_.flow` except that it creates a function that
* invokes the given functions from right to left.
*
* @static
* @since 3.0.0
* @memberOf _
* @category Util
* @param {...(Function|Function[])} [funcs] The functions to invoke.
* @returns {Function} Returns the new composite function.
* @see _.flow
* @example
*
* function square(n) {
* return n * n;
* }
*
* var addSquare = _.flowRight([square, _.add]);
* addSquare(1, 2);
* // => 9
*/
var flowRight = createFlow(true);
/**
* This method returns the first argument it receives.
*
* @static
* @since 0.1.0
* @memberOf _
* @category Util
* @param {*} value Any value.
* @returns {*} Returns `value`.
* @example
*
* var object = { 'a': 1 };
*
* console.log(_.identity(object) === object);
* // => true
*/
function identity(value) {
return value;
}
/**
* Creates a function that invokes `func` with the arguments of the created
* function. If `func` is a property name, the created function returns the
* property value for a given element. If `func` is an array or object, the
* created function returns `true` for elements that contain the equivalent
* source properties, otherwise it returns `false`.
*
* @static
* @since 4.0.0
* @memberOf _
* @category Util
* @param {*} [func=_.identity] The value to convert to a callback.
* @returns {Function} Returns the callback.
* @example
*
* var users = [
* { 'user': 'barney', 'age': 36, 'active': true },
* { 'user': 'fred', 'age': 40, 'active': false }
* ];
*
* // The `_.matches` iteratee shorthand.
* _.filter(users, _.iteratee({ 'user': 'barney', 'active': true }));
* // => [{ 'user': 'barney', 'age': 36, 'active': true }]
*
* // The `_.matchesProperty` iteratee shorthand.
* _.filter(users, _.iteratee(['user', 'fred']));
* // => [{ 'user': 'fred', 'age': 40 }]
*
* // The `_.property` iteratee shorthand.
* _.map(users, _.iteratee('user'));
* // => ['barney', 'fred']
*
* // Create custom iteratee shorthands.
* _.iteratee = _.wrap(_.iteratee, function(iteratee, func) {
* return !_.isRegExp(func) ? iteratee(func) : function(string) {
* return func.test(string);
* };
* });
*
* _.filter(['abc', 'def'], /ef/);
* // => ['def']
*/
function iteratee(func) {
return baseIteratee(typeof func == 'function' ? func : baseClone(func, CLONE_DEEP_FLAG));
}
/**
* Creates a function that performs a partial deep comparison between a given
* object and `source`, returning `true` if the given object has equivalent
* property values, else `false`.
*
* **Note:** The created function is equivalent to `_.isMatch` with `source`
* partially applied.
*
* Partial comparisons will match empty array and empty object `source`
* values against any array or object value, respectively. See `_.isEqual`
* for a list of supported value comparisons.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Util
* @param {Object} source The object of property values to match.
* @returns {Function} Returns the new spec function.
* @example
*
* var objects = [
* { 'a': 1, 'b': 2, 'c': 3 },
* { 'a': 4, 'b': 5, 'c': 6 }
* ];
*
* _.filter(objects, _.matches({ 'a': 4, 'c': 6 }));
* // => [{ 'a': 4, 'b': 5, 'c': 6 }]
*/
function matches(source) {
return baseMatches(baseClone(source, CLONE_DEEP_FLAG));
}
/**
* Creates a function that performs a partial deep comparison between the
* value at `path` of a given object to `srcValue`, returning `true` if the
* object value is equivalent, else `false`.
*
* **Note:** Partial comparisons will match empty array and empty object
* `srcValue` values against any array or object value, respectively. See
* `_.isEqual` for a list of supported value comparisons.
*
* @static
* @memberOf _
* @since 3.2.0
* @category Util
* @param {Array|string} path The path of the property to get.
* @param {*} srcValue The value to match.
* @returns {Function} Returns the new spec function.
* @example
*
* var objects = [
* { 'a': 1, 'b': 2, 'c': 3 },
* { 'a': 4, 'b': 5, 'c': 6 }
* ];
*
* _.find(objects, _.matchesProperty('a', 4));
* // => { 'a': 4, 'b': 5, 'c': 6 }
*/
function matchesProperty(path, srcValue) {
return baseMatchesProperty(path, baseClone(srcValue, CLONE_DEEP_FLAG));
}
/**
* Creates a function that invokes the method at `path` of a given object.
* Any additional arguments are provided to the invoked method.
*
* @static
* @memberOf _
* @since 3.7.0
* @category Util
* @param {Array|string} path The path of the method to invoke.
* @param {...*} [args] The arguments to invoke the method with.
* @returns {Function} Returns the new invoker function.
* @example
*
* var objects = [
* { 'a': { 'b': _.constant(2) } },
* { 'a': { 'b': _.constant(1) } }
* ];
*
* _.map(objects, _.method('a.b'));
* // => [2, 1]
*
* _.map(objects, _.method(['a', 'b']));
* // => [2, 1]
*/
var method = baseRest(function(path, args) {
return function(object) {
return baseInvoke(object, path, args);
};
});
/**
* The opposite of `_.method`; this method creates a function that invokes
* the method at a given path of `object`. Any additional arguments are
* provided to the invoked method.
*
* @static
* @memberOf _
* @since 3.7.0
* @category Util
* @param {Object} object The object to query.
* @param {...*} [args] The arguments to invoke the method with.
* @returns {Function} Returns the new invoker function.
* @example
*
* var array = _.times(3, _.constant),
* object = { 'a': array, 'b': array, 'c': array };
*
* _.map(['a[2]', 'c[0]'], _.methodOf(object));
* // => [2, 0]
*
* _.map([['a', '2'], ['c', '0']], _.methodOf(object));
* // => [2, 0]
*/
var methodOf = baseRest(function(object, args) {
return function(path) {
return baseInvoke(object, path, args);
};
});
/**
* Adds all own enumerable string keyed function properties of a source
* object to the destination object. If `object` is a function, then methods
* are added to its prototype as well.
*
* **Note:** Use `_.runInContext` to create a pristine `lodash` function to
* avoid conflicts caused by modifying the original.
*
* @static
* @since 0.1.0
* @memberOf _
* @category Util
* @param {Function|Object} [object=lodash] The destination object.
* @param {Object} source The object of functions to add.
* @param {Object} [options={}] The options object.
* @param {boolean} [options.chain=true] Specify whether mixins are chainable.
* @returns {Function|Object} Returns `object`.
* @example
*
* function vowels(string) {
* return _.filter(string, function(v) {
* return /[aeiou]/i.test(v);
* });
* }
*
* _.mixin({ 'vowels': vowels });
* _.vowels('fred');
* // => ['e']
*
* _('fred').vowels().value();
* // => ['e']
*
* _.mixin({ 'vowels': vowels }, { 'chain': false });
* _('fred').vowels();
* // => ['e']
*/
function mixin(object, source, options) {
var props = keys(source),
methodNames = baseFunctions(source, props);
if (options == null &&
!(isObject(source) && (methodNames.length || !props.length))) {
options = source;
source = object;
object = this;
methodNames = baseFunctions(source, keys(source));
}
var chain = !(isObject(options) && 'chain' in options) || !!options.chain,
isFunc = isFunction(object);
arrayEach(methodNames, function(methodName) {
var func = source[methodName];
object[methodName] = func;
if (isFunc) {
object.prototype[methodName] = function() {
var chainAll = this.__chain__;
if (chain || chainAll) {
var result = object(this.__wrapped__),
actions = result.__actions__ = copyArray(this.__actions__);
actions.push({ 'func': func, 'args': arguments, 'thisArg': object });
result.__chain__ = chainAll;
return result;
}
return func.apply(object, arrayPush([this.value()], arguments));
};
}
});
return object;
}
/**
* Reverts the `_` variable to its previous value and returns a reference to
* the `lodash` function.
*
* @static
* @since 0.1.0
* @memberOf _
* @category Util
* @returns {Function} Returns the `lodash` function.
* @example
*
* var lodash = _.noConflict();
*/
function noConflict() {
if (root._ === this) {
root._ = oldDash;
}
return this;
}
/**
* This method returns `undefined`.
*
* @static
* @memberOf _
* @since 2.3.0
* @category Util
* @example
*
* _.times(2, _.noop);
* // => [undefined, undefined]
*/
function noop() {
// No operation performed.
}
/**
* Creates a function that gets the argument at index `n`. If `n` is negative,
* the nth argument from the end is returned.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Util
* @param {number} [n=0] The index of the argument to return.
* @returns {Function} Returns the new pass-thru function.
* @example
*
* var func = _.nthArg(1);
* func('a', 'b', 'c', 'd');
* // => 'b'
*
* var func = _.nthArg(-2);
* func('a', 'b', 'c', 'd');
* // => 'c'
*/
function nthArg(n) {
n = toInteger(n);
return baseRest(function(args) {
return baseNth(args, n);
});
}
/**
* Creates a function that invokes `iteratees` with the arguments it receives
* and returns their results.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Util
* @param {...(Function|Function[])} [iteratees=[_.identity]]
* The iteratees to invoke.
* @returns {Function} Returns the new function.
* @example
*
* var func = _.over([Math.max, Math.min]);
*
* func(1, 2, 3, 4);
* // => [4, 1]
*/
var over = createOver(arrayMap);
/**
* Creates a function that checks if **all** of the `predicates` return
* truthy when invoked with the arguments it receives.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Util
* @param {...(Function|Function[])} [predicates=[_.identity]]
* The predicates to check.
* @returns {Function} Returns the new function.
* @example
*
* var func = _.overEvery([Boolean, isFinite]);
*
* func('1');
* // => true
*
* func(null);
* // => false
*
* func(NaN);
* // => false
*/
var overEvery = createOver(arrayEvery);
/**
* Creates a function that checks if **any** of the `predicates` return
* truthy when invoked with the arguments it receives.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Util
* @param {...(Function|Function[])} [predicates=[_.identity]]
* The predicates to check.
* @returns {Function} Returns the new function.
* @example
*
* var func = _.overSome([Boolean, isFinite]);
*
* func('1');
* // => true
*
* func(null);
* // => true
*
* func(NaN);
* // => false
*/
var overSome = createOver(arraySome);
/**
* Creates a function that returns the value at `path` of a given object.
*
* @static
* @memberOf _
* @since 2.4.0
* @category Util
* @param {Array|string} path The path of the property to get.
* @returns {Function} Returns the new accessor function.
* @example
*
* var objects = [
* { 'a': { 'b': 2 } },
* { 'a': { 'b': 1 } }
* ];
*
* _.map(objects, _.property('a.b'));
* // => [2, 1]
*
* _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');
* // => [1, 2]
*/
function property(path) {
return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
}
/**
* The opposite of `_.property`; this method creates a function that returns
* the value at a given path of `object`.
*
* @static
* @memberOf _
* @since 3.0.0
* @category Util
* @param {Object} object The object to query.
* @returns {Function} Returns the new accessor function.
* @example
*
* var array = [0, 1, 2],
* object = { 'a': array, 'b': array, 'c': array };
*
* _.map(['a[2]', 'c[0]'], _.propertyOf(object));
* // => [2, 0]
*
* _.map([['a', '2'], ['c', '0']], _.propertyOf(object));
* // => [2, 0]
*/
function propertyOf(object) {
return function(path) {
return object == null ? undefined : baseGet(object, path);
};
}
/**
* Creates an array of numbers (positive and/or negative) progressing from
* `start` up to, but not including, `end`. A step of `-1` is used if a negative
* `start` is specified without an `end` or `step`. If `end` is not specified,
* it's set to `start` with `start` then set to `0`.
*
* **Note:** JavaScript follows the IEEE-754 standard for resolving
* floating-point values which can produce unexpected results.
*
* @static
* @since 0.1.0
* @memberOf _
* @category Util
* @param {number} [start=0] The start of the range.
* @param {number} end The end of the range.
* @param {number} [step=1] The value to increment or decrement by.
* @returns {Array} Returns the range of numbers.
* @see _.inRange, _.rangeRight
* @example
*
* _.range(4);
* // => [0, 1, 2, 3]
*
* _.range(-4);
* // => [0, -1, -2, -3]
*
* _.range(1, 5);
* // => [1, 2, 3, 4]
*
* _.range(0, 20, 5);
* // => [0, 5, 10, 15]
*
* _.range(0, -4, -1);
* // => [0, -1, -2, -3]
*
* _.range(1, 4, 0);
* // => [1, 1, 1]
*
* _.range(0);
* // => []
*/
var range = createRange();
/**
* This method is like `_.range` except that it populates values in
* descending order.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Util
* @param {number} [start=0] The start of the range.
* @param {number} end The end of the range.
* @param {number} [step=1] The value to increment or decrement by.
* @returns {Array} Returns the range of numbers.
* @see _.inRange, _.range
* @example
*
* _.rangeRight(4);
* // => [3, 2, 1, 0]
*
* _.rangeRight(-4);
* // => [-3, -2, -1, 0]
*
* _.rangeRight(1, 5);
* // => [4, 3, 2, 1]
*
* _.rangeRight(0, 20, 5);
* // => [15, 10, 5, 0]
*
* _.rangeRight(0, -4, -1);
* // => [-3, -2, -1, 0]
*
* _.rangeRight(1, 4, 0);
* // => [1, 1, 1]
*
* _.rangeRight(0);
* // => []
*/
var rangeRight = createRange(true);
/**
* This method returns a new empty array.
*
* @static
* @memberOf _
* @since 4.13.0
* @category Util
* @returns {Array} Returns the new empty array.
* @example
*
* var arrays = _.times(2, _.stubArray);
*
* console.log(arrays);
* // => [[], []]
*
* console.log(arrays[0] === arrays[1]);
* // => false
*/
function stubArray() {
return [];
}
/**
* This method returns `false`.
*
* @static
* @memberOf _
* @since 4.13.0
* @category Util
* @returns {boolean} Returns `false`.
* @example
*
* _.times(2, _.stubFalse);
* // => [false, false]
*/
function stubFalse() {
return false;
}
/**
* This method returns a new empty object.
*
* @static
* @memberOf _
* @since 4.13.0
* @category Util
* @returns {Object} Returns the new empty object.
* @example
*
* var objects = _.times(2, _.stubObject);
*
* console.log(objects);
* // => [{}, {}]
*
* console.log(objects[0] === objects[1]);
* // => false
*/
function stubObject() {
return {};
}
/**
* This method returns an empty string.
*
* @static
* @memberOf _
* @since 4.13.0
* @category Util
* @returns {string} Returns the empty string.
* @example
*
* _.times(2, _.stubString);
* // => ['', '']
*/
function stubString() {
return '';
}
/**
* This method returns `true`.
*
* @static
* @memberOf _
* @since 4.13.0
* @category Util
* @returns {boolean} Returns `true`.
* @example
*
* _.times(2, _.stubTrue);
* // => [true, true]
*/
function stubTrue() {
return true;
}
/**
* Invokes the iteratee `n` times, returning an array of the results of
* each invocation. The iteratee is invoked with one argument; (index).
*
* @static
* @since 0.1.0
* @memberOf _
* @category Util
* @param {number} n The number of times to invoke `iteratee`.
* @param {Function} [iteratee=_.identity] The function invoked per iteration.
* @returns {Array} Returns the array of results.
* @example
*
* _.times(3, String);
* // => ['0', '1', '2']
*
* _.times(4, _.constant(0));
* // => [0, 0, 0, 0]
*/
function times(n, iteratee) {
n = toInteger(n);
if (n < 1 || n > MAX_SAFE_INTEGER) {
return [];
}
var index = MAX_ARRAY_LENGTH,
length = nativeMin(n, MAX_ARRAY_LENGTH);
iteratee = getIteratee(iteratee);
n -= MAX_ARRAY_LENGTH;
var result = baseTimes(length, iteratee);
while (++index < n) {
iteratee(index);
}
return result;
}
/**
* Converts `value` to a property path array.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Util
* @param {*} value The value to convert.
* @returns {Array} Returns the new property path array.
* @example
*
* _.toPath('a.b.c');
* // => ['a', 'b', 'c']
*
* _.toPath('a[0].b.c');
* // => ['a', '0', 'b', 'c']
*/
function toPath(value) {
if (isArray(value)) {
return arrayMap(value, toKey);
}
return isSymbol(value) ? [value] : copyArray(stringToPath(toString(value)));
}
/**
* Generates a unique ID. If `prefix` is given, the ID is appended to it.
*
* @static
* @since 0.1.0
* @memberOf _
* @category Util
* @param {string} [prefix=''] The value to prefix the ID with.
* @returns {string} Returns the unique ID.
* @example
*
* _.uniqueId('contact_');
* // => 'contact_104'
*
* _.uniqueId();
* // => '105'
*/
function uniqueId(prefix) {
var id = ++idCounter;
return toString(prefix) + id;
}
/*------------------------------------------------------------------------*/
/**
* Adds two numbers.
*
* @static
* @memberOf _
* @since 3.4.0
* @category Math
* @param {number} augend The first number in an addition.
* @param {number} addend The second number in an addition.
* @returns {number} Returns the total.
* @example
*
* _.add(6, 4);
* // => 10
*/
var add = createMathOperation(function(augend, addend) {
return augend + addend;
}, 0);
/**
* Computes `number` rounded up to `precision`.
*
* @static
* @memberOf _
* @since 3.10.0
* @category Math
* @param {number} number The number to round up.
* @param {number} [precision=0] The precision to round up to.
* @returns {number} Returns the rounded up number.
* @example
*
* _.ceil(4.006);
* // => 5
*
* _.ceil(6.004, 2);
* // => 6.01
*
* _.ceil(6040, -2);
* // => 6100
*/
var ceil = createRound('ceil');
/**
* Divide two numbers.
*
* @static
* @memberOf _
* @since 4.7.0
* @category Math
* @param {number} dividend The first number in a division.
* @param {number} divisor The second number in a division.
* @returns {number} Returns the quotient.
* @example
*
* _.divide(6, 4);
* // => 1.5
*/
var divide = createMathOperation(function(dividend, divisor) {
return dividend / divisor;
}, 1);
/**
* Computes `number` rounded down to `precision`.
*
* @static
* @memberOf _
* @since 3.10.0
* @category Math
* @param {number} number The number to round down.
* @param {number} [precision=0] The precision to round down to.
* @returns {number} Returns the rounded down number.
* @example
*
* _.floor(4.006);
* // => 4
*
* _.floor(0.046, 2);
* // => 0.04
*
* _.floor(4060, -2);
* // => 4000
*/
var floor = createRound('floor');
/**
* Computes the maximum value of `array`. If `array` is empty or falsey,
* `undefined` is returned.
*
* @static
* @since 0.1.0
* @memberOf _
* @category Math
* @param {Array} array The array to iterate over.
* @returns {*} Returns the maximum value.
* @example
*
* _.max([4, 2, 8, 6]);
* // => 8
*
* _.max([]);
* // => undefined
*/
function max(array) {
return (array && array.length)
? baseExtremum(array, identity, baseGt)
: undefined;
}
/**
* This method is like `_.max` except that it accepts `iteratee` which is
* invoked for each element in `array` to generate the criterion by which
* the value is ranked. The iteratee is invoked with one argument: (value).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Math
* @param {Array} array The array to iterate over.
* @param {Function} [iteratee=_.identity] The iteratee invoked per element.
* @returns {*} Returns the maximum value.
* @example
*
* var objects = [{ 'n': 1 }, { 'n': 2 }];
*
* _.maxBy(objects, function(o) { return o.n; });
* // => { 'n': 2 }
*
* // The `_.property` iteratee shorthand.
* _.maxBy(objects, 'n');
* // => { 'n': 2 }
*/
function maxBy(array, iteratee) {
return (array && array.length)
? baseExtremum(array, getIteratee(iteratee, 2), baseGt)
: undefined;
}
/**
* Computes the mean of the values in `array`.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Math
* @param {Array} array The array to iterate over.
* @returns {number} Returns the mean.
* @example
*
* _.mean([4, 2, 8, 6]);
* // => 5
*/
function mean(array) {
return baseMean(array, identity);
}
/**
* This method is like `_.mean` except that it accepts `iteratee` which is
* invoked for each element in `array` to generate the value to be averaged.
* The iteratee is invoked with one argument: (value).
*
* @static
* @memberOf _
* @since 4.7.0
* @category Math
* @param {Array} array The array to iterate over.
* @param {Function} [iteratee=_.identity] The iteratee invoked per element.
* @returns {number} Returns the mean.
* @example
*
* var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
*
* _.meanBy(objects, function(o) { return o.n; });
* // => 5
*
* // The `_.property` iteratee shorthand.
* _.meanBy(objects, 'n');
* // => 5
*/
function meanBy(array, iteratee) {
return baseMean(array, getIteratee(iteratee, 2));
}
/**
* Computes the minimum value of `array`. If `array` is empty or falsey,
* `undefined` is returned.
*
* @static
* @since 0.1.0
* @memberOf _
* @category Math
* @param {Array} array The array to iterate over.
* @returns {*} Returns the minimum value.
* @example
*
* _.min([4, 2, 8, 6]);
* // => 2
*
* _.min([]);
* // => undefined
*/
function min(array) {
return (array && array.length)
? baseExtremum(array, identity, baseLt)
: undefined;
}
/**
* This method is like `_.min` except that it accepts `iteratee` which is
* invoked for each element in `array` to generate the criterion by which
* the value is ranked. The iteratee is invoked with one argument: (value).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Math
* @param {Array} array The array to iterate over.
* @param {Function} [iteratee=_.identity] The iteratee invoked per element.
* @returns {*} Returns the minimum value.
* @example
*
* var objects = [{ 'n': 1 }, { 'n': 2 }];
*
* _.minBy(objects, function(o) { return o.n; });
* // => { 'n': 1 }
*
* // The `_.property` iteratee shorthand.
* _.minBy(objects, 'n');
* // => { 'n': 1 }
*/
function minBy(array, iteratee) {
return (array && array.length)
? baseExtremum(array, getIteratee(iteratee, 2), baseLt)
: undefined;
}
/**
* Multiply two numbers.
*
* @static
* @memberOf _
* @since 4.7.0
* @category Math
* @param {number} multiplier The first number in a multiplication.
* @param {number} multiplicand The second number in a multiplication.
* @returns {number} Returns the product.
* @example
*
* _.multiply(6, 4);
* // => 24
*/
var multiply = createMathOperation(function(multiplier, multiplicand) {
return multiplier * multiplicand;
}, 1);
/**
* Computes `number` rounded to `precision`.
*
* @static
* @memberOf _
* @since 3.10.0
* @category Math
* @param {number} number The number to round.
* @param {number} [precision=0] The precision to round to.
* @returns {number} Returns the rounded number.
* @example
*
* _.round(4.006);
* // => 4
*
* _.round(4.006, 2);
* // => 4.01
*
* _.round(4060, -2);
* // => 4100
*/
var round = createRound('round');
/**
* Subtract two numbers.
*
* @static
* @memberOf _
* @since 4.0.0
* @category Math
* @param {number} minuend The first number in a subtraction.
* @param {number} subtrahend The second number in a subtraction.
* @returns {number} Returns the difference.
* @example
*
* _.subtract(6, 4);
* // => 2
*/
var subtract = createMathOperation(function(minuend, subtrahend) {
return minuend - subtrahend;
}, 0);
/**
* Computes the sum of the values in `array`.
*
* @static
* @memberOf _
* @since 3.4.0
* @category Math
* @param {Array} array The array to iterate over.
* @returns {number} Returns the sum.
* @example
*
* _.sum([4, 2, 8, 6]);
* // => 20
*/
function sum(array) {
return (array && array.length)
? baseSum(array, identity)
: 0;
}
/**
* This method is like `_.sum` except that it accepts `iteratee` which is
* invoked for each element in `array` to generate the value to be summed.
* The iteratee is invoked with one argument: (value).
*
* @static
* @memberOf _
* @since 4.0.0
* @category Math
* @param {Array} array The array to iterate over.
* @param {Function} [iteratee=_.identity] The iteratee invoked per element.
* @returns {number} Returns the sum.
* @example
*
* var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
*
* _.sumBy(objects, function(o) { return o.n; });
* // => 20
*
* // The `_.property` iteratee shorthand.
* _.sumBy(objects, 'n');
* // => 20
*/
function sumBy(array, iteratee) {
return (array && array.length)
? baseSum(array, getIteratee(iteratee, 2))
: 0;
}
/*------------------------------------------------------------------------*/
// Add methods that return wrapped values in chain sequences.
lodash.after = after;
lodash.ary = ary;
lodash.assign = assign;
lodash.assignIn = assignIn;
lodash.assignInWith = assignInWith;
lodash.assignWith = assignWith;
lodash.at = at;
lodash.before = before;
lodash.bind = bind;
lodash.bindAll = bindAll;
lodash.bindKey = bindKey;
lodash.castArray = castArray;
lodash.chain = chain;
lodash.chunk = chunk;
lodash.compact = compact;
lodash.concat = concat;
lodash.cond = cond;
lodash.conforms = conforms;
lodash.constant = constant;
lodash.countBy = countBy;
lodash.create = create;
lodash.curry = curry;
lodash.curryRight = curryRight;
lodash.debounce = debounce;
lodash.defaults = defaults;
lodash.defaultsDeep = defaultsDeep;
lodash.defer = defer;
lodash.delay = delay;
lodash.difference = difference;
lodash.differenceBy = differenceBy;
lodash.differenceWith = differenceWith;
lodash.drop = drop;
lodash.dropRight = dropRight;
lodash.dropRightWhile = dropRightWhile;
lodash.dropWhile = dropWhile;
lodash.fill = fill;
lodash.filter = filter;
lodash.flatMap = flatMap;
lodash.flatMapDeep = flatMapDeep;
lodash.flatMapDepth = flatMapDepth;
lodash.flatten = flatten;
lodash.flattenDeep = flattenDeep;
lodash.flattenDepth = flattenDepth;
lodash.flip = flip;
lodash.flow = flow;
lodash.flowRight = flowRight;
lodash.fromPairs = fromPairs;
lodash.functions = functions;
lodash.functionsIn = functionsIn;
lodash.groupBy = groupBy;
lodash.initial = initial;
lodash.intersection = intersection;
lodash.intersectionBy = intersectionBy;
lodash.intersectionWith = intersectionWith;
lodash.invert = invert;
lodash.invertBy = invertBy;
lodash.invokeMap = invokeMap;
lodash.iteratee = iteratee;
lodash.keyBy = keyBy;
lodash.keys = keys;
lodash.keysIn = keysIn;
lodash.map = map;
lodash.mapKeys = mapKeys;
lodash.mapValues = mapValues;
lodash.matches = matches;
lodash.matchesProperty = matchesProperty;
lodash.memoize = memoize;
lodash.merge = merge;
lodash.mergeWith = mergeWith;
lodash.method = method;
lodash.methodOf = methodOf;
lodash.mixin = mixin;
lodash.negate = negate;
lodash.nthArg = nthArg;
lodash.omit = omit;
lodash.omitBy = omitBy;
lodash.once = once;
lodash.orderBy = orderBy;
lodash.over = over;
lodash.overArgs = overArgs;
lodash.overEvery = overEvery;
lodash.overSome = overSome;
lodash.partial = partial;
lodash.partialRight = partialRight;
lodash.partition = partition;
lodash.pick = pick;
lodash.pickBy = pickBy;
lodash.property = property;
lodash.propertyOf = propertyOf;
lodash.pull = pull;
lodash.pullAll = pullAll;
lodash.pullAllBy = pullAllBy;
lodash.pullAllWith = pullAllWith;
lodash.pullAt = pullAt;
lodash.range = range;
lodash.rangeRight = rangeRight;
lodash.rearg = rearg;
lodash.reject = reject;
lodash.remove = remove;
lodash.rest = rest;
lodash.reverse = reverse;
lodash.sampleSize = sampleSize;
lodash.set = set;
lodash.setWith = setWith;
lodash.shuffle = shuffle;
lodash.slice = slice;
lodash.sortBy = sortBy;
lodash.sortedUniq = sortedUniq;
lodash.sortedUniqBy = sortedUniqBy;
lodash.split = split;
lodash.spread = spread;
lodash.tail = tail;
lodash.take = take;
lodash.takeRight = takeRight;
lodash.takeRightWhile = takeRightWhile;
lodash.takeWhile = takeWhile;
lodash.tap = tap;
lodash.throttle = throttle;
lodash.thru = thru;
lodash.toArray = toArray;
lodash.toPairs = toPairs;
lodash.toPairsIn = toPairsIn;
lodash.toPath = toPath;
lodash.toPlainObject = toPlainObject;
lodash.transform = transform;
lodash.unary = unary;
lodash.union = union;
lodash.unionBy = unionBy;
lodash.unionWith = unionWith;
lodash.uniq = uniq;
lodash.uniqBy = uniqBy;
lodash.uniqWith = uniqWith;
lodash.unset = unset;
lodash.unzip = unzip;
lodash.unzipWith = unzipWith;
lodash.update = update;
lodash.updateWith = updateWith;
lodash.values = values;
lodash.valuesIn = valuesIn;
lodash.without = without;
lodash.words = words;
lodash.wrap = wrap;
lodash.xor = xor;
lodash.xorBy = xorBy;
lodash.xorWith = xorWith;
lodash.zip = zip;
lodash.zipObject = zipObject;
lodash.zipObjectDeep = zipObjectDeep;
lodash.zipWith = zipWith;
// Add aliases.
lodash.entries = toPairs;
lodash.entriesIn = toPairsIn;
lodash.extend = assignIn;
lodash.extendWith = assignInWith;
// Add methods to `lodash.prototype`.
mixin(lodash, lodash);
/*------------------------------------------------------------------------*/
// Add methods that return unwrapped values in chain sequences.
lodash.add = add;
lodash.attempt = attempt;
lodash.camelCase = camelCase;
lodash.capitalize = capitalize;
lodash.ceil = ceil;
lodash.clamp = clamp;
lodash.clone = clone;
lodash.cloneDeep = cloneDeep;
lodash.cloneDeepWith = cloneDeepWith;
lodash.cloneWith = cloneWith;
lodash.conformsTo = conformsTo;
lodash.deburr = deburr;
lodash.defaultTo = defaultTo;
lodash.divide = divide;
lodash.endsWith = endsWith;
lodash.eq = eq;
lodash.escape = escape;
lodash.escapeRegExp = escapeRegExp;
lodash.every = every;
lodash.find = find;
lodash.findIndex = findIndex;
lodash.findKey = findKey;
lodash.findLast = findLast;
lodash.findLastIndex = findLastIndex;
lodash.findLastKey = findLastKey;
lodash.floor = floor;
lodash.forEach = forEach;
lodash.forEachRight = forEachRight;
lodash.forIn = forIn;
lodash.forInRight = forInRight;
lodash.forOwn = forOwn;
lodash.forOwnRight = forOwnRight;
lodash.get = get;
lodash.gt = gt;
lodash.gte = gte;
lodash.has = has;
lodash.hasIn = hasIn;
lodash.head = head;
lodash.identity = identity;
lodash.includes = includes;
lodash.indexOf = indexOf;
lodash.inRange = inRange;
lodash.invoke = invoke;
lodash.isArguments = isArguments;
lodash.isArray = isArray;
lodash.isArrayBuffer = isArrayBuffer;
lodash.isArrayLike = isArrayLike;
lodash.isArrayLikeObject = isArrayLikeObject;
lodash.isBoolean = isBoolean;
lodash.isBuffer = isBuffer;
lodash.isDate = isDate;
lodash.isElement = isElement;
lodash.isEmpty = isEmpty;
lodash.isEqual = isEqual;
lodash.isEqualWith = isEqualWith;
lodash.isError = isError;
lodash.isFinite = isFinite;
lodash.isFunction = isFunction;
lodash.isInteger = isInteger;
lodash.isLength = isLength;
lodash.isMap = isMap;
lodash.isMatch = isMatch;
lodash.isMatchWith = isMatchWith;
lodash.isNaN = isNaN;
lodash.isNative = isNative;
lodash.isNil = isNil;
lodash.isNull = isNull;
lodash.isNumber = isNumber;
lodash.isObject = isObject;
lodash.isObjectLike = isObjectLike;
lodash.isPlainObject = isPlainObject;
lodash.isRegExp = isRegExp;
lodash.isSafeInteger = isSafeInteger;
lodash.isSet = isSet;
lodash.isString = isString;
lodash.isSymbol = isSymbol;
lodash.isTypedArray = isTypedArray;
lodash.isUndefined = isUndefined;
lodash.isWeakMap = isWeakMap;
lodash.isWeakSet = isWeakSet;
lodash.join = join;
lodash.kebabCase = kebabCase;
lodash.last = last;
lodash.lastIndexOf = lastIndexOf;
lodash.lowerCase = lowerCase;
lodash.lowerFirst = lowerFirst;
lodash.lt = lt;
lodash.lte = lte;
lodash.max = max;
lodash.maxBy = maxBy;
lodash.mean = mean;
lodash.meanBy = meanBy;
lodash.min = min;
lodash.minBy = minBy;
lodash.stubArray = stubArray;
lodash.stubFalse = stubFalse;
lodash.stubObject = stubObject;
lodash.stubString = stubString;
lodash.stubTrue = stubTrue;
lodash.multiply = multiply;
lodash.nth = nth;
lodash.noConflict = noConflict;
lodash.noop = noop;
lodash.now = now;
lodash.pad = pad;
lodash.padEnd = padEnd;
lodash.padStart = padStart;
lodash.parseInt = parseInt;
lodash.random = random;
lodash.reduce = reduce;
lodash.reduceRight = reduceRight;
lodash.repeat = repeat;
lodash.replace = replace;
lodash.result = result;
lodash.round = round;
lodash.runInContext = runInContext;
lodash.sample = sample;
lodash.size = size;
lodash.snakeCase = snakeCase;
lodash.some = some;
lodash.sortedIndex = sortedIndex;
lodash.sortedIndexBy = sortedIndexBy;
lodash.sortedIndexOf = sortedIndexOf;
lodash.sortedLastIndex = sortedLastIndex;
lodash.sortedLastIndexBy = sortedLastIndexBy;
lodash.sortedLastIndexOf = sortedLastIndexOf;
lodash.startCase = startCase;
lodash.startsWith = startsWith;
lodash.subtract = subtract;
lodash.sum = sum;
lodash.sumBy = sumBy;
lodash.template = template;
lodash.times = times;
lodash.toFinite = toFinite;
lodash.toInteger = toInteger;
lodash.toLength = toLength;
lodash.toLower = toLower;
lodash.toNumber = toNumber;
lodash.toSafeInteger = toSafeInteger;
lodash.toString = toString;
lodash.toUpper = toUpper;
lodash.trim = trim;
lodash.trimEnd = trimEnd;
lodash.trimStart = trimStart;
lodash.truncate = truncate;
lodash.unescape = unescape;
lodash.uniqueId = uniqueId;
lodash.upperCase = upperCase;
lodash.upperFirst = upperFirst;
// Add aliases.
lodash.each = forEach;
lodash.eachRight = forEachRight;
lodash.first = head;
mixin(lodash, (function() {
var source = {};
baseForOwn(lodash, function(func, methodName) {
if (!hasOwnProperty.call(lodash.prototype, methodName)) {
source[methodName] = func;
}
});
return source;
}()), { 'chain': false });
/*------------------------------------------------------------------------*/
/**
* The semantic version number.
*
* @static
* @memberOf _
* @type {string}
*/
lodash.VERSION = VERSION;
// Assign default placeholders.
arrayEach(['bind', 'bindKey', 'curry', 'curryRight', 'partial', 'partialRight'], function(methodName) {
lodash[methodName].placeholder = lodash;
});
// Add `LazyWrapper` methods for `_.drop` and `_.take` variants.
arrayEach(['drop', 'take'], function(methodName, index) {
LazyWrapper.prototype[methodName] = function(n) {
n = n === undefined ? 1 : nativeMax(toInteger(n), 0);
var result = (this.__filtered__ && !index)
? new LazyWrapper(this)
: this.clone();
if (result.__filtered__) {
result.__takeCount__ = nativeMin(n, result.__takeCount__);
} else {
result.__views__.push({
'size': nativeMin(n, MAX_ARRAY_LENGTH),
'type': methodName + (result.__dir__ < 0 ? 'Right' : '')
});
}
return result;
};
LazyWrapper.prototype[methodName + 'Right'] = function(n) {
return this.reverse()[methodName](n).reverse();
};
});
// Add `LazyWrapper` methods that accept an `iteratee` value.
arrayEach(['filter', 'map', 'takeWhile'], function(methodName, index) {
var type = index + 1,
isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG;
LazyWrapper.prototype[methodName] = function(iteratee) {
var result = this.clone();
result.__iteratees__.push({
'iteratee': getIteratee(iteratee, 3),
'type': type
});
result.__filtered__ = result.__filtered__ || isFilter;
return result;
};
});
// Add `LazyWrapper` methods for `_.head` and `_.last`.
arrayEach(['head', 'last'], function(methodName, index) {
var takeName = 'take' + (index ? 'Right' : '');
LazyWrapper.prototype[methodName] = function() {
return this[takeName](1).value()[0];
};
});
// Add `LazyWrapper` methods for `_.initial` and `_.tail`.
arrayEach(['initial', 'tail'], function(methodName, index) {
var dropName = 'drop' + (index ? '' : 'Right');
LazyWrapper.prototype[methodName] = function() {
return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);
};
});
LazyWrapper.prototype.compact = function() {
return this.filter(identity);
};
LazyWrapper.prototype.find = function(predicate) {
return this.filter(predicate).head();
};
LazyWrapper.prototype.findLast = function(predicate) {
return this.reverse().find(predicate);
};
LazyWrapper.prototype.invokeMap = baseRest(function(path, args) {
if (typeof path == 'function') {
return new LazyWrapper(this);
}
return this.map(function(value) {
return baseInvoke(value, path, args);
});
});
LazyWrapper.prototype.reject = function(predicate) {
return this.filter(negate(getIteratee(predicate)));
};
LazyWrapper.prototype.slice = function(start, end) {
start = toInteger(start);
var result = this;
if (result.__filtered__ && (start > 0 || end < 0)) {
return new LazyWrapper(result);
}
if (start < 0) {
result = result.takeRight(-start);
} else if (start) {
result = result.drop(start);
}
if (end !== undefined) {
end = toInteger(end);
result = end < 0 ? result.dropRight(-end) : result.take(end - start);
}
return result;
};
LazyWrapper.prototype.takeRightWhile = function(predicate) {
return this.reverse().takeWhile(predicate).reverse();
};
LazyWrapper.prototype.toArray = function() {
return this.take(MAX_ARRAY_LENGTH);
};
// Add `LazyWrapper` methods to `lodash.prototype`.
baseForOwn(LazyWrapper.prototype, function(func, methodName) {
var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName),
isTaker = /^(?:head|last)$/.test(methodName),
lodashFunc = lodash[isTaker ? ('take' + (methodName == 'last' ? 'Right' : '')) : methodName],
retUnwrapped = isTaker || /^find/.test(methodName);
if (!lodashFunc) {
return;
}
lodash.prototype[methodName] = function() {
var value = this.__wrapped__,
args = isTaker ? [1] : arguments,
isLazy = value instanceof LazyWrapper,
iteratee = args[0],
useLazy = isLazy || isArray(value);
var interceptor = function(value) {
var result = lodashFunc.apply(lodash, arrayPush([value], args));
return (isTaker && chainAll) ? result[0] : result;
};
if (useLazy && checkIteratee && typeof iteratee == 'function' && iteratee.length != 1) {
// Avoid lazy use if the iteratee has a "length" value other than `1`.
isLazy = useLazy = false;
}
var chainAll = this.__chain__,
isHybrid = !!this.__actions__.length,
isUnwrapped = retUnwrapped && !chainAll,
onlyLazy = isLazy && !isHybrid;
if (!retUnwrapped && useLazy) {
value = onlyLazy ? value : new LazyWrapper(this);
var result = func.apply(value, args);
result.__actions__.push({ 'func': thru, 'args': [interceptor], 'thisArg': undefined });
return new LodashWrapper(result, chainAll);
}
if (isUnwrapped && onlyLazy) {
return func.apply(this, args);
}
result = this.thru(interceptor);
return isUnwrapped ? (isTaker ? result.value()[0] : result.value()) : result;
};
});
// Add `Array` methods to `lodash.prototype`.
arrayEach(['pop', 'push', 'shift', 'sort', 'splice', 'unshift'], function(methodName) {
var func = arrayProto[methodName],
chainName = /^(?:push|sort|unshift)$/.test(methodName) ? 'tap' : 'thru',
retUnwrapped = /^(?:pop|shift)$/.test(methodName);
lodash.prototype[methodName] = function() {
var args = arguments;
if (retUnwrapped && !this.__chain__) {
var value = this.value();
return func.apply(isArray(value) ? value : [], args);
}
return this[chainName](function(value) {
return func.apply(isArray(value) ? value : [], args);
});
};
});
// Map minified method names to their real names.
baseForOwn(LazyWrapper.prototype, function(func, methodName) {
var lodashFunc = lodash[methodName];
if (lodashFunc) {
var key = (lodashFunc.name + ''),
names = realNames[key] || (realNames[key] = []);
names.push({ 'name': methodName, 'func': lodashFunc });
}
});
realNames[createHybrid(undefined, WRAP_BIND_KEY_FLAG).name] = [{
'name': 'wrapper',
'func': undefined
}];
// Add methods to `LazyWrapper`.
LazyWrapper.prototype.clone = lazyClone;
LazyWrapper.prototype.reverse = lazyReverse;
LazyWrapper.prototype.value = lazyValue;
// Add chain sequence methods to the `lodash` wrapper.
lodash.prototype.at = wrapperAt;
lodash.prototype.chain = wrapperChain;
lodash.prototype.commit = wrapperCommit;
lodash.prototype.next = wrapperNext;
lodash.prototype.plant = wrapperPlant;
lodash.prototype.reverse = wrapperReverse;
lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue;
// Add lazy aliases.
lodash.prototype.first = lodash.prototype.head;
if (symIterator) {
lodash.prototype[symIterator] = wrapperToIterator;
}
return lodash;
});
/*--------------------------------------------------------------------------*/
// Export lodash.
var _ = runInContext();
// Some AMD build optimizers, like r.js, check for condition patterns like:
if (true) {
// Expose Lodash on the global object to prevent errors when Lodash is
// loaded by a script tag in the presence of an AMD loader.
// See http://requirejs.org/docs/errors.html#mismatch for more details.
// Use `_.noConflict` to remove Lodash from the global object.
root._ = _;
// Define as an anonymous module so, through path mapping, it can be
// referenced as the "underscore" module.
!(__WEBPACK_AMD_DEFINE_RESULT__ = (function() {
return _;
}).call(exports, __webpack_require__, exports, module),
__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
}
// Check for `exports` after `define` in case a build optimizer adds it.
else if (freeModule) {
// Export for Node.js.
(freeModule.exports = _)._ = _;
// Export for CommonJS support.
freeExports._ = _;
}
else {
// Export to the global object.
root._ = _;
}
}.call(this));
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5), __webpack_require__(11)(module)))
/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
var _ = __webpack_require__(0);
var utils = __webpack_require__(2);
/**
* Constructs a client action factory that uses specific defaults
* @type {Function}
*/
exports.makeFactoryWithModifier = makeFactoryWithModifier;
/**
* Constructs a function that can be called to make a request to ES
* @type {Function}
*/
exports.factory = makeFactoryWithModifier();
/**
* Constructs a proxy to another api method
* @type {Function}
*/
exports.proxyFactory = exports.factory.proxy; // export so that we can test this
exports._resolveUrl = resolveUrl;
exports.ApiNamespace = function () {};
exports.namespaceFactory = function () {
function ClientNamespace(transport, client) {
this.transport = transport;
this.client = client;
}
ClientNamespace.prototype = new exports.ApiNamespace();
return ClientNamespace;
};
function makeFactoryWithModifier(modifier) {
modifier = modifier || _.identity;
var factory = function factory(spec) {
spec = modifier(spec);
if (!_.isPlainObject(spec.params)) {
spec.params = {};
}
if (!spec.method) {
spec.method = 'GET';
}
function action(params, cb) {
if (typeof params === 'function') {
cb = params;
params = {};
} else {
params = params || {};
cb = typeof cb === 'function' ? cb : null;
}
try {
return exec(this.transport, spec, _.clone(params), cb);
} catch (e) {
if (typeof cb === 'function') {
utils.nextTick(cb, e);
} else {
var def = this.transport.defer();
def.reject(e);
return def.promise;
}
}
}
action.spec = spec;
return action;
};
factory.proxy = function (fn, spec) {
return function (params, cb) {
if (typeof params === 'function') {
cb = params;
params = {};
} else {
params = params || {};
cb = typeof cb === 'function' ? cb : null;
}
if (spec.transform) {
spec.transform(params);
}
return fn.call(this, params, cb);
};
};
return factory;
}
var castType = {
'enum': function validSelection(param, val, name) {
if (_.isString(val) && val.indexOf(',') > -1) {
val = commaSepList(val);
}
if (_.isArray(val)) {
return val.map(function (v) {
return validSelection(param, v, name);
}).join(',');
}
for (var i = 0; i < param.options.length; i++) {
if (param.options[i] === String(val)) {
return param.options[i];
}
}
throw new TypeError('Invalid ' + name + ': expected ' + (param.options.length > 1 ? 'one of ' + param.options.join(',') : param.options[0]));
},
duration: function duration(param, val, name) {
if (utils.isNumeric(val) || utils.isInterval(val)) {
return val;
} else {
throw new TypeError('Invalid ' + name + ': expected a number or interval ' + '(an integer followed by one of M, w, d, h, m, s, y or ms).');
}
},
list: function list(param, val, name) {
switch (_typeof(val)) {
case 'number':
case 'boolean':
return '' + val;
case 'string':
val = commaSepList(val);
/* falls through */
case 'object':
if (_.isArray(val)) {
return val.join(',');
}
/* falls through */
default:
throw new TypeError('Invalid ' + name + ': expected be a comma separated list, array, number or string.');
}
},
'boolean': function boolean(param, val) {
val = _.isString(val) ? val.toLowerCase() : val;
return val === 'no' || val === 'off' ? false : !!val;
},
number: function number(param, val, name) {
if (utils.isNumeric(val)) {
return val * 1;
} else {
throw new TypeError('Invalid ' + name + ': expected a number.');
}
},
string: function string(param, val, name) {
switch (_typeof(val)) {
case 'number':
case 'string':
return '' + val;
default:
throw new TypeError('Invalid ' + name + ': expected a string.');
}
},
time: function time(param, val, name) {
if (typeof val === 'string') {
return val;
} else if (utils.isNumeric(val)) {
return '' + val;
} else if (val instanceof Date) {
return '' + val.getTime();
} else {
throw new TypeError('Invalid ' + name + ': expected some sort of time.');
}
}
};
function resolveUrl(url, params) {
var vars = {},
i,
key;
if (url.req) {
// url has required params
if (!url.reqParamKeys) {
// create cached key list on demand
url.reqParamKeys = _.keys(url.req);
}
for (i = 0; i < url.reqParamKeys.length; i++) {
key = url.reqParamKeys[i];
if (!params.hasOwnProperty(key) || params[key] == null) {
// missing a required param
return false;
} else {
// cast of copy required param
if (castType[url.req[key].type]) {
vars[key] = castType[url.req[key].type](url.req[key], params[key], key);
} else {
vars[key] = params[key];
}
}
}
}
if (url.opt) {
// url has optional params
if (!url.optParamKeys) {
url.optParamKeys = _.keys(url.opt);
}
for (i = 0; i < url.optParamKeys.length; i++) {
key = url.optParamKeys[i];
if (params[key]) {
if (castType[url.opt[key].type] || params[key] == null) {
vars[key] = castType[url.opt[key].type](url.opt[key], params[key], key);
} else {
vars[key] = params[key];
}
} else {
vars[key] = url.opt[key]['default'];
}
}
}
if (!url.template) {
// compile the template on demand
url.template = _.template(url.fmt);
}
return url.template(_.transform(vars, function (note, val, name) {
// encode each value
note[name] = encodeURIComponent(val); // remove it from the params so that it isn't sent to the final request
delete params[name];
}, {}));
}
function exec(transport, spec, params, cb) {
var request = {
method: spec.method
};
var query = {};
var i; // pass the timeout from the spec
if (spec.requestTimeout) {
request.requestTimeout = spec.requestTimeout;
}
if (!params.body && spec.paramAsBody) {
if (_typeof(spec.paramAsBody) === 'object') {
params.body = {};
if (spec.paramAsBody.castToArray) {
params.body[spec.paramAsBody.body] = [].concat(params[spec.paramAsBody.param]);
} else {
params.body[spec.paramAsBody.body] = params[spec.paramAsBody.param];
}
delete params[spec.paramAsBody.param];
} else {
params.body = params[spec.paramAsBody];
delete params[spec.paramAsBody];
}
} // verify that we have the body if needed
if (spec.needsBody && !params.body) {
throw new TypeError('A request body is required.');
} // control params
if (spec.bulkBody) {
request.bulkBody = true;
}
if (spec.method === 'HEAD') {
request.castExists = true;
} // pick the url
if (spec.url) {
// only one url option
request.path = resolveUrl(spec.url, params);
} else {
for (i = 0; i < spec.urls.length; i++) {
if (request.path = resolveUrl(spec.urls[i], params)) {
break;
}
}
}
if (!request.path) {
// there must have been some mimimun requirements that were not met
var minUrl = spec.url || spec.urls[spec.urls.length - 1];
throw new TypeError('Unable to build a path with those params. Supply at least ' + _.keys(minUrl.req).join(', '));
} // build the query string
if (!spec.paramKeys) {
// build a key list on demand
spec.paramKeys = _.keys(spec.params);
spec.requireParamKeys = _.transform(spec.params, function (req, param, key) {
if (param.required) {
req.push(key);
}
}, []);
}
for (var key in params) {
if (params.hasOwnProperty(key) && params[key] != null) {
switch (key) {
case 'body':
case 'headers':
case 'requestTimeout':
case 'maxRetries':
request[key] = params[key];
break;
case 'ignore':
request.ignore = _.isArray(params[key]) ? params[key] : [params[key]];
break;
case 'method':
request.method = utils.toUpperString(params[key]);
break;
default:
var paramSpec = spec.params[key];
if (paramSpec) {
// param keys don't always match the param name, in those cases it's stored in the param def as "name"
paramSpec.name = paramSpec.name || key;
if (params[key] != null) {
if (castType[paramSpec.type]) {
query[paramSpec.name] = castType[paramSpec.type](paramSpec, params[key], key);
} else {
query[paramSpec.name] = params[key];
}
if (paramSpec['default'] && query[paramSpec.name] === paramSpec['default']) {
delete query[paramSpec.name];
}
}
} else {
query[key] = params[key];
}
}
}
}
for (i = 0; i < spec.requireParamKeys.length; i++) {
if (!query.hasOwnProperty(spec.requireParamKeys[i])) {
throw new TypeError('Missing required parameter ' + spec.requireParamKeys[i]);
}
}
request.query = query;
return transport.request(request, cb);
}
function commaSepList(str) {
return str.split(',').map(function (i) {
return i.trim();
});
}
/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(process, Buffer) {
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
var _ = __webpack_require__(0);
var nodeUtils = __webpack_require__(30);
/**
* Custom utils library
*
* @class utils
* @static
*/
var utils = {};
utils.inherits = nodeUtils.inherits;
/**
* Test if a value is an array and its contents are string type
*
* @method isArrayOfStrings
* @param {Array} arr - An array to check
* @return {Boolean}
*/
utils.isArrayOfStrings = function (arr) {
// quick shallow check of arrays
return _.isArray(arr) && _.every(arr.slice(0, 10), _.isString);
};
/**
* Capitalize the first letter of a word
*
* @method ucfirst
* @param {string} word - The word to transform
* @return {string}
*/
utils.ucfirst = function (word) {
return word[0].toUpperCase() + word.substring(1).toLowerCase();
};
/**
* Base algo for studlyCase and camelCase
* @param {boolean} firstWordCap - Should the first character of the first word be capitalized
* @return {Function}
*/
function adjustWordCase(firstWordCap, otherWordsCap, sep) {
return function (string) {
var i = 0;
var words = [];
var word = '';
var code, c, upper, lower;
for (; i < string.length; i++) {
code = string.charCodeAt(i);
c = string.charAt(i);
lower = code >= 97 && code <= 122 || code >= 48 && code <= 57;
upper = code >= 65 && code <= 90;
if (upper || !lower) {
// new word
if (word.length) {
words.push(word);
}
word = '';
}
if (upper || lower) {
if (lower && word.length) {
word += c;
} else {
if (!words.length && firstWordCap || words.length && otherWordsCap) {
word = c.toUpperCase();
} else {
word = c.toLowerCase();
}
}
}
}
if (word.length) {
words.push(word);
} // add the leading underscore back to strings the had it originally
if (words.length && string.charAt(0) === '_') {
words[0] = '_' + words[0];
}
return words.join(sep);
};
}
/**
* Transform a string into StudlyCase
*
* @method studlyCase
* @param {String} string
* @return {String}
*/
utils.studlyCase = adjustWordCase(true, true, '');
/**
* Transform a string into camelCase
*
* @method camelCase
* @param {String} string
* @return {String}
*/
utils.camelCase = adjustWordCase(false, true, '');
/**
* Transform a string into snakeCase
*
* @method snakeCase
* @param {String} string
* @return {String}
*/
utils.snakeCase = adjustWordCase(false, false, '_');
/**
* Upper-case the string, return an empty string if any is not a string
*
* @param any {*} - Something or nothing
* @returns {string}
*/
utils.toUpperString = function (any) {
if (any) {
if (typeof any !== 'string') {
any = any.toString();
}
} else {
any = '';
}
return any.toUpperCase();
};
/**
* Test if a value is "numeric" meaning that it can be transformed into something besides NaN
*
* @method isNumeric
* @param {*} val
* @return {Boolean}
*/
utils.isNumeric = function (val) {
return _typeof(val) !== 'object' && val - parseFloat(val) >= 0;
}; // regexp to test for intervals
var intervalRE = /^(\d+(?:\.\d+)?)(M|w|d|h|m|s|y|ms)$/;
/**
* Test if a string represents an interval (eg. 1m, 2Y)
*
* @method isInterval
* @param {String} val
* @return {Boolean}
*/
utils.isInterval = function (val) {
return !!(val.match && val.match(intervalRE));
};
/**
* Repeat a string n times
*
* @todo TestPerformance
* @method repeat
* @param {String} what - The string to repeat
* @param {Number} times - Times the string should be repeated
* @return {String}
*/
utils.repeat = function (what, times) {
return new Array(times + 1).join(what);
};
/**
* Call a function, applying the arguments object to it in an optimized way, rather than always turning it into an array
*
* @param func {Function} - The function to execute
* @param context {*} - The context the function will be executed with
* @param args {Arguments} - The arguments to send to func
* @param [sliceIndex=0] {Integer} - The index that args should be sliced at, before feeding args to func
* @returns {*} - the return value of func
*/
utils.applyArgs = function (func, context, args, sliceIndex) {
sliceIndex = sliceIndex || 0;
switch (args.length - sliceIndex) {
case 0:
return func.call(context);
case 1:
return func.call(context, args[0 + sliceIndex]);
case 2:
return func.call(context, args[0 + sliceIndex], args[1 + sliceIndex]);
case 3:
return func.call(context, args[0 + sliceIndex], args[1 + sliceIndex], args[2 + sliceIndex]);
case 4:
return func.call(context, args[0 + sliceIndex], args[1 + sliceIndex], args[2 + sliceIndex], args[3 + sliceIndex]);
case 5:
return func.call(context, args[0 + sliceIndex], args[1 + sliceIndex], args[2 + sliceIndex], args[3 + sliceIndex], args[4 + sliceIndex]);
default:
return func.apply(context, Array.prototype.slice.call(args, sliceIndex));
}
};
/**
* Schedule a function to be called on the next tick, and supply it with these arguments
* when it is called.
* @return {[type]} [description]
*/
utils.nextTick = function (cb) {
// bind the function and schedule it
process.nextTick(_.bindKey(utils, 'applyArgs', cb, null, arguments, 1));
};
/**
* Marks a method as a handler. Currently this just makes a property on the method
* flagging it to be bound to the object at object creation when "makeBoundMethods" is called
*
* ```
* ClassName.prototype.methodName = utils.handler(function () {
* // this will always be bound when called via classInstance.bound.methodName
* this === classInstance
* });
* ```
*
* @param {Function} func - The method that is being defined
* @return {Function}
*/
utils.handler = function (func) {
func._provideBound = true;
return func;
};
/**
* Creates an "bound" property on an object, which all or a subset of methods from
* the object which are bound to the original object.
*
* ```
* var obj = {
* onEvent: function () {}
* };
*
* utils.makeBoundMethods(obj);
*
* obj.bound.onEvent() // is bound to obj, and can safely be used as an event handler.
* ```
*
* @param {Object} obj - The object to bind the methods to
*/
utils.makeBoundMethods = function (obj) {
obj.bound = {};
for (var prop in obj) {
// dearest maintainer, we want to look through the prototype
if (typeof obj[prop] === 'function' && obj[prop]._provideBound === true) {
obj.bound[prop] = _.bind(obj[prop], obj);
}
}
};
/**
* Implements the standard "string or constructor" check that I was copy/pasting everywhere
* @param {String|Function} val - the value that the user passed in
* @param {Object} opts - a map of the options
* @return {Function|undefined} - If a valid option was specified, then the constructor is returned
*/
utils.funcEnum = function (config, name, opts, def) {
var val = config[name];
switch (_typeof(val)) {
case 'undefined':
return opts[def];
case 'function':
return val;
case 'string':
if (opts.hasOwnProperty(val)) {
return opts[val];
}
/* falls through */
default:
var err = 'Invalid ' + name + ' "' + val + '", expected a function';
switch (_.size(opts)) {
case 0:
break;
case 1:
err += ' or ' + _.keys(opts)[0];
break;
default:
err += ' or one of ' + _.keys(opts).join(', ');
break;
}
throw new TypeError(err);
}
};
/**
* Accepts any object and attempts to convert it into an array. If the object passed in is not
* an array it will be wrapped in one. Then the transform/map function will be called for each element
* and create a new array that is returned. If the map function fails to return something, the loop is
* halted and false is returned instead of an array.
*
* @param {*} input - The value to convert
* @param {Function} transform - A function called for each element of the resulting array
* @return {Array|false} - an array on success, or false on failure.
*/
utils.createArray = function (input, transform) {
transform = typeof transform === 'function' ? transform : _.identity;
var output = [];
var item;
var i;
if (!_.isArray(input)) {
input = [input];
}
for (i = 0; i < input.length; i++) {
item = transform(input[i]);
if (item === void 0) {
return false;
} else {
output.push(item);
}
}
return output;
};
/**
* Takes a WritableStream, and returns the chunks that have not successfully written, returning them as a string.
*
* ONLY WORKS FOR TEXT STREAMS
*
* @param {WritableStream} stream - an instance of stream.Writable
* @return {string} - the remaining test to be written to the stream
*/
utils.getUnwrittenFromStream = function (stream) {
var writeBuffer = utils.getStreamWriteBuffer(stream);
if (!writeBuffer) return; // flush the write buffer
var out = '';
if (!writeBuffer.length) return out;
_.each(writeBuffer, function (writeReq) {
if (writeReq.chunk) {
// 0.9.12+ uses WriteReq objects with a chunk prop
out += '' + writeReq.chunk;
} else if (_.isArray(writeReq) && (typeof writeReq[0] === 'string' || Buffer.isBuffer(writeReq[0]))) {
// 0.9.4 - 0.9.9 buffers are arrays of arrays like [[chunk, cb], [chunk, undef], ...].
out += '' + writeReq[0];
} else {
return false;
}
});
return out;
};
utils.getStreamWriteBuffer = function (stream) {
if (!stream || !stream._writableState) return;
var writeState = stream._writableState;
if (writeState.getBuffer) {
return writeState.getBuffer();
} else if (writeState.buffer) {
return writeState.buffer;
}
};
utils.clearWriteStreamBuffer = function (stream) {
var buffer = utils.getStreamWriteBuffer(stream);
return buffer && buffer.splice(0);
};
/**
* return the current time in milliseconds since epoch
*/
utils.now = function () {
return typeof Date.now === 'function' ? Date.now() : new Date().getTime();
};
module.exports = utils;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3), __webpack_require__(12).Buffer))
/***/ }),
/* 3 */
/***/ (function(module, exports) {
// shim for using process in browser
var process = module.exports = {};
// cached from whatever global is present so that test runners that stub it
// don't break things. But we need to wrap it in a try catch in case it is
// wrapped in strict mode code which doesn't define any globals. It's inside a
// function because try/catches deoptimize in certain engines.
var cachedSetTimeout;
var cachedClearTimeout;
function defaultSetTimout() {
throw new Error('setTimeout has not been defined');
}
function defaultClearTimeout () {
throw new Error('clearTimeout has not been defined');
}
(function () {
try {
if (typeof setTimeout === 'function') {
cachedSetTimeout = setTimeout;
} else {
cachedSetTimeout = defaultSetTimout;
}
} catch (e) {
cachedSetTimeout = defaultSetTimout;
}
try {
if (typeof clearTimeout === 'function') {
cachedClearTimeout = clearTimeout;
} else {
cachedClearTimeout = defaultClearTimeout;
}
} catch (e) {
cachedClearTimeout = defaultClearTimeout;
}
} ())
function runTimeout(fun) {
if (cachedSetTimeout === setTimeout) {
//normal enviroments in sane situations
return setTimeout(fun, 0);
}
// if setTimeout wasn't available but was latter defined
if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
cachedSetTimeout = setTimeout;
return setTimeout(fun, 0);
}
try {
// when when somebody has screwed with setTimeout but no I.E. maddness
return cachedSetTimeout(fun, 0);
} catch(e){
try {
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
return cachedSetTimeout.call(null, fun, 0);
} catch(e){
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
return cachedSetTimeout.call(this, fun, 0);
}
}
}
function runClearTimeout(marker) {
if (cachedClearTimeout === clearTimeout) {
//normal enviroments in sane situations
return clearTimeout(marker);
}
// if clearTimeout wasn't available but was latter defined
if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
cachedClearTimeout = clearTimeout;
return clearTimeout(marker);
}
try {
// when when somebody has screwed with setTimeout but no I.E. maddness
return cachedClearTimeout(marker);
} catch (e){
try {
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
return cachedClearTimeout.call(null, marker);
} catch (e){
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
// Some versions of I.E. have different rules for clearTimeout vs setTimeout
return cachedClearTimeout.call(this, marker);
}
}
}
var queue = [];
var draining = false;
var currentQueue;
var queueIndex = -1;
function cleanUpNextTick() {
if (!draining || !currentQueue) {
return;
}
draining = false;
if (currentQueue.length) {
queue = currentQueue.concat(queue);
} else {
queueIndex = -1;
}
if (queue.length) {
drainQueue();
}
}
function drainQueue() {
if (draining) {
return;
}
var timeout = runTimeout(cleanUpNextTick);
draining = true;
var len = queue.length;
while(len) {
currentQueue = queue;
queue = [];
while (++queueIndex < len) {
if (currentQueue) {
currentQueue[queueIndex].run();
}
}
queueIndex = -1;
len = queue.length;
}
currentQueue = null;
draining = false;
runClearTimeout(timeout);
}
process.nextTick = function (fun) {
var args = new Array(arguments.length - 1);
if (arguments.length > 1) {
for (var i = 1; i < arguments.length; i++) {
args[i - 1] = arguments[i];
}
}
queue.push(new Item(fun, args));
if (queue.length === 1 && !draining) {
runTimeout(drainQueue);
}
};
// v8 likes predictible objects
function Item(fun, array) {
this.fun = fun;
this.array = array;
}
Item.prototype.run = function () {
this.fun.apply(null, this.array);
};
process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];
process.version = ''; // empty string to avoid regexp issues
process.versions = {};
function noop() {}
process.on = noop;
process.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = noop;
process.emit = noop;
process.prependListener = noop;
process.prependOnceListener = noop;
process.listeners = function (name) { return [] }
process.binding = function (name) {
throw new Error('process.binding is not supported');
};
process.cwd = function () { return '/' };
process.chdir = function (dir) {
throw new Error('process.chdir is not supported');
};
process.umask = function() { return 0; };
/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
var _ = __webpack_require__(0);
var utils = __webpack_require__(2);
var errors = module.exports;
var canCapture = typeof Error.captureStackTrace === 'function';
var canStack = !!new Error().stack;
function ErrorAbstract(msg, constructor, metadata) {
this.message = msg;
Error.call(this, this.message);
if (canCapture) {
Error.captureStackTrace(this, constructor);
} else if (canStack) {
this.stack = new Error().stack;
} else {
this.stack = '';
}
if (metadata) {
_.assign(this, metadata);
this.toString = function () {
return msg + ' :: ' + JSON.stringify(metadata);
};
this.toJSON = function () {
return _.assign({
msg: msg
}, metadata);
};
}
}
errors._Abstract = ErrorAbstract;
utils.inherits(ErrorAbstract, Error);
/**
* Connection Error
* @param {String} [msg] - An error message that will probably end up in a log.
*/
errors.ConnectionFault = function ConnectionFault(msg) {
ErrorAbstract.call(this, msg || 'Connection Failure', errors.ConnectionFault);
};
utils.inherits(errors.ConnectionFault, ErrorAbstract);
/**
* No Living Connections
* @param {String} [msg] - An error message that will probably end up in a log.
*/
errors.NoConnections = function NoConnections(msg) {
ErrorAbstract.call(this, msg || 'No Living connections', errors.NoConnections);
};
utils.inherits(errors.NoConnections, ErrorAbstract);
/**
* Generic Error
* @param {String} [msg] - An error message that will probably end up in a log.
*/
errors.Generic = function Generic(msg, metadata) {
ErrorAbstract.call(this, msg || 'Generic Error', errors.Generic, metadata);
};
utils.inherits(errors.Generic, ErrorAbstract);
/**
* Request Timeout Error
* @param {String} [msg] - An error message that will probably end up in a log.
*/
errors.RequestTimeout = function RequestTimeout(msg) {
ErrorAbstract.call(this, msg || 'Request Timeout', errors.RequestTimeout);
};
utils.inherits(errors.RequestTimeout, ErrorAbstract);
/**
* Request Body could not be parsed
* @param {String} [msg] - An error message that will probably end up in a log.
*/
errors.Serialization = function Serialization(msg) {
ErrorAbstract.call(this, msg || 'Unable to parse/serialize body', errors.Serialization);
};
utils.inherits(errors.Serialization, ErrorAbstract);
/**
* Thrown when a browser compatability issue is detected (cough, IE, cough)
*/
errors.RequestTypeError = function RequestTypeError(feature) {
ErrorAbstract.call(this, 'Cross-domain AJAX requests ' + feature + ' are not supported', errors.RequestTypeError);
};
utils.inherits(errors.RequestTypeError, ErrorAbstract);
var statusCodes = [[300, 'Multiple Choices'], [301, 'Moved Permanently'], [302, 'Found'], [303, 'See Other'], [304, 'Not Modified'], [305, 'Use Proxy'], [307, 'Temporary Redirect'], [308, 'Permanent Redirect'], [400, 'Bad Request'], [401, 'Authentication Exception'], [402, 'Payment Required'], [403, ['Authorization Exception', 'Forbidden']], [404, 'Not Found'], [405, 'Method Not Allowed'], [406, 'Not Acceptable'], [407, 'Proxy Authentication Required'], [408, 'Request Timeout'], [409, 'Conflict'], [410, 'Gone'], [411, 'Length Required'], [412, 'Precondition Failed'], [413, 'Request Entity Too Large'], [414, 'Request URIToo Long'], [415, 'Unsupported Media Type'], [416, 'Requested Range Not Satisfiable'], [417, 'Expectation Failed'], [418, 'Im ATeapot'], [421, 'Too Many Connections From This IP'], [426, 'Upgrade Required'], [429, 'Too Many Requests'], [450, 'Blocked By Windows Parental Controls'], [494, 'Request Header Too Large'], [497, 'HTTPTo HTTPS'], [499, 'Client Closed Request'], [500, 'Internal Server Error'], [501, 'Not Implemented'], [502, 'Bad Gateway'], [503, 'Service Unavailable'], [504, 'Gateway Timeout'], [505, 'HTTPVersion Not Supported'], [506, 'Variant Also Negotiates'], [510, 'Not Extended']];
_.each(statusCodes, function createStatusCodeError(tuple) {
var status = tuple[0];
var names = tuple[1];
var allNames = [].concat(names, status);
var primaryName = allNames[0];
var className = utils.studlyCase(primaryName);
allNames = _.uniq(allNames.concat(className));
function StatusCodeError(msg, metadata) {
this.status = status;
this.displayName = className;
var esErrObject = null;
if (_.isPlainObject(msg)) {
esErrObject = msg;
msg = null;
}
if (!esErrObject) {
// errors from es now come in two forms, an error string < 2.0 and
// an object >= 2.0
// TODO: remove after dropping support for < 2.0
ErrorAbstract.call(this, msg || primaryName, StatusCodeError, metadata);
return this;
}
msg = [].concat(esErrObject.root_cause || []).reduce(function (memo, cause) {
if (memo) memo += ' (and) ';
memo += '[' + cause.type + '] ' + cause.reason;
var extraData = _.omit(cause, ['type', 'reason']);
if (_.size(extraData)) {
memo += ', with ' + prettyPrint(extraData);
}
return memo;
}, '');
if (!msg) {
if (esErrObject.type) msg += '[' + esErrObject.type + '] ';
if (esErrObject.reason) msg += esErrObject.reason;
}
ErrorAbstract.call(this, msg || primaryName, StatusCodeError, metadata);
return this;
}
utils.inherits(StatusCodeError, ErrorAbstract);
allNames.forEach(function (name) {
errors[name] = StatusCodeError;
});
});
function prettyPrint(data) {
var path = [];
return function print(v) {
if (_typeof(v) === 'object') {
if (path.indexOf(v) > -1) return '[circular]';
path.push(v);
try {
return '{ ' + _.map(v, function (subv, name) {
return name + '=' + print(subv);
}).join(' & ') + ' }';
} finally {
path.pop();
}
} else {
return JSON.stringify(v);
}
}(data);
}
/***/ }),
/* 5 */
/***/ (function(module, exports) {
var g;
// This works in non-strict mode
g = (function() {
return this;
})();
try {
// This works if eval is allowed (see CSP)
g = g || Function("return this")() || (1,eval)("this");
} catch(e) {
// This works if the window reference is available
if(typeof window === "object")
g = window;
}
// g can still be undefined, but nothing to do about it...
// We return undefined, instead of nothing here, so it's
// easier to handle this case. if(!global) { ...}
module.exports = g;
/***/ }),
/* 6 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(process) {
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
var _ = __webpack_require__(0);
var utils = __webpack_require__(2);
var url = __webpack_require__(13);
var EventEmitter = __webpack_require__(15).EventEmitter;
/**
* Log bridge, which is an [EventEmitter](http://nodejs.org/api/events.html#events_class_events_eventemitter)
* that sends events to one or more outputs/loggers. Setup these loggers by
* specifying their config as the first argument, or by passing it to addOutput().
*
* @class Log
* @uses Loggers.Stdio
* @constructor
* @param {object} config
* @param {string|Object|ArrayOfStrings|ArrayOfObjects} config.log - Either the level
* to setup a single logger, a full config object for a logger, or an array of
* config objects to use for creating log outputs.
* @param {string|array} config.log.level|config.log.levels - One or more keys in Log.levels (error, warning, etc.)
* @param {string} config.log.type - The name of the logger to use for this output
*/
function Log(config) {
config = config || {};
if (!config.log) return;
var i;
var outputs;
if (utils.isArrayOfStrings(config.log)) {
outputs = [{
levels: config.log
}];
} else {
outputs = utils.createArray(config.log, function (val) {
if (_.isPlainObject(val)) {
return val;
}
if (typeof val === 'string') {
return {
level: val
};
}
});
}
if (!outputs) {
throw new TypeError('Invalid logging output config. Expected either a log level, array of log levels, ' + 'a logger config object, or an array of logger config objects.');
}
for (i = 0; i < outputs.length; i++) {
this.addOutput(outputs[i]);
}
}
utils.inherits(Log, EventEmitter);
Log.loggers = __webpack_require__(16);
Log.prototype.close = function () {
this.emit('closing');
if (this.listenerCount()) {
console.error('Something is still listening for log events, but the logger is closing.'); // eslint-disable-line no-console
this.clearAllListeners();
}
};
if (EventEmitter.prototype.listenerCount) {
// If the event emitter implements it's own listenerCount method
// we don't need to (newer nodes do this).
Log.prototype.listenerCount = EventEmitter.prototype.listenerCount;
} else if (EventEmitter.listenerCount) {
// some versions of node expose EventEmitter::listenerCount
// which is more efficient the getting all listeners of a
// specific type
Log.prototype.listenerCount = function (event) {
return EventEmitter.listenerCount(this, event);
};
} else {
// all other versions of node expose a #listeners() method, which returns
// and array we have to count
Log.prototype.listenerCount = function (event) {
return this.listeners(event).length;
};
}
/**
* Levels observed by the loggers, ordered by rank
*
* @property levels
* @type Array
* @static
*/
Log.levels = [
/**
* Event fired for error level log entries
* @event error
* @param {Error} error - The error object to log
*/
'error',
/**
* Event fired for "warning" level log entries, which usually represent things
* like correctly formatted error responses from ES (400, ...) and recoverable
* errors (one node unresponsive)
*
* @event warning
* @param {String} message - A message to be logged
*/
'warning',
/**
* Event fired for "info" level log entries, which usually describe what a
* client is doing (sniffing etc)
*
* @event info
* @param {String} message - A message to be logged
*/
'info',
/**
* Event fired for "debug" level log entries, which will describe requests sent,
* including their url (no data, response codes, or exec times)
*
* @event debug
* @param {String} message - A message to be logged
*/
'debug',
/**
* Event fired for "trace" level log entries, which provide detailed information
* about each request made from a client, including reponse codes, execution times,
* and a full curl command that can be copied and pasted into a terminal
*
* @event trace
* @param {String} method method, , body, responseStatus, responseBody
* @param {String} url - The url the request was made to
* @param {String} body - The body of the request
* @param {Integer} responseStatus - The status code returned from the response
* @param {String} responseBody - The body of the response
*/
'trace'];
/**
* Converts a log config value (string or array) to an array of level names which
* it represents
*
* @method parseLevels
* @static
* @private
* @param {String|ArrayOfStrings} input - Cound be a string to specify the max
* level, or an array of exact levels
* @return {Array} -
*/
Log.parseLevels = function (input) {
switch (_typeof(input)) {
case 'string':
var i = _.indexOf(Log.levels, input);
if (i >= 0) {
return Log.levels.slice(0, i + 1);
}
/* fall through */
case 'object':
if (_.isArray(input)) {
var valid = _.intersection(input, Log.levels);
if (valid.length === input.length) {
return valid;
}
}
/* fall through */
default:
throw new TypeError('invalid logging level ' + input + '. Expected zero or more of these options: ' + Log.levels.join(', '));
}
};
/**
* Combine the array-like param into a simple string
*
* @method join
* @static
* @private
* @param {*} arrayish - An array like object that can be itterated by _.each
* @return {String} - The final string.
*/
Log.join = function (arrayish) {
return _.map(arrayish, function (item) {
if (_.isPlainObject(item)) {
return JSON.stringify(item, null, 2) + '\n';
} else {
return item.toString();
}
}).join(' ');
};
/**
* Create a new logger, based on the config.
*
* @method addOutput
* @param {object} config - An object with config options for the logger.
* @param {String} [config.type=stdio] - The name of an output/logger. Options
* can be found in the `src/loggers` directory.
* @param {String|ArrayOfStrings} [config.level|config.levels=warning] - The levels to output
* to this logger, when an array is specified no levels other than the ones
* specified will be listened to. When a string is specified, that and all lower
* levels will be logged.
* @return {Logger}
*/
Log.prototype.addOutput = function (config) {
config = config || {}; // force "levels" key
config.levels = Log.parseLevels(config.levels || config.level || 'warning');
delete config.level;
var Logger = utils.funcEnum(config, 'type', Log.loggers, process.browser ? 'console' : 'stdio');
return new Logger(this, config);
};
/**
* Log an error
*
* @method error
* @param {Error|String} error The Error to log
* @return {Boolean} - True if any outputs accepted the message
*/
Log.prototype.error = function (e) {
if (this.listenerCount('error')) {
return this.emit('error', e instanceof Error ? e : new Error(e));
}
};
/**
* Log a warning message
*
* @method warning
* @param {*} msg* - Any amount of messages that will be joined before logged
* @return {Boolean} - True if any outputs accepted the message
*/
Log.prototype.warning = function ()
/* ...msg */
{
if (this.listenerCount('warning')) {
return this.emit('warning', Log.join(arguments));
}
};
/**
* Log useful info about what's going on
*
* @method info
* @param {*} msg* - Any amount of messages that will be joined before logged
* @return {Boolean} - True if any outputs accepted the message
*/
Log.prototype.info = function ()
/* ...msg */
{
if (this.listenerCount('info')) {
return this.emit('info', Log.join(arguments));
}
};
/**
* Log a debug level message
*
* @method debug
* @param {*} msg* - Any amount of messages that will be joined before logged
* @return {Boolean} - True if any outputs accepted the message
*/
Log.prototype.debug = function ()
/* ...msg */
{
if (this.listenerCount('debug')) {
return this.emit('debug', Log.join(arguments));
}
};
/**
* Log a trace level message
*
* @method trace
* @param {String} method - HTTP request method
* @param {String|Object} requestUrl - URL requested. If the value is an object,
* it is expected to be the return value of Node's url.parse()
* @param {String} body - The request's body
* @param {String} responseBody - body returned from ES
* @param {String} responseStatus - HTTP status code
* @return {Boolean} - True if any outputs accepted the message
*/
Log.prototype.trace = function (method, requestUrl, body, responseBody, responseStatus) {
if (this.listenerCount('trace')) {
return this.emit('trace', Log.normalizeTraceArgs(method, requestUrl, body, responseBody, responseStatus));
}
};
Log.normalizeTraceArgs = function (method, requestUrl, body, responseBody, responseStatus) {
if (typeof requestUrl === 'string') {
requestUrl = url.parse(requestUrl, true, true);
} else {
requestUrl = _.clone(requestUrl);
if (requestUrl.path) {
requestUrl.query = url.parse(requestUrl.path, true, false).query;
}
if (!requestUrl.pathname && requestUrl.path) {
requestUrl.pathname = requestUrl.path.split('?').shift();
}
}
delete requestUrl.auth;
return {
method: method,
url: url.format(requestUrl),
body: body,
status: responseStatus,
response: responseBody
};
};
module.exports = Log;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
/***/ }),
/* 7 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(process) {
/**
* Class that manages making request, called by all of the API methods.
* @type {[type]}
*/
module.exports = Transport;
var _ = __webpack_require__(0);
var utils = __webpack_require__(2);
var errors = __webpack_require__(4);
var Host = __webpack_require__(8);
var patchSniffOnConnectionFault = __webpack_require__(37);
var findCommonProtocol = __webpack_require__(38);
function Transport(config) {
var self = this;
config = self._config = config || {};
var LogClass = typeof config.log === 'function' ? config.log : __webpack_require__(6);
config.log = self.log = new LogClass(config); // setup the connection pool
var ConnectionPool = utils.funcEnum(config, 'connectionPool', Transport.connectionPools, 'main');
self.connectionPool = new ConnectionPool(config); // setup the serializer
var Serializer = utils.funcEnum(config, 'serializer', Transport.serializers, 'json');
self.serializer = new Serializer(config); // setup the nodesToHostCallback
self.nodesToHostCallback = utils.funcEnum(config, 'nodesToHostCallback', Transport.nodesToHostCallbacks, 'main'); // setup max retries
self.maxRetries = config.hasOwnProperty('maxRetries') ? config.maxRetries : 3; // setup endpoint to use for sniffing
self.sniffEndpoint = config.hasOwnProperty('sniffEndpoint') ? config.sniffEndpoint : '/_nodes/_all/http'; // setup requestTimeout default
self.requestTimeout = config.hasOwnProperty('requestTimeout') ? config.requestTimeout : 30000;
if (config.hasOwnProperty('defer')) {
self.defer = config.defer;
} // randomizeHosts option
var randomizeHosts = config.hasOwnProperty('randomizeHosts') ? !!config.randomizeHosts : true;
if (config.host) {
config.hosts = config.host;
}
if (config.hosts) {
var hostsConfig = utils.createArray(config.hosts, function (val) {
if (_.isPlainObject(val) || _.isString(val) || val instanceof Host) {
return val;
}
});
if (!hostsConfig) {
throw new TypeError('Invalid hosts config. Expected a URL, an array of urls, a host config object, ' + 'or an array of host config objects.');
}
if (randomizeHosts) {
hostsConfig = _.shuffle(hostsConfig);
}
self.setHosts(hostsConfig);
}
if (config.hasOwnProperty('sniffedNodesProtocol')) {
self.sniffedNodesProtocol = config.sniffedNodesProtocol || null;
} else {
self.sniffedNodesProtocol = findCommonProtocol(self.connectionPool.getAllHosts()) || null;
}
if (config.hasOwnProperty('sniffedNodesFilterPath')) {
self.sniffedNodesFilterPath = config.sniffedNodesFilterPath;
} else {
self.sniffedNodesFilterPath = ['nodes.*.http.publish_address', 'nodes.*.name', 'nodes.*.hostname', 'nodes.*.host', 'nodes.*.version'].join(',');
}
if (config.sniffOnStart) {
self.sniff();
}
if (config.sniffInterval) {
self._timeout(function doSniff() {
self.sniff();
self._timeout(doSniff, config.sniffInterval);
}, config.sniffInterval);
}
if (config.sniffOnConnectionFault) {
patchSniffOnConnectionFault(self);
}
}
Transport.connectionPools = {
main: __webpack_require__(9)
};
Transport.serializers = __webpack_require__(21);
Transport.nodesToHostCallbacks = {
main: __webpack_require__(23)
};
Transport.prototype.defer = function () {
if (typeof Promise === 'undefined') {
throw new Error('No Promise implementation found. In order for elasticsearch-js to create promises ' + 'either specify the `defer` configuration or include a global Promise shim');
}
var defer = {};
defer.promise = new Promise(function (resolve, reject) {
defer.resolve = resolve;
defer.reject = reject;
});
return defer;
};
/**
* Perform a request with the client's transport
*
* @method request
* @todo async body writing
* @todo abort
* @todo access to custom headers, modifying of request in general
* @param {object} params
* @param {Number} params.requestTimeout - timeout for the entire request (inculding all retries)
* @param {Number} params.maxRetries - number of times to re-run request if the
* original node chosen can not be connected to.
* @param {string} [params.path="/"] - URL pathname. Do not include query string.
* @param {string|object} [params.query] - Query string.
* @param {String} params.method - The HTTP method for the request
* @param {String} params.body - The body of the HTTP request
* @param {Function} cb - A function to call back with (error, responseBody, responseStatus)
*/
Transport.prototype.request = function (params, cb) {
var self = this;
var remainingRetries = this.maxRetries;
var requestTimeout = this.requestTimeout;
var connection; // set in sendReqWithConnection
var aborted = false; // several connector will respond with an error when the request is aborted
var requestAborter; // an abort function, returned by connection#request()
var requestTimeoutId; // the id of the ^timeout
var ret; // the object returned to the user, might be a promise
var defer; // the defer object, will be set when we are using promises.
var body = params.body;
var headers = !params.headers ? {} : _.transform(params.headers, function (headers, val, name) {
headers[String(name).toLowerCase()] = val;
});
self.log.debug('starting request', params); // determine the response based on the presense of a callback
if (typeof cb === 'function') {
// handle callbacks within a domain
if (process.domain) {
cb = process.domain.bind(cb);
}
ret = {
abort: abortRequest
};
} else {
defer = this.defer();
ret = defer.promise;
ret.abort = abortRequest;
}
if (body && params.method === 'GET') {
utils.nextTick(respond, new TypeError('Body can not be sent with method "GET"'));
return ret;
} // serialize the body
if (body) {
var serializer = self.serializer;
var serializeFn = serializer[params.bulkBody ? 'bulkBody' : 'serialize'];
body = serializeFn.call(serializer, body);
if (!headers['content-type']) {
headers['content-type'] = serializeFn.contentType;
}
}
if (params.hasOwnProperty('maxRetries')) {
remainingRetries = params.maxRetries;
}
if (params.hasOwnProperty('requestTimeout')) {
requestTimeout = params.requestTimeout;
}
params.req = {
method: params.method,
path: params.path || '/',
query: params.query,
body: body,
headers: headers
};
function sendReqWithConnection(err, _connection) {
if (aborted) {
return;
}
if (err) {
respond(err);
} else if (_connection) {
connection = _connection;
requestAborter = connection.request(params.req, checkRespForFailure);
} else {
self.log.warning('No living connections');
respond(new errors.NoConnections());
}
}
function checkRespForFailure(err, body, status, headers) {
if (aborted) {
return;
}
requestAborter = void 0;
if (err instanceof errors.RequestTypeError) {
self.log.error('Connection refused to execute the request', err);
respond(err, body, status, headers);
return;
}
if (err) {
connection.setStatus('dead');
var errMsg = err.message || '';
errMsg = '\n' + params.req.method + ' ' + connection.host.makeUrl(params.req) + (errMsg.length ? ' => ' : '') + errMsg;
if (remainingRetries) {
remainingRetries--;
self.log.error('Request error, retrying' + errMsg);
self.connectionPool.select(sendReqWithConnection);
} else {
self.log.error('Request complete with error' + errMsg);
respond(new errors.ConnectionFault(err));
}
} else {
self.log.debug('Request complete');
respond(void 0, body, status, headers);
}
}
function respond(err, body, status, headers) {
if (aborted) {
return;
}
self._timeout(requestTimeoutId);
var parsedBody;
var isJson = !headers || headers['content-type'] && ~headers['content-type'].indexOf('application/json');
if (!err && body) {
if (isJson) {
parsedBody = self.serializer.deserialize(body);
if (parsedBody == null) {
err = new errors.Serialization();
parsedBody = body;
}
} else {
parsedBody = body;
}
} // does the response represent an error?
if ((!err || err instanceof errors.Serialization) && (status < 200 || status >= 300) && (!params.ignore || !_.includes(params.ignore, status))) {
var errorMetadata = _.pick(params.req, ['path', 'query', 'body']);
errorMetadata.statusCode = status;
errorMetadata.response = body;
if (status === 401 && headers && headers['www-authenticate']) {
errorMetadata.wwwAuthenticateDirective = headers['www-authenticate'];
}
if (errors[status]) {
err = new errors[status](parsedBody && parsedBody.error, errorMetadata);
} else {
err = new errors.Generic('unknown error', errorMetadata);
}
} // can we cast notfound to false?
if (params.castExists) {
if (err && err instanceof errors.NotFound) {
parsedBody = false;
err = void 0;
} else {
parsedBody = !err;
}
} // how do we send the response?
if (typeof cb === 'function') {
if (err) {
cb(err, parsedBody, status);
} else {
cb(void 0, parsedBody, status);
}
} else if (err) {
err.body = parsedBody;
err.status = status;
defer.reject(err);
} else {
defer.resolve(parsedBody);
}
}
function abortRequest() {
if (aborted) {
return;
}
aborted = true;
remainingRetries = 0;
self._timeout(requestTimeoutId);
if (typeof requestAborter === 'function') {
requestAborter();
}
}
if (requestTimeout && requestTimeout !== Infinity) {
requestTimeoutId = this._timeout(function () {
respond(new errors.RequestTimeout('Request Timeout after ' + requestTimeout + 'ms'));
abortRequest();
}, requestTimeout);
}
if (connection) {
sendReqWithConnection(void 0, connection);
} else {
self.connectionPool.select(sendReqWithConnection);
}
return ret;
};
Transport.prototype._timeout = function (cb, delay) {
if (this.closed) return;
var id;
var timers = this._timers || (this._timers = []);
if ('function' !== typeof cb) {
id = cb;
cb = void 0;
}
if (cb) {
// set the timer
id = setTimeout(function () {
_.pull(timers, id);
cb();
}, delay);
timers.push(id);
return id;
}
if (id) {
clearTimeout(id);
var i = this._timers.indexOf(id);
if (i !== -1) {
this._timers.splice(i, 1);
}
}
};
/**
* Ask an ES node for a list of all the nodes, add/remove nodes from the connection
* pool as appropriate
*
* @param {Function} cb - Function to call back once complete
*/
Transport.prototype.sniff = function (cb) {
var self = this;
var nodesToHostCallback = this.nodesToHostCallback;
var log = this.log;
var sniffedNodesProtocol = this.sniffedNodesProtocol;
var sniffedNodesFilterPath = this.sniffedNodesFilterPath; // make cb a function if it isn't
cb = typeof cb === 'function' ? cb : _.noop;
this.request({
path: this.sniffEndpoint,
query: {
filter_path: sniffedNodesFilterPath
},
method: 'GET'
}, function (err, resp, status) {
if (!err && resp && resp.nodes) {
var hostsConfigs;
try {
hostsConfigs = nodesToHostCallback(resp.nodes);
} catch (e) {
log.error(new Error('Unable to convert node list from ' + self.sniffEndpoint + ' to hosts durring sniff. Encountered error:\n' + (e.stack || e.message)));
return;
}
_.forEach(hostsConfigs, function (hostConfig) {
if (sniffedNodesProtocol) hostConfig.protocol = sniffedNodesProtocol;
});
self.setHosts(hostsConfigs);
}
cb(err, resp, status);
});
};
/**
* Set the host list that the transport should use.
*
* @param {Array<HostConfig>} hostsConfigs - an array of Hosts, or configuration objects
* that will be used to create Host objects.
*/
Transport.prototype.setHosts = function (hostsConfigs) {
var globalConfig = this._config;
this.connectionPool.setHosts(_.map(hostsConfigs, function (conf) {
return conf instanceof Host ? conf : new Host(conf, globalConfig);
}));
};
/**
* Close the Transport, which closes the logs and connection pool
* @return {[type]} [description]
*/
Transport.prototype.close = function () {
this.log.close();
this.closed = true;
_.each(this._timers, clearTimeout);
this._timers = null;
this.connectionPool.close();
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
/***/ }),
/* 8 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(Buffer) {
/**
* Class to wrap URLS, formatting them and maintaining their separate details
* @type {[type]}
*/
module.exports = Host;
var url = __webpack_require__(13);
var qs = __webpack_require__(14);
var _ = __webpack_require__(0);
var utils = __webpack_require__(2);
var startsWithProtocolRE = /^([a-z]+:)?\/\//;
var defaultProto = 'http:';
var btoa;
if (typeof window !== 'undefined' && typeof window.location !== 'undefined') {
defaultProto = window.location.protocol;
btoa = window.btoa;
}
btoa = btoa || function (data) {
return new Buffer(data, 'utf8').toString('base64');
};
var urlParseFields = ['protocol', 'hostname', 'pathname', 'port', 'auth', 'query'];
var simplify = ['host', 'path'];
var sslDefaults = {
pfx: null,
key: null,
passphrase: null,
cert: null,
ca: null,
ciphers: null,
rejectUnauthorized: false,
secureProtocol: null
}; // simple reference used when formatting as a url
// and defines when parsing from a string
Host.defaultPorts = {
http: 80,
https: 443
};
function Host(config, globalConfig) {
config = _.clone(config || {});
globalConfig = globalConfig || {}; // defaults
this.protocol = 'http';
this.host = 'localhost';
this.path = '';
this.port = 9200;
this.query = null;
this.headers = null;
this.suggestCompression = !!globalConfig.suggestCompression;
this.ssl = _.defaults({}, config.ssl || {}, globalConfig.ssl || {}, sslDefaults);
if (typeof config === 'string') {
var firstColon = config.indexOf(':');
var firstSlash = config.indexOf('/');
var noSlash = firstSlash === -1;
var portNoPath = firstColon > -1 && noSlash;
var portWithPath = !portNoPath && firstColon < firstSlash;
if ((noSlash || portNoPath || portWithPath) && !startsWithProtocolRE.test(config)) {
config = defaultProto + '//' + config;
}
config = _.pick(url.parse(config, false, true), urlParseFields); // default logic for the port is to use 9200 for the default. When a string is specified though,
// we will use the default from the protocol of the string.
if (!config.port) {
var proto = config.protocol || 'http';
if (proto.charAt(proto.length - 1) === ':') {
proto = proto.substring(0, proto.length - 1);
}
if (Host.defaultPorts[proto]) {
config.port = Host.defaultPorts[proto];
}
}
}
if (_.isObject(config)) {
// move hostname/portname to host/port semi-intelligently.
_.each(simplify, function (to) {
var from = to + 'name';
if (config[from] && config[to]) {
if (config[to].indexOf(config[from]) === 0) {
config[to] = config[from];
}
} else if (config[from]) {
config[to] = config[from];
}
delete config[from];
});
} else {
config = {};
}
if (!config.auth && globalConfig.httpAuth) {
config.auth = globalConfig.httpAuth;
}
if (config.auth) {
config.headers = config.headers || {};
config.headers.Authorization = 'Basic ' + btoa(config.auth);
delete config.auth;
}
_.forOwn(config, _.bind(function (val, prop) {
if (val != null) this[prop] = _.clone(val);
}, this)); // make sure the query string is parsed
if (this.query === null) {
// majority case
this.query = {};
} else if (!_.isPlainObject(this.query)) {
this.query = qs.parse(this.query);
} // make sure that the port is a number
if (utils.isNumeric(this.port)) {
this.port = parseInt(this.port, 10);
} else {
this.port = 9200;
} // make sure the path starts with a leading slash
if (this.path === '/') {
this.path = '';
} else if (this.path && this.path.charAt(0) !== '/') {
this.path = '/' + (this.path || '');
} // strip trailing ':' on the protocol (when config comes from url.parse)
if (this.protocol.substr(-1) === ':') {
this.protocol = this.protocol.substring(0, this.protocol.length - 1);
}
}
Host.prototype.makeUrl = function (params) {
params = params || {}; // build the port
var port = '';
if (this.port !== Host.defaultPorts[this.protocol]) {
// add an actual port
port = ':' + this.port;
} // build the path
var path = '' + (this.path || '') + (params.path || ''); // if path doesn't start with '/' add it.
if (path.charAt(0) !== '/') {
path = '/' + path;
} // build the query string
var query = qs.stringify(this.getQuery(params.query));
if (this.host) {
return this.protocol + '://' + this.host + port + path + (query ? '?' + query : '');
} else {
return path + (query ? '?' + query : '');
}
};
function objectPropertyGetter(prop, preOverride) {
return function (overrides) {
if (preOverride) {
overrides = preOverride.call(this, overrides);
}
var obj = this[prop];
if (!obj && !overrides) {
return null;
}
if (overrides) {
obj = _.assign({}, obj, overrides);
}
return _.size(obj) ? obj : null;
};
}
Host.prototype.getHeaders = objectPropertyGetter('headers', function (overrides) {
if (!this.suggestCompression) {
return overrides;
}
return _.defaults(overrides || {}, {
'Accept-Encoding': 'gzip,deflate'
});
});
Host.prototype.getQuery = objectPropertyGetter('query', function (query) {
return typeof query === 'string' ? qs.parse(query) : query;
});
Host.prototype.toString = function () {
return this.makeUrl();
};
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(12).Buffer))
/***/ }),
/* 9 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(process) {
/**
* Manager of connections to a node(s), capable of ensuring that connections are clear and living
* before providing them to the application
*
* @class ConnectionPool
* @constructor
* @param {Object} config - The config object passed to the transport.
*/
module.exports = ConnectionPool;
var _ = __webpack_require__(0);
var utils = __webpack_require__(2);
var Log = __webpack_require__(6);
function ConnectionPool(config) {
config = config || {};
utils.makeBoundMethods(this);
if (!config.log) {
this.log = new Log();
config.log = this.log;
} else {
this.log = config.log;
} // we will need this when we create connections down the road
this._config = config; // get the selector config var
this.selector = utils.funcEnum(config, 'selector', ConnectionPool.selectors, ConnectionPool.defaultSelector); // get the connection class
this.Connection = utils.funcEnum(config, 'connectionClass', ConnectionPool.connectionClasses, ConnectionPool.defaultConnectionClass); // time that connections will wait before being revived
this.deadTimeout = config.hasOwnProperty('deadTimeout') ? config.deadTimeout : 60000;
this.maxDeadTimeout = config.hasOwnProperty('maxDeadTimeout') ? config.maxDeadTimeout : 18e5;
this.calcDeadTimeout = utils.funcEnum(config, 'calcDeadTimeout', ConnectionPool.calcDeadTimeoutOptions, 'exponential'); // a map of connections to their "id" property, used when sniffing
this.index = {};
this._conns = {
alive: [],
dead: []
}; // information about timeouts for dead connections
this._timeouts = [];
} // selector options
ConnectionPool.selectors = __webpack_require__(18);
ConnectionPool.defaultSelector = 'roundRobin'; // get the connection options
ConnectionPool.connectionClasses = __webpack_require__(19);
ConnectionPool.defaultConnectionClass = ConnectionPool.connectionClasses._default;
delete ConnectionPool.connectionClasses._default; // the function that calculates timeouts based on attempts
ConnectionPool.calcDeadTimeoutOptions = {
flat: function flat(attempt, baseTimeout) {
return baseTimeout;
},
exponential: function exponential(attempt, baseTimeout) {
return Math.min(baseTimeout * 2 * Math.pow(2, attempt * 0.5 - 1), this.maxDeadTimeout);
}
};
/**
* Selects a connection from the list using the this.selector
* Features:
* - detects if the selector is async or not
* - sync selectors should still return asynchronously
* - catches errors in sync selectors
* - automatically selects the first dead connection when there no living connections
*
* @param {Function} cb [description]
* @return {[type]} [description]
*/
ConnectionPool.prototype.select = function (cb) {
if (this._conns.alive.length) {
if (this.selector.length > 1) {
this.selector(this._conns.alive, cb);
} else {
try {
utils.nextTick(cb, void 0, this.selector(this._conns.alive));
} catch (e) {
cb(e);
}
}
} else if (this._timeouts.length) {
this._selectDeadConnection(cb);
} else {
utils.nextTick(cb, void 0);
}
};
/**
* Handler for the "set status" event emitted but the connections. It will move
* the connection to it's proper connection list (unless it was closed).
*
* @param {String} status - the connection's new status
* @param {String} oldStatus - the connection's old status
* @param {ConnectionAbstract} connection - the connection object itself
*/
ConnectionPool.prototype.onStatusSet = utils.handler(function (status, oldStatus, connection) {
var index;
var died = status === 'dead';
var wasAlreadyDead = died && oldStatus === 'dead';
var revived = !died && oldStatus === 'dead';
var noChange = oldStatus === status;
var from = this._conns[oldStatus];
var to = this._conns[status];
if (noChange && !died) {
return true;
}
if (from !== to) {
if (_.isArray(from)) {
index = from.indexOf(connection);
if (index !== -1) {
from.splice(index, 1);
}
}
if (_.isArray(to)) {
index = to.indexOf(connection);
if (index === -1) {
to.push(connection);
}
}
}
if (died) {
this._onConnectionDied(connection, wasAlreadyDead);
}
if (revived) {
this._onConnectionRevived(connection);
}
});
/**
* Handler used to clear the times created when a connection dies
* @param {ConnectionAbstract} connection
*/
ConnectionPool.prototype._onConnectionRevived = function (connection) {
var timeout;
for (var i = 0; i < this._timeouts.length; i++) {
if (this._timeouts[i].conn === connection) {
timeout = this._timeouts[i];
if (timeout.id) {
clearTimeout(timeout.id);
}
this._timeouts.splice(i, 1);
break;
}
}
};
/**
* Handler used to update or create a timeout for the connection which has died
* @param {ConnectionAbstract} connection
* @param {Boolean} alreadyWasDead - If the connection was preivously dead this must be set to true
*/
ConnectionPool.prototype._onConnectionDied = function (connection, alreadyWasDead) {
var timeout;
if (alreadyWasDead) {
for (var i = 0; i < this._timeouts.length; i++) {
if (this._timeouts[i].conn === connection) {
timeout = this._timeouts[i];
break;
}
}
} else {
timeout = {
conn: connection,
attempt: 0,
revive: function revive(cb) {
timeout.attempt++;
connection.ping(function (err) {
connection.setStatus(err ? 'dead' : 'alive');
if (cb && typeof cb === 'function') {
cb(err);
}
});
}
};
this._timeouts.push(timeout);
}
if (timeout.id) {
clearTimeout(timeout.id);
}
var ms = this.calcDeadTimeout(timeout.attempt, this.deadTimeout);
timeout.id = setTimeout(timeout.revive, ms);
timeout.runAt = utils.now() + ms;
};
ConnectionPool.prototype._selectDeadConnection = function (cb) {
var orderedTimeouts = _.sortBy(this._timeouts, 'runAt');
var log = this.log;
process.nextTick(function next() {
var timeout = orderedTimeouts.shift();
if (!timeout) {
cb(void 0);
return;
}
if (!timeout.conn) {
next();
return;
}
if (timeout.conn.status === 'dead') {
timeout.revive(function (err) {
if (err) {
log.warning('Unable to revive connection: ' + timeout.conn.id);
process.nextTick(next);
} else {
cb(void 0, timeout.conn);
}
});
} else {
cb(void 0, timeout.conn);
}
});
};
/**
* Returns a random list of nodes from the living connections up to the limit.
* If there are no living connections it will fall back to the dead connections.
* If there are no dead connections it will return nothing.
*
* This is used for testing (when we just want the one existing node)
* and sniffing, where using the selector to get all of the living connections
* is not reasonable.
*
* @param {string} [status] - optional status of the connection to fetch
* @param {Number} [limit] - optional limit on the number of connections to return
*/
ConnectionPool.prototype.getConnections = function (status, limit) {
var list;
if (status) {
list = this._conns[status];
} else {
list = this._conns[this._conns.alive.length ? 'alive' : 'dead'];
}
if (limit == null) {
return list.slice(0);
} else {
return _.shuffle(list).slice(0, limit);
}
};
/**
* Add a single connection to the pool and change it's status to "alive".
* The connection should inherit from ConnectionAbstract
*
* @param {ConnectionAbstract} connection - The connection to add
*/
ConnectionPool.prototype.addConnection = function (connection) {
if (!connection.id) {
connection.id = connection.host.toString();
}
if (!this.index[connection.id]) {
this.log.info('Adding connection to', connection.id);
this.index[connection.id] = connection;
connection.on('status set', this.bound.onStatusSet);
connection.setStatus('alive');
}
};
/**
* Remove a connection from the pool, and set it's status to "closed".
*
* @param {ConnectionAbstract} connection - The connection to remove/close
*/
ConnectionPool.prototype.removeConnection = function (connection) {
if (!connection.id) {
connection.id = connection.host.toString();
}
if (this.index[connection.id]) {
delete this.index[connection.id];
connection.setStatus('closed');
connection.removeListener('status set', this.bound.onStatusSet);
}
};
/**
* Override the internal node list. All connections that are not in the new host
* list are closed and removed. Non-unique hosts are ignored.
*
* @param {Host[]} hosts - An array of Host instances.
*/
ConnectionPool.prototype.setHosts = function (hosts) {
var connection;
var i;
var id;
var host;
var toRemove = _.clone(this.index);
for (i = 0; i < hosts.length; i++) {
host = hosts[i];
id = host.toString();
if (this.index[id]) {
delete toRemove[id];
} else {
connection = new this.Connection(host, this._config);
connection.id = id;
this.addConnection(connection);
}
}
var removeIds = _.keys(toRemove);
for (i = 0; i < removeIds.length; i++) {
this.removeConnection(this.index[removeIds[i]]);
}
};
ConnectionPool.prototype.getAllHosts = function () {
return _.values(this.index).map(function (connection) {
return connection.host;
});
};
/**
* Close the conncetion pool, as well as all of it's connections
*/
ConnectionPool.prototype.close = function () {
this.setHosts([]);
};
ConnectionPool.prototype.empty = ConnectionPool.prototype.close;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))
/***/ }),
/* 10 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* A client that makes requests to Elasticsearch via a {{#crossLink "Transport"}}Transport{{/crossLink}}
*
* Initializing a client might look something like:
*
* ```
* var client = new es.Client({
* hosts: [
* 'es1.net:9200',
* {
* host: 'es2.net',
* port: 9200
* }
* ],
* sniffOnStart: true,
* log: {
* type: 'file',
* level: 'warning'
* }
* });
* ```
*
* @class Client
* @constructor
*/
module.exports = Client;
var Transport = __webpack_require__(7);
var clientAction = __webpack_require__(1);
var _ = __webpack_require__(0);
var utils = __webpack_require__(2);
function Client(config) {
config = config || {};
if (config.__reused) {
throw new Error('Do not reuse objects to configure the elasticsearch Client class: ' + 'https://github.com/elasticsearch/elasticsearch-js/issues/33');
} else {
config.__reused = true;
}
function EsApiClient() {
// our client will log minimally by default
if (!config.hasOwnProperty('log')) {
config.log = 'warning';
}
if (!config.hosts && !config.host) {
config.host = 'http://localhost:9200';
}
this.close = function () {
this.transport.close();
};
this.transport = new Transport(config);
_.each(EsApiClient.prototype, _.bind(function (Fn, prop) {
if (Fn.prototype instanceof clientAction.ApiNamespace) {
this[prop] = new Fn(this.transport, this);
}
}, this));
delete this._namespaces;
}
EsApiClient.prototype = utils.funcEnum(config, 'apiVersion', Client.apis, '_default');
if (!config.sniffEndpoint && EsApiClient.prototype === Client.apis['0.90']) {
config.sniffEndpoint = '/_cluster/nodes';
}
var Constructor = EsApiClient;
if (config.plugins) {
Constructor.prototype = _.cloneDeep(Constructor.prototype);
_.each(config.plugins, function (setup) {
Constructor = setup(Constructor, config, {
apis: __webpack_require__(24),
connectors: __webpack_require__(19),
loggers: __webpack_require__(16),
selectors: __webpack_require__(18),
serializers: __webpack_require__(21),
Client: __webpack_require__(10),
clientAction: clientAction,
Connection: __webpack_require__(20),
ConnectionPool: __webpack_require__(9),
Errors: __webpack_require__(4),
Host: __webpack_require__(8),
Log: __webpack_require__(6),
Logger: __webpack_require__(17),
NodesToHost: __webpack_require__(23),
Transport: __webpack_require__(7)
}) || Constructor;
});
}
return new Constructor();
}
Client.apis = __webpack_require__(24);
/***/ }),
/* 11 */
/***/ (function(module, exports) {
module.exports = function(module) {
if(!module.webpackPolyfill) {
module.deprecate = function() {};
module.paths = [];
// module.parent = undefined by default
if(!module.children) module.children = [];
Object.defineProperty(module, "loaded", {
enumerable: true,
get: function() {
return module.l;
}
});
Object.defineProperty(module, "id", {
enumerable: true,
get: function() {
return module.i;
}
});
module.webpackPolyfill = 1;
}
return module;
};
/***/ }),
/* 12 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/* WEBPACK VAR INJECTION */(function(global) {/*!
* The buffer module from node.js, for the browser.
*
* @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
* @license MIT
*/
/* eslint-disable no-proto */
var base64 = __webpack_require__(27)
var ieee754 = __webpack_require__(28)
var isArray = __webpack_require__(29)
exports.Buffer = Buffer
exports.SlowBuffer = SlowBuffer
exports.INSPECT_MAX_BYTES = 50
/**
* If `Buffer.TYPED_ARRAY_SUPPORT`:
* === true Use Uint8Array implementation (fastest)
* === false Use Object implementation (most compatible, even IE6)
*
* Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
* Opera 11.6+, iOS 4.2+.
*
* Due to various browser bugs, sometimes the Object implementation will be used even
* when the browser supports typed arrays.
*
* Note:
*
* - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
* See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
*
* - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
*
* - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
* incorrect length in some situations.
* We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
* get the Object implementation, which is slower but behaves correctly.
*/
Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined
? global.TYPED_ARRAY_SUPPORT
: typedArraySupport()
/*
* Export kMaxLength after typed array support is determined.
*/
exports.kMaxLength = kMaxLength()
function typedArraySupport () {
try {
var arr = new Uint8Array(1)
arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}
return arr.foo() === 42 && // typed array instances can be augmented
typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
} catch (e) {
return false
}
}
function kMaxLength () {
return Buffer.TYPED_ARRAY_SUPPORT
? 0x7fffffff
: 0x3fffffff
}
function createBuffer (that, length) {
if (kMaxLength() < length) {
throw new RangeError('Invalid typed array length')
}
if (Buffer.TYPED_ARRAY_SUPPORT) {
// Return an augmented `Uint8Array` instance, for best performance
that = new Uint8Array(length)
that.__proto__ = Buffer.prototype
} else {
// Fallback: Return an object instance of the Buffer class
if (that === null) {
that = new Buffer(length)
}
that.length = length
}
return that
}
/**
* The Buffer constructor returns instances of `Uint8Array` that have their
* prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
* `Uint8Array`, so the returned instances will have all the node `Buffer` methods
* and the `Uint8Array` methods. Square bracket notation works as expected -- it
* returns a single octet.
*
* The `Uint8Array` prototype remains unmodified.
*/
function Buffer (arg, encodingOrOffset, length) {
if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {
return new Buffer(arg, encodingOrOffset, length)
}
// Common case.
if (typeof arg === 'number') {
if (typeof encodingOrOffset === 'string') {
throw new Error(
'If encoding is specified then the first argument must be a string'
)
}
return allocUnsafe(this, arg)
}
return from(this, arg, encodingOrOffset, length)
}
Buffer.poolSize = 8192 // not used by this implementation
// TODO: Legacy, not needed anymore. Remove in next major version.
Buffer._augment = function (arr) {
arr.__proto__ = Buffer.prototype
return arr
}
function from (that, value, encodingOrOffset, length) {
if (typeof value === 'number') {
throw new TypeError('"value" argument must not be a number')
}
if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
return fromArrayBuffer(that, value, encodingOrOffset, length)
}
if (typeof value === 'string') {
return fromString(that, value, encodingOrOffset)
}
return fromObject(that, value)
}
/**
* Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
* if value is a number.
* Buffer.from(str[, encoding])
* Buffer.from(array)
* Buffer.from(buffer)
* Buffer.from(arrayBuffer[, byteOffset[, length]])
**/
Buffer.from = function (value, encodingOrOffset, length) {
return from(null, value, encodingOrOffset, length)
}
if (Buffer.TYPED_ARRAY_SUPPORT) {
Buffer.prototype.__proto__ = Uint8Array.prototype
Buffer.__proto__ = Uint8Array
if (typeof Symbol !== 'undefined' && Symbol.species &&
Buffer[Symbol.species] === Buffer) {
// Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
Object.defineProperty(Buffer, Symbol.species, {
value: null,
configurable: true
})
}
}
function assertSize (size) {
if (typeof size !== 'number') {
throw new TypeError('"size" argument must be a number')
} else if (size < 0) {
throw new RangeError('"size" argument must not be negative')
}
}
function alloc (that, size, fill, encoding) {
assertSize(size)
if (size <= 0) {
return createBuffer(that, size)
}
if (fill !== undefined) {
// Only pay attention to encoding if it's a string. This
// prevents accidentally sending in a number that would
// be interpretted as a start offset.
return typeof encoding === 'string'
? createBuffer(that, size).fill(fill, encoding)
: createBuffer(that, size).fill(fill)
}
return createBuffer(that, size)
}
/**
* Creates a new filled Buffer instance.
* alloc(size[, fill[, encoding]])
**/
Buffer.alloc = function (size, fill, encoding) {
return alloc(null, size, fill, encoding)
}
function allocUnsafe (that, size) {
assertSize(size)
that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)
if (!Buffer.TYPED_ARRAY_SUPPORT) {
for (var i = 0; i < size; ++i) {
that[i] = 0
}
}
return that
}
/**
* Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
* */
Buffer.allocUnsafe = function (size) {
return allocUnsafe(null, size)
}
/**
* Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
*/
Buffer.allocUnsafeSlow = function (size) {
return allocUnsafe(null, size)
}
function fromString (that, string, encoding) {
if (typeof encoding !== 'string' || encoding === '') {
encoding = 'utf8'
}
if (!Buffer.isEncoding(encoding)) {
throw new TypeError('"encoding" must be a valid string encoding')
}
var length = byteLength(string, encoding) | 0
that = createBuffer(that, length)
var actual = that.write(string, encoding)
if (actual !== length) {
// Writing a hex string, for example, that contains invalid characters will
// cause everything after the first invalid character to be ignored. (e.g.
// 'abxxcd' will be treated as 'ab')
that = that.slice(0, actual)
}
return that
}
function fromArrayLike (that, array) {
var length = array.length < 0 ? 0 : checked(array.length) | 0
that = createBuffer(that, length)
for (var i = 0; i < length; i += 1) {
that[i] = array[i] & 255
}
return that
}
function fromArrayBuffer (that, array, byteOffset, length) {
array.byteLength // this throws if `array` is not a valid ArrayBuffer
if (byteOffset < 0 || array.byteLength < byteOffset) {
throw new RangeError('\'offset\' is out of bounds')
}
if (array.byteLength < byteOffset + (length || 0)) {
throw new RangeError('\'length\' is out of bounds')
}
if (byteOffset === undefined && length === undefined) {
array = new Uint8Array(array)
} else if (length === undefined) {
array = new Uint8Array(array, byteOffset)
} else {
array = new Uint8Array(array, byteOffset, length)
}
if (Buffer.TYPED_ARRAY_SUPPORT) {
// Return an augmented `Uint8Array` instance, for best performance
that = array
that.__proto__ = Buffer.prototype
} else {
// Fallback: Return an object instance of the Buffer class
that = fromArrayLike(that, array)
}
return that
}
function fromObject (that, obj) {
if (Buffer.isBuffer(obj)) {
var len = checked(obj.length) | 0
that = createBuffer(that, len)
if (that.length === 0) {
return that
}
obj.copy(that, 0, 0, len)
return that
}
if (obj) {
if ((typeof ArrayBuffer !== 'undefined' &&
obj.buffer instanceof ArrayBuffer) || 'length' in obj) {
if (typeof obj.length !== 'number' || isnan(obj.length)) {
return createBuffer(that, 0)
}
return fromArrayLike(that, obj)
}
if (obj.type === 'Buffer' && isArray(obj.data)) {
return fromArrayLike(that, obj.data)
}
}
throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
}
function checked (length) {
// Note: cannot use `length < kMaxLength()` here because that fails when
// length is NaN (which is otherwise coerced to zero.)
if (length >= kMaxLength()) {
throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
'size: 0x' + kMaxLength().toString(16) + ' bytes')
}
return length | 0
}
function SlowBuffer (length) {
if (+length != length) { // eslint-disable-line eqeqeq
length = 0
}
return Buffer.alloc(+length)
}
Buffer.isBuffer = function isBuffer (b) {
return !!(b != null && b._isBuffer)
}
Buffer.compare = function compare (a, b) {
if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
throw new TypeError('Arguments must be Buffers')
}
if (a === b) return 0
var x = a.length
var y = b.length
for (var i = 0, len = Math.min(x, y); i < len; ++i) {
if (a[i] !== b[i]) {
x = a[i]
y = b[i]
break
}
}
if (x < y) return -1
if (y < x) return 1
return 0
}
Buffer.isEncoding = function isEncoding (encoding) {
switch (String(encoding).toLowerCase()) {
case 'hex':
case 'utf8':
case 'utf-8':
case 'ascii':
case 'latin1':
case 'binary':
case 'base64':
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return true
default:
return false
}
}
Buffer.concat = function concat (list, length) {
if (!isArray(list)) {
throw new TypeError('"list" argument must be an Array of Buffers')
}
if (list.length === 0) {
return Buffer.alloc(0)
}
var i
if (length === undefined) {
length = 0
for (i = 0; i < list.length; ++i) {
length += list[i].length
}
}
var buffer = Buffer.allocUnsafe(length)
var pos = 0
for (i = 0; i < list.length; ++i) {
var buf = list[i]
if (!Buffer.isBuffer(buf)) {
throw new TypeError('"list" argument must be an Array of Buffers')
}
buf.copy(buffer, pos)
pos += buf.length
}
return buffer
}
function byteLength (string, encoding) {
if (Buffer.isBuffer(string)) {
return string.length
}
if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&
(ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
return string.byteLength
}
if (typeof string !== 'string') {
string = '' + string
}
var len = string.length
if (len === 0) return 0
// Use a for loop to avoid recursion
var loweredCase = false
for (;;) {
switch (encoding) {
case 'ascii':
case 'latin1':
case 'binary':
return len
case 'utf8':
case 'utf-8':
case undefined:
return utf8ToBytes(string).length
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return len * 2
case 'hex':
return len >>> 1
case 'base64':
return base64ToBytes(string).length
default:
if (loweredCase) return utf8ToBytes(string).length // assume utf8
encoding = ('' + encoding).toLowerCase()
loweredCase = true
}
}
}
Buffer.byteLength = byteLength
function slowToString (encoding, start, end) {
var loweredCase = false
// No need to verify that "this.length <= MAX_UINT32" since it's a read-only
// property of a typed array.
// This behaves neither like String nor Uint8Array in that we set start/end
// to their upper/lower bounds if the value passed is out of range.
// undefined is handled specially as per ECMA-262 6th Edition,
// Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
if (start === undefined || start < 0) {
start = 0
}
// Return early if start > this.length. Done here to prevent potential uint32
// coercion fail below.
if (start > this.length) {
return ''
}
if (end === undefined || end > this.length) {
end = this.length
}
if (end <= 0) {
return ''
}
// Force coersion to uint32. This will also coerce falsey/NaN values to 0.
end >>>= 0
start >>>= 0
if (end <= start) {
return ''
}
if (!encoding) encoding = 'utf8'
while (true) {
switch (encoding) {
case 'hex':
return hexSlice(this, start, end)
case 'utf8':
case 'utf-8':
return utf8Slice(this, start, end)
case 'ascii':
return asciiSlice(this, start, end)
case 'latin1':
case 'binary':
return latin1Slice(this, start, end)
case 'base64':
return base64Slice(this, start, end)
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return utf16leSlice(this, start, end)
default:
if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
encoding = (encoding + '').toLowerCase()
loweredCase = true
}
}
}
// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
// Buffer instances.
Buffer.prototype._isBuffer = true
function swap (b, n, m) {
var i = b[n]
b[n] = b[m]
b[m] = i
}
Buffer.prototype.swap16 = function swap16 () {
var len = this.length
if (len % 2 !== 0) {
throw new RangeError('Buffer size must be a multiple of 16-bits')
}
for (var i = 0; i < len; i += 2) {
swap(this, i, i + 1)
}
return this
}
Buffer.prototype.swap32 = function swap32 () {
var len = this.length
if (len % 4 !== 0) {
throw new RangeError('Buffer size must be a multiple of 32-bits')
}
for (var i = 0; i < len; i += 4) {
swap(this, i, i + 3)
swap(this, i + 1, i + 2)
}
return this
}
Buffer.prototype.swap64 = function swap64 () {
var len = this.length
if (len % 8 !== 0) {
throw new RangeError('Buffer size must be a multiple of 64-bits')
}
for (var i = 0; i < len; i += 8) {
swap(this, i, i + 7)
swap(this, i + 1, i + 6)
swap(this, i + 2, i + 5)
swap(this, i + 3, i + 4)
}
return this
}
Buffer.prototype.toString = function toString () {
var length = this.length | 0
if (length === 0) return ''
if (arguments.length === 0) return utf8Slice(this, 0, length)
return slowToString.apply(this, arguments)
}
Buffer.prototype.equals = function equals (b) {
if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
if (this === b) return true
return Buffer.compare(this, b) === 0
}
Buffer.prototype.inspect = function inspect () {
var str = ''
var max = exports.INSPECT_MAX_BYTES
if (this.length > 0) {
str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
if (this.length > max) str += ' ... '
}
return '<Buffer ' + str + '>'
}
Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
if (!Buffer.isBuffer(target)) {
throw new TypeError('Argument must be a Buffer')
}
if (start === undefined) {
start = 0
}
if (end === undefined) {
end = target ? target.length : 0
}
if (thisStart === undefined) {
thisStart = 0
}
if (thisEnd === undefined) {
thisEnd = this.length
}
if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
throw new RangeError('out of range index')
}
if (thisStart >= thisEnd && start >= end) {
return 0
}
if (thisStart >= thisEnd) {
return -1
}
if (start >= end) {
return 1
}
start >>>= 0
end >>>= 0
thisStart >>>= 0
thisEnd >>>= 0
if (this === target) return 0
var x = thisEnd - thisStart
var y = end - start
var len = Math.min(x, y)
var thisCopy = this.slice(thisStart, thisEnd)
var targetCopy = target.slice(start, end)
for (var i = 0; i < len; ++i) {
if (thisCopy[i] !== targetCopy[i]) {
x = thisCopy[i]
y = targetCopy[i]
break
}
}
if (x < y) return -1
if (y < x) return 1
return 0
}
// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
//
// Arguments:
// - buffer - a Buffer to search
// - val - a string, Buffer, or number
// - byteOffset - an index into `buffer`; will be clamped to an int32
// - encoding - an optional encoding, relevant is val is a string
// - dir - true for indexOf, false for lastIndexOf
function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
// Empty buffer means no match
if (buffer.length === 0) return -1
// Normalize byteOffset
if (typeof byteOffset === 'string') {
encoding = byteOffset
byteOffset = 0
} else if (byteOffset > 0x7fffffff) {
byteOffset = 0x7fffffff
} else if (byteOffset < -0x80000000) {
byteOffset = -0x80000000
}
byteOffset = +byteOffset // Coerce to Number.
if (isNaN(byteOffset)) {
// byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
byteOffset = dir ? 0 : (buffer.length - 1)
}
// Normalize byteOffset: negative offsets start from the end of the buffer
if (byteOffset < 0) byteOffset = buffer.length + byteOffset
if (byteOffset >= buffer.length) {
if (dir) return -1
else byteOffset = buffer.length - 1
} else if (byteOffset < 0) {
if (dir) byteOffset = 0
else return -1
}
// Normalize val
if (typeof val === 'string') {
val = Buffer.from(val, encoding)
}
// Finally, search either indexOf (if dir is true) or lastIndexOf
if (Buffer.isBuffer(val)) {
// Special case: looking for empty string/buffer always fails
if (val.length === 0) {
return -1
}
return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
} else if (typeof val === 'number') {
val = val & 0xFF // Search for a byte value [0-255]
if (Buffer.TYPED_ARRAY_SUPPORT &&
typeof Uint8Array.prototype.indexOf === 'function') {
if (dir) {
return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
} else {
return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
}
}
return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
}
throw new TypeError('val must be string, number or Buffer')
}
function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
var indexSize = 1
var arrLength = arr.length
var valLength = val.length
if (encoding !== undefined) {
encoding = String(encoding).toLowerCase()
if (encoding === 'ucs2' || encoding === 'ucs-2' ||
encoding === 'utf16le' || encoding === 'utf-16le') {
if (arr.length < 2 || val.length < 2) {
return -1
}
indexSize = 2
arrLength /= 2
valLength /= 2
byteOffset /= 2
}
}
function read (buf, i) {
if (indexSize === 1) {
return buf[i]
} else {
return buf.readUInt16BE(i * indexSize)
}
}
var i
if (dir) {
var foundIndex = -1
for (i = byteOffset; i < arrLength; i++) {
if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
if (foundIndex === -1) foundIndex = i
if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
} else {
if (foundIndex !== -1) i -= i - foundIndex
foundIndex = -1
}
}
} else {
if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
for (i = byteOffset; i >= 0; i--) {
var found = true
for (var j = 0; j < valLength; j++) {
if (read(arr, i + j) !== read(val, j)) {
found = false
break
}
}
if (found) return i
}
}
return -1
}
Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
return this.indexOf(val, byteOffset, encoding) !== -1
}
Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
}
Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
}
function hexWrite (buf, string, offset, length) {
offset = Number(offset) || 0
var remaining = buf.length - offset
if (!length) {
length = remaining
} else {
length = Number(length)
if (length > remaining) {
length = remaining
}
}
// must be an even number of digits
var strLen = string.length
if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')
if (length > strLen / 2) {
length = strLen / 2
}
for (var i = 0; i < length; ++i) {
var parsed = parseInt(string.substr(i * 2, 2), 16)
if (isNaN(parsed)) return i
buf[offset + i] = parsed
}
return i
}
function utf8Write (buf, string, offset, length) {
return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
}
function asciiWrite (buf, string, offset, length) {
return blitBuffer(asciiToBytes(string), buf, offset, length)
}
function latin1Write (buf, string, offset, length) {
return asciiWrite(buf, string, offset, length)
}
function base64Write (buf, string, offset, length) {
return blitBuffer(base64ToBytes(string), buf, offset, length)
}
function ucs2Write (buf, string, offset, length) {
return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
}
Buffer.prototype.write = function write (string, offset, length, encoding) {
// Buffer#write(string)
if (offset === undefined) {
encoding = 'utf8'
length = this.length
offset = 0
// Buffer#write(string, encoding)
} else if (length === undefined && typeof offset === 'string') {
encoding = offset
length = this.length
offset = 0
// Buffer#write(string, offset[, length][, encoding])
} else if (isFinite(offset)) {
offset = offset | 0
if (isFinite(length)) {
length = length | 0
if (encoding === undefined) encoding = 'utf8'
} else {
encoding = length
length = undefined
}
// legacy write(string, encoding, offset, length) - remove in v0.13
} else {
throw new Error(
'Buffer.write(string, encoding, offset[, length]) is no longer supported'
)
}
var remaining = this.length - offset
if (length === undefined || length > remaining) length = remaining
if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
throw new RangeError('Attempt to write outside buffer bounds')
}
if (!encoding) encoding = 'utf8'
var loweredCase = false
for (;;) {
switch (encoding) {
case 'hex':
return hexWrite(this, string, offset, length)
case 'utf8':
case 'utf-8':
return utf8Write(this, string, offset, length)
case 'ascii':
return asciiWrite(this, string, offset, length)
case 'latin1':
case 'binary':
return latin1Write(this, string, offset, length)
case 'base64':
// Warning: maxLength not taken into account in base64Write
return base64Write(this, string, offset, length)
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return ucs2Write(this, string, offset, length)
default:
if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
encoding = ('' + encoding).toLowerCase()
loweredCase = true
}
}
}
Buffer.prototype.toJSON = function toJSON () {
return {
type: 'Buffer',
data: Array.prototype.slice.call(this._arr || this, 0)
}
}
function base64Slice (buf, start, end) {
if (start === 0 && end === buf.length) {
return base64.fromByteArray(buf)
} else {
return base64.fromByteArray(buf.slice(start, end))
}
}
function utf8Slice (buf, start, end) {
end = Math.min(buf.length, end)
var res = []
var i = start
while (i < end) {
var firstByte = buf[i]
var codePoint = null
var bytesPerSequence = (firstByte > 0xEF) ? 4
: (firstByte > 0xDF) ? 3
: (firstByte > 0xBF) ? 2
: 1
if (i + bytesPerSequence <= end) {
var secondByte, thirdByte, fourthByte, tempCodePoint
switch (bytesPerSequence) {
case 1:
if (firstByte < 0x80) {
codePoint = firstByte
}
break
case 2:
secondByte = buf[i + 1]
if ((secondByte & 0xC0) === 0x80) {
tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
if (tempCodePoint > 0x7F) {
codePoint = tempCodePoint
}
}
break
case 3:
secondByte = buf[i + 1]
thirdByte = buf[i + 2]
if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
codePoint = tempCodePoint
}
}
break
case 4:
secondByte = buf[i + 1]
thirdByte = buf[i + 2]
fourthByte = buf[i + 3]
if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
codePoint = tempCodePoint
}
}
}
}
if (codePoint === null) {
// we did not generate a valid codePoint so insert a
// replacement char (U+FFFD) and advance only 1 byte
codePoint = 0xFFFD
bytesPerSequence = 1
} else if (codePoint > 0xFFFF) {
// encode to utf16 (surrogate pair dance)
codePoint -= 0x10000
res.push(codePoint >>> 10 & 0x3FF | 0xD800)
codePoint = 0xDC00 | codePoint & 0x3FF
}
res.push(codePoint)
i += bytesPerSequence
}
return decodeCodePointsArray(res)
}
// Based on http://stackoverflow.com/a/22747272/680742, the browser with
// the lowest limit is Chrome, with 0x10000 args.
// We go 1 magnitude less, for safety
var MAX_ARGUMENTS_LENGTH = 0x1000
function decodeCodePointsArray (codePoints) {
var len = codePoints.length
if (len <= MAX_ARGUMENTS_LENGTH) {
return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
}
// Decode in chunks to avoid "call stack size exceeded".
var res = ''
var i = 0
while (i < len) {
res += String.fromCharCode.apply(
String,
codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
)
}
return res
}
function asciiSlice (buf, start, end) {
var ret = ''
end = Math.min(buf.length, end)
for (var i = start; i < end; ++i) {
ret += String.fromCharCode(buf[i] & 0x7F)
}
return ret
}
function latin1Slice (buf, start, end) {
var ret = ''
end = Math.min(buf.length, end)
for (var i = start; i < end; ++i) {
ret += String.fromCharCode(buf[i])
}
return ret
}
function hexSlice (buf, start, end) {
var len = buf.length
if (!start || start < 0) start = 0
if (!end || end < 0 || end > len) end = len
var out = ''
for (var i = start; i < end; ++i) {
out += toHex(buf[i])
}
return out
}
function utf16leSlice (buf, start, end) {
var bytes = buf.slice(start, end)
var res = ''
for (var i = 0; i < bytes.length; i += 2) {
res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)
}
return res
}
Buffer.prototype.slice = function slice (start, end) {
var len = this.length
start = ~~start
end = end === undefined ? len : ~~end
if (start < 0) {
start += len
if (start < 0) start = 0
} else if (start > len) {
start = len
}
if (end < 0) {
end += len
if (end < 0) end = 0
} else if (end > len) {
end = len
}
if (end < start) end = start
var newBuf
if (Buffer.TYPED_ARRAY_SUPPORT) {
newBuf = this.subarray(start, end)
newBuf.__proto__ = Buffer.prototype
} else {
var sliceLen = end - start
newBuf = new Buffer(sliceLen, undefined)
for (var i = 0; i < sliceLen; ++i) {
newBuf[i] = this[i + start]
}
}
return newBuf
}
/*
* Need to make sure that buffer isn't trying to write out of bounds.
*/
function checkOffset (offset, ext, length) {
if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
}
Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
offset = offset | 0
byteLength = byteLength | 0
if (!noAssert) checkOffset(offset, byteLength, this.length)
var val = this[offset]
var mul = 1
var i = 0
while (++i < byteLength && (mul *= 0x100)) {
val += this[offset + i] * mul
}
return val
}
Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
offset = offset | 0
byteLength = byteLength | 0
if (!noAssert) {
checkOffset(offset, byteLength, this.length)
}
var val = this[offset + --byteLength]
var mul = 1
while (byteLength > 0 && (mul *= 0x100)) {
val += this[offset + --byteLength] * mul
}
return val
}
Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
if (!noAssert) checkOffset(offset, 1, this.length)
return this[offset]
}
Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 2, this.length)
return this[offset] | (this[offset + 1] << 8)
}
Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 2, this.length)
return (this[offset] << 8) | this[offset + 1]
}
Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 4, this.length)
return ((this[offset]) |
(this[offset + 1] << 8) |
(this[offset + 2] << 16)) +
(this[offset + 3] * 0x1000000)
}
Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 4, this.length)
return (this[offset] * 0x1000000) +
((this[offset + 1] << 16) |
(this[offset + 2] << 8) |
this[offset + 3])
}
Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
offset = offset | 0
byteLength = byteLength | 0
if (!noAssert) checkOffset(offset, byteLength, this.length)
var val = this[offset]
var mul = 1
var i = 0
while (++i < byteLength && (mul *= 0x100)) {
val += this[offset + i] * mul
}
mul *= 0x80
if (val >= mul) val -= Math.pow(2, 8 * byteLength)
return val
}
Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
offset = offset | 0
byteLength = byteLength | 0
if (!noAssert) checkOffset(offset, byteLength, this.length)
var i = byteLength
var mul = 1
var val = this[offset + --i]
while (i > 0 && (mul *= 0x100)) {
val += this[offset + --i] * mul
}
mul *= 0x80
if (val >= mul) val -= Math.pow(2, 8 * byteLength)
return val
}
Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
if (!noAssert) checkOffset(offset, 1, this.length)
if (!(this[offset] & 0x80)) return (this[offset])
return ((0xff - this[offset] + 1) * -1)
}
Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 2, this.length)
var val = this[offset] | (this[offset + 1] << 8)
return (val & 0x8000) ? val | 0xFFFF0000 : val
}
Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 2, this.length)
var val = this[offset + 1] | (this[offset] << 8)
return (val & 0x8000) ? val | 0xFFFF0000 : val
}
Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 4, this.length)
return (this[offset]) |
(this[offset + 1] << 8) |
(this[offset + 2] << 16) |
(this[offset + 3] << 24)
}
Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 4, this.length)
return (this[offset] << 24) |
(this[offset + 1] << 16) |
(this[offset + 2] << 8) |
(this[offset + 3])
}
Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 4, this.length)
return ieee754.read(this, offset, true, 23, 4)
}
Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 4, this.length)
return ieee754.read(this, offset, false, 23, 4)
}
Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 8, this.length)
return ieee754.read(this, offset, true, 52, 8)
}
Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
if (!noAssert) checkOffset(offset, 8, this.length)
return ieee754.read(this, offset, false, 52, 8)
}
function checkInt (buf, value, offset, ext, max, min) {
if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
if (offset + ext > buf.length) throw new RangeError('Index out of range')
}
Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
value = +value
offset = offset | 0
byteLength = byteLength | 0
if (!noAssert) {
var maxBytes = Math.pow(2, 8 * byteLength) - 1
checkInt(this, value, offset, byteLength, maxBytes, 0)
}
var mul = 1
var i = 0
this[offset] = value & 0xFF
while (++i < byteLength && (mul *= 0x100)) {
this[offset + i] = (value / mul) & 0xFF
}
return offset + byteLength
}
Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
value = +value
offset = offset | 0
byteLength = byteLength | 0
if (!noAssert) {
var maxBytes = Math.pow(2, 8 * byteLength) - 1
checkInt(this, value, offset, byteLength, maxBytes, 0)
}
var i = byteLength - 1
var mul = 1
this[offset + i] = value & 0xFF
while (--i >= 0 && (mul *= 0x100)) {
this[offset + i] = (value / mul) & 0xFF
}
return offset + byteLength
}
Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
value = +value
offset = offset | 0
if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
this[offset] = (value & 0xff)
return offset + 1
}
function objectWriteUInt16 (buf, value, offset, littleEndian) {
if (value < 0) value = 0xffff + value + 1
for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {
buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
(littleEndian ? i : 1 - i) * 8
}
}
Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
value = +value
offset = offset | 0
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value & 0xff)
this[offset + 1] = (value >>> 8)
} else {
objectWriteUInt16(this, value, offset, true)
}
return offset + 2
}
Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
value = +value
offset = offset | 0
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 8)
this[offset + 1] = (value & 0xff)
} else {
objectWriteUInt16(this, value, offset, false)
}
return offset + 2
}
function objectWriteUInt32 (buf, value, offset, littleEndian) {
if (value < 0) value = 0xffffffff + value + 1
for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {
buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
}
}
Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
value = +value
offset = offset | 0
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset + 3] = (value >>> 24)
this[offset + 2] = (value >>> 16)
this[offset + 1] = (value >>> 8)
this[offset] = (value & 0xff)
} else {
objectWriteUInt32(this, value, offset, true)
}
return offset + 4
}
Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
value = +value
offset = offset | 0
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 24)
this[offset + 1] = (value >>> 16)
this[offset + 2] = (value >>> 8)
this[offset + 3] = (value & 0xff)
} else {
objectWriteUInt32(this, value, offset, false)
}
return offset + 4
}
Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
value = +value
offset = offset | 0
if (!noAssert) {
var limit = Math.pow(2, 8 * byteLength - 1)
checkInt(this, value, offset, byteLength, limit - 1, -limit)
}
var i = 0
var mul = 1
var sub = 0
this[offset] = value & 0xFF
while (++i < byteLength && (mul *= 0x100)) {
if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
sub = 1
}
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
}
return offset + byteLength
}
Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
value = +value
offset = offset | 0
if (!noAssert) {
var limit = Math.pow(2, 8 * byteLength - 1)
checkInt(this, value, offset, byteLength, limit - 1, -limit)
}
var i = byteLength - 1
var mul = 1
var sub = 0
this[offset + i] = value & 0xFF
while (--i >= 0 && (mul *= 0x100)) {
if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
sub = 1
}
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
}
return offset + byteLength
}
Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
value = +value
offset = offset | 0
if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
if (value < 0) value = 0xff + value + 1
this[offset] = (value & 0xff)
return offset + 1
}
Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
value = +value
offset = offset | 0
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value & 0xff)
this[offset + 1] = (value >>> 8)
} else {
objectWriteUInt16(this, value, offset, true)
}
return offset + 2
}
Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
value = +value
offset = offset | 0
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 8)
this[offset + 1] = (value & 0xff)
} else {
objectWriteUInt16(this, value, offset, false)
}
return offset + 2
}
Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
value = +value
offset = offset | 0
if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value & 0xff)
this[offset + 1] = (value >>> 8)
this[offset + 2] = (value >>> 16)
this[offset + 3] = (value >>> 24)
} else {
objectWriteUInt32(this, value, offset, true)
}
return offset + 4
}
Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
value = +value
offset = offset | 0
if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
if (value < 0) value = 0xffffffff + value + 1
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 24)
this[offset + 1] = (value >>> 16)
this[offset + 2] = (value >>> 8)
this[offset + 3] = (value & 0xff)
} else {
objectWriteUInt32(this, value, offset, false)
}
return offset + 4
}
function checkIEEE754 (buf, value, offset, ext, max, min) {
if (offset + ext > buf.length) throw new RangeError('Index out of range')
if (offset < 0) throw new RangeError('Index out of range')
}
function writeFloat (buf, value, offset, littleEndian, noAssert) {
if (!noAssert) {
checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
}
ieee754.write(buf, value, offset, littleEndian, 23, 4)
return offset + 4
}
Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
return writeFloat(this, value, offset, true, noAssert)
}
Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
return writeFloat(this, value, offset, false, noAssert)
}
function writeDouble (buf, value, offset, littleEndian, noAssert) {
if (!noAssert) {
checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
}
ieee754.write(buf, value, offset, littleEndian, 52, 8)
return offset + 8
}
Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
return writeDouble(this, value, offset, true, noAssert)
}
Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
return writeDouble(this, value, offset, false, noAssert)
}
// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
Buffer.prototype.copy = function copy (target, targetStart, start, end) {
if (!start) start = 0
if (!end && end !== 0) end = this.length
if (targetStart >= target.length) targetStart = target.length
if (!targetStart) targetStart = 0
if (end > 0 && end < start) end = start
// Copy 0 bytes; we're done
if (end === start) return 0
if (target.length === 0 || this.length === 0) return 0
// Fatal error conditions
if (targetStart < 0) {
throw new RangeError('targetStart out of bounds')
}
if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
if (end < 0) throw new RangeError('sourceEnd out of bounds')
// Are we oob?
if (end > this.length) end = this.length
if (target.length - targetStart < end - start) {
end = target.length - targetStart + start
}
var len = end - start
var i
if (this === target && start < targetStart && targetStart < end) {
// descending copy from end
for (i = len - 1; i >= 0; --i) {
target[i + targetStart] = this[i + start]
}
} else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
// ascending copy from start
for (i = 0; i < len; ++i) {
target[i + targetStart] = this[i + start]
}
} else {
Uint8Array.prototype.set.call(
target,
this.subarray(start, start + len),
targetStart
)
}
return len
}
// Usage:
// buffer.fill(number[, offset[, end]])
// buffer.fill(buffer[, offset[, end]])
// buffer.fill(string[, offset[, end]][, encoding])
Buffer.prototype.fill = function fill (val, start, end, encoding) {
// Handle string cases:
if (typeof val === 'string') {
if (typeof start === 'string') {
encoding = start
start = 0
end = this.length
} else if (typeof end === 'string') {
encoding = end
end = this.length
}
if (val.length === 1) {
var code = val.charCodeAt(0)
if (code < 256) {
val = code
}
}
if (encoding !== undefined && typeof encoding !== 'string') {
throw new TypeError('encoding must be a string')
}
if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
throw new TypeError('Unknown encoding: ' + encoding)
}
} else if (typeof val === 'number') {
val = val & 255
}
// Invalid ranges are not set to a default, so can range check early.
if (start < 0 || this.length < start || this.length < end) {
throw new RangeError('Out of range index')
}
if (end <= start) {
return this
}
start = start >>> 0
end = end === undefined ? this.length : end >>> 0
if (!val) val = 0
var i
if (typeof val === 'number') {
for (i = start; i < end; ++i) {
this[i] = val
}
} else {
var bytes = Buffer.isBuffer(val)
? val
: utf8ToBytes(new Buffer(val, encoding).toString())
var len = bytes.length
for (i = 0; i < end - start; ++i) {
this[i + start] = bytes[i % len]
}
}
return this
}
// HELPER FUNCTIONS
// ================
var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g
function base64clean (str) {
// Node strips out invalid characters like \n and \t from the string, base64-js does not
str = stringtrim(str).replace(INVALID_BASE64_RE, '')
// Node converts strings with length < 2 to ''
if (str.length < 2) return ''
// Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
while (str.length % 4 !== 0) {
str = str + '='
}
return str
}
function stringtrim (str) {
if (str.trim) return str.trim()
return str.replace(/^\s+|\s+$/g, '')
}
function toHex (n) {
if (n < 16) return '0' + n.toString(16)
return n.toString(16)
}
function utf8ToBytes (string, units) {
units = units || Infinity
var codePoint
var length = string.length
var leadSurrogate = null
var bytes = []
for (var i = 0; i < length; ++i) {
codePoint = string.charCodeAt(i)
// is surrogate component
if (codePoint > 0xD7FF && codePoint < 0xE000) {
// last char was a lead
if (!leadSurrogate) {
// no lead yet
if (codePoint > 0xDBFF) {
// unexpected trail
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
continue
} else if (i + 1 === length) {
// unpaired lead
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
continue
}
// valid lead
leadSurrogate = codePoint
continue
}
// 2 leads in a row
if (codePoint < 0xDC00) {
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
leadSurrogate = codePoint
continue
}
// valid surrogate pair
codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
} else if (leadSurrogate) {
// valid bmp char, but last char was a lead
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
}
leadSurrogate = null
// encode utf8
if (codePoint < 0x80) {
if ((units -= 1) < 0) break
bytes.push(codePoint)
} else if (codePoint < 0x800) {
if ((units -= 2) < 0) break
bytes.push(
codePoint >> 0x6 | 0xC0,
codePoint & 0x3F | 0x80
)
} else if (codePoint < 0x10000) {
if ((units -= 3) < 0) break
bytes.push(
codePoint >> 0xC | 0xE0,
codePoint >> 0x6 & 0x3F | 0x80,
codePoint & 0x3F | 0x80
)
} else if (codePoint < 0x110000) {
if ((units -= 4) < 0) break
bytes.push(
codePoint >> 0x12 | 0xF0,
codePoint >> 0xC & 0x3F | 0x80,
codePoint >> 0x6 & 0x3F | 0x80,
codePoint & 0x3F | 0x80
)
} else {
throw new Error('Invalid code point')
}
}
return bytes
}
function asciiToBytes (str) {
var byteArray = []
for (var i = 0; i < str.length; ++i) {
// Node's code seems to be doing this and not & 0x7F..
byteArray.push(str.charCodeAt(i) & 0xFF)
}
return byteArray
}
function utf16leToBytes (str, units) {
var c, hi, lo
var byteArray = []
for (var i = 0; i < str.length; ++i) {
if ((units -= 2) < 0) break
c = str.charCodeAt(i)
hi = c >> 8
lo = c % 256
byteArray.push(lo)
byteArray.push(hi)
}
return byteArray
}
function base64ToBytes (str) {
return base64.toByteArray(base64clean(str))
}
function blitBuffer (src, dst, offset, length) {
for (var i = 0; i < length; ++i) {
if ((i + offset >= dst.length) || (i >= src.length)) break
dst[i + offset] = src[i]
}
return i
}
function isnan (val) {
return val !== val // eslint-disable-line no-self-compare
}
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5)))
/***/ }),
/* 13 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
var punycode = __webpack_require__(33);
var util = __webpack_require__(34);
exports.parse = urlParse;
exports.resolve = urlResolve;
exports.resolveObject = urlResolveObject;
exports.format = urlFormat;
exports.Url = Url;
function Url() {
this.protocol = null;
this.slashes = null;
this.auth = null;
this.host = null;
this.port = null;
this.hostname = null;
this.hash = null;
this.search = null;
this.query = null;
this.pathname = null;
this.path = null;
this.href = null;
}
// Reference: RFC 3986, RFC 1808, RFC 2396
// define these here so at least they only have to be
// compiled once on the first module load.
var protocolPattern = /^([a-z0-9.+-]+:)/i,
portPattern = /:[0-9]*$/,
// Special case for a simple path URL
simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,
// RFC 2396: characters reserved for delimiting URLs.
// We actually just auto-escape these.
delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'],
// RFC 2396: characters not allowed for various reasons.
unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims),
// Allowed by RFCs, but cause of XSS attacks. Always escape these.
autoEscape = ['\''].concat(unwise),
// Characters that are never ever allowed in a hostname.
// Note that any invalid chars are also handled, but these
// are the ones that are *expected* to be seen, so we fast-path
// them.
nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),
hostEndingChars = ['/', '?', '#'],
hostnameMaxLen = 255,
hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,
hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,
// protocols that can allow "unsafe" and "unwise" chars.
unsafeProtocol = {
'javascript': true,
'javascript:': true
},
// protocols that never have a hostname.
hostlessProtocol = {
'javascript': true,
'javascript:': true
},
// protocols that always contain a // bit.
slashedProtocol = {
'http': true,
'https': true,
'ftp': true,
'gopher': true,
'file': true,
'http:': true,
'https:': true,
'ftp:': true,
'gopher:': true,
'file:': true
},
querystring = __webpack_require__(14);
function urlParse(url, parseQueryString, slashesDenoteHost) {
if (url && util.isObject(url) && url instanceof Url) return url;
var u = new Url;
u.parse(url, parseQueryString, slashesDenoteHost);
return u;
}
Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
if (!util.isString(url)) {
throw new TypeError("Parameter 'url' must be a string, not " + typeof url);
}
// Copy chrome, IE, opera backslash-handling behavior.
// Back slashes before the query string get converted to forward slashes
// See: https://code.google.com/p/chromium/issues/detail?id=25916
var queryIndex = url.indexOf('?'),
splitter =
(queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',
uSplit = url.split(splitter),
slashRegex = /\\/g;
uSplit[0] = uSplit[0].replace(slashRegex, '/');
url = uSplit.join(splitter);
var rest = url;
// trim before proceeding.
// This is to support parse stuff like " http://foo.com \n"
rest = rest.trim();
if (!slashesDenoteHost && url.split('#').length === 1) {
// Try fast path regexp
var simplePath = simplePathPattern.exec(rest);
if (simplePath) {
this.path = rest;
this.href = rest;
this.pathname = simplePath[1];
if (simplePath[2]) {
this.search = simplePath[2];
if (parseQueryString) {
this.query = querystring.parse(this.search.substr(1));
} else {
this.query = this.search.substr(1);
}
} else if (parseQueryString) {
this.search = '';
this.query = {};
}
return this;
}
}
var proto = protocolPattern.exec(rest);
if (proto) {
proto = proto[0];
var lowerProto = proto.toLowerCase();
this.protocol = lowerProto;
rest = rest.substr(proto.length);
}
// figure out if it's got a host
// user@server is *always* interpreted as a hostname, and url
// resolution will treat //foo/bar as host=foo,path=bar because that's
// how the browser resolves relative URLs.
if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
var slashes = rest.substr(0, 2) === '//';
if (slashes && !(proto && hostlessProtocol[proto])) {
rest = rest.substr(2);
this.slashes = true;
}
}
if (!hostlessProtocol[proto] &&
(slashes || (proto && !slashedProtocol[proto]))) {
// there's a hostname.
// the first instance of /, ?, ;, or # ends the host.
//
// If there is an @ in the hostname, then non-host chars *are* allowed
// to the left of the last @ sign, unless some host-ending character
// comes *before* the @-sign.
// URLs are obnoxious.
//
// ex:
// http://a@b@c/ => user:a@b host:c
// http://a@b?@c => user:a host:c path:/?@c
// v0.12 TODO(isaacs): This is not quite how Chrome does things.
// Review our test case against browsers more comprehensively.
// find the first instance of any hostEndingChars
var hostEnd = -1;
for (var i = 0; i < hostEndingChars.length; i++) {
var hec = rest.indexOf(hostEndingChars[i]);
if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
hostEnd = hec;
}
// at this point, either we have an explicit point where the
// auth portion cannot go past, or the last @ char is the decider.
var auth, atSign;
if (hostEnd === -1) {
// atSign can be anywhere.
atSign = rest.lastIndexOf('@');
} else {
// atSign must be in auth portion.
// http://a@b/c@d => host:b auth:a path:/c@d
atSign = rest.lastIndexOf('@', hostEnd);
}
// Now we have a portion which is definitely the auth.
// Pull that off.
if (atSign !== -1) {
auth = rest.slice(0, atSign);
rest = rest.slice(atSign + 1);
this.auth = decodeURIComponent(auth);
}
// the host is the remaining to the left of the first non-host char
hostEnd = -1;
for (var i = 0; i < nonHostChars.length; i++) {
var hec = rest.indexOf(nonHostChars[i]);
if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
hostEnd = hec;
}
// if we still have not hit it, then the entire thing is a host.
if (hostEnd === -1)
hostEnd = rest.length;
this.host = rest.slice(0, hostEnd);
rest = rest.slice(hostEnd);
// pull out port.
this.parseHost();
// we've indicated that there is a hostname,
// so even if it's empty, it has to be present.
this.hostname = this.hostname || '';
// if hostname begins with [ and ends with ]
// assume that it's an IPv6 address.
var ipv6Hostname = this.hostname[0] === '[' &&
this.hostname[this.hostname.length - 1] === ']';
// validate a little.
if (!ipv6Hostname) {
var hostparts = this.hostname.split(/\./);
for (var i = 0, l = hostparts.length; i < l; i++) {
var part = hostparts[i];
if (!part) continue;
if (!part.match(hostnamePartPattern)) {
var newpart = '';
for (var j = 0, k = part.length; j < k; j++) {
if (part.charCodeAt(j) > 127) {
// we replace non-ASCII char with a temporary placeholder
// we need this to make sure size of hostname is not
// broken by replacing non-ASCII by nothing
newpart += 'x';
} else {
newpart += part[j];
}
}
// we test again with ASCII char only
if (!newpart.match(hostnamePartPattern)) {
var validParts = hostparts.slice(0, i);
var notHost = hostparts.slice(i + 1);
var bit = part.match(hostnamePartStart);
if (bit) {
validParts.push(bit[1]);
notHost.unshift(bit[2]);
}
if (notHost.length) {
rest = '/' + notHost.join('.') + rest;
}
this.hostname = validParts.join('.');
break;
}
}
}
}
if (this.hostname.length > hostnameMaxLen) {
this.hostname = '';
} else {
// hostnames are always lower case.
this.hostname = this.hostname.toLowerCase();
}
if (!ipv6Hostname) {
// IDNA Support: Returns a punycoded representation of "domain".
// It only converts parts of the domain name that
// have non-ASCII characters, i.e. it doesn't matter if
// you call it with a domain that already is ASCII-only.
this.hostname = punycode.toASCII(this.hostname);
}
var p = this.port ? ':' + this.port : '';
var h = this.hostname || '';
this.host = h + p;
this.href += this.host;
// strip [ and ] from the hostname
// the host field still retains them, though
if (ipv6Hostname) {
this.hostname = this.hostname.substr(1, this.hostname.length - 2);
if (rest[0] !== '/') {
rest = '/' + rest;
}
}
}
// now rest is set to the post-host stuff.
// chop off any delim chars.
if (!unsafeProtocol[lowerProto]) {
// First, make 100% sure that any "autoEscape" chars get
// escaped, even if encodeURIComponent doesn't think they
// need to be.
for (var i = 0, l = autoEscape.length; i < l; i++) {
var ae = autoEscape[i];
if (rest.indexOf(ae) === -1)
continue;
var esc = encodeURIComponent(ae);
if (esc === ae) {
esc = escape(ae);
}
rest = rest.split(ae).join(esc);
}
}
// chop off from the tail first.
var hash = rest.indexOf('#');
if (hash !== -1) {
// got a fragment string.
this.hash = rest.substr(hash);
rest = rest.slice(0, hash);
}
var qm = rest.indexOf('?');
if (qm !== -1) {
this.search = rest.substr(qm);
this.query = rest.substr(qm + 1);
if (parseQueryString) {
this.query = querystring.parse(this.query);
}
rest = rest.slice(0, qm);
} else if (parseQueryString) {
// no query string, but parseQueryString still requested
this.search = '';
this.query = {};
}
if (rest) this.pathname = rest;
if (slashedProtocol[lowerProto] &&
this.hostname && !this.pathname) {
this.pathname = '/';
}
//to support http.request
if (this.pathname || this.search) {
var p = this.pathname || '';
var s = this.search || '';
this.path = p + s;
}
// finally, reconstruct the href based on what has been validated.
this.href = this.format();
return this;
};
// format a parsed object into a url string
function urlFormat(obj) {
// ensure it's an object, and not a string url.
// If it's an obj, this is a no-op.
// this way, you can call url_format() on strings
// to clean up potentially wonky urls.
if (util.isString(obj)) obj = urlParse(obj);
if (!(obj instanceof Url)) return Url.prototype.format.call(obj);
return obj.format();
}
Url.prototype.format = function() {
var auth = this.auth || '';
if (auth) {
auth = encodeURIComponent(auth);
auth = auth.replace(/%3A/i, ':');
auth += '@';
}
var protocol = this.protocol || '',
pathname = this.pathname || '',
hash = this.hash || '',
host = false,
query = '';
if (this.host) {
host = auth + this.host;
} else if (this.hostname) {
host = auth + (this.hostname.indexOf(':') === -1 ?
this.hostname :
'[' + this.hostname + ']');
if (this.port) {
host += ':' + this.port;
}
}
if (this.query &&
util.isObject(this.query) &&
Object.keys(this.query).length) {
query = querystring.stringify(this.query);
}
var search = this.search || (query && ('?' + query)) || '';
if (protocol && protocol.substr(-1) !== ':') protocol += ':';
// only the slashedProtocols get the //. Not mailto:, xmpp:, etc.
// unless they had them to begin with.
if (this.slashes ||
(!protocol || slashedProtocol[protocol]) && host !== false) {
host = '//' + (host || '');
if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;
} else if (!host) {
host = '';
}
if (hash && hash.charAt(0) !== '#') hash = '#' + hash;
if (search && search.charAt(0) !== '?') search = '?' + search;
pathname = pathname.replace(/[?#]/g, function(match) {
return encodeURIComponent(match);
});
search = search.replace('#', '%23');
return protocol + host + pathname + search + hash;
};
function urlResolve(source, relative) {
return urlParse(source, false, true).resolve(relative);
}
Url.prototype.resolve = function(relative) {
return this.resolveObject(urlParse(relative, false, true)).format();
};
function urlResolveObject(source, relative) {
if (!source) return relative;
return urlParse(source, false, true).resolveObject(relative);
}
Url.prototype.resolveObject = function(relative) {
if (util.isString(relative)) {
var rel = new Url();
rel.parse(relative, false, true);
relative = rel;
}
var result = new Url();
var tkeys = Object.keys(this);
for (var tk = 0; tk < tkeys.length; tk++) {
var tkey = tkeys[tk];
result[tkey] = this[tkey];
}
// hash is always overridden, no matter what.
// even href="" will remove it.
result.hash = relative.hash;
// if the relative url is empty, then there's nothing left to do here.
if (relative.href === '') {
result.href = result.format();
return result;
}
// hrefs like //foo/bar always cut to the protocol.
if (relative.slashes && !relative.protocol) {
// take everything except the protocol from relative
var rkeys = Object.keys(relative);
for (var rk = 0; rk < rkeys.length; rk++) {
var rkey = rkeys[rk];
if (rkey !== 'protocol')
result[rkey] = relative[rkey];
}
//urlParse appends trailing / to urls like http://www.example.com
if (slashedProtocol[result.protocol] &&
result.hostname && !result.pathname) {
result.path = result.pathname = '/';
}
result.href = result.format();
return result;
}
if (relative.protocol && relative.protocol !== result.protocol) {
// if it's a known url protocol, then changing
// the protocol does weird things
// first, if it's not file:, then we MUST have a host,
// and if there was a path
// to begin with, then we MUST have a path.
// if it is file:, then the host is dropped,
// because that's known to be hostless.
// anything else is assumed to be absolute.
if (!slashedProtocol[relative.protocol]) {
var keys = Object.keys(relative);
for (var v = 0; v < keys.length; v++) {
var k = keys[v];
result[k] = relative[k];
}
result.href = result.format();
return result;
}
result.protocol = relative.protocol;
if (!relative.host && !hostlessProtocol[relative.protocol]) {
var relPath = (relative.pathname || '').split('/');
while (relPath.length && !(relative.host = relPath.shift()));
if (!relative.host) relative.host = '';
if (!relative.hostname) relative.hostname = '';
if (relPath[0] !== '') relPath.unshift('');
if (relPath.length < 2) relPath.unshift('');
result.pathname = relPath.join('/');
} else {
result.pathname = relative.pathname;
}
result.search = relative.search;
result.query = relative.query;
result.host = relative.host || '';
result.auth = relative.auth;
result.hostname = relative.hostname || relative.host;
result.port = relative.port;
// to support http.request
if (result.pathname || result.search) {
var p = result.pathname || '';
var s = result.search || '';
result.path = p + s;
}
result.slashes = result.slashes || relative.slashes;
result.href = result.format();
return result;
}
var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),
isRelAbs = (
relative.host ||
relative.pathname && relative.pathname.charAt(0) === '/'
),
mustEndAbs = (isRelAbs || isSourceAbs ||
(result.host && relative.pathname)),
removeAllDots = mustEndAbs,
srcPath = result.pathname && result.pathname.split('/') || [],
relPath = relative.pathname && relative.pathname.split('/') || [],
psychotic = result.protocol && !slashedProtocol[result.protocol];
// if the url is a non-slashed url, then relative
// links like ../.. should be able
// to crawl up to the hostname, as well. This is strange.
// result.protocol has already been set by now.
// Later on, put the first path part into the host field.
if (psychotic) {
result.hostname = '';
result.port = null;
if (result.host) {
if (srcPath[0] === '') srcPath[0] = result.host;
else srcPath.unshift(result.host);
}
result.host = '';
if (relative.protocol) {
relative.hostname = null;
relative.port = null;
if (relative.host) {
if (relPath[0] === '') relPath[0] = relative.host;
else relPath.unshift(relative.host);
}
relative.host = null;
}
mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');
}
if (isRelAbs) {
// it's absolute.
result.host = (relative.host || relative.host === '') ?
relative.host : result.host;
result.hostname = (relative.hostname || relative.hostname === '') ?
relative.hostname : result.hostname;
result.search = relative.search;
result.query = relative.query;
srcPath = relPath;
// fall through to the dot-handling below.
} else if (relPath.length) {
// it's relative
// throw away the existing file, and take the new path instead.
if (!srcPath) srcPath = [];
srcPath.pop();
srcPath = srcPath.concat(relPath);
result.search = relative.search;
result.query = relative.query;
} else if (!util.isNullOrUndefined(relative.search)) {
// just pull out the search.
// like href='?foo'.
// Put this after the other two cases because it simplifies the booleans
if (psychotic) {
result.hostname = result.host = srcPath.shift();
//occationaly the auth can get stuck only in host
//this especially happens in cases like
//url.resolveObject('mailto:local1@domain1', 'local2@domain2')
var authInHost = result.host && result.host.indexOf('@') > 0 ?
result.host.split('@') : false;
if (authInHost) {
result.auth = authInHost.shift();
result.host = result.hostname = authInHost.shift();
}
}
result.search = relative.search;
result.query = relative.query;
//to support http.request
if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
result.path = (result.pathname ? result.pathname : '') +
(result.search ? result.search : '');
}
result.href = result.format();
return result;
}
if (!srcPath.length) {
// no path at all. easy.
// we've already handled the other stuff above.
result.pathname = null;
//to support http.request
if (result.search) {
result.path = '/' + result.search;
} else {
result.path = null;
}
result.href = result.format();
return result;
}
// if a url ENDs in . or .., then it must get a trailing slash.
// however, if it ends in anything else non-slashy,
// then it must NOT get a trailing slash.
var last = srcPath.slice(-1)[0];
var hasTrailingSlash = (
(result.host || relative.host || srcPath.length > 1) &&
(last === '.' || last === '..') || last === '');
// strip single dots, resolve double dots to parent dir
// if the path tries to go above the root, `up` ends up > 0
var up = 0;
for (var i = srcPath.length; i >= 0; i--) {
last = srcPath[i];
if (last === '.') {
srcPath.splice(i, 1);
} else if (last === '..') {
srcPath.splice(i, 1);
up++;
} else if (up) {
srcPath.splice(i, 1);
up--;
}
}
// if the path is allowed to go above the root, restore leading ..s
if (!mustEndAbs && !removeAllDots) {
for (; up--; up) {
srcPath.unshift('..');
}
}
if (mustEndAbs && srcPath[0] !== '' &&
(!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
srcPath.unshift('');
}
if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {
srcPath.push('');
}
var isAbsolute = srcPath[0] === '' ||
(srcPath[0] && srcPath[0].charAt(0) === '/');
// put the host back
if (psychotic) {
result.hostname = result.host = isAbsolute ? '' :
srcPath.length ? srcPath.shift() : '';
//occationaly the auth can get stuck only in host
//this especially happens in cases like
//url.resolveObject('mailto:local1@domain1', 'local2@domain2')
var authInHost = result.host && result.host.indexOf('@') > 0 ?
result.host.split('@') : false;
if (authInHost) {
result.auth = authInHost.shift();
result.host = result.hostname = authInHost.shift();
}
}
mustEndAbs = mustEndAbs || (result.host && srcPath.length);
if (mustEndAbs && !isAbsolute) {
srcPath.unshift('');
}
if (!srcPath.length) {
result.pathname = null;
result.path = null;
} else {
result.pathname = srcPath.join('/');
}
//to support request.http
if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
result.path = (result.pathname ? result.pathname : '') +
(result.search ? result.search : '');
}
result.auth = relative.auth || result.auth;
result.slashes = result.slashes || relative.slashes;
result.href = result.format();
return result;
};
Url.prototype.parseHost = function() {
var host = this.host;
var port = portPattern.exec(host);
if (port) {
port = port[0];
if (port !== ':') {
this.port = port.substr(1);
}
host = host.substr(0, host.length - port.length);
}
if (host) this.hostname = host;
};
/***/ }),
/* 14 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
exports.decode = exports.parse = __webpack_require__(35);
exports.encode = exports.stringify = __webpack_require__(36);
/***/ }),
/* 15 */
/***/ (function(module, exports) {
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
function EventEmitter() {
this._events = this._events || {};
this._maxListeners = this._maxListeners || undefined;
}
module.exports = EventEmitter;
// Backwards-compat with node 0.10.x
EventEmitter.EventEmitter = EventEmitter;
EventEmitter.prototype._events = undefined;
EventEmitter.prototype._maxListeners = undefined;
// By default EventEmitters will print a warning if more than 10 listeners are
// added to it. This is a useful default which helps finding memory leaks.
EventEmitter.defaultMaxListeners = 10;
// Obviously not all Emitters should be limited to 10. This function allows
// that to be increased. Set to zero for unlimited.
EventEmitter.prototype.setMaxListeners = function(n) {
if (!isNumber(n) || n < 0 || isNaN(n))
throw TypeError('n must be a positive number');
this._maxListeners = n;
return this;
};
EventEmitter.prototype.emit = function(type) {
var er, handler, len, args, i, listeners;
if (!this._events)
this._events = {};
// If there is no 'error' event listener then throw.
if (type === 'error') {
if (!this._events.error ||
(isObject(this._events.error) && !this._events.error.length)) {
er = arguments[1];
if (er instanceof Error) {
throw er; // Unhandled 'error' event
} else {
// At least give some kind of context to the user
var err = new Error('Uncaught, unspecified "error" event. (' + er + ')');
err.context = er;
throw err;
}
}
}
handler = this._events[type];
if (isUndefined(handler))
return false;
if (isFunction(handler)) {
switch (arguments.length) {
// fast cases
case 1:
handler.call(this);
break;
case 2:
handler.call(this, arguments[1]);
break;
case 3:
handler.call(this, arguments[1], arguments[2]);
break;
// slower
default:
args = Array.prototype.slice.call(arguments, 1);
handler.apply(this, args);
}
} else if (isObject(handler)) {
args = Array.prototype.slice.call(arguments, 1);
listeners = handler.slice();
len = listeners.length;
for (i = 0; i < len; i++)
listeners[i].apply(this, args);
}
return true;
};
EventEmitter.prototype.addListener = function(type, listener) {
var m;
if (!isFunction(listener))
throw TypeError('listener must be a function');
if (!this._events)
this._events = {};
// To avoid recursion in the case that type === "newListener"! Before
// adding it to the listeners, first emit "newListener".
if (this._events.newListener)
this.emit('newListener', type,
isFunction(listener.listener) ?
listener.listener : listener);
if (!this._events[type])
// Optimize the case of one listener. Don't need the extra array object.
this._events[type] = listener;
else if (isObject(this._events[type]))
// If we've already got an array, just append.
this._events[type].push(listener);
else
// Adding the second element, need to change to array.
this._events[type] = [this._events[type], listener];
// Check for listener leak
if (isObject(this._events[type]) && !this._events[type].warned) {
if (!isUndefined(this._maxListeners)) {
m = this._maxListeners;
} else {
m = EventEmitter.defaultMaxListeners;
}
if (m && m > 0 && this._events[type].length > m) {
this._events[type].warned = true;
console.error('(node) warning: possible EventEmitter memory ' +
'leak detected. %d listeners added. ' +
'Use emitter.setMaxListeners() to increase limit.',
this._events[type].length);
if (typeof console.trace === 'function') {
// not supported in IE 10
console.trace();
}
}
}
return this;
};
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
EventEmitter.prototype.once = function(type, listener) {
if (!isFunction(listener))
throw TypeError('listener must be a function');
var fired = false;
function g() {
this.removeListener(type, g);
if (!fired) {
fired = true;
listener.apply(this, arguments);
}
}
g.listener = listener;
this.on(type, g);
return this;
};
// emits a 'removeListener' event iff the listener was removed
EventEmitter.prototype.removeListener = function(type, listener) {
var list, position, length, i;
if (!isFunction(listener))
throw TypeError('listener must be a function');
if (!this._events || !this._events[type])
return this;
list = this._events[type];
length = list.length;
position = -1;
if (list === listener ||
(isFunction(list.listener) && list.listener === listener)) {
delete this._events[type];
if (this._events.removeListener)
this.emit('removeListener', type, listener);
} else if (isObject(list)) {
for (i = length; i-- > 0;) {
if (list[i] === listener ||
(list[i].listener && list[i].listener === listener)) {
position = i;
break;
}
}
if (position < 0)
return this;
if (list.length === 1) {
list.length = 0;
delete this._events[type];
} else {
list.splice(position, 1);
}
if (this._events.removeListener)
this.emit('removeListener', type, listener);
}
return this;
};
EventEmitter.prototype.removeAllListeners = function(type) {
var key, listeners;
if (!this._events)
return this;
// not listening for removeListener, no need to emit
if (!this._events.removeListener) {
if (arguments.length === 0)
this._events = {};
else if (this._events[type])
delete this._events[type];
return this;
}
// emit removeListener for all listeners on all events
if (arguments.length === 0) {
for (key in this._events) {
if (key === 'removeListener') continue;
this.removeAllListeners(key);
}
this.removeAllListeners('removeListener');
this._events = {};
return this;
}
listeners = this._events[type];
if (isFunction(listeners)) {
this.removeListener(type, listeners);
} else if (listeners) {
// LIFO order
while (listeners.length)
this.removeListener(type, listeners[listeners.length - 1]);
}
delete this._events[type];
return this;
};
EventEmitter.prototype.listeners = function(type) {
var ret;
if (!this._events || !this._events[type])
ret = [];
else if (isFunction(this._events[type]))
ret = [this._events[type]];
else
ret = this._events[type].slice();
return ret;
};
EventEmitter.prototype.listenerCount = function(type) {
if (this._events) {
var evlistener = this._events[type];
if (isFunction(evlistener))
return 1;
else if (evlistener)
return evlistener.length;
}
return 0;
};
EventEmitter.listenerCount = function(emitter, type) {
return emitter.listenerCount(type);
};
function isFunction(arg) {
return typeof arg === 'function';
}
function isNumber(arg) {
return typeof arg === 'number';
}
function isObject(arg) {
return typeof arg === 'object' && arg !== null;
}
function isUndefined(arg) {
return arg === void 0;
}
/***/ }),
/* 16 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
module.exports = {
console: __webpack_require__(39)
};
/***/ }),
/* 17 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var _ = __webpack_require__(0);
var utils = __webpack_require__(2);
/**
* Abstract class providing common functionality to loggers
* @param {[type]} log [description]
* @param {[type]} config [description]
*/
function LoggerAbstract(log, config) {
this.log = log;
this.listeningLevels = [];
utils.makeBoundMethods(this); // when the log closes, remove our event listeners
this.log.once('closing', this.bound.cleanUpListeners);
this.setupListeners(config.levels);
}
function padNumToTen(n) {
return n < 10 ? '0' + n.toString(10) : n.toString(10);
}
/**
* Create a timestamp string used in the format function. Defers to Log.timestamp if it is defined,
* Also, feel free to override this at the logger level.
* @return {String} - Timestamp in ISO 8601 UTC
*/
LoggerAbstract.prototype.timestamp = function () {
var d = new Date();
return d.getUTCFullYear() + '-' + padNumToTen(d.getUTCMonth() + 1) + '-' + padNumToTen(d.getUTCDate()) + 'T' + padNumToTen(d.getUTCHours()) + ':' + padNumToTen(d.getUTCMinutes()) + ':' + padNumToTen(d.getUTCSeconds()) + 'Z';
};
function indent(text, spaces) {
var space = utils.repeat(' ', spaces || 2);
return (text || '').split(/\r?\n/).map(function (line) {
return space + line;
}).join('\n');
}
LoggerAbstract.prototype.format = function (label, message) {
return label + ': ' + this.timestamp() + '\n' + indent(message) + '\n\n';
};
LoggerAbstract.prototype.write = function () {
throw new Error('This should be overwritten by the logger');
};
/**
* Clear the current event listeners and then re-listen for events based on the level specified
*
* @method setupListeners
* @private
* @param {Integer} level - The max log level that this logger should listen to
* @return {undefined}
*/
LoggerAbstract.prototype.setupListeners = function (levels) {
this.cleanUpListeners();
this.listeningLevels = [];
_.each(levels, _.bind(function (level) {
var fnName = 'on' + utils.ucfirst(level);
if (this.bound[fnName]) {
this.listeningLevels.push(level);
this.log.on(level, this.bound[fnName]);
} else {
throw new Error('Unable to listen for level "' + level + '"');
}
}, this));
};
/**
* Clear the current event listeners
*
* @method cleanUpListeners
* @private
* @return {undefined}
*/
LoggerAbstract.prototype.cleanUpListeners = utils.handler(function () {
_.each(this.listeningLevels, _.bind(function (level) {
this.log.removeListener(level, this.bound['on' + utils.ucfirst(level)]);
}, this));
});
/**
* Handler for the logs "error" event
*
* @method onError
* @private
* @param {Error} e - The Error object to log
* @return {undefined}
*/
LoggerAbstract.prototype.onError = utils.handler(function (e) {
this.write(e.name === 'Error' ? 'ERROR' : e.name, e.stack);
});
/**
* Handler for the logs "warning" event
*
* @method onWarning
* @private
* @param {String} msg - The message to be logged
* @return {undefined}
*/
LoggerAbstract.prototype.onWarning = utils.handler(function (msg) {
this.write('WARNING', msg);
});
/**
* Handler for the logs "info" event
*
* @method onInfo
* @private
* @param {String} msg - The message to be logged
* @return {undefined}
*/
LoggerAbstract.prototype.onInfo = utils.handler(function (msg) {
this.write('INFO', msg);
});
/**
* Handler for the logs "debug" event
*
* @method onDebug
* @private
* @param {String} msg - The message to be logged
* @return {undefined}
*/
LoggerAbstract.prototype.onDebug = utils.handler(function (msg) {
this.write('DEBUG', msg);
});
/**
* Handler for the logs "trace" event
*
* @method onTrace
* @private
* @param {String} msg - The message to be logged
* @return {undefined}
*/
LoggerAbstract.prototype.onTrace = utils.handler(function (requestDetails) {
this.write('TRACE', this._formatTraceMessage(requestDetails));
});
LoggerAbstract.prototype._formatTraceMessage = function (req) {
return '-> ' + req.method + ' ' + req.url + '\n' + this._prettyJson(req.body) + '\n' + '<- ' + req.status + '\n' + this._prettyJson(req.response);
/*
-> GET https://sldfkjsdlfksjdf:9200/slsdkfjlxckvxhclks?sdlkj=sdlfkje
{
asdflksjdf
}
<- 502
{
sldfksjdlf
}
*/
};
LoggerAbstract.prototype._prettyJson = function (body) {
try {
if (typeof body === 'string') {
body = JSON.parse(body);
}
return JSON.stringify(body, null, ' ').replace(/'/g, "\\u0027");
} catch (e) {
return typeof body === 'string' ? body : '';
}
};
module.exports = LoggerAbstract;
/***/ }),
/* 18 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
module.exports = {
random: __webpack_require__(40),
roundRobin: __webpack_require__(41)
};
/***/ }),
/* 19 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var opts = {
xhr: __webpack_require__(42),
jquery: __webpack_require__(43),
angular: __webpack_require__(44)
};
var _ = __webpack_require__(0); // remove modules that have been ignored by browserify
_.each(opts, function (conn, name) {
if (typeof conn !== 'function') {
delete opts[name];
}
}); // custom _default specification
if (opts.xhr) {
opts._default = 'xhr';
} else if (opts.angular) {
opts._default = 'angular';
} else {
opts._default = 'jquery';
}
module.exports = opts;
/***/ }),
/* 20 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
module.exports = ConnectionAbstract;
var _ = __webpack_require__(0);
var utils = __webpack_require__(2);
var EventEmitter = __webpack_require__(15).EventEmitter;
var Log = __webpack_require__(6);
var Host = __webpack_require__(8);
var errors = __webpack_require__(4);
/**
* Abstract class used for Connection classes
* @class ConnectionAbstract
* @constructor
*/
function ConnectionAbstract(host, config) {
config = config || {};
EventEmitter.call(this);
this.log = config.log || new Log();
this.pingTimeout = config.pingTimeout || 3000;
if (!host) {
throw new TypeError('Missing host');
} else if (host instanceof Host) {
this.host = host;
} else {
throw new TypeError('Invalid host');
}
utils.makeBoundMethods(this);
}
utils.inherits(ConnectionAbstract, EventEmitter);
/**
* Make a request using this connection. Must be overridden by Connection classes, which can add whatever keys to
* params that they like. These are just the basics.
*
* @param [params] {Object} - The parameters for the request
* @param params.path {String} - The path for which you are requesting
* @param params.method {String} - The HTTP method for the request (GET, HEAD, etc.)
* @param params.requestTimeout {Integer} - The amount of time in milliseconds that this request should be allowed to run for.
* @param cb {Function} - A callback to be called once with `cb(err, responseBody, responseStatus)`
*/
ConnectionAbstract.prototype.request = function () {
throw new Error('Connection#request must be overwritten by the Connector');
};
ConnectionAbstract.prototype.ping = function (params, cb) {
if (typeof params === 'function') {
cb = params;
params = null;
} else {
cb = typeof cb === 'function' ? cb : null;
}
var requestTimeout = this.pingTimeout;
var requestTimeoutId;
var aborted;
var abort;
if (params && params.hasOwnProperty('requestTimeout')) {
requestTimeout = params.requestTimeout;
}
abort = this.request(_.defaults(params || {}, {
path: '/',
method: 'HEAD'
}), function (err) {
if (aborted) {
return;
}
clearTimeout(requestTimeoutId);
if (cb) {
cb(err);
}
});
if (requestTimeout) {
requestTimeoutId = setTimeout(function () {
if (abort) {
abort();
}
aborted = true;
if (cb) {
cb(new errors.RequestTimeout('Ping Timeout after ' + requestTimeout + 'ms'));
}
}, requestTimeout);
}
};
ConnectionAbstract.prototype.setStatus = function (status) {
var origStatus = this.status;
this.status = status;
this.emit('status set', status, origStatus, this);
if (status === 'closed') {
this.removeAllListeners();
}
};
/***/ }),
/* 21 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
module.exports = {
angular: __webpack_require__(45),
json: __webpack_require__(22)
};
/***/ }),
/* 22 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
/**
* Simple JSON serializer
* @type {[type]}
*/
module.exports = Json;
var _ = __webpack_require__(0);
function Json() {}
/**
* Converts a value into a string, or an error
* @param {*} val - Any value, methods are stripped and
* see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify about other params
* @return {String|Error} - A string is always returned, unless an error occured. then it will be that error.
*/
Json.prototype.serialize = function (val, replacer, spaces) {
switch (_typeof(val)) {
case 'string':
return val;
case 'object':
if (val) {
return JSON.stringify(val, replacer, spaces);
}
/* falls through */
default:
return;
}
};
Json.prototype.serialize.contentType = 'application/json';
/**
* Parse a JSON string, if it is already parsed it is ignored
* @param {String} str - the string to parse
* @return {[type]}
*/
Json.prototype.deserialize = function (str) {
if (typeof str === 'string') {
try {
return JSON.parse(str);
} catch (e) {}
}
};
Json.prototype.bulkBody = function (val) {
var body = '',
i;
if (_.isArray(val)) {
for (i = 0; i < val.length; i++) {
body += this.serialize(val[i]) + '\n';
}
} else if (typeof val === 'string') {
// make sure the string ends in a new line
body = val + (val[val.length - 1] === '\n' ? '' : '\n');
} else {
throw new TypeError('Bulk body should either be an Array of commands/string, or a String');
}
return body;
};
Json.prototype.bulkBody.contentType = 'application/x-ndjson';
/***/ }),
/* 23 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var _ = __webpack_require__(0);
var extractHostPartsRE1x = /\[(?:(.*)\/)?(.+?):(\d+)\]/;
function makeNodeParser(hostProp) {
return function (nodes) {
return _.transform(nodes, function (hosts, node, id) {
var address = _.get(node, hostProp);
if (!address) return;
var host = {
host: undefined,
port: undefined,
_meta: {
id: id,
name: node.name,
version: node.version
}
};
var malformedError = new Error('Malformed ' + hostProp + '.' + ' Got ' + JSON.stringify(address) + ' and expected it to match "{hostname?}/{ip}:{port}".');
var matches1x = extractHostPartsRE1x.exec(address);
if (matches1x) {
host.host = matches1x[1] || matches1x[2];
host.port = parseInt(matches1x[3], 10);
hosts.push(host);
return;
}
if (address.indexOf('/') > -1) {
var withHostParts = address.split('/');
if (withHostParts.length !== 2) throw malformedError;
host.host = withHostParts.shift();
address = withHostParts.shift();
}
if (address.indexOf(':') < 0) {
throw malformedError;
}
var addressParts = address.split(':');
if (addressParts.length !== 2) {
throw malformedError;
}
host.host = host.host || addressParts[0];
host.port = parseInt(addressParts[1], 10);
hosts.push(host);
}, []);
};
}
module.exports = makeNodeParser('http.publish_address');
/***/ }),
/* 24 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
module.exports = {
'_default': __webpack_require__(25),
'6.2': __webpack_require__(25),
'6.1': __webpack_require__(46),
'6.0': __webpack_require__(47),
'5.6': __webpack_require__(48),
'5.5': __webpack_require__(49),
'6.x': __webpack_require__(50),
'master': __webpack_require__(51)
};
/***/ }),
/* 25 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var ca = __webpack_require__(1).makeFactoryWithModifier(function (spec) {
return __webpack_require__(0).merge(spec, {
params: {
filterPath: {
type: 'list',
name: 'filter_path'
}
}
});
});
var namespace = __webpack_require__(1).namespaceFactory;
var api = module.exports = {};
api._namespaces = ['cat', 'cluster', 'indices', 'ingest', 'nodes', 'snapshot', 'tasks'];
/**
* Perform a [bulk](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-bulk.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the bulk operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the effected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.type - Default document type for items which don't provide one
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - Default comma-separated list of fields to return in the response for updates, can be overridden on each sub-request
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or default list of fields to return, can be overridden on each sub-request
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - Default list of fields to exclude from the returned _source field, can be overridden on each sub-request
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - Default list of fields to extract and return from the _source field, can be overridden on each sub-request
* @param {<<api-param-type-string,`String`>>} params.pipeline - The pipeline id to preprocess incoming documents with
* @param {<<api-param-type-string,`String`>>} params.index - Default index for items which don't provide one
*/
api.bulk = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
type: {
type: 'string'
},
fields: {
type: 'list'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
pipeline: {
type: 'string'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_bulk',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/_bulk',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_bulk'
}],
needBody: true,
bulkBody: true,
method: 'POST'
});
api.cat = namespace();
/**
* Perform a [cat.aliases](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - A comma-separated list of alias names to return
*/
api.cat.prototype.aliases = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/aliases/<%=name%>',
req: {
name: {
type: 'list'
}
}
}, {
fmt: '/_cat/aliases'
}]
});
/**
* Perform a [cat.allocation](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-allocation.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information
*/
api.cat.prototype.allocation = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/allocation/<%=nodeId%>',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_cat/allocation'
}]
});
/**
* Perform a [cat.count](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-count.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.count = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/count/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/count'
}]
});
/**
* Perform a [cat.fielddata](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-fielddata.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to return the fielddata size
*/
api.cat.prototype.fielddata = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
},
fields: {
type: 'list'
}
},
urls: [{
fmt: '/_cat/fielddata/<%=fields%>',
req: {
fields: {
type: 'list'
}
}
}, {
fmt: '/_cat/fielddata'
}]
});
/**
* Perform a [cat.health](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-health.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} [params.ts=true] - Set to false to disable timestamping
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.health = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
ts: {
type: 'boolean',
'default': true
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/health'
}
});
/**
* Perform a [cat.help](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
*/
api.cat.prototype.help = ca({
params: {
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
}
},
url: {
fmt: '/_cat'
}
});
/**
* Perform a [cat.indices](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-indices.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-string,`String`>>} params.health - A health status ("green", "yellow", or "red" to filter only indices matching the specified health status
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-boolean,`Boolean`>>} params.pri - Set to true to return stats only for primary shards
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.indices = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'm', 'g']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
health: {
type: 'enum',
'default': null,
options: ['green', 'yellow', 'red']
},
help: {
type: 'boolean',
'default': false
},
pri: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/indices/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/indices'
}]
});
/**
* Perform a [cat.master](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-master.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.master = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/master'
}
});
/**
* Perform a [cat.nodeattrs](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-nodeattrs.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.nodeattrs = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/nodeattrs'
}
});
/**
* Perform a [cat.nodes](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-nodes.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.fullId - Return the full node ID instead of the shortened version (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.nodes = ca({
params: {
format: {
type: 'string'
},
fullId: {
type: 'boolean',
name: 'full_id'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/nodes'
}
});
/**
* Perform a [cat.pendingTasks](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-pending-tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.pendingTasks = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/pending_tasks'
}
});
/**
* Perform a [cat.plugins](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-plugins.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.plugins = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/plugins'
}
});
/**
* Perform a [cat.recovery](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-recovery.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.recovery = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/recovery/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/recovery'
}]
});
/**
* Perform a [cat.repositories](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-repositories.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.repositories = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean',
'default': false
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/repositories'
}
});
/**
* Perform a [cat.segments](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-segments.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.segments = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/segments/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/segments'
}]
});
/**
* Perform a [cat.shards](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-shards.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.shards = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/shards/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/shards'
}]
});
/**
* Perform a [cat.snapshots](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Set to true to ignore unavailable snapshots
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.repository - Name of repository from which to fetch the snapshot information
*/
api.cat.prototype.snapshots = ca({
params: {
format: {
type: 'string'
},
ignoreUnavailable: {
type: 'boolean',
'default': false,
name: 'ignore_unavailable'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/snapshots/<%=repository%>',
req: {
repository: {
type: 'list'
}
}
}, {
fmt: '/_cat/snapshots'
}]
});
/**
* Perform a [cat.tasks](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.actions - A comma-separated list of actions that should be returned. Leave empty to return all.
* @param {<<api-param-type-boolean,`Boolean`>>} params.detailed - Return detailed task information (default: false)
* @param {<<api-param-type-string,`String`>>} params.parentNode - Return tasks with specified parent node.
* @param {<<api-param-type-number,`Number`>>} params.parentTask - Return tasks with specified parent task id. Set to -1 to return all.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.tasks = ca({
params: {
format: {
type: 'string'
},
nodeId: {
type: 'list',
name: 'node_id'
},
actions: {
type: 'list'
},
detailed: {
type: 'boolean'
},
parentNode: {
type: 'string',
name: 'parent_node'
},
parentTask: {
type: 'number',
name: 'parent_task'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/tasks'
}
});
/**
* Perform a [cat.templates](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>} params.name - A pattern that returned template names must match
*/
api.cat.prototype.templates = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/templates/<%=name%>',
req: {
name: {
type: 'string'
}
}
}, {
fmt: '/_cat/templates'
}]
});
/**
* Perform a [cat.threadPool](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cat-thread-pool.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.size - The multiplier in which to display values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.threadPoolPatterns - A comma-separated list of regular-expressions to filter the thread pools in the output
*/
api.cat.prototype.threadPool = ca({
params: {
format: {
type: 'string'
},
size: {
type: 'enum',
options: ['', 'k', 'm', 'g', 't', 'p']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/thread_pool/<%=threadPoolPatterns%>',
req: {
threadPoolPatterns: {
type: 'list'
}
}
}, {
fmt: '/_cat/thread_pool'
}]
});
/**
* Perform a [clearScroll](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/search-request-scroll.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.scrollId - A comma-separated list of scroll IDs to clear
*/
api.clearScroll = ca({
urls: [{
fmt: '/_search/scroll/<%=scrollId%>',
req: {
scrollId: {
type: 'list'
}
}
}, {
fmt: '/_search/scroll'
}],
paramAsBody: {
param: 'scrollId',
body: 'scroll_id'
},
method: 'DELETE'
});
api.cluster = namespace();
/**
* Perform a [cluster.allocationExplain](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cluster-allocation-explain.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeYesDecisions - Return 'YES' decisions in explanation (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDiskInfo - Return information about disk usage and shard sizes (default: false)
*/
api.cluster.prototype.allocationExplain = ca({
params: {
includeYesDecisions: {
type: 'boolean',
name: 'include_yes_decisions'
},
includeDiskInfo: {
type: 'boolean',
name: 'include_disk_info'
}
},
url: {
fmt: '/_cluster/allocation/explain'
},
method: 'POST'
});
/**
* Perform a [cluster.getSettings](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cluster-update-settings.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether to return all default clusters setting.
*/
api.cluster.prototype.getSettings = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
},
includeDefaults: {
type: 'boolean',
'default': false,
name: 'include_defaults'
}
},
url: {
fmt: '/_cluster/settings'
}
});
/**
* Perform a [cluster.health](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cluster-health.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} [params.level=cluster] - Specify the level of detail for returned information
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Wait until the specified number of shards is active
* @param {<<api-param-type-string,`String`>>} params.waitForNodes - Wait until the specified number of nodes is available
* @param {<<api-param-type-string,`String`>>} params.waitForEvents - Wait until all currently queued events with the given priority are processed
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForNoRelocatingShards - Whether to wait until there are no relocating shards in the cluster
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForNoInitializingShards - Whether to wait until there are no initializing shards in the cluster
* @param {<<api-param-type-string,`String`>>} params.waitForStatus - Wait until cluster is in a specific state
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - Limit the information returned to a specific index
*/
api.cluster.prototype.health = ca({
params: {
level: {
type: 'enum',
'default': 'cluster',
options: ['cluster', 'indices', 'shards']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
waitForNodes: {
type: 'string',
name: 'wait_for_nodes'
},
waitForEvents: {
type: 'enum',
options: ['immediate', 'urgent', 'high', 'normal', 'low', 'languid'],
name: 'wait_for_events'
},
waitForNoRelocatingShards: {
type: 'boolean',
name: 'wait_for_no_relocating_shards'
},
waitForNoInitializingShards: {
type: 'boolean',
name: 'wait_for_no_initializing_shards'
},
waitForStatus: {
type: 'enum',
'default': null,
options: ['green', 'yellow', 'red'],
name: 'wait_for_status'
}
},
urls: [{
fmt: '/_cluster/health/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cluster/health'
}]
});
/**
* Perform a [cluster.pendingTasks](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cluster-pending.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
*/
api.cluster.prototype.pendingTasks = ca({
params: {
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_cluster/pending_tasks'
}
});
/**
* Perform a [cluster.putSettings](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cluster-update-settings.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
*/
api.cluster.prototype.putSettings = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_cluster/settings'
},
needBody: true,
method: 'PUT'
});
/**
* Perform a [cluster.remoteInfo](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cluster-remote-info.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
*/
api.cluster.prototype.remoteInfo = ca({
url: {
fmt: '/_remote/info'
}
});
/**
* Perform a [cluster.reroute](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cluster-reroute.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.dryRun - Simulate the operation only and return the resulting state
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - Return an explanation of why the commands can or cannot be executed
* @param {<<api-param-type-boolean,`Boolean`>>} params.retryFailed - Retries allocation of shards that are blocked due to too many subsequent allocation failures
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned to the specified metrics. Defaults to all but metadata
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
*/
api.cluster.prototype.reroute = ca({
params: {
dryRun: {
type: 'boolean',
name: 'dry_run'
},
explain: {
type: 'boolean'
},
retryFailed: {
type: 'boolean',
name: 'retry_failed'
},
metric: {
type: 'list',
options: ['_all', 'blocks', 'metadata', 'nodes', 'routing_table', 'master_node', 'version']
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_cluster/reroute'
},
method: 'POST'
});
/**
* Perform a [cluster.state](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cluster-state.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned to the specified metrics
*/
api.cluster.prototype.state = ca({
params: {
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/_cluster/state/<%=metric%>/<%=index%>',
req: {
metric: {
type: 'list',
options: ['_all', 'blocks', 'metadata', 'nodes', 'routing_table', 'routing_nodes', 'master_node', 'version']
},
index: {
type: 'list'
}
}
}, {
fmt: '/_cluster/state/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'blocks', 'metadata', 'nodes', 'routing_table', 'routing_nodes', 'master_node', 'version']
}
}
}, {
fmt: '/_cluster/state'
}]
});
/**
* Perform a [cluster.stats](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cluster-stats.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
*/
api.cluster.prototype.stats = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
timeout: {
type: 'time'
}
},
urls: [{
fmt: '/_cluster/stats/nodes/<%=nodeId%>',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_cluster/stats'
}]
});
/**
* Perform a [count](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/search-count.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-number,`Number`>>} params.minScore - Include only documents with a specific `_score` value in the result
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-number,`Number`>>} params.terminateAfter - The maximum count for each shard, upon reaching which the query execution will terminate early
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of indices to restrict the results
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of types to restrict the results
*/
api.count = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
minScore: {
type: 'number',
name: 'min_score'
},
preference: {
type: 'string'
},
routing: {
type: 'list'
},
q: {
type: 'string'
},
analyzer: {
type: 'string'
},
analyzeWildcard: {
type: 'boolean',
name: 'analyze_wildcard'
},
defaultOperator: {
type: 'enum',
'default': 'OR',
options: ['AND', 'OR'],
name: 'default_operator'
},
df: {
type: 'string'
},
lenient: {
type: 'boolean'
},
terminateAfter: {
type: 'number',
name: 'terminate_after'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_count',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_count',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_count'
}],
method: 'POST'
});
/**
* Perform a [create](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-index_.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the index operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>} params.parent - ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.pipeline - The pipeline id to preprocess incoming documents with
* @param {<<api-param-type-string,`String`>>} params.id - Document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.create = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
parent: {
type: 'string'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
},
pipeline: {
type: 'string'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_create',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
needBody: true,
method: 'POST'
});
/**
* Perform a [delete](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-delete.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the delete operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>} params.parent - ID of parent document
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the effected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api['delete'] = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
parent: {
type: 'string'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [deleteByQuery](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-delete-by-query.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-number,`Number`>>} params.from - Starting offset (default: 0)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.conflicts=abort] - What to do when the delete-by-query hits version conflicts?
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-duration-string,`DurationString`>>} params.searchTimeout - Explicit timeout for each search request. Defaults to no timeout.
* @param {<<api-param-type-number,`Number`>>} params.size - Number of hits to return (default: 10)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.sort - A comma-separated list of <field>:<direction> pairs
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.terminateAfter - The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.stats - Specific 'tag' of the request for logging and statistical purposes
* @param {<<api-param-type-boolean,`Boolean`>>} params.version - Specify whether to return document version as part of a hit
* @param {<<api-param-type-boolean,`Boolean`>>} params.requestCache - Specify if request cache should be used for this request or not, defaults to index level setting
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Should the effected indexes be refreshed?
* @param {<<api-param-type-duration-string,`DurationString`>>} [params.timeout=1m] - Time each individual bulk request should wait for shards that are unavailable.
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the delete by query operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-number,`Number`>>} params.scrollSize - Size on the scroll request powering the update_by_query
* @param {<<api-param-type-boolean,`Boolean`>>} [params.waitForCompletion=true] - Should the request should block until the delete-by-query is complete.
* @param {<<api-param-type-number,`Number`>>} params.requestsPerSecond - The throttle for this request in sub-requests per second. -1 means no throttle.
* @param {<<api-param-type-number,`Number`>>} [params.slices=1] - The number of slices this task should be divided into. Defaults to 1 meaning the task isn't sliced into subtasks.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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'
},
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'
},
preference: {
type: 'string'
},
q: {
type: 'string'
},
routing: {
type: 'list'
},
scroll: {
type: 'time'
},
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'
},
version: {
type: 'boolean'
},
requestCache: {
type: 'boolean',
name: 'request_cache'
},
refresh: {
type: 'boolean'
},
timeout: {
type: 'time',
'default': '1m'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
scrollSize: {
type: 'number',
name: 'scroll_size'
},
waitForCompletion: {
type: 'boolean',
'default': true,
name: 'wait_for_completion'
},
requestsPerSecond: {
type: 'number',
'default': 0,
name: 'requests_per_second'
},
slices: {
type: 'number',
'default': 1
}
},
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](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/modules-scripting.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.id - Script ID
*/
api.deleteScript = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_scripts/<%=id%>',
req: {
id: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [exists](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return in the response
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document (use `_all` to fetch the first document matching the ID across all types)
*/
api.exists = ca({
params: {
storedFields: {
type: 'list',
name: 'stored_fields'
},
parent: {
type: 'string'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'HEAD'
});
/**
* Perform a [existsSource](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document; use `_all` to fetch the first document matching the ID across all types
*/
api.existsSource = ca({
params: {
parent: {
type: 'string'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_source',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'HEAD'
});
/**
* Perform a [explain](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/search-explain.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcards and prefix queries in the query string query should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer for the query string query
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The default field for query string query (default: _all)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return in the response
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.explain = ca({
params: {
analyzeWildcard: {
type: 'boolean',
name: 'analyze_wildcard'
},
analyzer: {
type: 'string'
},
defaultOperator: {
type: 'enum',
'default': 'OR',
options: ['AND', 'OR'],
name: 'default_operator'
},
df: {
type: 'string'
},
storedFields: {
type: 'list',
name: 'stored_fields'
},
lenient: {
type: 'boolean'
},
parent: {
type: 'string'
},
preference: {
type: 'string'
},
q: {
type: 'string'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_explain',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [fieldCaps](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/search-field-caps.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of field names
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.fieldCaps = ca({
params: {
fields: {
type: 'list'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_field_caps',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_field_caps'
}],
method: 'POST'
});
/**
* Perform a [get](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return in the response
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document (use `_all` to fetch the first document matching the ID across all types)
*/
api.get = ca({
params: {
storedFields: {
type: 'list',
name: 'stored_fields'
},
parent: {
type: 'string'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}
});
/**
* Perform a [getScript](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/modules-scripting.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.id - Script ID
*/
api.getScript = ca({
url: {
fmt: '/_scripts/<%=id%>',
req: {
id: {
type: 'string'
}
}
}
});
/**
* Perform a [getSource](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document; use `_all` to fetch the first document matching the ID across all types
*/
api.getSource = ca({
params: {
parent: {
type: 'string'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_source',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}
});
/**
* Perform a [index](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-index_.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the index operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>} [params.opType=index] - Explicit operation type
* @param {<<api-param-type-string,`String`>>} params.parent - ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.pipeline - The pipeline id to preprocess incoming documents with
* @param {<<api-param-type-string,`String`>>} params.id - Document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.index = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
opType: {
type: 'enum',
'default': 'index',
options: ['index', 'create'],
name: 'op_type'
},
parent: {
type: 'string'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
},
pipeline: {
type: 'string'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/<%=id%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/<%=type%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}],
needBody: true,
method: 'POST'
});
api.indices = namespace();
/**
* Perform a [indices.analyze](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-analyze.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index to scope the operation
* @param {<<api-param-type-boolean,`Boolean`>>} params.preferLocal - With `true`, specify that a local shard should be used if available, with `false`, use a random shard (default: true)
* @param {<<api-param-type-string,`String`>>} [params.format=detailed] - Format of the output
*/
api.indices.prototype.analyze = ca({
params: {
index: {
type: 'string'
},
preferLocal: {
type: 'boolean',
name: 'prefer_local'
},
format: {
type: 'enum',
'default': 'detailed',
options: ['detailed', 'text']
}
},
urls: [{
fmt: '/<%=index%>/_analyze',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_analyze'
}],
method: 'POST'
});
/**
* Perform a [indices.clearCache](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-clearcache.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.fieldData - Clear field data
* @param {<<api-param-type-boolean,`Boolean`>>} params.fielddata - Clear field data
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to clear when using the `field_data` parameter (default: all)
* @param {<<api-param-type-boolean,`Boolean`>>} params.query - Clear query caches
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index name to limit the operation
* @param {<<api-param-type-boolean,`Boolean`>>} params.recycler - Clear the recycler cache
* @param {<<api-param-type-boolean,`Boolean`>>} params.requestCache - Clear request cache
* @param {<<api-param-type-boolean,`Boolean`>>} params.request - Clear request cache
*/
api.indices.prototype.clearCache = ca({
params: {
fieldData: {
type: 'boolean',
name: 'field_data'
},
fielddata: {
type: 'boolean'
},
fields: {
type: 'list'
},
query: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
index: {
type: 'list'
},
recycler: {
type: 'boolean'
},
requestCache: {
type: 'boolean',
name: 'request_cache'
},
request: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_cache/clear',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cache/clear'
}],
method: 'POST'
});
/**
* Perform a [indices.close](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-open-close.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma separated list of indices to close
*/
api.indices.prototype.close = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
url: {
fmt: '/<%=index%>/_close',
req: {
index: {
type: 'list'
}
}
},
method: 'POST'
});
/**
* Perform a [indices.create](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-create-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Set the number of active shards to wait for before the operation returns.
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.updateAllTypes - Whether to update the mapping for all fields with the same name across all types or not
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
*/
api.indices.prototype.create = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
updateAllTypes: {
type: 'boolean',
name: 'update_all_types'
}
},
url: {
fmt: '/<%=index%>',
req: {
index: {
type: 'string'
}
}
},
method: 'PUT'
});
/**
* Perform a [indices.delete](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-delete-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Ignore unavailable indexes (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.allowNoIndices - Ignore if a wildcard expression resolves to no concrete indices (default: false)
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether wildcard expressions should get expanded to open or closed indices (default: open)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of indices to delete; use `_all` or `*` string to delete all indices
*/
api.indices.prototype['delete'] = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
url: {
fmt: '/<%=index%>',
req: {
index: {
type: 'list'
}
}
},
method: 'DELETE'
});
/**
* Perform a [indices.deleteAlias](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit timestamp for the document
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names (supports wildcards); use `_all` for all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - A comma-separated list of aliases to delete (supports wildcards); use `_all` to delete all aliases for the specified indices.
*/
api.indices.prototype.deleteAlias = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/<%=index%>/_alias/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'list'
}
}
},
method: 'DELETE'
});
/**
* Perform a [indices.deleteTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.name - The name of the template
*/
api.indices.prototype.deleteTemplate = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_template/<%=name%>',
req: {
name: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [indices.exists](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-exists.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Ignore unavailable indexes (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.allowNoIndices - Ignore if a wildcard expression resolves to no concrete indices (default: false)
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether wildcard expressions should get expanded to open or closed indices (default: open)
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether to return all default setting for each of the indices.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names
*/
api.indices.prototype.exists = ca({
params: {
local: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
includeDefaults: {
type: 'boolean',
'default': false,
name: 'include_defaults'
}
},
url: {
fmt: '/<%=index%>',
req: {
index: {
type: 'list'
}
}
},
method: 'HEAD'
});
/**
* Perform a [indices.existsAlias](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=all] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to filter aliases
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - A comma-separated list of alias names to return
*/
api.indices.prototype.existsAlias = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'all',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_alias/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'list'
}
}
}, {
fmt: '/_alias/<%=name%>',
req: {
name: {
type: 'list'
}
}
}],
method: 'HEAD'
});
/**
* Perform a [indices.existsTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - The comma separated names of the index templates
*/
api.indices.prototype.existsTemplate = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
local: {
type: 'boolean'
}
},
url: {
fmt: '/_template/<%=name%>',
req: {
name: {
type: 'list'
}
}
},
method: 'HEAD'
});
/**
* Perform a [indices.existsType](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-types-exists.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` to check the types across all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to check
*/
api.indices.prototype.existsType = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
url: {
fmt: '/<%=index%>/_mapping/<%=type%>',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
},
method: 'HEAD'
});
/**
* Perform a [indices.flush](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-flush.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.force - Whether a flush should be forced even if it is not necessarily needed ie. if no changes will be committed to the index. This is useful if transaction log IDs should be incremented even if no uncommitted changes are present. (This setting can be considered as internal)
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitIfOngoing - If set to true the flush operation will block until the flush can be executed if another flush operation is already executing. The default is true. If set to false the flush will be skipped iff if another flush operation is already running.
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string for all indices
*/
api.indices.prototype.flush = ca({
params: {
force: {
type: 'boolean'
},
waitIfOngoing: {
type: 'boolean',
name: 'wait_if_ongoing'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_flush',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_flush'
}],
method: 'POST'
});
/**
* Perform a [indices.flushSynced](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-synced-flush.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string for all indices
*/
api.indices.prototype.flushSynced = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_flush/synced',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_flush/synced'
}],
method: 'POST'
});
/**
* Perform a [indices.forcemerge](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-forcemerge.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flush - Specify whether the index should be flushed after performing the operation (default: true)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-number,`Number`>>} params.maxNumSegments - The number of segments the index should be merged into (default: dynamic)
* @param {<<api-param-type-boolean,`Boolean`>>} params.onlyExpungeDeletes - Specify whether the operation should only expunge deleted documents
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.forcemerge = ca({
params: {
flush: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
maxNumSegments: {
type: 'number',
name: 'max_num_segments'
},
onlyExpungeDeletes: {
type: 'boolean',
name: 'only_expunge_deletes'
}
},
urls: [{
fmt: '/<%=index%>/_forcemerge',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_forcemerge'
}],
method: 'POST'
});
/**
* Perform a [indices.get](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-get-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Ignore unavailable indexes (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.allowNoIndices - Ignore if a wildcard expression resolves to no concrete indices (default: false)
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether wildcard expressions should get expanded to open or closed indices (default: open)
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether to return all default setting for each of the indices.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names
*/
api.indices.prototype.get = ca({
params: {
local: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
includeDefaults: {
type: 'boolean',
'default': false,
name: 'include_defaults'
}
},
url: {
fmt: '/<%=index%>',
req: {
index: {
type: 'list'
}
}
}
});
/**
* Perform a [indices.getAlias](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=all] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to filter aliases
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - A comma-separated list of alias names to return
*/
api.indices.prototype.getAlias = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'all',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_alias/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'list'
}
}
}, {
fmt: '/_alias/<%=name%>',
req: {
name: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_alias',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_alias'
}]
});
/**
* Perform a [indices.getFieldMapping](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-get-field-mapping.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether the default mapping values should be returned as well
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields
*/
api.indices.prototype.getFieldMapping = ca({
params: {
includeDefaults: {
type: 'boolean',
name: 'include_defaults'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_mapping/<%=type%>/field/<%=fields%>',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
},
fields: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_mapping/field/<%=fields%>',
req: {
index: {
type: 'list'
},
fields: {
type: 'list'
}
}
}, {
fmt: '/_mapping/<%=type%>/field/<%=fields%>',
req: {
type: {
type: 'list'
},
fields: {
type: 'list'
}
}
}, {
fmt: '/_mapping/field/<%=fields%>',
req: {
fields: {
type: 'list'
}
}
}]
});
/**
* Perform a [indices.getMapping](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-get-mapping.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types
*/
api.indices.prototype.getMapping = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_mapping/<%=type%>',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_mapping',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_mapping/<%=type%>',
req: {
type: {
type: 'list'
}
}
}, {
fmt: '/_mapping'
}]
});
/**
* Perform a [indices.getSettings](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-get-settings.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open,closed] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether to return all default setting for each of the indices.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - The name of the settings that should be included
*/
api.indices.prototype.getSettings = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': ['open', 'closed'],
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
local: {
type: 'boolean'
},
includeDefaults: {
type: 'boolean',
'default': false,
name: 'include_defaults'
}
},
urls: [{
fmt: '/<%=index%>/_settings/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_settings',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_settings/<%=name%>',
req: {
name: {
type: 'list'
}
}
}, {
fmt: '/_settings'
}]
});
/**
* Perform a [indices.getTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - The comma separated names of the index templates
*/
api.indices.prototype.getTemplate = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/_template/<%=name%>',
req: {
name: {
type: 'list'
}
}
}, {
fmt: '/_template'
}]
});
/**
* Perform a [indices.getUpgrade](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-upgrade.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.getUpgrade = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_upgrade',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_upgrade'
}]
});
/**
* Perform a [indices.open](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-open-close.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=closed] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of active shards to wait for before the operation returns.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma separated list of indices to open
*/
api.indices.prototype.open = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'closed',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
}
},
url: {
fmt: '/<%=index%>/_open',
req: {
index: {
type: 'list'
}
}
},
method: 'POST'
});
/**
* Perform a [indices.putAlias](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit timestamp for the document
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names the alias should point to (supports wildcards); use `_all` to perform the operation on all indices.
* @param {<<api-param-type-string,`String`>>} params.name - The name of the alias to be created or updated
*/
api.indices.prototype.putAlias = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/<%=index%>/_alias/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'string'
}
}
},
method: 'PUT'
});
/**
* Perform a [indices.putMapping](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-put-mapping.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.updateAllTypes - Whether to update the mapping for all fields with the same name across all types or not
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices.
* @param {<<api-param-type-string,`String`>>} params.type - The name of the document type
*/
api.indices.prototype.putMapping = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
updateAllTypes: {
type: 'boolean',
name: 'update_all_types'
}
},
urls: [{
fmt: '/<%=index%>/_mapping/<%=type%>',
req: {
index: {
type: 'list'
},
type: {
type: 'string'
}
}
}, {
fmt: '/_mapping/<%=type%>',
req: {
type: {
type: 'string'
}
}
}],
needBody: true,
method: 'PUT'
});
/**
* Perform a [indices.putSettings](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-update-settings.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.preserveExisting - Whether to update existing settings. If set to `true` existing settings on an index remain unchanged, the default is `false`
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.putSettings = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
preserveExisting: {
type: 'boolean',
name: 'preserve_existing'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
}
},
urls: [{
fmt: '/<%=index%>/_settings',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_settings'
}],
needBody: true,
method: 'PUT'
});
/**
* Perform a [indices.putTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-number,`Number`>>} params.order - The order for this template when merging multiple matching ones (higher numbers are merged later, overriding the lower numbers)
* @param {<<api-param-type-boolean,`Boolean`>>} params.create - Whether the index template should only be added if new or can also replace an existing one
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-string,`String`>>} params.name - The name of the template
*/
api.indices.prototype.putTemplate = ca({
params: {
order: {
type: 'number'
},
create: {
type: 'boolean',
'default': false
},
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
}
},
url: {
fmt: '/_template/<%=name%>',
req: {
name: {
type: 'string'
}
}
},
needBody: true,
method: 'PUT'
});
/**
* Perform a [indices.recovery](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-recovery.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.detailed - Whether to display detailed information about shard recovery
* @param {<<api-param-type-boolean,`Boolean`>>} params.activeOnly - Display only those recoveries that are currently on-going
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.recovery = ca({
params: {
detailed: {
type: 'boolean',
'default': false
},
activeOnly: {
type: 'boolean',
'default': false,
name: 'active_only'
}
},
urls: [{
fmt: '/<%=index%>/_recovery',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_recovery'
}]
});
/**
* Perform a [indices.refresh](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-refresh.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.refresh = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_refresh',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_refresh'
}],
method: 'POST'
});
/**
* Perform a [indices.rollover](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-rollover-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.dryRun - If set to true the rollover action will only be validated but not actually performed even if a condition matches. The default is false
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Set the number of active shards to wait for on the newly created rollover index before the operation returns.
* @param {<<api-param-type-string,`String`>>} params.alias - The name of the alias to rollover
* @param {<<api-param-type-string,`String`>>} params.newIndex - The name of the rollover index
*/
api.indices.prototype.rollover = ca({
params: {
timeout: {
type: 'time'
},
dryRun: {
type: 'boolean',
name: 'dry_run'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
}
},
urls: [{
fmt: '/<%=alias%>/_rollover/<%=newIndex%>',
req: {
alias: {
type: 'string'
},
newIndex: {
type: 'string'
}
}
}, {
fmt: '/<%=alias%>/_rollover',
req: {
alias: {
type: 'string'
}
}
}],
method: 'POST'
});
/**
* Perform a [indices.segments](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-segments.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.verbose - Includes detailed memory usage by Lucene.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.segments = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
verbose: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/<%=index%>/_segments',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_segments'
}]
});
/**
* Perform a [indices.shardStores](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-shards-stores.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.status - A comma-separated list of statuses used to filter on shards to get store information for
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.shardStores = ca({
params: {
status: {
type: 'list',
options: ['green', 'yellow', 'red', 'all']
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_shard_stores',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_shard_stores'
}]
});
/**
* Perform a [indices.shrink](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-shrink-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Set the number of active shards to wait for on the shrunken index before the operation returns.
* @param {<<api-param-type-string,`String`>>} params.index - The name of the source index to shrink
* @param {<<api-param-type-string,`String`>>} params.target - The name of the target index to shrink into
*/
api.indices.prototype.shrink = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
}
},
url: {
fmt: '/<%=index%>/_shrink/<%=target%>',
req: {
index: {
type: 'string'
},
target: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [indices.split](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-split-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Set the number of active shards to wait for on the shrunken index before the operation returns.
* @param {<<api-param-type-string,`String`>>} params.index - The name of the source index to split
* @param {<<api-param-type-string,`String`>>} params.target - The name of the target index to split into
*/
api.indices.prototype.split = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
}
},
url: {
fmt: '/<%=index%>/_split/<%=target%>',
req: {
index: {
type: 'string'
},
target: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [indices.stats](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-stats.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.completionFields - A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fielddataFields - A comma-separated list of fields for `fielddata` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.groups - A comma-separated list of search groups for `search` index metric
* @param {<<api-param-type-string,`String`>>} [params.level=indices] - Return stats aggregated at cluster, index or shard level
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.types - A comma-separated list of document types for the `indexing` index metric
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeSegmentFileSizes - Whether to report the aggregated disk usage of each one of the Lucene index files (only applies if segment stats are requested)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned the specific metrics.
*/
api.indices.prototype.stats = ca({
params: {
completionFields: {
type: 'list',
name: 'completion_fields'
},
fielddataFields: {
type: 'list',
name: 'fielddata_fields'
},
fields: {
type: 'list'
},
groups: {
type: 'list'
},
level: {
type: 'enum',
'default': 'indices',
options: ['cluster', 'indices', 'shards']
},
types: {
type: 'list'
},
includeSegmentFileSizes: {
type: 'boolean',
'default': false,
name: 'include_segment_file_sizes'
}
},
urls: [{
fmt: '/<%=index%>/_stats/<%=metric%>',
req: {
index: {
type: 'list'
},
metric: {
type: 'list',
options: ['_all', 'completion', 'docs', 'fielddata', 'query_cache', 'flush', 'get', 'indexing', 'merge', 'request_cache', 'refresh', 'search', 'segments', 'store', 'warmer', 'suggest']
}
}
}, {
fmt: '/_stats/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'completion', 'docs', 'fielddata', 'query_cache', 'flush', 'get', 'indexing', 'merge', 'request_cache', 'refresh', 'search', 'segments', 'store', 'warmer', 'suggest']
}
}
}, {
fmt: '/<%=index%>/_stats',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_stats'
}]
});
/**
* Perform a [indices.updateAliases](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Request timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
*/
api.indices.prototype.updateAliases = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_aliases'
},
needBody: true,
method: 'POST'
});
/**
* Perform a [indices.upgrade](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/indices-upgrade.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Specify whether the request should block until the all segments are upgraded (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.onlyAncientSegments - If true, only ancient (an older Lucene major release) segments will be upgraded
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.upgrade = ca({
params: {
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
waitForCompletion: {
type: 'boolean',
name: 'wait_for_completion'
},
onlyAncientSegments: {
type: 'boolean',
name: 'only_ancient_segments'
}
},
urls: [{
fmt: '/<%=index%>/_upgrade',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_upgrade'
}],
method: 'POST'
});
/**
* Perform a [indices.validateQuery](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/search-validate.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - Return detailed information about the error
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-boolean,`Boolean`>>} params.rewrite - Provide a more detailed explanation showing the actual Lucene query that will be executed.
* @param {<<api-param-type-boolean,`Boolean`>>} params.allShards - Execute validation on all shards instead of one random shard per index
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types
*/
api.indices.prototype.validateQuery = ca({
params: {
explain: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
q: {
type: 'string'
},
analyzer: {
type: 'string'
},
analyzeWildcard: {
type: 'boolean',
name: 'analyze_wildcard'
},
defaultOperator: {
type: 'enum',
'default': 'OR',
options: ['AND', 'OR'],
name: 'default_operator'
},
df: {
type: 'string'
},
lenient: {
type: 'boolean'
},
rewrite: {
type: 'boolean'
},
allShards: {
type: 'boolean',
name: 'all_shards'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_validate/query',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_validate/query',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_validate/query'
}],
method: 'POST'
});
/**
* Perform a [info](http://www.elastic.co/guide/) request
*
* @param {Object} params - An object with parameters used to carry out this action
*/
api.info = ca({
url: {
fmt: '/'
}
});
api.ingest = namespace();
/**
* Perform a [ingest.deletePipeline](https://www.elastic.co/guide/en/elasticsearch/plugins/6.2/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.id - Pipeline ID
*/
api.ingest.prototype.deletePipeline = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_ingest/pipeline/<%=id%>',
req: {
id: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [ingest.getPipeline](https://www.elastic.co/guide/en/elasticsearch/plugins/6.2/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>} params.id - Comma separated list of pipeline ids. Wildcards supported
*/
api.ingest.prototype.getPipeline = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
urls: [{
fmt: '/_ingest/pipeline/<%=id%>',
req: {
id: {
type: 'string'
}
}
}, {
fmt: '/_ingest/pipeline'
}]
});
/**
* Perform a [ingest.processorGrok](https://www.elastic.co/guide/en/elasticsearch/plugins/6.2/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
*/
api.ingest.prototype.processorGrok = ca({
url: {
fmt: '/_ingest/processor/grok'
}
});
/**
* Perform a [ingest.putPipeline](https://www.elastic.co/guide/en/elasticsearch/plugins/6.2/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.id - Pipeline ID
*/
api.ingest.prototype.putPipeline = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_ingest/pipeline/<%=id%>',
req: {
id: {
type: 'string'
}
}
},
needBody: true,
method: 'PUT'
});
/**
* Perform a [ingest.simulate](https://www.elastic.co/guide/en/elasticsearch/plugins/6.2/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.verbose - Verbose mode. Display data output for each processor in executed pipeline
* @param {<<api-param-type-string,`String`>>} params.id - Pipeline ID
*/
api.ingest.prototype.simulate = ca({
params: {
verbose: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_ingest/pipeline/<%=id%>/_simulate',
req: {
id: {
type: 'string'
}
}
}, {
fmt: '/_ingest/pipeline/_simulate'
}],
needBody: true,
method: 'POST'
});
/**
* Perform a [mget](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-multi-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return in the response
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.mget = ca({
params: {
storedFields: {
type: 'list',
name: 'stored_fields'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_mget',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/_mget',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_mget'
}],
needBody: true,
method: 'POST'
});
/**
* Perform a [msearch](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/search-multi-search.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-number,`Number`>>} params.maxConcurrentSearches - Controls the maximum number of concurrent searches the multi search api will execute
* @param {<<api-param-type-boolean,`Boolean`>>} params.typedKeys - Specify whether aggregation and suggester names should be prefixed by their respective types in the response
* @param {<<api-param-type-number,`Number`>>} [params.preFilterShardSize=128] - A threshold that enforces a pre-filter roundtrip to prefilter search shards based on query rewriting if the number of shards the search request expands to exceeds the threshold. This filter roundtrip can limit the number of shards significantly if for instance a shard can not match any documents based on it's rewrite method ie. if date filters are mandatory to match but the shard bounds and the query are disjoint.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to use as default
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to use as default
*/
api.msearch = ca({
params: {
searchType: {
type: 'enum',
options: ['query_then_fetch', 'query_and_fetch', 'dfs_query_then_fetch', 'dfs_query_and_fetch'],
name: 'search_type'
},
maxConcurrentSearches: {
type: 'number',
name: 'max_concurrent_searches'
},
typedKeys: {
type: 'boolean',
name: 'typed_keys'
},
preFilterShardSize: {
type: 'number',
'default': 128,
name: 'pre_filter_shard_size'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_msearch',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_msearch',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_msearch'
}],
needBody: true,
bulkBody: true,
method: 'POST'
});
/**
* Perform a [msearchTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/search-multi-search.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-boolean,`Boolean`>>} params.typedKeys - Specify whether aggregation and suggester names should be prefixed by their respective types in the response
* @param {<<api-param-type-number,`Number`>>} params.maxConcurrentSearches - Controls the maximum number of concurrent searches the multi search api will execute
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to use as default
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to use as default
*/
api.msearchTemplate = ca({
params: {
searchType: {
type: 'enum',
options: ['query_then_fetch', 'query_and_fetch', 'dfs_query_then_fetch', 'dfs_query_and_fetch'],
name: 'search_type'
},
typedKeys: {
type: 'boolean',
name: 'typed_keys'
},
maxConcurrentSearches: {
type: 'number',
name: 'max_concurrent_searches'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_msearch/template',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_msearch/template',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_msearch/template'
}],
needBody: true,
bulkBody: true,
method: 'POST'
});
/**
* Perform a [mtermvectors](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-multi-termvectors.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.ids - A comma-separated list of documents ids. You must define ids as parameter or set "ids" or "docs" in the request body
* @param {<<api-param-type-boolean,`Boolean`>>} params.termStatistics - Specifies if total term frequency and document frequency should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} [params.fieldStatistics=true] - Specifies if document count, sum of document frequencies and sum of total term frequencies should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to return. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} [params.offsets=true] - Specifies if term offsets should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} [params.positions=true] - Specifies if term positions should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} [params.payloads=true] - Specifies if term payloads should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random) .Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-string,`String`>>} params.parent - Parent id of documents. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specifies if requests are real-time as opposed to near-real-time (default: true).
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.index - The index in which the document resides.
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document.
*/
api.mtermvectors = ca({
params: {
ids: {
type: 'list',
required: false
},
termStatistics: {
type: 'boolean',
'default': false,
required: false,
name: 'term_statistics'
},
fieldStatistics: {
type: 'boolean',
'default': true,
required: false,
name: 'field_statistics'
},
fields: {
type: 'list',
required: false
},
offsets: {
type: 'boolean',
'default': true,
required: false
},
positions: {
type: 'boolean',
'default': true,
required: false
},
payloads: {
type: 'boolean',
'default': true,
required: false
},
preference: {
type: 'string',
required: false
},
routing: {
type: 'string',
required: false
},
parent: {
type: 'string',
required: false
},
realtime: {
type: 'boolean',
required: false
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_mtermvectors',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/_mtermvectors',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_mtermvectors'
}],
method: 'POST'
});
api.nodes = namespace();
/**
* Perform a [nodes.hotThreads](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cluster-nodes-hot-threads.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.interval - The interval for the second sampling of threads
* @param {<<api-param-type-number,`Number`>>} params.snapshots - Number of samples of thread stacktrace (default: 10)
* @param {<<api-param-type-number,`Number`>>} params.threads - Specify the number of threads to provide information for (default: 3)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreIdleThreads - Don't show threads that are in known-idle places, such as waiting on a socket select or pulling from an empty task queue (default: true)
* @param {<<api-param-type-string,`String`>>} params.type - The type to sample (default: cpu)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
*/
api.nodes.prototype.hotThreads = ca({
params: {
interval: {
type: 'time'
},
snapshots: {
type: 'number'
},
threads: {
type: 'number'
},
ignoreIdleThreads: {
type: 'boolean',
name: 'ignore_idle_threads'
},
type: {
type: 'enum',
options: ['cpu', 'wait', 'block']
},
timeout: {
type: 'time'
}
},
urls: [{
fmt: '/_nodes/<%=nodeId%>/hotthreads',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_nodes/hotthreads'
}]
});
/**
* Perform a [nodes.info](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cluster-nodes-info.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - A comma-separated list of metrics you wish returned. Leave empty to return all.
*/
api.nodes.prototype.info = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
timeout: {
type: 'time'
}
},
urls: [{
fmt: '/_nodes/<%=nodeId%>/<%=metric%>',
req: {
nodeId: {
type: 'list'
},
metric: {
type: 'list',
options: ['settings', 'os', 'process', 'jvm', 'thread_pool', 'transport', 'http', 'plugins', 'ingest']
}
}
}, {
fmt: '/_nodes/<%=nodeId%>',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_nodes/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['settings', 'os', 'process', 'jvm', 'thread_pool', 'transport', 'http', 'plugins', 'ingest']
}
}
}, {
fmt: '/_nodes'
}]
});
/**
* Perform a [nodes.stats](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cluster-nodes-stats.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.completionFields - A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fielddataFields - A comma-separated list of fields for `fielddata` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards)
* @param {<<api-param-type-boolean,`Boolean`>>} params.groups - A comma-separated list of search groups for `search` index metric
* @param {<<api-param-type-string,`String`>>} [params.level=node] - Return indices stats aggregated at index, node or shard level
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.types - A comma-separated list of document types for the `indexing` index metric
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeSegmentFileSizes - Whether to report the aggregated disk usage of each one of the Lucene index files (only applies if segment stats are requested)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned to the specified metrics
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.indexMetric - Limit the information returned for `indices` metric to the specific index metrics. Isn't used if `indices` (or `all`) metric isn't specified.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
*/
api.nodes.prototype.stats = ca({
params: {
completionFields: {
type: 'list',
name: 'completion_fields'
},
fielddataFields: {
type: 'list',
name: 'fielddata_fields'
},
fields: {
type: 'list'
},
groups: {
type: 'boolean'
},
level: {
type: 'enum',
'default': 'node',
options: ['indices', 'node', 'shards']
},
types: {
type: 'list'
},
timeout: {
type: 'time'
},
includeSegmentFileSizes: {
type: 'boolean',
'default': false,
name: 'include_segment_file_sizes'
}
},
urls: [{
fmt: '/_nodes/<%=nodeId%>/stats/<%=metric%>/<%=indexMetric%>',
req: {
nodeId: {
type: 'list'
},
metric: {
type: 'list',
options: ['_all', 'breaker', 'fs', 'http', 'indices', 'jvm', 'os', 'process', 'thread_pool', 'transport', 'discovery']
},
indexMetric: {
type: 'list',
options: ['_all', 'completion', 'docs', 'fielddata', 'query_cache', 'flush', 'get', 'indexing', 'merge', 'request_cache', 'refresh', 'search', 'segments', 'store', 'warmer', 'suggest']
}
}
}, {
fmt: '/_nodes/<%=nodeId%>/stats/<%=metric%>',
req: {
nodeId: {
type: 'list'
},
metric: {
type: 'list',
options: ['_all', 'breaker', 'fs', 'http', 'indices', 'jvm', 'os', 'process', 'thread_pool', 'transport', 'discovery']
}
}
}, {
fmt: '/_nodes/stats/<%=metric%>/<%=indexMetric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'breaker', 'fs', 'http', 'indices', 'jvm', 'os', 'process', 'thread_pool', 'transport', 'discovery']
},
indexMetric: {
type: 'list',
options: ['_all', 'completion', 'docs', 'fielddata', 'query_cache', 'flush', 'get', 'indexing', 'merge', 'request_cache', 'refresh', 'search', 'segments', 'store', 'warmer', 'suggest']
}
}
}, {
fmt: '/_nodes/<%=nodeId%>/stats',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_nodes/stats/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'breaker', 'fs', 'http', 'indices', 'jvm', 'os', 'process', 'thread_pool', 'transport', 'discovery']
}
}
}, {
fmt: '/_nodes/stats'
}]
});
/**
* Perform a [nodes.usage](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/cluster-nodes-usage.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.human - Whether to return time and byte values in human-readable format.
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned to the specified metrics
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
*/
api.nodes.prototype.usage = ca({
params: {
human: {
type: 'boolean',
'default': false
},
timeout: {
type: 'time'
}
},
urls: [{
fmt: '/_nodes/<%=nodeId%>/usage/<%=metric%>',
req: {
nodeId: {
type: 'list'
},
metric: {
type: 'list',
options: ['_all', 'rest_actions']
}
}
}, {
fmt: '/_nodes/<%=nodeId%>/usage',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_nodes/usage/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'rest_actions']
}
}
}, {
fmt: '/_nodes/usage'
}]
});
/**
* Perform a [ping](http://www.elastic.co/guide/) request
*
* @param {Object} params - An object with parameters used to carry out this action
*/
api.ping = ca({
url: {
fmt: '/'
},
requestTimeout: 3000,
method: 'HEAD'
});
/**
* Perform a [putScript](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/modules-scripting.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.context - Script context
* @param {<<api-param-type-string,`String`>>} params.id - Script ID
*/
api.putScript = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
context: {
type: 'string'
}
},
urls: [{
fmt: '/_scripts/<%=id%>/<%=context%>',
req: {
id: {
type: 'string'
},
context: {
type: 'string'
}
}
}, {
fmt: '/_scripts/<%=id%>',
req: {
id: {
type: 'string'
}
}
}],
needBody: true,
method: 'PUT'
});
/**
* Perform a [rankEval](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/search-rank-eval.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to search; leave empty to perform the operation on all types
*/
api.rankEval = ca({
urls: [{
fmt: '/<%=index%>/<%=type%>/_rank_eval',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_rank_eval',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_rank_eval'
}],
needBody: true,
method: 'POST'
});
/**
* Perform a [reindex](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-reindex.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Should the effected indexes be refreshed?
* @param {<<api-param-type-duration-string,`DurationString`>>} [params.timeout=1m] - Time each individual bulk request should wait for shards that are unavailable.
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the reindex operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-boolean,`Boolean`>>} [params.waitForCompletion=true] - Should the request should block until the reindex is complete.
* @param {<<api-param-type-number,`Number`>>} params.requestsPerSecond - The throttle to set on this request in sub-requests per second. -1 means no throttle.
* @param {<<api-param-type-number,`Number`>>} [params.slices=1] - The number of slices this task should be divided into. Defaults to 1 meaning the task isn't sliced into subtasks.
*/
api.reindex = ca({
params: {
refresh: {
type: 'boolean'
},
timeout: {
type: 'time',
'default': '1m'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
waitForCompletion: {
type: 'boolean',
'default': true,
name: 'wait_for_completion'
},
requestsPerSecond: {
type: 'number',
'default': 0,
name: 'requests_per_second'
},
slices: {
type: 'number',
'default': 1
}
},
url: {
fmt: '/_reindex'
},
needBody: true,
method: 'POST'
});
/**
* Perform a [reindexRethrottle](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-reindex.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-number,`Number`>>} params.requestsPerSecond - The throttle to set on this request in floating sub-requests per second. -1 means set no throttle.
* @param {<<api-param-type-string,`String`>>} params.taskId - The task id to rethrottle
*/
api.reindexRethrottle = ca({
params: {
requestsPerSecond: {
type: 'number',
required: true,
name: 'requests_per_second'
}
},
url: {
fmt: '/_reindex/<%=taskId%>/_rethrottle',
req: {
taskId: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [renderSearchTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/search-template.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.id - The id of the stored search template
*/
api.renderSearchTemplate = ca({
urls: [{
fmt: '/_render/template/<%=id%>',
req: {
id: {
type: 'string'
}
}
}, {
fmt: '/_render/template'
}],
method: 'POST'
});
/**
* Perform a [scroll](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/search-request-scroll.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.scrollId - The scroll ID
*/
api.scroll = ca({
params: {
scroll: {
type: 'time'
},
scrollId: {
type: 'string',
name: 'scroll_id'
}
},
urls: [{
fmt: '/_search/scroll/<%=scrollId%>',
req: {
scrollId: {
type: 'string'
}
}
}, {
fmt: '/_search/scroll'
}],
paramAsBody: {
param: 'scrollId',
body: 'scroll_id'
},
method: 'POST'
});
/**
* Perform a [search](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/search-search.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - Specify whether to return detailed information about score computation as part of a hit
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return as part of a hit
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.docvalueFields - A comma-separated list of fields to return as the docvalue representation of a field for each hit
* @param {<<api-param-type-number,`Number`>>} params.from - Starting offset (default: 0)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-number,`Number`>>} params.size - Number of hits to return (default: 10)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.sort - A comma-separated list of <field>:<direction> pairs
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.terminateAfter - The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.stats - Specific 'tag' of the request for logging and statistical purposes
* @param {<<api-param-type-string,`String`>>} params.suggestField - Specify which field to use for suggestions
* @param {<<api-param-type-string,`String`>>} [params.suggestMode=missing] - Specify suggest mode
* @param {<<api-param-type-number,`Number`>>} params.suggestSize - How many suggestions to return in response
* @param {<<api-param-type-string,`String`>>} params.suggestText - The source text for which the suggestions should be returned
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.trackScores - Whether to calculate and return scores even if they are not used for sorting
* @param {<<api-param-type-boolean,`Boolean`>>} params.trackTotalHits - Indicate if the number of documents that match the query should be tracked
* @param {<<api-param-type-boolean,`Boolean`>>} params.typedKeys - Specify whether aggregation and suggester names should be prefixed by their respective types in the response
* @param {<<api-param-type-boolean,`Boolean`>>} params.version - Specify whether to return document version as part of a hit
* @param {<<api-param-type-boolean,`Boolean`>>} params.requestCache - Specify if request cache should be used for this request or not, defaults to index level setting
* @param {<<api-param-type-number,`Number`>>} [params.batchedReduceSize=512] - The number of shard results that should be reduced at once on the coordinating node. This value should be used as a protection mechanism to reduce the memory overhead per search request if the potential number of shards in the request can be large.
* @param {<<api-param-type-number,`Number`>>} [params.maxConcurrentShardRequests=The default grows with the number of nodes in the cluster but is at most 256.] - The number of concurrent shard requests this search executes concurrently. This value should be used to limit the impact of the search on the cluster in order to limit the number of concurrent shard requests
* @param {<<api-param-type-number,`Number`>>} [params.preFilterShardSize=128] - A threshold that enforces a pre-filter roundtrip to prefilter search shards based on query rewriting if the number of shards the search request expands to exceeds the threshold. This filter roundtrip can limit the number of shards significantly if for instance a shard can not match any documents based on it's rewrite method ie. if date filters are mandatory to match but the shard bounds and the query are disjoint.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to search; leave empty to perform the operation on all types
*/
api.search = 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'
},
storedFields: {
type: 'list',
name: 'stored_fields'
},
docvalueFields: {
type: 'list',
name: 'docvalue_fields'
},
from: {
type: 'number'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
lenient: {
type: 'boolean'
},
preference: {
type: 'string'
},
q: {
type: 'string'
},
routing: {
type: 'list'
},
scroll: {
type: 'time'
},
searchType: {
type: 'enum',
options: ['query_then_fetch', 'dfs_query_then_fetch'],
name: 'search_type'
},
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: 'string',
name: 'suggest_text'
},
timeout: {
type: 'time'
},
trackScores: {
type: 'boolean',
name: 'track_scores'
},
trackTotalHits: {
type: 'boolean',
name: 'track_total_hits'
},
typedKeys: {
type: 'boolean',
name: 'typed_keys'
},
version: {
type: 'boolean'
},
requestCache: {
type: 'boolean',
name: 'request_cache'
},
batchedReduceSize: {
type: 'number',
'default': 512,
name: 'batched_reduce_size'
},
maxConcurrentShardRequests: {
type: 'number',
'default': 'The default grows with the number of nodes in the cluster but is at most 256.',
name: 'max_concurrent_shard_requests'
},
preFilterShardSize: {
type: 'number',
'default': 128,
name: 'pre_filter_shard_size'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_search',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_search',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_search'
}],
method: 'POST'
});
/**
* Perform a [searchShards](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/search-shards.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices
*/
api.searchShards = ca({
params: {
preference: {
type: 'string'
},
routing: {
type: 'string'
},
local: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_search_shards',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_search_shards'
}],
method: 'POST'
});
/**
* Perform a [searchTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/search-template.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - Specify whether to return detailed information about score computation as part of a hit
* @param {<<api-param-type-boolean,`Boolean`>>} params.profile - Specify whether to profile the query execution
* @param {<<api-param-type-boolean,`Boolean`>>} params.typedKeys - Specify whether aggregation and suggester names should be prefixed by their respective types in the response
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to search; leave empty to perform the operation on all types
*/
api.searchTemplate = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
preference: {
type: 'string'
},
routing: {
type: 'list'
},
scroll: {
type: 'time'
},
searchType: {
type: 'enum',
options: ['query_then_fetch', 'query_and_fetch', 'dfs_query_then_fetch', 'dfs_query_and_fetch'],
name: 'search_type'
},
explain: {
type: 'boolean'
},
profile: {
type: 'boolean'
},
typedKeys: {
type: 'boolean',
name: 'typed_keys'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_search/template',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_search/template',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_search/template'
}],
needBody: true,
method: 'POST'
});
api.snapshot = namespace();
/**
* Perform a [snapshot.create](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Should this request wait until the operation has completed before returning
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>} params.snapshot - A snapshot name
*/
api.snapshot.prototype.create = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForCompletion: {
type: 'boolean',
'default': false,
name: 'wait_for_completion'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [snapshot.createRepository](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.verify - Whether to verify the repository after creation
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
*/
api.snapshot.prototype.createRepository = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
},
verify: {
type: 'boolean'
}
},
url: {
fmt: '/_snapshot/<%=repository%>',
req: {
repository: {
type: 'string'
}
}
},
needBody: true,
method: 'POST'
});
/**
* Perform a [snapshot.delete](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>} params.snapshot - A snapshot name
*/
api.snapshot.prototype['delete'] = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [snapshot.deleteRepository](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.repository - A comma-separated list of repository names
*/
api.snapshot.prototype.deleteRepository = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_snapshot/<%=repository%>',
req: {
repository: {
type: 'list'
}
}
},
method: 'DELETE'
});
/**
* Perform a [snapshot.get](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether to ignore unavailable snapshots, defaults to false which means a SnapshotMissingException is thrown
* @param {<<api-param-type-boolean,`Boolean`>>} params.verbose - Whether to show verbose snapshot info or only show the basic info found in the repository index blob
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.snapshot - A comma-separated list of snapshot names
*/
api.snapshot.prototype.get = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
verbose: {
type: 'boolean'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'list'
}
}
}
});
/**
* Perform a [snapshot.getRepository](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.repository - A comma-separated list of repository names
*/
api.snapshot.prototype.getRepository = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/_snapshot/<%=repository%>',
req: {
repository: {
type: 'list'
}
}
}, {
fmt: '/_snapshot'
}]
});
/**
* Perform a [snapshot.restore](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Should this request wait until the operation has completed before returning
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>} params.snapshot - A snapshot name
*/
api.snapshot.prototype.restore = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForCompletion: {
type: 'boolean',
'default': false,
name: 'wait_for_completion'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>/_restore',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [snapshot.status](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether to ignore unavailable snapshots, defaults to false which means a SnapshotMissingException is thrown
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.snapshot - A comma-separated list of snapshot names
*/
api.snapshot.prototype.status = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
}
},
urls: [{
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>/_status',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'list'
}
}
}, {
fmt: '/_snapshot/<%=repository%>/_status',
req: {
repository: {
type: 'string'
}
}
}, {
fmt: '/_snapshot/_status'
}]
});
/**
* Perform a [snapshot.verifyRepository](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
*/
api.snapshot.prototype.verifyRepository = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/_verify',
req: {
repository: {
type: 'string'
}
}
},
method: 'POST'
});
api.tasks = namespace();
/**
* Perform a [tasks.cancel](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodes - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.actions - A comma-separated list of actions that should be cancelled. Leave empty to cancel all.
* @param {<<api-param-type-string,`String`>>} params.parentNode - Cancel tasks with specified parent node.
* @param {<<api-param-type-string,`String`>>} params.parentTaskId - Cancel tasks with specified parent task id (node_id:task_number). Set to -1 to cancel all.
* @param {<<api-param-type-string,`String`>>} params.taskId - Cancel the task with specified task id (node_id:task_number)
*/
api.tasks.prototype.cancel = ca({
params: {
nodes: {
type: 'list'
},
actions: {
type: 'list'
},
parentNode: {
type: 'string',
name: 'parent_node'
},
parentTaskId: {
type: 'string',
name: 'parent_task_id'
}
},
urls: [{
fmt: '/_tasks/<%=taskId%>/_cancel',
req: {
taskId: {
type: 'string'
}
}
}, {
fmt: '/_tasks/_cancel'
}],
method: 'POST'
});
/**
* Perform a [tasks.get](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Wait for the matching tasks to complete (default: false)
* @param {<<api-param-type-string,`String`>>} params.taskId - Return the task with specified id (node_id:task_number)
*/
api.tasks.prototype.get = ca({
params: {
waitForCompletion: {
type: 'boolean',
name: 'wait_for_completion'
}
},
url: {
fmt: '/_tasks/<%=taskId%>',
req: {
taskId: {
type: 'string'
}
}
}
});
/**
* Perform a [tasks.list](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodes - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.actions - A comma-separated list of actions that should be returned. Leave empty to return all.
* @param {<<api-param-type-boolean,`Boolean`>>} params.detailed - Return detailed task information (default: false)
* @param {<<api-param-type-string,`String`>>} params.parentNode - Return tasks with specified parent node.
* @param {<<api-param-type-string,`String`>>} params.parentTaskId - Return tasks with specified parent task id (node_id:task_number). Set to -1 to return all.
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Wait for the matching tasks to complete (default: false)
* @param {<<api-param-type-string,`String`>>} [params.groupBy=nodes] - Group tasks by nodes or parent/child relationships
*/
api.tasks.prototype.list = ca({
params: {
nodes: {
type: 'list'
},
actions: {
type: 'list'
},
detailed: {
type: 'boolean'
},
parentNode: {
type: 'string',
name: 'parent_node'
},
parentTaskId: {
type: 'string',
name: 'parent_task_id'
},
waitForCompletion: {
type: 'boolean',
name: 'wait_for_completion'
},
groupBy: {
type: 'enum',
'default': 'nodes',
options: ['nodes', 'parents', 'none'],
name: 'group_by'
}
},
url: {
fmt: '/_tasks'
}
});
/**
* Perform a [termvectors](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-termvectors.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.termStatistics - Specifies if total term frequency and document frequency should be returned.
* @param {<<api-param-type-boolean,`Boolean`>>} [params.fieldStatistics=true] - Specifies if document count, sum of document frequencies and sum of total term frequencies should be returned.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to return.
* @param {<<api-param-type-boolean,`Boolean`>>} [params.offsets=true] - Specifies if term offsets should be returned.
* @param {<<api-param-type-boolean,`Boolean`>>} [params.positions=true] - Specifies if term positions should be returned.
* @param {<<api-param-type-boolean,`Boolean`>>} [params.payloads=true] - Specifies if term payloads should be returned.
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random).
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value.
* @param {<<api-param-type-string,`String`>>} params.parent - Parent id of documents.
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specifies if request is real-time as opposed to near-real-time (default: true).
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.index - The index in which the document resides.
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document.
* @param {<<api-param-type-string,`String`>>} params.id - The id of the document, when not specified a doc param should be supplied.
*/
api.termvectors = ca({
params: {
termStatistics: {
type: 'boolean',
'default': false,
required: false,
name: 'term_statistics'
},
fieldStatistics: {
type: 'boolean',
'default': true,
required: false,
name: 'field_statistics'
},
fields: {
type: 'list',
required: false
},
offsets: {
type: 'boolean',
'default': true,
required: false
},
positions: {
type: 'boolean',
'default': true,
required: false
},
payloads: {
type: 'boolean',
'default': true,
required: false
},
preference: {
type: 'string',
required: false
},
routing: {
type: 'string',
required: false
},
parent: {
type: 'string',
required: false
},
realtime: {
type: 'boolean',
required: false
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/<%=id%>/_termvectors',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/<%=type%>/_termvectors',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}],
method: 'POST'
});
/**
* Perform a [update](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-update.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the update operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to return in the response
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-string,`String`>>} params.lang - The script language (default: painless)
* @param {<<api-param-type-string,`String`>>} params.parent - ID of the parent document. Is is only used for routing and when for the upsert request
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the effected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-number,`Number`>>} params.retryOnConflict - Specify how many times should the operation be retried when a conflict occurs (default: 0)
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - Document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.update = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
fields: {
type: 'list'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
lang: {
type: 'string'
},
parent: {
type: 'string'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
retryOnConflict: {
type: 'number',
name: 'retry_on_conflict'
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_update',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
needBody: true,
method: 'POST'
});
/**
* Perform a [updateByQuery](https://www.elastic.co/guide/en/elasticsearch/reference/6.2/docs-update-by-query.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-number,`Number`>>} params.from - Starting offset (default: 0)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.conflicts=abort] - What to do when the update by query hits version conflicts?
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-string,`String`>>} params.pipeline - Ingest pipeline to set on index requests made by this action. (default: none)
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-duration-string,`DurationString`>>} params.searchTimeout - Explicit timeout for each search request. Defaults to no timeout.
* @param {<<api-param-type-number,`Number`>>} params.size - Number of hits to return (default: 10)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.sort - A comma-separated list of <field>:<direction> pairs
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.terminateAfter - The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.stats - Specific 'tag' of the request for logging and statistical purposes
* @param {<<api-param-type-boolean,`Boolean`>>} params.version - Specify whether to return document version as part of a hit
* @param {<<api-param-type-boolean,`Boolean`>>} params.versionType - Should the document increment the version number (internal) on hit or not (reindex)
* @param {<<api-param-type-boolean,`Boolean`>>} params.requestCache - Specify if request cache should be used for this request or not, defaults to index level setting
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Should the effected indexes be refreshed?
* @param {<<api-param-type-duration-string,`DurationString`>>} [params.timeout=1m] - Time each individual bulk request should wait for shards that are unavailable.
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the update by query operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-number,`Number`>>} params.scrollSize - Size on the scroll request powering the update_by_query
* @param {<<api-param-type-boolean,`Boolean`>>} [params.waitForCompletion=true] - Should the request should block until the update by query operation is complete.
* @param {<<api-param-type-number,`Number`>>} params.requestsPerSecond - The throttle to set on this request in sub-requests per second. -1 means no throttle.
* @param {<<api-param-type-number,`Number`>>} [params.slices=1] - The number of slices this task should be divided into. Defaults to 1 meaning the task isn't sliced into subtasks.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to search; leave empty to perform the operation on all types
*/
api.updateByQuery = 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'
},
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'
},
pipeline: {
type: 'string'
},
preference: {
type: 'string'
},
q: {
type: 'string'
},
routing: {
type: 'list'
},
scroll: {
type: 'time'
},
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'
},
version: {
type: 'boolean'
},
versionType: {
type: 'boolean',
name: 'version_type'
},
requestCache: {
type: 'boolean',
name: 'request_cache'
},
refresh: {
type: 'boolean'
},
timeout: {
type: 'time',
'default': '1m'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
scrollSize: {
type: 'number',
name: 'scroll_size'
},
waitForCompletion: {
type: 'boolean',
'default': true,
name: 'wait_for_completion'
},
requestsPerSecond: {
type: 'number',
'default': 0,
name: 'requests_per_second'
},
slices: {
type: 'number',
'default': 1
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_update_by_query',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_update_by_query',
req: {
index: {
type: 'list'
}
}
}],
method: 'POST'
});
/***/ }),
/* 26 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
// In order to help people who were accidentally upgraded to this ES client,
// throw an error when they try to instanciate the exported function.
// previous "elasticsearch" module -> https://github.com/ncb000gt/node-es
function es() {
throw new Error('Looks like you are expecting the previous "elasticsearch" module. ' + 'It is now the "es" module. To create a client with this module use ' + '`new es.Client(params)`.');
}
es.Client = __webpack_require__(10);
es.ConnectionPool = __webpack_require__(9);
es.Transport = __webpack_require__(7);
es.errors = __webpack_require__(4);
module.exports = es;
/***/ }),
/* 27 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
exports.byteLength = byteLength
exports.toByteArray = toByteArray
exports.fromByteArray = fromByteArray
var lookup = []
var revLookup = []
var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
for (var i = 0, len = code.length; i < len; ++i) {
lookup[i] = code[i]
revLookup[code.charCodeAt(i)] = i
}
// Support decoding URL-safe base64 strings, as Node.js does.
// See: https://en.wikipedia.org/wiki/Base64#URL_applications
revLookup['-'.charCodeAt(0)] = 62
revLookup['_'.charCodeAt(0)] = 63
function getLens (b64) {
var len = b64.length
if (len % 4 > 0) {
throw new Error('Invalid string. Length must be a multiple of 4')
}
// Trim off extra bytes after placeholder bytes are found
// See: https://github.com/beatgammit/base64-js/issues/42
var validLen = b64.indexOf('=')
if (validLen === -1) validLen = len
var placeHoldersLen = validLen === len
? 0
: 4 - (validLen % 4)
return [validLen, placeHoldersLen]
}
// base64 is 4/3 + up to two characters of the original data
function byteLength (b64) {
var lens = getLens(b64)
var validLen = lens[0]
var placeHoldersLen = lens[1]
return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
}
function _byteLength (b64, validLen, placeHoldersLen) {
return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
}
function toByteArray (b64) {
var tmp
var lens = getLens(b64)
var validLen = lens[0]
var placeHoldersLen = lens[1]
var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
var curByte = 0
// if there are placeholders, only get up to the last complete 4 chars
var len = placeHoldersLen > 0
? validLen - 4
: validLen
for (var i = 0; i < len; i += 4) {
tmp =
(revLookup[b64.charCodeAt(i)] << 18) |
(revLookup[b64.charCodeAt(i + 1)] << 12) |
(revLookup[b64.charCodeAt(i + 2)] << 6) |
revLookup[b64.charCodeAt(i + 3)]
arr[curByte++] = (tmp >> 16) & 0xFF
arr[curByte++] = (tmp >> 8) & 0xFF
arr[curByte++] = tmp & 0xFF
}
if (placeHoldersLen === 2) {
tmp =
(revLookup[b64.charCodeAt(i)] << 2) |
(revLookup[b64.charCodeAt(i + 1)] >> 4)
arr[curByte++] = tmp & 0xFF
}
if (placeHoldersLen === 1) {
tmp =
(revLookup[b64.charCodeAt(i)] << 10) |
(revLookup[b64.charCodeAt(i + 1)] << 4) |
(revLookup[b64.charCodeAt(i + 2)] >> 2)
arr[curByte++] = (tmp >> 8) & 0xFF
arr[curByte++] = tmp & 0xFF
}
return arr
}
function tripletToBase64 (num) {
return lookup[num >> 18 & 0x3F] +
lookup[num >> 12 & 0x3F] +
lookup[num >> 6 & 0x3F] +
lookup[num & 0x3F]
}
function encodeChunk (uint8, start, end) {
var tmp
var output = []
for (var i = start; i < end; i += 3) {
tmp =
((uint8[i] << 16) & 0xFF0000) +
((uint8[i + 1] << 8) & 0xFF00) +
(uint8[i + 2] & 0xFF)
output.push(tripletToBase64(tmp))
}
return output.join('')
}
function fromByteArray (uint8) {
var tmp
var len = uint8.length
var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
var parts = []
var maxChunkLength = 16383 // must be multiple of 3
// go through the array every three bytes, we'll deal with trailing stuff later
for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
parts.push(encodeChunk(
uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)
))
}
// pad the end with zeros, but make sure to not forget the extra bytes
if (extraBytes === 1) {
tmp = uint8[len - 1]
parts.push(
lookup[tmp >> 2] +
lookup[(tmp << 4) & 0x3F] +
'=='
)
} else if (extraBytes === 2) {
tmp = (uint8[len - 2] << 8) + uint8[len - 1]
parts.push(
lookup[tmp >> 10] +
lookup[(tmp >> 4) & 0x3F] +
lookup[(tmp << 2) & 0x3F] +
'='
)
}
return parts.join('')
}
/***/ }),
/* 28 */
/***/ (function(module, exports) {
exports.read = function (buffer, offset, isLE, mLen, nBytes) {
var e, m
var eLen = (nBytes * 8) - mLen - 1
var eMax = (1 << eLen) - 1
var eBias = eMax >> 1
var nBits = -7
var i = isLE ? (nBytes - 1) : 0
var d = isLE ? -1 : 1
var s = buffer[offset + i]
i += d
e = s & ((1 << (-nBits)) - 1)
s >>= (-nBits)
nBits += eLen
for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}
m = e & ((1 << (-nBits)) - 1)
e >>= (-nBits)
nBits += mLen
for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}
if (e === 0) {
e = 1 - eBias
} else if (e === eMax) {
return m ? NaN : ((s ? -1 : 1) * Infinity)
} else {
m = m + Math.pow(2, mLen)
e = e - eBias
}
return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
}
exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
var e, m, c
var eLen = (nBytes * 8) - mLen - 1
var eMax = (1 << eLen) - 1
var eBias = eMax >> 1
var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
var i = isLE ? 0 : (nBytes - 1)
var d = isLE ? 1 : -1
var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
value = Math.abs(value)
if (isNaN(value) || value === Infinity) {
m = isNaN(value) ? 1 : 0
e = eMax
} else {
e = Math.floor(Math.log(value) / Math.LN2)
if (value * (c = Math.pow(2, -e)) < 1) {
e--
c *= 2
}
if (e + eBias >= 1) {
value += rt / c
} else {
value += rt * Math.pow(2, 1 - eBias)
}
if (value * c >= 2) {
e++
c /= 2
}
if (e + eBias >= eMax) {
m = 0
e = eMax
} else if (e + eBias >= 1) {
m = ((value * c) - 1) * Math.pow(2, mLen)
e = e + eBias
} else {
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
e = 0
}
}
for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
e = (e << mLen) | m
eLen += mLen
for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
buffer[offset + i - d] |= s * 128
}
/***/ }),
/* 29 */
/***/ (function(module, exports) {
var toString = {}.toString;
module.exports = Array.isArray || function (arr) {
return toString.call(arr) == '[object Array]';
};
/***/ }),
/* 30 */
/***/ (function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(global, process) {// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
var formatRegExp = /%[sdj%]/g;
exports.format = function(f) {
if (!isString(f)) {
var objects = [];
for (var i = 0; i < arguments.length; i++) {
objects.push(inspect(arguments[i]));
}
return objects.join(' ');
}
var i = 1;
var args = arguments;
var len = args.length;
var str = String(f).replace(formatRegExp, function(x) {
if (x === '%%') return '%';
if (i >= len) return x;
switch (x) {
case '%s': return String(args[i++]);
case '%d': return Number(args[i++]);
case '%j':
try {
return JSON.stringify(args[i++]);
} catch (_) {
return '[Circular]';
}
default:
return x;
}
});
for (var x = args[i]; i < len; x = args[++i]) {
if (isNull(x) || !isObject(x)) {
str += ' ' + x;
} else {
str += ' ' + inspect(x);
}
}
return str;
};
// Mark that a method should not be used.
// Returns a modified function which warns once by default.
// If --no-deprecation is set, then it is a no-op.
exports.deprecate = function(fn, msg) {
// Allow for deprecating things in the process of starting up.
if (isUndefined(global.process)) {
return function() {
return exports.deprecate(fn, msg).apply(this, arguments);
};
}
if (process.noDeprecation === true) {
return fn;
}
var warned = false;
function deprecated() {
if (!warned) {
if (process.throwDeprecation) {
throw new Error(msg);
} else if (process.traceDeprecation) {
console.trace(msg);
} else {
console.error(msg);
}
warned = true;
}
return fn.apply(this, arguments);
}
return deprecated;
};
var debugs = {};
var debugEnviron;
exports.debuglog = function(set) {
if (isUndefined(debugEnviron))
debugEnviron = process.env.NODE_DEBUG || '';
set = set.toUpperCase();
if (!debugs[set]) {
if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
var pid = process.pid;
debugs[set] = function() {
var msg = exports.format.apply(exports, arguments);
console.error('%s %d: %s', set, pid, msg);
};
} else {
debugs[set] = function() {};
}
}
return debugs[set];
};
/**
* Echos the value of a value. Trys to print the value out
* in the best way possible given the different types.
*
* @param {Object} obj The object to print out.
* @param {Object} opts Optional options object that alters the output.
*/
/* legacy: obj, showHidden, depth, colors*/
function inspect(obj, opts) {
// default options
var ctx = {
seen: [],
stylize: stylizeNoColor
};
// legacy...
if (arguments.length >= 3) ctx.depth = arguments[2];
if (arguments.length >= 4) ctx.colors = arguments[3];
if (isBoolean(opts)) {
// legacy...
ctx.showHidden = opts;
} else if (opts) {
// got an "options" object
exports._extend(ctx, opts);
}
// set default options
if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
if (isUndefined(ctx.depth)) ctx.depth = 2;
if (isUndefined(ctx.colors)) ctx.colors = false;
if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
if (ctx.colors) ctx.stylize = stylizeWithColor;
return formatValue(ctx, obj, ctx.depth);
}
exports.inspect = inspect;
// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
inspect.colors = {
'bold' : [1, 22],
'italic' : [3, 23],
'underline' : [4, 24],
'inverse' : [7, 27],
'white' : [37, 39],
'grey' : [90, 39],
'black' : [30, 39],
'blue' : [34, 39],
'cyan' : [36, 39],
'green' : [32, 39],
'magenta' : [35, 39],
'red' : [31, 39],
'yellow' : [33, 39]
};
// Don't use 'blue' not visible on cmd.exe
inspect.styles = {
'special': 'cyan',
'number': 'yellow',
'boolean': 'yellow',
'undefined': 'grey',
'null': 'bold',
'string': 'green',
'date': 'magenta',
// "name": intentionally not styling
'regexp': 'red'
};
function stylizeWithColor(str, styleType) {
var style = inspect.styles[styleType];
if (style) {
return '\u001b[' + inspect.colors[style][0] + 'm' + str +
'\u001b[' + inspect.colors[style][1] + 'm';
} else {
return str;
}
}
function stylizeNoColor(str, styleType) {
return str;
}
function arrayToHash(array) {
var hash = {};
array.forEach(function(val, idx) {
hash[val] = true;
});
return hash;
}
function formatValue(ctx, value, recurseTimes) {
// Provide a hook for user-specified inspect functions.
// Check that value is an object with an inspect function on it
if (ctx.customInspect &&
value &&
isFunction(value.inspect) &&
// Filter out the util module, it's inspect function is special
value.inspect !== exports.inspect &&
// Also filter out any prototype objects using the circular check.
!(value.constructor && value.constructor.prototype === value)) {
var ret = value.inspect(recurseTimes, ctx);
if (!isString(ret)) {
ret = formatValue(ctx, ret, recurseTimes);
}
return ret;
}
// Primitive types cannot have properties
var primitive = formatPrimitive(ctx, value);
if (primitive) {
return primitive;
}
// Look up the keys of the object.
var keys = Object.keys(value);
var visibleKeys = arrayToHash(keys);
if (ctx.showHidden) {
keys = Object.getOwnPropertyNames(value);
}
// IE doesn't make error fields non-enumerable
// http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
if (isError(value)
&& (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
return formatError(value);
}
// Some type of object without properties can be shortcutted.
if (keys.length === 0) {
if (isFunction(value)) {
var name = value.name ? ': ' + value.name : '';
return ctx.stylize('[Function' + name + ']', 'special');
}
if (isRegExp(value)) {
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
}
if (isDate(value)) {
return ctx.stylize(Date.prototype.toString.call(value), 'date');
}
if (isError(value)) {
return formatError(value);
}
}
var base = '', array = false, braces = ['{', '}'];
// Make Array say that they are Array
if (isArray(value)) {
array = true;
braces = ['[', ']'];
}
// Make functions say that they are functions
if (isFunction(value)) {
var n = value.name ? ': ' + value.name : '';
base = ' [Function' + n + ']';
}
// Make RegExps say that they are RegExps
if (isRegExp(value)) {
base = ' ' + RegExp.prototype.toString.call(value);
}
// Make dates with properties first say the date
if (isDate(value)) {
base = ' ' + Date.prototype.toUTCString.call(value);
}
// Make error with message first say the error
if (isError(value)) {
base = ' ' + formatError(value);
}
if (keys.length === 0 && (!array || value.length == 0)) {
return braces[0] + base + braces[1];
}
if (recurseTimes < 0) {
if (isRegExp(value)) {
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
} else {
return ctx.stylize('[Object]', 'special');
}
}
ctx.seen.push(value);
var output;
if (array) {
output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
} else {
output = keys.map(function(key) {
return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
});
}
ctx.seen.pop();
return reduceToSingleString(output, base, braces);
}
function formatPrimitive(ctx, value) {
if (isUndefined(value))
return ctx.stylize('undefined', 'undefined');
if (isString(value)) {
var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
.replace(/'/g, "\\'")
.replace(/\\"/g, '"') + '\'';
return ctx.stylize(simple, 'string');
}
if (isNumber(value))
return ctx.stylize('' + value, 'number');
if (isBoolean(value))
return ctx.stylize('' + value, 'boolean');
// For some reason typeof null is "object", so special case here.
if (isNull(value))
return ctx.stylize('null', 'null');
}
function formatError(value) {
return '[' + Error.prototype.toString.call(value) + ']';
}
function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
var output = [];
for (var i = 0, l = value.length; i < l; ++i) {
if (hasOwnProperty(value, String(i))) {
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
String(i), true));
} else {
output.push('');
}
}
keys.forEach(function(key) {
if (!key.match(/^\d+$/)) {
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
key, true));
}
});
return output;
}
function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
var name, str, desc;
desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
if (desc.get) {
if (desc.set) {
str = ctx.stylize('[Getter/Setter]', 'special');
} else {
str = ctx.stylize('[Getter]', 'special');
}
} else {
if (desc.set) {
str = ctx.stylize('[Setter]', 'special');
}
}
if (!hasOwnProperty(visibleKeys, key)) {
name = '[' + key + ']';
}
if (!str) {
if (ctx.seen.indexOf(desc.value) < 0) {
if (isNull(recurseTimes)) {
str = formatValue(ctx, desc.value, null);
} else {
str = formatValue(ctx, desc.value, recurseTimes - 1);
}
if (str.indexOf('\n') > -1) {
if (array) {
str = str.split('\n').map(function(line) {
return ' ' + line;
}).join('\n').substr(2);
} else {
str = '\n' + str.split('\n').map(function(line) {
return ' ' + line;
}).join('\n');
}
}
} else {
str = ctx.stylize('[Circular]', 'special');
}
}
if (isUndefined(name)) {
if (array && key.match(/^\d+$/)) {
return str;
}
name = JSON.stringify('' + key);
if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
name = name.substr(1, name.length - 2);
name = ctx.stylize(name, 'name');
} else {
name = name.replace(/'/g, "\\'")
.replace(/\\"/g, '"')
.replace(/(^"|"$)/g, "'");
name = ctx.stylize(name, 'string');
}
}
return name + ': ' + str;
}
function reduceToSingleString(output, base, braces) {
var numLinesEst = 0;
var length = output.reduce(function(prev, cur) {
numLinesEst++;
if (cur.indexOf('\n') >= 0) numLinesEst++;
return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
}, 0);
if (length > 60) {
return braces[0] +
(base === '' ? '' : base + '\n ') +
' ' +
output.join(',\n ') +
' ' +
braces[1];
}
return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
}
// NOTE: These type checking functions intentionally don't use `instanceof`
// because it is fragile and can be easily faked with `Object.create()`.
function isArray(ar) {
return Array.isArray(ar);
}
exports.isArray = isArray;
function isBoolean(arg) {
return typeof arg === 'boolean';
}
exports.isBoolean = isBoolean;
function isNull(arg) {
return arg === null;
}
exports.isNull = isNull;
function isNullOrUndefined(arg) {
return arg == null;
}
exports.isNullOrUndefined = isNullOrUndefined;
function isNumber(arg) {
return typeof arg === 'number';
}
exports.isNumber = isNumber;
function isString(arg) {
return typeof arg === 'string';
}
exports.isString = isString;
function isSymbol(arg) {
return typeof arg === 'symbol';
}
exports.isSymbol = isSymbol;
function isUndefined(arg) {
return arg === void 0;
}
exports.isUndefined = isUndefined;
function isRegExp(re) {
return isObject(re) && objectToString(re) === '[object RegExp]';
}
exports.isRegExp = isRegExp;
function isObject(arg) {
return typeof arg === 'object' && arg !== null;
}
exports.isObject = isObject;
function isDate(d) {
return isObject(d) && objectToString(d) === '[object Date]';
}
exports.isDate = isDate;
function isError(e) {
return isObject(e) &&
(objectToString(e) === '[object Error]' || e instanceof Error);
}
exports.isError = isError;
function isFunction(arg) {
return typeof arg === 'function';
}
exports.isFunction = isFunction;
function isPrimitive(arg) {
return arg === null ||
typeof arg === 'boolean' ||
typeof arg === 'number' ||
typeof arg === 'string' ||
typeof arg === 'symbol' || // ES6 symbol
typeof arg === 'undefined';
}
exports.isPrimitive = isPrimitive;
exports.isBuffer = __webpack_require__(31);
function objectToString(o) {
return Object.prototype.toString.call(o);
}
function pad(n) {
return n < 10 ? '0' + n.toString(10) : n.toString(10);
}
var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
'Oct', 'Nov', 'Dec'];
// 26 Feb 16:19:34
function timestamp() {
var d = new Date();
var time = [pad(d.getHours()),
pad(d.getMinutes()),
pad(d.getSeconds())].join(':');
return [d.getDate(), months[d.getMonth()], time].join(' ');
}
// log is just a thin wrapper to console.log that prepends a timestamp
exports.log = function() {
console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
};
/**
* Inherit the prototype methods from one constructor into another.
*
* The Function.prototype.inherits from lang.js rewritten as a standalone
* function (not on Function.prototype). NOTE: If this file is to be loaded
* during bootstrapping this function needs to be rewritten using some native
* functions as prototype setup using normal JavaScript does not work as
* expected during bootstrapping (see mirror.js in r114903).
*
* @param {function} ctor Constructor function which needs to inherit the
* prototype.
* @param {function} superCtor Constructor function to inherit prototype from.
*/
exports.inherits = __webpack_require__(32);
exports._extend = function(origin, add) {
// Don't do anything if add isn't an object
if (!add || !isObject(add)) return origin;
var keys = Object.keys(add);
var i = keys.length;
while (i--) {
origin[keys[i]] = add[keys[i]];
}
return origin;
};
function hasOwnProperty(obj, prop) {
return Object.prototype.hasOwnProperty.call(obj, prop);
}
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5), __webpack_require__(3)))
/***/ }),
/* 31 */
/***/ (function(module, exports) {
module.exports = function isBuffer(arg) {
return arg && typeof arg === 'object'
&& typeof arg.copy === 'function'
&& typeof arg.fill === 'function'
&& typeof arg.readUInt8 === 'function';
}
/***/ }),
/* 32 */
/***/ (function(module, exports) {
if (typeof Object.create === 'function') {
// implementation from standard node.js 'util' module
module.exports = function inherits(ctor, superCtor) {
ctor.super_ = superCtor
ctor.prototype = Object.create(superCtor.prototype, {
constructor: {
value: ctor,
enumerable: false,
writable: true,
configurable: true
}
});
};
} else {
// old school shim for old browsers
module.exports = function inherits(ctor, superCtor) {
ctor.super_ = superCtor
var TempCtor = function () {}
TempCtor.prototype = superCtor.prototype
ctor.prototype = new TempCtor()
ctor.prototype.constructor = ctor
}
}
/***/ }),
/* 33 */
/***/ (function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(module, global) {var __WEBPACK_AMD_DEFINE_RESULT__;/*! https://mths.be/punycode v1.4.1 by @mathias */
;(function(root) {
/** Detect free variables */
var freeExports = typeof exports == 'object' && exports &&
!exports.nodeType && exports;
var freeModule = typeof module == 'object' && module &&
!module.nodeType && module;
var freeGlobal = typeof global == 'object' && global;
if (
freeGlobal.global === freeGlobal ||
freeGlobal.window === freeGlobal ||
freeGlobal.self === freeGlobal
) {
root = freeGlobal;
}
/**
* The `punycode` object.
* @name punycode
* @type Object
*/
var punycode,
/** Highest positive signed 32-bit float value */
maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1
/** Bootstring parameters */
base = 36,
tMin = 1,
tMax = 26,
skew = 38,
damp = 700,
initialBias = 72,
initialN = 128, // 0x80
delimiter = '-', // '\x2D'
/** Regular expressions */
regexPunycode = /^xn--/,
regexNonASCII = /[^\x20-\x7E]/, // unprintable ASCII chars + non-ASCII chars
regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, // RFC 3490 separators
/** Error messages */
errors = {
'overflow': 'Overflow: input needs wider integers to process',
'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
'invalid-input': 'Invalid input'
},
/** Convenience shortcuts */
baseMinusTMin = base - tMin,
floor = Math.floor,
stringFromCharCode = String.fromCharCode,
/** Temporary variable */
key;
/*--------------------------------------------------------------------------*/
/**
* A generic error utility function.
* @private
* @param {String} type The error type.
* @returns {Error} Throws a `RangeError` with the applicable error message.
*/
function error(type) {
throw new RangeError(errors[type]);
}
/**
* A generic `Array#map` utility function.
* @private
* @param {Array} array The array to iterate over.
* @param {Function} callback The function that gets called for every array
* item.
* @returns {Array} A new array of values returned by the callback function.
*/
function map(array, fn) {
var length = array.length;
var result = [];
while (length--) {
result[length] = fn(array[length]);
}
return result;
}
/**
* A simple `Array#map`-like wrapper to work with domain name strings or email
* addresses.
* @private
* @param {String} domain The domain name or email address.
* @param {Function} callback The function that gets called for every
* character.
* @returns {Array} A new string of characters returned by the callback
* function.
*/
function mapDomain(string, fn) {
var parts = string.split('@');
var result = '';
if (parts.length > 1) {
// In email addresses, only the domain name should be punycoded. Leave
// the local part (i.e. everything up to `@`) intact.
result = parts[0] + '@';
string = parts[1];
}
// Avoid `split(regex)` for IE8 compatibility. See #17.
string = string.replace(regexSeparators, '\x2E');
var labels = string.split('.');
var encoded = map(labels, fn).join('.');
return result + encoded;
}
/**
* Creates an array containing the numeric code points of each Unicode
* character in the string. While JavaScript uses UCS-2 internally,
* this function will convert a pair of surrogate halves (each of which
* UCS-2 exposes as separate characters) into a single code point,
* matching UTF-16.
* @see `punycode.ucs2.encode`
* @see <https://mathiasbynens.be/notes/javascript-encoding>
* @memberOf punycode.ucs2
* @name decode
* @param {String} string The Unicode input string (UCS-2).
* @returns {Array} The new array of code points.
*/
function ucs2decode(string) {
var output = [],
counter = 0,
length = string.length,
value,
extra;
while (counter < length) {
value = string.charCodeAt(counter++);
if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
// high surrogate, and there is a next character
extra = string.charCodeAt(counter++);
if ((extra & 0xFC00) == 0xDC00) { // low surrogate
output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
} else {
// unmatched surrogate; only append this code unit, in case the next
// code unit is the high surrogate of a surrogate pair
output.push(value);
counter--;
}
} else {
output.push(value);
}
}
return output;
}
/**
* Creates a string based on an array of numeric code points.
* @see `punycode.ucs2.decode`
* @memberOf punycode.ucs2
* @name encode
* @param {Array} codePoints The array of numeric code points.
* @returns {String} The new Unicode string (UCS-2).
*/
function ucs2encode(array) {
return map(array, function(value) {
var output = '';
if (value > 0xFFFF) {
value -= 0x10000;
output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
value = 0xDC00 | value & 0x3FF;
}
output += stringFromCharCode(value);
return output;
}).join('');
}
/**
* Converts a basic code point into a digit/integer.
* @see `digitToBasic()`
* @private
* @param {Number} codePoint The basic numeric code point value.
* @returns {Number} The numeric value of a basic code point (for use in
* representing integers) in the range `0` to `base - 1`, or `base` if
* the code point does not represent a value.
*/
function basicToDigit(codePoint) {
if (codePoint - 48 < 10) {
return codePoint - 22;
}
if (codePoint - 65 < 26) {
return codePoint - 65;
}
if (codePoint - 97 < 26) {
return codePoint - 97;
}
return base;
}
/**
* Converts a digit/integer into a basic code point.
* @see `basicToDigit()`
* @private
* @param {Number} digit The numeric value of a basic code point.
* @returns {Number} The basic code point whose value (when used for
* representing integers) is `digit`, which needs to be in the range
* `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
* used; else, the lowercase form is used. The behavior is undefined
* if `flag` is non-zero and `digit` has no uppercase form.
*/
function digitToBasic(digit, flag) {
// 0..25 map to ASCII a..z or A..Z
// 26..35 map to ASCII 0..9
return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
}
/**
* Bias adaptation function as per section 3.4 of RFC 3492.
* https://tools.ietf.org/html/rfc3492#section-3.4
* @private
*/
function adapt(delta, numPoints, firstTime) {
var k = 0;
delta = firstTime ? floor(delta / damp) : delta >> 1;
delta += floor(delta / numPoints);
for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
delta = floor(delta / baseMinusTMin);
}
return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
}
/**
* Converts a Punycode string of ASCII-only symbols to a string of Unicode
* symbols.
* @memberOf punycode
* @param {String} input The Punycode string of ASCII-only symbols.
* @returns {String} The resulting string of Unicode symbols.
*/
function decode(input) {
// Don't use UCS-2
var output = [],
inputLength = input.length,
out,
i = 0,
n = initialN,
bias = initialBias,
basic,
j,
index,
oldi,
w,
k,
digit,
t,
/** Cached calculation results */
baseMinusT;
// Handle the basic code points: let `basic` be the number of input code
// points before the last delimiter, or `0` if there is none, then copy
// the first basic code points to the output.
basic = input.lastIndexOf(delimiter);
if (basic < 0) {
basic = 0;
}
for (j = 0; j < basic; ++j) {
// if it's not a basic code point
if (input.charCodeAt(j) >= 0x80) {
error('not-basic');
}
output.push(input.charCodeAt(j));
}
// Main decoding loop: start just after the last delimiter if any basic code
// points were copied; start at the beginning otherwise.
for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {
// `index` is the index of the next character to be consumed.
// Decode a generalized variable-length integer into `delta`,
// which gets added to `i`. The overflow checking is easier
// if we increase `i` as we go, then subtract off its starting
// value at the end to obtain `delta`.
for (oldi = i, w = 1, k = base; /* no condition */; k += base) {
if (index >= inputLength) {
error('invalid-input');
}
digit = basicToDigit(input.charCodeAt(index++));
if (digit >= base || digit > floor((maxInt - i) / w)) {
error('overflow');
}
i += digit * w;
t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
if (digit < t) {
break;
}
baseMinusT = base - t;
if (w > floor(maxInt / baseMinusT)) {
error('overflow');
}
w *= baseMinusT;
}
out = output.length + 1;
bias = adapt(i - oldi, out, oldi == 0);
// `i` was supposed to wrap around from `out` to `0`,
// incrementing `n` each time, so we'll fix that now:
if (floor(i / out) > maxInt - n) {
error('overflow');
}
n += floor(i / out);
i %= out;
// Insert `n` at position `i` of the output
output.splice(i++, 0, n);
}
return ucs2encode(output);
}
/**
* Converts a string of Unicode symbols (e.g. a domain name label) to a
* Punycode string of ASCII-only symbols.
* @memberOf punycode
* @param {String} input The string of Unicode symbols.
* @returns {String} The resulting Punycode string of ASCII-only symbols.
*/
function encode(input) {
var n,
delta,
handledCPCount,
basicLength,
bias,
j,
m,
q,
k,
t,
currentValue,
output = [],
/** `inputLength` will hold the number of code points in `input`. */
inputLength,
/** Cached calculation results */
handledCPCountPlusOne,
baseMinusT,
qMinusT;
// Convert the input in UCS-2 to Unicode
input = ucs2decode(input);
// Cache the length
inputLength = input.length;
// Initialize the state
n = initialN;
delta = 0;
bias = initialBias;
// Handle the basic code points
for (j = 0; j < inputLength; ++j) {
currentValue = input[j];
if (currentValue < 0x80) {
output.push(stringFromCharCode(currentValue));
}
}
handledCPCount = basicLength = output.length;
// `handledCPCount` is the number of code points that have been handled;
// `basicLength` is the number of basic code points.
// Finish the basic string - if it is not empty - with a delimiter
if (basicLength) {
output.push(delimiter);
}
// Main encoding loop:
while (handledCPCount < inputLength) {
// All non-basic code points < n have been handled already. Find the next
// larger one:
for (m = maxInt, j = 0; j < inputLength; ++j) {
currentValue = input[j];
if (currentValue >= n && currentValue < m) {
m = currentValue;
}
}
// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,
// but guard against overflow
handledCPCountPlusOne = handledCPCount + 1;
if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
error('overflow');
}
delta += (m - n) * handledCPCountPlusOne;
n = m;
for (j = 0; j < inputLength; ++j) {
currentValue = input[j];
if (currentValue < n && ++delta > maxInt) {
error('overflow');
}
if (currentValue == n) {
// Represent delta as a generalized variable-length integer
for (q = delta, k = base; /* no condition */; k += base) {
t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
if (q < t) {
break;
}
qMinusT = q - t;
baseMinusT = base - t;
output.push(
stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
);
q = floor(qMinusT / baseMinusT);
}
output.push(stringFromCharCode(digitToBasic(q, 0)));
bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
delta = 0;
++handledCPCount;
}
}
++delta;
++n;
}
return output.join('');
}
/**
* Converts a Punycode string representing a domain name or an email address
* to Unicode. Only the Punycoded parts of the input will be converted, i.e.
* it doesn't matter if you call it on a string that has already been
* converted to Unicode.
* @memberOf punycode
* @param {String} input The Punycoded domain name or email address to
* convert to Unicode.
* @returns {String} The Unicode representation of the given Punycode
* string.
*/
function toUnicode(input) {
return mapDomain(input, function(string) {
return regexPunycode.test(string)
? decode(string.slice(4).toLowerCase())
: string;
});
}
/**
* Converts a Unicode string representing a domain name or an email address to
* Punycode. Only the non-ASCII parts of the domain name will be converted,
* i.e. it doesn't matter if you call it with a domain that's already in
* ASCII.
* @memberOf punycode
* @param {String} input The domain name or email address to convert, as a
* Unicode string.
* @returns {String} The Punycode representation of the given domain name or
* email address.
*/
function toASCII(input) {
return mapDomain(input, function(string) {
return regexNonASCII.test(string)
? 'xn--' + encode(string)
: string;
});
}
/*--------------------------------------------------------------------------*/
/** Define the public API */
punycode = {
/**
* A string representing the current Punycode.js version number.
* @memberOf punycode
* @type String
*/
'version': '1.4.1',
/**
* An object of methods to convert from JavaScript's internal character
* representation (UCS-2) to Unicode code points, and back.
* @see <https://mathiasbynens.be/notes/javascript-encoding>
* @memberOf punycode
* @type Object
*/
'ucs2': {
'decode': ucs2decode,
'encode': ucs2encode
},
'decode': decode,
'encode': encode,
'toASCII': toASCII,
'toUnicode': toUnicode
};
/** Expose `punycode` */
// Some AMD build optimizers, like r.js, check for specific condition patterns
// like the following:
if (
true
) {
!(__WEBPACK_AMD_DEFINE_RESULT__ = (function() {
return punycode;
}).call(exports, __webpack_require__, exports, module),
__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
} else if (freeExports && freeModule) {
if (module.exports == freeExports) {
// in Node.js, io.js, or RingoJS v0.8.0+
freeModule.exports = punycode;
} else {
// in Narwhal or RingoJS v0.7.0-
for (key in punycode) {
punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
}
}
} else {
// in Rhino or a web browser
root.punycode = punycode;
}
}(this));
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(11)(module), __webpack_require__(5)))
/***/ }),
/* 34 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
module.exports = {
isString: function(arg) {
return typeof(arg) === 'string';
},
isObject: function(arg) {
return typeof(arg) === 'object' && arg !== null;
},
isNull: function(arg) {
return arg === null;
},
isNullOrUndefined: function(arg) {
return arg == null;
}
};
/***/ }),
/* 35 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
// If obj.hasOwnProperty has been overridden, then calling
// obj.hasOwnProperty(prop) will break.
// See: https://github.com/joyent/node/issues/1707
function hasOwnProperty(obj, prop) {
return Object.prototype.hasOwnProperty.call(obj, prop);
}
module.exports = function(qs, sep, eq, options) {
sep = sep || '&';
eq = eq || '=';
var obj = {};
if (typeof qs !== 'string' || qs.length === 0) {
return obj;
}
var regexp = /\+/g;
qs = qs.split(sep);
var maxKeys = 1000;
if (options && typeof options.maxKeys === 'number') {
maxKeys = options.maxKeys;
}
var len = qs.length;
// maxKeys <= 0 means that we should not limit keys count
if (maxKeys > 0 && len > maxKeys) {
len = maxKeys;
}
for (var i = 0; i < len; ++i) {
var x = qs[i].replace(regexp, '%20'),
idx = x.indexOf(eq),
kstr, vstr, k, v;
if (idx >= 0) {
kstr = x.substr(0, idx);
vstr = x.substr(idx + 1);
} else {
kstr = x;
vstr = '';
}
k = decodeURIComponent(kstr);
v = decodeURIComponent(vstr);
if (!hasOwnProperty(obj, k)) {
obj[k] = v;
} else if (isArray(obj[k])) {
obj[k].push(v);
} else {
obj[k] = [obj[k], v];
}
}
return obj;
};
var isArray = Array.isArray || function (xs) {
return Object.prototype.toString.call(xs) === '[object Array]';
};
/***/ }),
/* 36 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
var stringifyPrimitive = function(v) {
switch (typeof v) {
case 'string':
return v;
case 'boolean':
return v ? 'true' : 'false';
case 'number':
return isFinite(v) ? v : '';
default:
return '';
}
};
module.exports = function(obj, sep, eq, name) {
sep = sep || '&';
eq = eq || '=';
if (obj === null) {
obj = undefined;
}
if (typeof obj === 'object') {
return map(objectKeys(obj), function(k) {
var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
if (isArray(obj[k])) {
return map(obj[k], function(v) {
return ks + encodeURIComponent(stringifyPrimitive(v));
}).join(sep);
} else {
return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
}
}).join(sep);
}
if (!name) return '';
return encodeURIComponent(stringifyPrimitive(name)) + eq +
encodeURIComponent(stringifyPrimitive(obj));
};
var isArray = Array.isArray || function (xs) {
return Object.prototype.toString.call(xs) === '[object Array]';
};
function map (xs, f) {
if (xs.map) return xs.map(f);
var res = [];
for (var i = 0; i < xs.length; i++) {
res.push(f(xs[i], i));
}
return res;
}
var objectKeys = Object.keys || function (obj) {
var res = [];
for (var key in obj) {
if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);
}
return res;
};
/***/ }),
/* 37 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var utils = __webpack_require__(2);
/**
* Patch the transport's connection pool to schedule a sniff after a connection fails.
* When a connection fails for the first time it will schedule a sniff 1 second in the
* future, and increase the timeout based on the deadTimeout algorithm chosen by the
* connectionPool, and the number of times the sniff has failed.
*
* @param {Transport} transport - the transport that will be using this behavior
* @return {undefined}
*/
module.exports = function setupSniffOnConnectionFault(transport) {
var failures = 0;
var pool = transport.connectionPool;
var originalOnDied = pool._onConnectionDied; // do the actual sniff, if the sniff is unable to
// connect to a node this function will be called again by the connectionPool
var work = function work() {
work.timerId = transport._timeout(work.timerId);
transport.sniff();
}; // create a function that will count down to a
// point n milliseconds into the future
var countdownTo = function countdownTo(ms) {
var start = utils.now();
return function () {
return start - ms;
};
}; // overwrite the function, but still call it
pool._onConnectionDied = function (connection, wasAlreadyDead) {
var ret = originalOnDied.call(pool, connection, wasAlreadyDead); // clear the failures if this is the first failure we have seen
failures = work.timerId ? failures + 1 : 0;
var ms = pool.calcDeadTimeout(failures, 1000);
if (work.timerId && ms < work.timerId && work.countdown()) {
// clear the timer
work.timerId = transport._timeout(work.timerId);
}
if (!work.timerId) {
work.timerId = transport._timeout(work, ms);
work.countdown = countdownTo(ms);
}
return ret;
};
pool._onConnectionDied.restore = function () {
pool._onConnectionDied = originalOnDied;
};
};
/***/ }),
/* 38 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var _ = __webpack_require__(0);
module.exports = function (hosts) {
if (_.isEmpty(hosts)) return false;
var commonProtocol = hosts.shift().protocol;
for (var i = 0; i < hosts.length; i++) {
if (commonProtocol !== hosts[i].protocol) {
return false;
}
}
return commonProtocol;
};
/***/ }),
/* 39 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* Special version of the Stream logger, which logs errors and warnings to stderr and all other
* levels to stdout.
*
* @class Loggers.Console
* @extends LoggerAbstract
* @constructor
* @param {Object} config - The configuration for the Logger
* @param {string} config.level - The highest log level for this logger to output.
* @param {Log} bridge - The object that triggers logging events, which we will record
*/
module.exports = Console;
var LoggerAbstract = __webpack_require__(17);
var _ = __webpack_require__(0);
var utils = __webpack_require__(2);
function Console(log, config) {
LoggerAbstract.call(this, log, config); // config/state
this.color = _.has(config, 'color') ? !!config.color : true;
}
utils.inherits(Console, LoggerAbstract);
/**
* Override the LoggerAbstract's setup listeners to do a little extra setup
*
* @param {Array} levels - The levels that we should be listeneing for
*/
Console.prototype.setupListeners = function (levels) {
// call the super method
LoggerAbstract.prototype.setupListeners.call(this, levels);
};
Console.prototype.write = function (label, message, to) {
if (console[to]) {
console[to](this.format(label, message));
}
};
/**
* Handler for the bridges "error" event
*
* @method onError
* @private
* @param {Error} e - The Error object to log
* @return {undefined}
*/
Console.prototype.onError = utils.handler(function (e) {
var to = console.error ? 'error' : 'log';
this.write(e.name === 'Error' ? 'ERROR' : e.name, e.stack || e.message, to);
});
/**
* Handler for the bridges "warning" event
*
* @method onWarning
* @private
* @param {String} msg - The message to be logged
* @return {undefined}
*/
Console.prototype.onWarning = utils.handler(function (msg) {
this.write('WARNING', msg, console.warn ? 'warn' : 'log');
});
/**
* Handler for the bridges "info" event
*
* @method onInfo
* @private
* @param {String} msg - The message to be logged
* @return {undefined}
*/
Console.prototype.onInfo = utils.handler(function (msg) {
this.write('INFO', msg, console.info ? 'info' : 'log');
});
/**
* Handler for the bridges "debug" event
*
* @method onDebug
* @private
* @param {String} msg - The message to be logged
* @return {undefined}
*/
Console.prototype.onDebug = utils.handler(function (msg) {
this.write('DEBUG', msg, console.debug ? 'debug' : 'log');
});
/**
* Handler for the bridges "trace" event
*
* @method onTrace
* @private
* @return {undefined}
*/
Console.prototype.onTrace = utils.handler(function (msg) {
this.write('TRACE', this._formatTraceMessage(msg), 'log');
});
/***/ }),
/* 40 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* Selects a connection randomly
*
* @module selectors
* @type {Function}
* @param {Array} connection - The list of connections to choose from
* @return {Connection} - The selected connection
*/
module.exports = function RandomSelector(connections) {
return connections[Math.floor(Math.random() * connections.length)];
};
/***/ }),
/* 41 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* Selects a connection the simplest way possible, Round Robin
*
* @module selectors
* @type {Function}
* @param {Array} connections - The list of connections that this selector needs to choose from
* @return {Connection} - The selected connection
*/
module.exports = function (connections) {
var connection = connections[0];
connections.push(connections.shift());
return connection;
};
/***/ }),
/* 42 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
/**
* Generic Transport for the browser, using the XmlHttpRequest object
*
* @class connections.Xhr
*/
module.exports = XhrConnector;
/* jshint browser:true */
var utils = __webpack_require__(2);
var ConnectionAbstract = __webpack_require__(20);
var ConnectionFault = __webpack_require__(4).ConnectionFault;
var asyncDefault = !(navigator && /PhantomJS/i.test(navigator.userAgent));
function XhrConnector(host, config) {
ConnectionAbstract.call(this, host, config);
}
utils.inherits(XhrConnector, ConnectionAbstract);
/**
* Simply returns an XHR object cross browser
* @type {Function}
*/
var getXhr = _.noop;
if (typeof XMLHttpRequest !== 'undefined') {
// rewrite the getXhr method to always return the native implementation
getXhr = function getXhr() {
return new XMLHttpRequest();
};
} else {
// find the first MS implementation available
getXhr = _(['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0']).map(function (appName) {
/* jshint unused: false */
try {
var test = new window.ActiveXObject(appName); // eslint-disable-line no-unused-vars
return function () {
return new window.ActiveXObject(appName);
};
} catch (e) {
return false;
}
}).compact().head();
}
if (!getXhr) {
throw new Error('getXhr(): XMLHttpRequest not available');
}
XhrConnector.prototype.request = function (params, cb) {
var xhr = getXhr();
var timeoutId;
var host = this.host;
var log = this.log;
var url = host.makeUrl(params);
var headers = host.getHeaders(params.headers);
var async = params.async === false ? false : asyncDefault;
xhr.open(params.method || 'GET', url, async);
if (headers) {
for (var key in headers) {
if (headers[key] !== void 0) {
xhr.setRequestHeader(key, headers[key]);
}
}
}
xhr.onreadystatechange = function () {
if (xhr.readyState === 4) {
clearTimeout(timeoutId);
log.trace(params.method, url, params.body, xhr.responseText, xhr.status);
var err = xhr.status ? void 0 : new ConnectionFault(xhr.statusText || 'Request failed to complete.');
cb(err, xhr.responseText, xhr.status);
}
};
xhr.send(params.body || void 0);
return function () {
xhr.abort();
};
};
/***/ }),
/* 43 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
// empty (null-loader)
/***/ }),
/* 44 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
// empty (null-loader)
/***/ }),
/* 45 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
/* global angular */
var utils = __webpack_require__(2);
var JsonSerializer = __webpack_require__(22);
function AngularSerializer() {}
utils.inherits(AngularSerializer, JsonSerializer); // mimic the JsonSerializer's encode method, but use angular's toJson instead
AngularSerializer.prototype.encode = function (val) {
switch (_typeof(val)) {
case 'string':
return val;
case 'object':
if (val) return angular.toJson(val);
/* falls through */
default:
return;
}
};
module.exports = AngularSerializer;
/***/ }),
/* 46 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var ca = __webpack_require__(1).makeFactoryWithModifier(function (spec) {
return __webpack_require__(0).merge(spec, {
params: {
filterPath: {
type: 'list',
name: 'filter_path'
}
}
});
});
var namespace = __webpack_require__(1).namespaceFactory;
var api = module.exports = {};
api._namespaces = ['cat', 'cluster', 'indices', 'ingest', 'nodes', 'snapshot', 'tasks'];
/**
* Perform a [bulk](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/docs-bulk.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the bulk operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the effected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.type - Default document type for items which don't provide one
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - Default comma-separated list of fields to return in the response for updates, can be overridden on each sub-request
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or default list of fields to return, can be overridden on each sub-request
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - Default list of fields to exclude from the returned _source field, can be overridden on each sub-request
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - Default list of fields to extract and return from the _source field, can be overridden on each sub-request
* @param {<<api-param-type-string,`String`>>} params.pipeline - The pipeline id to preprocess incoming documents with
* @param {<<api-param-type-string,`String`>>} params.index - Default index for items which don't provide one
*/
api.bulk = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
type: {
type: 'string'
},
fields: {
type: 'list'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
pipeline: {
type: 'string'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_bulk',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/_bulk',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_bulk'
}],
needBody: true,
bulkBody: true,
method: 'POST'
});
api.cat = namespace();
/**
* Perform a [cat.aliases](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cat.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - A comma-separated list of alias names to return
*/
api.cat.prototype.aliases = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/aliases/<%=name%>',
req: {
name: {
type: 'list'
}
}
}, {
fmt: '/_cat/aliases'
}]
});
/**
* Perform a [cat.allocation](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cat-allocation.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information
*/
api.cat.prototype.allocation = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/allocation/<%=nodeId%>',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_cat/allocation'
}]
});
/**
* Perform a [cat.count](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cat-count.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.count = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/count/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/count'
}]
});
/**
* Perform a [cat.fielddata](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cat-fielddata.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to return the fielddata size
*/
api.cat.prototype.fielddata = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
},
fields: {
type: 'list'
}
},
urls: [{
fmt: '/_cat/fielddata/<%=fields%>',
req: {
fields: {
type: 'list'
}
}
}, {
fmt: '/_cat/fielddata'
}]
});
/**
* Perform a [cat.health](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cat-health.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} [params.ts=true] - Set to false to disable timestamping
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.health = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
ts: {
type: 'boolean',
'default': true
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/health'
}
});
/**
* Perform a [cat.help](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cat.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
*/
api.cat.prototype.help = ca({
params: {
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
}
},
url: {
fmt: '/_cat'
}
});
/**
* Perform a [cat.indices](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cat-indices.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-string,`String`>>} params.health - A health status ("green", "yellow", or "red" to filter only indices matching the specified health status
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-boolean,`Boolean`>>} params.pri - Set to true to return stats only for primary shards
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.indices = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'm', 'g']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
health: {
type: 'enum',
'default': null,
options: ['green', 'yellow', 'red']
},
help: {
type: 'boolean',
'default': false
},
pri: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/indices/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/indices'
}]
});
/**
* Perform a [cat.master](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cat-master.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.master = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/master'
}
});
/**
* Perform a [cat.nodeattrs](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cat-nodeattrs.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.nodeattrs = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/nodeattrs'
}
});
/**
* Perform a [cat.nodes](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cat-nodes.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.fullId - Return the full node ID instead of the shortened version (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.nodes = ca({
params: {
format: {
type: 'string'
},
fullId: {
type: 'boolean',
name: 'full_id'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/nodes'
}
});
/**
* Perform a [cat.pendingTasks](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cat-pending-tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.pendingTasks = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/pending_tasks'
}
});
/**
* Perform a [cat.plugins](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cat-plugins.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.plugins = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/plugins'
}
});
/**
* Perform a [cat.recovery](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cat-recovery.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.recovery = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/recovery/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/recovery'
}]
});
/**
* Perform a [cat.repositories](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cat-repositories.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.repositories = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean',
'default': false
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/repositories'
}
});
/**
* Perform a [cat.segments](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cat-segments.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.segments = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/segments/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/segments'
}]
});
/**
* Perform a [cat.shards](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cat-shards.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.shards = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/shards/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/shards'
}]
});
/**
* Perform a [cat.snapshots](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cat-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Set to true to ignore unavailable snapshots
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.repository - Name of repository from which to fetch the snapshot information
*/
api.cat.prototype.snapshots = ca({
params: {
format: {
type: 'string'
},
ignoreUnavailable: {
type: 'boolean',
'default': false,
name: 'ignore_unavailable'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/snapshots/<%=repository%>',
req: {
repository: {
type: 'list'
}
}
}, {
fmt: '/_cat/snapshots'
}]
});
/**
* Perform a [cat.tasks](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.actions - A comma-separated list of actions that should be returned. Leave empty to return all.
* @param {<<api-param-type-boolean,`Boolean`>>} params.detailed - Return detailed task information (default: false)
* @param {<<api-param-type-string,`String`>>} params.parentNode - Return tasks with specified parent node.
* @param {<<api-param-type-number,`Number`>>} params.parentTask - Return tasks with specified parent task id. Set to -1 to return all.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.tasks = ca({
params: {
format: {
type: 'string'
},
nodeId: {
type: 'list',
name: 'node_id'
},
actions: {
type: 'list'
},
detailed: {
type: 'boolean'
},
parentNode: {
type: 'string',
name: 'parent_node'
},
parentTask: {
type: 'number',
name: 'parent_task'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/tasks'
}
});
/**
* Perform a [cat.templates](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cat-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>} params.name - A pattern that returned template names must match
*/
api.cat.prototype.templates = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/templates/<%=name%>',
req: {
name: {
type: 'string'
}
}
}, {
fmt: '/_cat/templates'
}]
});
/**
* Perform a [cat.threadPool](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cat-thread-pool.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.size - The multiplier in which to display values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.threadPoolPatterns - A comma-separated list of regular-expressions to filter the thread pools in the output
*/
api.cat.prototype.threadPool = ca({
params: {
format: {
type: 'string'
},
size: {
type: 'enum',
options: ['', 'k', 'm', 'g', 't', 'p']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/thread_pool/<%=threadPoolPatterns%>',
req: {
threadPoolPatterns: {
type: 'list'
}
}
}, {
fmt: '/_cat/thread_pool'
}]
});
/**
* Perform a [clearScroll](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/search-request-scroll.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.scrollId - A comma-separated list of scroll IDs to clear
*/
api.clearScroll = ca({
urls: [{
fmt: '/_search/scroll/<%=scrollId%>',
req: {
scrollId: {
type: 'list'
}
}
}, {
fmt: '/_search/scroll'
}],
paramAsBody: {
param: 'scrollId',
body: 'scroll_id'
},
method: 'DELETE'
});
api.cluster = namespace();
/**
* Perform a [cluster.allocationExplain](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cluster-allocation-explain.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeYesDecisions - Return 'YES' decisions in explanation (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDiskInfo - Return information about disk usage and shard sizes (default: false)
*/
api.cluster.prototype.allocationExplain = ca({
params: {
includeYesDecisions: {
type: 'boolean',
name: 'include_yes_decisions'
},
includeDiskInfo: {
type: 'boolean',
name: 'include_disk_info'
}
},
url: {
fmt: '/_cluster/allocation/explain'
},
method: 'POST'
});
/**
* Perform a [cluster.getSettings](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cluster-update-settings.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether to return all default clusters setting.
*/
api.cluster.prototype.getSettings = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
},
includeDefaults: {
type: 'boolean',
'default': false,
name: 'include_defaults'
}
},
url: {
fmt: '/_cluster/settings'
}
});
/**
* Perform a [cluster.health](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cluster-health.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} [params.level=cluster] - Specify the level of detail for returned information
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Wait until the specified number of shards is active
* @param {<<api-param-type-string,`String`>>} params.waitForNodes - Wait until the specified number of nodes is available
* @param {<<api-param-type-string,`String`>>} params.waitForEvents - Wait until all currently queued events with the given priority are processed
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForNoRelocatingShards - Whether to wait until there are no relocating shards in the cluster
* @param {<<api-param-type-string,`String`>>} params.waitForStatus - Wait until cluster is in a specific state
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - Limit the information returned to a specific index
*/
api.cluster.prototype.health = ca({
params: {
level: {
type: 'enum',
'default': 'cluster',
options: ['cluster', 'indices', 'shards']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
waitForNodes: {
type: 'string',
name: 'wait_for_nodes'
},
waitForEvents: {
type: 'enum',
options: ['immediate', 'urgent', 'high', 'normal', 'low', 'languid'],
name: 'wait_for_events'
},
waitForNoRelocatingShards: {
type: 'boolean',
name: 'wait_for_no_relocating_shards'
},
waitForStatus: {
type: 'enum',
'default': null,
options: ['green', 'yellow', 'red'],
name: 'wait_for_status'
}
},
urls: [{
fmt: '/_cluster/health/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cluster/health'
}]
});
/**
* Perform a [cluster.pendingTasks](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cluster-pending.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
*/
api.cluster.prototype.pendingTasks = ca({
params: {
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_cluster/pending_tasks'
}
});
/**
* Perform a [cluster.putSettings](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cluster-update-settings.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
*/
api.cluster.prototype.putSettings = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_cluster/settings'
},
needBody: true,
method: 'PUT'
});
/**
* Perform a [cluster.remoteInfo](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cluster-remote-info.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
*/
api.cluster.prototype.remoteInfo = ca({
url: {
fmt: '/_remote/info'
}
});
/**
* Perform a [cluster.reroute](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cluster-reroute.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.dryRun - Simulate the operation only and return the resulting state
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - Return an explanation of why the commands can or cannot be executed
* @param {<<api-param-type-boolean,`Boolean`>>} params.retryFailed - Retries allocation of shards that are blocked due to too many subsequent allocation failures
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned to the specified metrics. Defaults to all but metadata
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
*/
api.cluster.prototype.reroute = ca({
params: {
dryRun: {
type: 'boolean',
name: 'dry_run'
},
explain: {
type: 'boolean'
},
retryFailed: {
type: 'boolean',
name: 'retry_failed'
},
metric: {
type: 'list',
options: ['_all', 'blocks', 'metadata', 'nodes', 'routing_table', 'master_node', 'version']
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_cluster/reroute'
},
method: 'POST'
});
/**
* Perform a [cluster.state](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cluster-state.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned to the specified metrics
*/
api.cluster.prototype.state = ca({
params: {
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/_cluster/state/<%=metric%>/<%=index%>',
req: {
metric: {
type: 'list',
options: ['_all', 'blocks', 'metadata', 'nodes', 'routing_table', 'routing_nodes', 'master_node', 'version']
},
index: {
type: 'list'
}
}
}, {
fmt: '/_cluster/state/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'blocks', 'metadata', 'nodes', 'routing_table', 'routing_nodes', 'master_node', 'version']
}
}
}, {
fmt: '/_cluster/state'
}]
});
/**
* Perform a [cluster.stats](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cluster-stats.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
*/
api.cluster.prototype.stats = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
timeout: {
type: 'time'
}
},
urls: [{
fmt: '/_cluster/stats/nodes/<%=nodeId%>',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_cluster/stats'
}]
});
/**
* Perform a [count](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/search-count.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-number,`Number`>>} params.minScore - Include only documents with a specific `_score` value in the result
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-number,`Number`>>} params.terminateAfter - The maximum count for each shard, upon reaching which the query execution will terminate early
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of indices to restrict the results
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of types to restrict the results
*/
api.count = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
minScore: {
type: 'number',
name: 'min_score'
},
preference: {
type: 'string'
},
routing: {
type: 'list'
},
q: {
type: 'string'
},
analyzer: {
type: 'string'
},
analyzeWildcard: {
type: 'boolean',
name: 'analyze_wildcard'
},
defaultOperator: {
type: 'enum',
'default': 'OR',
options: ['AND', 'OR'],
name: 'default_operator'
},
df: {
type: 'string'
},
lenient: {
type: 'boolean'
},
terminateAfter: {
type: 'number',
name: 'terminate_after'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_count',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_count',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_count'
}],
method: 'POST'
});
/**
* Perform a [create](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/docs-index_.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the index operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>} params.parent - ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.pipeline - The pipeline id to preprocess incoming documents with
* @param {<<api-param-type-string,`String`>>} params.id - Document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.create = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
parent: {
type: 'string'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
},
pipeline: {
type: 'string'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_create',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
needBody: true,
method: 'POST'
});
/**
* Perform a [delete](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/docs-delete.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the delete operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>} params.parent - ID of parent document
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the effected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api['delete'] = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
parent: {
type: 'string'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [deleteByQuery](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/docs-delete-by-query.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-number,`Number`>>} params.from - Starting offset (default: 0)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.conflicts=abort] - What to do when the delete-by-query hits version conflicts?
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-duration-string,`DurationString`>>} params.searchTimeout - Explicit timeout for each search request. Defaults to no timeout.
* @param {<<api-param-type-number,`Number`>>} params.size - Number of hits to return (default: 10)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.sort - A comma-separated list of <field>:<direction> pairs
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.terminateAfter - The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.stats - Specific 'tag' of the request for logging and statistical purposes
* @param {<<api-param-type-boolean,`Boolean`>>} params.version - Specify whether to return document version as part of a hit
* @param {<<api-param-type-boolean,`Boolean`>>} params.requestCache - Specify if request cache should be used for this request or not, defaults to index level setting
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Should the effected indexes be refreshed?
* @param {<<api-param-type-duration-string,`DurationString`>>} [params.timeout=1m] - Time each individual bulk request should wait for shards that are unavailable.
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the delete by query operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-number,`Number`>>} params.scrollSize - Size on the scroll request powering the update_by_query
* @param {<<api-param-type-boolean,`Boolean`>>} [params.waitForCompletion=true] - Should the request should block until the delete-by-query is complete.
* @param {<<api-param-type-number,`Number`>>} params.requestsPerSecond - The throttle for this request in sub-requests per second. -1 means no throttle.
* @param {<<api-param-type-number,`Number`>>} [params.slices=1] - The number of slices this task should be divided into. Defaults to 1 meaning the task isn't sliced into subtasks.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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'
},
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'
},
preference: {
type: 'string'
},
q: {
type: 'string'
},
routing: {
type: 'list'
},
scroll: {
type: 'time'
},
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'
},
version: {
type: 'boolean'
},
requestCache: {
type: 'boolean',
name: 'request_cache'
},
refresh: {
type: 'boolean'
},
timeout: {
type: 'time',
'default': '1m'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
scrollSize: {
type: 'number',
name: 'scroll_size'
},
waitForCompletion: {
type: 'boolean',
'default': true,
name: 'wait_for_completion'
},
requestsPerSecond: {
type: 'number',
'default': 0,
name: 'requests_per_second'
},
slices: {
type: 'number',
'default': 1
}
},
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](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/modules-scripting.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.id - Script ID
*/
api.deleteScript = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_scripts/<%=id%>',
req: {
id: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [exists](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/docs-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return in the response
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document (use `_all` to fetch the first document matching the ID across all types)
*/
api.exists = ca({
params: {
storedFields: {
type: 'list',
name: 'stored_fields'
},
parent: {
type: 'string'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'HEAD'
});
/**
* Perform a [existsSource](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/docs-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document; use `_all` to fetch the first document matching the ID across all types
*/
api.existsSource = ca({
params: {
parent: {
type: 'string'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_source',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'HEAD'
});
/**
* Perform a [explain](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/search-explain.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcards and prefix queries in the query string query should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer for the query string query
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The default field for query string query (default: _all)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return in the response
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.explain = ca({
params: {
analyzeWildcard: {
type: 'boolean',
name: 'analyze_wildcard'
},
analyzer: {
type: 'string'
},
defaultOperator: {
type: 'enum',
'default': 'OR',
options: ['AND', 'OR'],
name: 'default_operator'
},
df: {
type: 'string'
},
storedFields: {
type: 'list',
name: 'stored_fields'
},
lenient: {
type: 'boolean'
},
parent: {
type: 'string'
},
preference: {
type: 'string'
},
q: {
type: 'string'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_explain',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [fieldCaps](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/search-field-caps.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of field names
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.fieldCaps = ca({
params: {
fields: {
type: 'list'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_field_caps',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_field_caps'
}],
method: 'POST'
});
/**
* Perform a [get](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/docs-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return in the response
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document (use `_all` to fetch the first document matching the ID across all types)
*/
api.get = ca({
params: {
storedFields: {
type: 'list',
name: 'stored_fields'
},
parent: {
type: 'string'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}
});
/**
* Perform a [getScript](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/modules-scripting.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.id - Script ID
*/
api.getScript = ca({
url: {
fmt: '/_scripts/<%=id%>',
req: {
id: {
type: 'string'
}
}
}
});
/**
* Perform a [getSource](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/docs-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document; use `_all` to fetch the first document matching the ID across all types
*/
api.getSource = ca({
params: {
parent: {
type: 'string'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_source',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}
});
/**
* Perform a [index](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/docs-index_.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the index operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>} [params.opType=index] - Explicit operation type
* @param {<<api-param-type-string,`String`>>} params.parent - ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.pipeline - The pipeline id to preprocess incoming documents with
* @param {<<api-param-type-string,`String`>>} params.id - Document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.index = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
opType: {
type: 'enum',
'default': 'index',
options: ['index', 'create'],
name: 'op_type'
},
parent: {
type: 'string'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
},
pipeline: {
type: 'string'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/<%=id%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/<%=type%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}],
needBody: true,
method: 'POST'
});
api.indices = namespace();
/**
* Perform a [indices.analyze](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-analyze.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index to scope the operation
* @param {<<api-param-type-boolean,`Boolean`>>} params.preferLocal - With `true`, specify that a local shard should be used if available, with `false`, use a random shard (default: true)
* @param {<<api-param-type-string,`String`>>} [params.format=detailed] - Format of the output
*/
api.indices.prototype.analyze = ca({
params: {
index: {
type: 'string'
},
preferLocal: {
type: 'boolean',
name: 'prefer_local'
},
format: {
type: 'enum',
'default': 'detailed',
options: ['detailed', 'text']
}
},
urls: [{
fmt: '/<%=index%>/_analyze',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_analyze'
}],
method: 'POST'
});
/**
* Perform a [indices.clearCache](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-clearcache.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.fieldData - Clear field data
* @param {<<api-param-type-boolean,`Boolean`>>} params.fielddata - Clear field data
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to clear when using the `field_data` parameter (default: all)
* @param {<<api-param-type-boolean,`Boolean`>>} params.query - Clear query caches
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index name to limit the operation
* @param {<<api-param-type-boolean,`Boolean`>>} params.recycler - Clear the recycler cache
* @param {<<api-param-type-boolean,`Boolean`>>} params.requestCache - Clear request cache
* @param {<<api-param-type-boolean,`Boolean`>>} params.request - Clear request cache
*/
api.indices.prototype.clearCache = ca({
params: {
fieldData: {
type: 'boolean',
name: 'field_data'
},
fielddata: {
type: 'boolean'
},
fields: {
type: 'list'
},
query: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
index: {
type: 'list'
},
recycler: {
type: 'boolean'
},
requestCache: {
type: 'boolean',
name: 'request_cache'
},
request: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_cache/clear',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cache/clear'
}],
method: 'POST'
});
/**
* Perform a [indices.close](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-open-close.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma separated list of indices to close
*/
api.indices.prototype.close = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
url: {
fmt: '/<%=index%>/_close',
req: {
index: {
type: 'list'
}
}
},
method: 'POST'
});
/**
* Perform a [indices.create](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-create-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Set the number of active shards to wait for before the operation returns.
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.updateAllTypes - Whether to update the mapping for all fields with the same name across all types or not
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
*/
api.indices.prototype.create = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
updateAllTypes: {
type: 'boolean',
name: 'update_all_types'
}
},
url: {
fmt: '/<%=index%>',
req: {
index: {
type: 'string'
}
}
},
method: 'PUT'
});
/**
* Perform a [indices.delete](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-delete-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Ignore unavailable indexes (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.allowNoIndices - Ignore if a wildcard expression resolves to no concrete indices (default: false)
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether wildcard expressions should get expanded to open or closed indices (default: open)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of indices to delete; use `_all` or `*` string to delete all indices
*/
api.indices.prototype['delete'] = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
url: {
fmt: '/<%=index%>',
req: {
index: {
type: 'list'
}
}
},
method: 'DELETE'
});
/**
* Perform a [indices.deleteAlias](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit timestamp for the document
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names (supports wildcards); use `_all` for all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - A comma-separated list of aliases to delete (supports wildcards); use `_all` to delete all aliases for the specified indices.
*/
api.indices.prototype.deleteAlias = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/<%=index%>/_alias/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'list'
}
}
},
method: 'DELETE'
});
/**
* Perform a [indices.deleteTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.name - The name of the template
*/
api.indices.prototype.deleteTemplate = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_template/<%=name%>',
req: {
name: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [indices.exists](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-exists.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Ignore unavailable indexes (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.allowNoIndices - Ignore if a wildcard expression resolves to no concrete indices (default: false)
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether wildcard expressions should get expanded to open or closed indices (default: open)
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether to return all default setting for each of the indices.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names
*/
api.indices.prototype.exists = ca({
params: {
local: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
includeDefaults: {
type: 'boolean',
'default': false,
name: 'include_defaults'
}
},
url: {
fmt: '/<%=index%>',
req: {
index: {
type: 'list'
}
}
},
method: 'HEAD'
});
/**
* Perform a [indices.existsAlias](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=all] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to filter aliases
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - A comma-separated list of alias names to return
*/
api.indices.prototype.existsAlias = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'all',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_alias/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'list'
}
}
}, {
fmt: '/_alias/<%=name%>',
req: {
name: {
type: 'list'
}
}
}],
method: 'HEAD'
});
/**
* Perform a [indices.existsTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - The comma separated names of the index templates
*/
api.indices.prototype.existsTemplate = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
local: {
type: 'boolean'
}
},
url: {
fmt: '/_template/<%=name%>',
req: {
name: {
type: 'list'
}
}
},
method: 'HEAD'
});
/**
* Perform a [indices.existsType](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-types-exists.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` to check the types across all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to check
*/
api.indices.prototype.existsType = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
url: {
fmt: '/<%=index%>/_mapping/<%=type%>',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
},
method: 'HEAD'
});
/**
* Perform a [indices.flush](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-flush.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.force - Whether a flush should be forced even if it is not necessarily needed ie. if no changes will be committed to the index. This is useful if transaction log IDs should be incremented even if no uncommitted changes are present. (This setting can be considered as internal)
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitIfOngoing - If set to true the flush operation will block until the flush can be executed if another flush operation is already executing. The default is true. If set to false the flush will be skipped iff if another flush operation is already running.
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string for all indices
*/
api.indices.prototype.flush = ca({
params: {
force: {
type: 'boolean'
},
waitIfOngoing: {
type: 'boolean',
name: 'wait_if_ongoing'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_flush',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_flush'
}],
method: 'POST'
});
/**
* Perform a [indices.flushSynced](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-synced-flush.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string for all indices
*/
api.indices.prototype.flushSynced = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_flush/synced',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_flush/synced'
}],
method: 'POST'
});
/**
* Perform a [indices.forcemerge](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-forcemerge.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flush - Specify whether the index should be flushed after performing the operation (default: true)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-number,`Number`>>} params.maxNumSegments - The number of segments the index should be merged into (default: dynamic)
* @param {<<api-param-type-boolean,`Boolean`>>} params.onlyExpungeDeletes - Specify whether the operation should only expunge deleted documents
* @param {anything} params.operationThreading - TODO: ?
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForMerge - Specify whether the request should block until the merge process is finished (default: true)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.forcemerge = ca({
params: {
flush: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
maxNumSegments: {
type: 'number',
name: 'max_num_segments'
},
onlyExpungeDeletes: {
type: 'boolean',
name: 'only_expunge_deletes'
},
operationThreading: {
name: 'operation_threading'
},
waitForMerge: {
type: 'boolean',
name: 'wait_for_merge'
}
},
urls: [{
fmt: '/<%=index%>/_forcemerge',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_forcemerge'
}],
method: 'POST'
});
/**
* Perform a [indices.get](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-get-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Ignore unavailable indexes (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.allowNoIndices - Ignore if a wildcard expression resolves to no concrete indices (default: false)
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether wildcard expressions should get expanded to open or closed indices (default: open)
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether to return all default setting for each of the indices.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names
*/
api.indices.prototype.get = ca({
params: {
local: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
includeDefaults: {
type: 'boolean',
'default': false,
name: 'include_defaults'
}
},
url: {
fmt: '/<%=index%>',
req: {
index: {
type: 'list'
}
}
}
});
/**
* Perform a [indices.getAlias](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=all] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to filter aliases
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - A comma-separated list of alias names to return
*/
api.indices.prototype.getAlias = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'all',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_alias/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'list'
}
}
}, {
fmt: '/_alias/<%=name%>',
req: {
name: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_alias',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_alias'
}]
});
/**
* Perform a [indices.getFieldMapping](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-get-field-mapping.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether the default mapping values should be returned as well
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields
*/
api.indices.prototype.getFieldMapping = ca({
params: {
includeDefaults: {
type: 'boolean',
name: 'include_defaults'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_mapping/<%=type%>/field/<%=fields%>',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
},
fields: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_mapping/field/<%=fields%>',
req: {
index: {
type: 'list'
},
fields: {
type: 'list'
}
}
}, {
fmt: '/_mapping/<%=type%>/field/<%=fields%>',
req: {
type: {
type: 'list'
},
fields: {
type: 'list'
}
}
}, {
fmt: '/_mapping/field/<%=fields%>',
req: {
fields: {
type: 'list'
}
}
}]
});
/**
* Perform a [indices.getMapping](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-get-mapping.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types
*/
api.indices.prototype.getMapping = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_mapping/<%=type%>',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_mapping',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_mapping/<%=type%>',
req: {
type: {
type: 'list'
}
}
}, {
fmt: '/_mapping'
}]
});
/**
* Perform a [indices.getSettings](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-get-settings.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open,closed] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether to return all default setting for each of the indices.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - The name of the settings that should be included
*/
api.indices.prototype.getSettings = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': ['open', 'closed'],
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
local: {
type: 'boolean'
},
includeDefaults: {
type: 'boolean',
'default': false,
name: 'include_defaults'
}
},
urls: [{
fmt: '/<%=index%>/_settings/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_settings',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_settings/<%=name%>',
req: {
name: {
type: 'list'
}
}
}, {
fmt: '/_settings'
}]
});
/**
* Perform a [indices.getTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - The comma separated names of the index templates
*/
api.indices.prototype.getTemplate = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/_template/<%=name%>',
req: {
name: {
type: 'list'
}
}
}, {
fmt: '/_template'
}]
});
/**
* Perform a [indices.getUpgrade](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-upgrade.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.getUpgrade = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_upgrade',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_upgrade'
}]
});
/**
* Perform a [indices.open](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-open-close.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=closed] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of active shards to wait for before the operation returns.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma separated list of indices to open
*/
api.indices.prototype.open = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'closed',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
}
},
url: {
fmt: '/<%=index%>/_open',
req: {
index: {
type: 'list'
}
}
},
method: 'POST'
});
/**
* Perform a [indices.putAlias](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit timestamp for the document
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names the alias should point to (supports wildcards); use `_all` to perform the operation on all indices.
* @param {<<api-param-type-string,`String`>>} params.name - The name of the alias to be created or updated
*/
api.indices.prototype.putAlias = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/<%=index%>/_alias/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'string'
}
}
},
method: 'PUT'
});
/**
* Perform a [indices.putMapping](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-put-mapping.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.updateAllTypes - Whether to update the mapping for all fields with the same name across all types or not
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices.
* @param {<<api-param-type-string,`String`>>} params.type - The name of the document type
*/
api.indices.prototype.putMapping = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
updateAllTypes: {
type: 'boolean',
name: 'update_all_types'
}
},
urls: [{
fmt: '/<%=index%>/_mapping/<%=type%>',
req: {
index: {
type: 'list'
},
type: {
type: 'string'
}
}
}, {
fmt: '/_mapping/<%=type%>',
req: {
type: {
type: 'string'
}
}
}],
needBody: true,
method: 'PUT'
});
/**
* Perform a [indices.putSettings](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-update-settings.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.preserveExisting - Whether to update existing settings. If set to `true` existing settings on an index remain unchanged, the default is `false`
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.putSettings = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
preserveExisting: {
type: 'boolean',
name: 'preserve_existing'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
}
},
urls: [{
fmt: '/<%=index%>/_settings',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_settings'
}],
needBody: true,
method: 'PUT'
});
/**
* Perform a [indices.putTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-number,`Number`>>} params.order - The order for this template when merging multiple matching ones (higher numbers are merged later, overriding the lower numbers)
* @param {<<api-param-type-boolean,`Boolean`>>} params.create - Whether the index template should only be added if new or can also replace an existing one
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-string,`String`>>} params.name - The name of the template
*/
api.indices.prototype.putTemplate = ca({
params: {
order: {
type: 'number'
},
create: {
type: 'boolean',
'default': false
},
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
}
},
url: {
fmt: '/_template/<%=name%>',
req: {
name: {
type: 'string'
}
}
},
needBody: true,
method: 'PUT'
});
/**
* Perform a [indices.recovery](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-recovery.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.detailed - Whether to display detailed information about shard recovery
* @param {<<api-param-type-boolean,`Boolean`>>} params.activeOnly - Display only those recoveries that are currently on-going
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.recovery = ca({
params: {
detailed: {
type: 'boolean',
'default': false
},
activeOnly: {
type: 'boolean',
'default': false,
name: 'active_only'
}
},
urls: [{
fmt: '/<%=index%>/_recovery',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_recovery'
}]
});
/**
* Perform a [indices.refresh](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-refresh.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.refresh = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_refresh',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_refresh'
}],
method: 'POST'
});
/**
* Perform a [indices.rollover](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-rollover-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.dryRun - If set to true the rollover action will only be validated but not actually performed even if a condition matches. The default is false
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Set the number of active shards to wait for on the newly created rollover index before the operation returns.
* @param {<<api-param-type-string,`String`>>} params.alias - The name of the alias to rollover
* @param {<<api-param-type-string,`String`>>} params.newIndex - The name of the rollover index
*/
api.indices.prototype.rollover = ca({
params: {
timeout: {
type: 'time'
},
dryRun: {
type: 'boolean',
name: 'dry_run'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
}
},
urls: [{
fmt: '/<%=alias%>/_rollover/<%=newIndex%>',
req: {
alias: {
type: 'string'
},
newIndex: {
type: 'string'
}
}
}, {
fmt: '/<%=alias%>/_rollover',
req: {
alias: {
type: 'string'
}
}
}],
method: 'POST'
});
/**
* Perform a [indices.segments](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-segments.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {anything} params.operationThreading - TODO: ?
* @param {<<api-param-type-boolean,`Boolean`>>} params.verbose - Includes detailed memory usage by Lucene.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.segments = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
operationThreading: {
name: 'operation_threading'
},
verbose: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/<%=index%>/_segments',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_segments'
}]
});
/**
* Perform a [indices.shardStores](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-shards-stores.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.status - A comma-separated list of statuses used to filter on shards to get store information for
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {anything} params.operationThreading - TODO: ?
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.shardStores = ca({
params: {
status: {
type: 'list',
options: ['green', 'yellow', 'red', 'all']
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
operationThreading: {
name: 'operation_threading'
}
},
urls: [{
fmt: '/<%=index%>/_shard_stores',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_shard_stores'
}]
});
/**
* Perform a [indices.shrink](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-shrink-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Set the number of active shards to wait for on the shrunken index before the operation returns.
* @param {<<api-param-type-string,`String`>>} params.index - The name of the source index to shrink
* @param {<<api-param-type-string,`String`>>} params.target - The name of the target index to shrink into
*/
api.indices.prototype.shrink = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
}
},
url: {
fmt: '/<%=index%>/_shrink/<%=target%>',
req: {
index: {
type: 'string'
},
target: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [indices.split](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-split-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Set the number of active shards to wait for on the shrunken index before the operation returns.
* @param {<<api-param-type-string,`String`>>} params.index - The name of the source index to split
* @param {<<api-param-type-string,`String`>>} params.target - The name of the target index to split into
*/
api.indices.prototype.split = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
}
},
url: {
fmt: '/<%=index%>/_split/<%=target%>',
req: {
index: {
type: 'string'
},
target: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [indices.stats](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-stats.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.completionFields - A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fielddataFields - A comma-separated list of fields for `fielddata` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.groups - A comma-separated list of search groups for `search` index metric
* @param {<<api-param-type-string,`String`>>} [params.level=indices] - Return stats aggregated at cluster, index or shard level
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.types - A comma-separated list of document types for the `indexing` index metric
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeSegmentFileSizes - Whether to report the aggregated disk usage of each one of the Lucene index files (only applies if segment stats are requested)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned the specific metrics.
*/
api.indices.prototype.stats = ca({
params: {
completionFields: {
type: 'list',
name: 'completion_fields'
},
fielddataFields: {
type: 'list',
name: 'fielddata_fields'
},
fields: {
type: 'list'
},
groups: {
type: 'list'
},
level: {
type: 'enum',
'default': 'indices',
options: ['cluster', 'indices', 'shards']
},
types: {
type: 'list'
},
includeSegmentFileSizes: {
type: 'boolean',
'default': false,
name: 'include_segment_file_sizes'
}
},
urls: [{
fmt: '/<%=index%>/_stats/<%=metric%>',
req: {
index: {
type: 'list'
},
metric: {
type: 'list',
options: ['_all', 'completion', 'docs', 'fielddata', 'query_cache', 'flush', 'get', 'indexing', 'merge', 'request_cache', 'refresh', 'search', 'segments', 'store', 'warmer', 'suggest']
}
}
}, {
fmt: '/_stats/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'completion', 'docs', 'fielddata', 'query_cache', 'flush', 'get', 'indexing', 'merge', 'request_cache', 'refresh', 'search', 'segments', 'store', 'warmer', 'suggest']
}
}
}, {
fmt: '/<%=index%>/_stats',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_stats'
}]
});
/**
* Perform a [indices.updateAliases](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Request timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
*/
api.indices.prototype.updateAliases = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_aliases'
},
needBody: true,
method: 'POST'
});
/**
* Perform a [indices.upgrade](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/indices-upgrade.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Specify whether the request should block until the all segments are upgraded (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.onlyAncientSegments - If true, only ancient (an older Lucene major release) segments will be upgraded
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.upgrade = ca({
params: {
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
waitForCompletion: {
type: 'boolean',
name: 'wait_for_completion'
},
onlyAncientSegments: {
type: 'boolean',
name: 'only_ancient_segments'
}
},
urls: [{
fmt: '/<%=index%>/_upgrade',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_upgrade'
}],
method: 'POST'
});
/**
* Perform a [indices.validateQuery](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/search-validate.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - Return detailed information about the error
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {anything} params.operationThreading - TODO: ?
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-boolean,`Boolean`>>} params.rewrite - Provide a more detailed explanation showing the actual Lucene query that will be executed.
* @param {<<api-param-type-boolean,`Boolean`>>} params.allShards - Execute validation on all shards instead of one random shard per index
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types
*/
api.indices.prototype.validateQuery = ca({
params: {
explain: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
operationThreading: {
name: 'operation_threading'
},
q: {
type: 'string'
},
analyzer: {
type: 'string'
},
analyzeWildcard: {
type: 'boolean',
name: 'analyze_wildcard'
},
defaultOperator: {
type: 'enum',
'default': 'OR',
options: ['AND', 'OR'],
name: 'default_operator'
},
df: {
type: 'string'
},
lenient: {
type: 'boolean'
},
rewrite: {
type: 'boolean'
},
allShards: {
type: 'boolean',
name: 'all_shards'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_validate/query',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_validate/query',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_validate/query'
}],
method: 'POST'
});
/**
* Perform a [info](http://www.elastic.co/guide/) request
*
* @param {Object} params - An object with parameters used to carry out this action
*/
api.info = ca({
url: {
fmt: '/'
}
});
api.ingest = namespace();
/**
* Perform a [ingest.deletePipeline](https://www.elastic.co/guide/en/elasticsearch/plugins/6.1/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.id - Pipeline ID
*/
api.ingest.prototype.deletePipeline = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_ingest/pipeline/<%=id%>',
req: {
id: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [ingest.getPipeline](https://www.elastic.co/guide/en/elasticsearch/plugins/6.1/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>} params.id - Comma separated list of pipeline ids. Wildcards supported
*/
api.ingest.prototype.getPipeline = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
urls: [{
fmt: '/_ingest/pipeline/<%=id%>',
req: {
id: {
type: 'string'
}
}
}, {
fmt: '/_ingest/pipeline'
}]
});
/**
* Perform a [ingest.processorGrok](https://www.elastic.co/guide/en/elasticsearch/plugins/6.1/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
*/
api.ingest.prototype.processorGrok = ca({
url: {
fmt: '/_ingest/processor/grok'
}
});
/**
* Perform a [ingest.putPipeline](https://www.elastic.co/guide/en/elasticsearch/plugins/6.1/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.id - Pipeline ID
*/
api.ingest.prototype.putPipeline = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_ingest/pipeline/<%=id%>',
req: {
id: {
type: 'string'
}
}
},
needBody: true,
method: 'PUT'
});
/**
* Perform a [ingest.simulate](https://www.elastic.co/guide/en/elasticsearch/plugins/6.1/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.verbose - Verbose mode. Display data output for each processor in executed pipeline
* @param {<<api-param-type-string,`String`>>} params.id - Pipeline ID
*/
api.ingest.prototype.simulate = ca({
params: {
verbose: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_ingest/pipeline/<%=id%>/_simulate',
req: {
id: {
type: 'string'
}
}
}, {
fmt: '/_ingest/pipeline/_simulate'
}],
needBody: true,
method: 'POST'
});
/**
* Perform a [mget](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/docs-multi-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return in the response
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.mget = ca({
params: {
storedFields: {
type: 'list',
name: 'stored_fields'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_mget',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/_mget',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_mget'
}],
needBody: true,
method: 'POST'
});
/**
* Perform a [msearch](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/search-multi-search.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-number,`Number`>>} params.maxConcurrentSearches - Controls the maximum number of concurrent searches the multi search api will execute
* @param {<<api-param-type-boolean,`Boolean`>>} params.typedKeys - Specify whether aggregation and suggester names should be prefixed by their respective types in the response
* @param {<<api-param-type-number,`Number`>>} [params.preFilterShardSize=128] - A threshold that enforces a pre-filter roundtrip to prefilter search shards based on query rewriting if the number of shards the search request expands to exceeds the threshold. This filter roundtrip can limit the number of shards significantly if for instance a shard can not match any documents based on it's rewrite method ie. if date filters are mandatory to match but the shard bounds and the query are disjoint.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to use as default
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to use as default
*/
api.msearch = ca({
params: {
searchType: {
type: 'enum',
options: ['query_then_fetch', 'query_and_fetch', 'dfs_query_then_fetch', 'dfs_query_and_fetch'],
name: 'search_type'
},
maxConcurrentSearches: {
type: 'number',
name: 'max_concurrent_searches'
},
typedKeys: {
type: 'boolean',
name: 'typed_keys'
},
preFilterShardSize: {
type: 'number',
'default': 128,
name: 'pre_filter_shard_size'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_msearch',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_msearch',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_msearch'
}],
needBody: true,
bulkBody: true,
method: 'POST'
});
/**
* Perform a [msearchTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/search-multi-search.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-boolean,`Boolean`>>} params.typedKeys - Specify whether aggregation and suggester names should be prefixed by their respective types in the response
* @param {<<api-param-type-number,`Number`>>} params.maxConcurrentSearches - Controls the maximum number of concurrent searches the multi search api will execute
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to use as default
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to use as default
*/
api.msearchTemplate = ca({
params: {
searchType: {
type: 'enum',
options: ['query_then_fetch', 'query_and_fetch', 'dfs_query_then_fetch', 'dfs_query_and_fetch'],
name: 'search_type'
},
typedKeys: {
type: 'boolean',
name: 'typed_keys'
},
maxConcurrentSearches: {
type: 'number',
name: 'max_concurrent_searches'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_msearch/template',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_msearch/template',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_msearch/template'
}],
needBody: true,
bulkBody: true,
method: 'POST'
});
/**
* Perform a [mtermvectors](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/docs-multi-termvectors.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.ids - A comma-separated list of documents ids. You must define ids as parameter or set "ids" or "docs" in the request body
* @param {<<api-param-type-boolean,`Boolean`>>} params.termStatistics - Specifies if total term frequency and document frequency should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} [params.fieldStatistics=true] - Specifies if document count, sum of document frequencies and sum of total term frequencies should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to return. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} [params.offsets=true] - Specifies if term offsets should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} [params.positions=true] - Specifies if term positions should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} [params.payloads=true] - Specifies if term payloads should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random) .Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-string,`String`>>} params.parent - Parent id of documents. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specifies if requests are real-time as opposed to near-real-time (default: true).
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.index - The index in which the document resides.
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document.
*/
api.mtermvectors = ca({
params: {
ids: {
type: 'list',
required: false
},
termStatistics: {
type: 'boolean',
'default': false,
required: false,
name: 'term_statistics'
},
fieldStatistics: {
type: 'boolean',
'default': true,
required: false,
name: 'field_statistics'
},
fields: {
type: 'list',
required: false
},
offsets: {
type: 'boolean',
'default': true,
required: false
},
positions: {
type: 'boolean',
'default': true,
required: false
},
payloads: {
type: 'boolean',
'default': true,
required: false
},
preference: {
type: 'string',
required: false
},
routing: {
type: 'string',
required: false
},
parent: {
type: 'string',
required: false
},
realtime: {
type: 'boolean',
required: false
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_mtermvectors',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/_mtermvectors',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_mtermvectors'
}],
method: 'POST'
});
api.nodes = namespace();
/**
* Perform a [nodes.hotThreads](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cluster-nodes-hot-threads.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.interval - The interval for the second sampling of threads
* @param {<<api-param-type-number,`Number`>>} params.snapshots - Number of samples of thread stacktrace (default: 10)
* @param {<<api-param-type-number,`Number`>>} params.threads - Specify the number of threads to provide information for (default: 3)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreIdleThreads - Don't show threads that are in known-idle places, such as waiting on a socket select or pulling from an empty task queue (default: true)
* @param {<<api-param-type-string,`String`>>} params.type - The type to sample (default: cpu)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
*/
api.nodes.prototype.hotThreads = ca({
params: {
interval: {
type: 'time'
},
snapshots: {
type: 'number'
},
threads: {
type: 'number'
},
ignoreIdleThreads: {
type: 'boolean',
name: 'ignore_idle_threads'
},
type: {
type: 'enum',
options: ['cpu', 'wait', 'block']
},
timeout: {
type: 'time'
}
},
urls: [{
fmt: '/_nodes/<%=nodeId%>/hotthreads',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_nodes/hotthreads'
}]
});
/**
* Perform a [nodes.info](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cluster-nodes-info.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - A comma-separated list of metrics you wish returned. Leave empty to return all.
*/
api.nodes.prototype.info = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
timeout: {
type: 'time'
}
},
urls: [{
fmt: '/_nodes/<%=nodeId%>/<%=metric%>',
req: {
nodeId: {
type: 'list'
},
metric: {
type: 'list',
options: ['settings', 'os', 'process', 'jvm', 'thread_pool', 'transport', 'http', 'plugins', 'ingest']
}
}
}, {
fmt: '/_nodes/<%=nodeId%>',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_nodes/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['settings', 'os', 'process', 'jvm', 'thread_pool', 'transport', 'http', 'plugins', 'ingest']
}
}
}, {
fmt: '/_nodes'
}]
});
/**
* Perform a [nodes.stats](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cluster-nodes-stats.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.completionFields - A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fielddataFields - A comma-separated list of fields for `fielddata` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards)
* @param {<<api-param-type-boolean,`Boolean`>>} params.groups - A comma-separated list of search groups for `search` index metric
* @param {<<api-param-type-string,`String`>>} [params.level=node] - Return indices stats aggregated at index, node or shard level
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.types - A comma-separated list of document types for the `indexing` index metric
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeSegmentFileSizes - Whether to report the aggregated disk usage of each one of the Lucene index files (only applies if segment stats are requested)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned to the specified metrics
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.indexMetric - Limit the information returned for `indices` metric to the specific index metrics. Isn't used if `indices` (or `all`) metric isn't specified.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
*/
api.nodes.prototype.stats = ca({
params: {
completionFields: {
type: 'list',
name: 'completion_fields'
},
fielddataFields: {
type: 'list',
name: 'fielddata_fields'
},
fields: {
type: 'list'
},
groups: {
type: 'boolean'
},
level: {
type: 'enum',
'default': 'node',
options: ['indices', 'node', 'shards']
},
types: {
type: 'list'
},
timeout: {
type: 'time'
},
includeSegmentFileSizes: {
type: 'boolean',
'default': false,
name: 'include_segment_file_sizes'
}
},
urls: [{
fmt: '/_nodes/<%=nodeId%>/stats/<%=metric%>/<%=indexMetric%>',
req: {
nodeId: {
type: 'list'
},
metric: {
type: 'list',
options: ['_all', 'breaker', 'fs', 'http', 'indices', 'jvm', 'os', 'process', 'thread_pool', 'transport', 'discovery']
},
indexMetric: {
type: 'list',
options: ['_all', 'completion', 'docs', 'fielddata', 'query_cache', 'flush', 'get', 'indexing', 'merge', 'request_cache', 'refresh', 'search', 'segments', 'store', 'warmer', 'suggest']
}
}
}, {
fmt: '/_nodes/<%=nodeId%>/stats/<%=metric%>',
req: {
nodeId: {
type: 'list'
},
metric: {
type: 'list',
options: ['_all', 'breaker', 'fs', 'http', 'indices', 'jvm', 'os', 'process', 'thread_pool', 'transport', 'discovery']
}
}
}, {
fmt: '/_nodes/stats/<%=metric%>/<%=indexMetric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'breaker', 'fs', 'http', 'indices', 'jvm', 'os', 'process', 'thread_pool', 'transport', 'discovery']
},
indexMetric: {
type: 'list',
options: ['_all', 'completion', 'docs', 'fielddata', 'query_cache', 'flush', 'get', 'indexing', 'merge', 'request_cache', 'refresh', 'search', 'segments', 'store', 'warmer', 'suggest']
}
}
}, {
fmt: '/_nodes/<%=nodeId%>/stats',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_nodes/stats/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'breaker', 'fs', 'http', 'indices', 'jvm', 'os', 'process', 'thread_pool', 'transport', 'discovery']
}
}
}, {
fmt: '/_nodes/stats'
}]
});
/**
* Perform a [nodes.usage](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/cluster-nodes-usage.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.human - Whether to return time and byte values in human-readable format.
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned to the specified metrics
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
*/
api.nodes.prototype.usage = ca({
params: {
human: {
type: 'boolean',
'default': false
},
timeout: {
type: 'time'
}
},
urls: [{
fmt: '/_nodes/<%=nodeId%>/usage/<%=metric%>',
req: {
nodeId: {
type: 'list'
},
metric: {
type: 'list',
options: ['_all', 'rest_actions']
}
}
}, {
fmt: '/_nodes/<%=nodeId%>/usage',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_nodes/usage/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'rest_actions']
}
}
}, {
fmt: '/_nodes/usage'
}]
});
/**
* Perform a [ping](http://www.elastic.co/guide/) request
*
* @param {Object} params - An object with parameters used to carry out this action
*/
api.ping = ca({
url: {
fmt: '/'
},
requestTimeout: 3000,
method: 'HEAD'
});
/**
* Perform a [putScript](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/modules-scripting.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.context - Script context
* @param {<<api-param-type-string,`String`>>} params.id - Script ID
*/
api.putScript = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
context: {
type: 'string'
}
},
urls: [{
fmt: '/_scripts/<%=id%>/<%=context%>',
req: {
id: {
type: 'string'
},
context: {
type: 'string'
}
}
}, {
fmt: '/_scripts/<%=id%>',
req: {
id: {
type: 'string'
}
}
}],
needBody: true,
method: 'PUT'
});
/**
* Perform a [reindex](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/docs-reindex.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Should the effected indexes be refreshed?
* @param {<<api-param-type-duration-string,`DurationString`>>} [params.timeout=1m] - Time each individual bulk request should wait for shards that are unavailable.
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the reindex operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-boolean,`Boolean`>>} [params.waitForCompletion=true] - Should the request should block until the reindex is complete.
* @param {<<api-param-type-number,`Number`>>} params.requestsPerSecond - The throttle to set on this request in sub-requests per second. -1 means no throttle.
* @param {<<api-param-type-number,`Number`>>} [params.slices=1] - The number of slices this task should be divided into. Defaults to 1 meaning the task isn't sliced into subtasks.
*/
api.reindex = ca({
params: {
refresh: {
type: 'boolean'
},
timeout: {
type: 'time',
'default': '1m'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
waitForCompletion: {
type: 'boolean',
'default': true,
name: 'wait_for_completion'
},
requestsPerSecond: {
type: 'number',
'default': 0,
name: 'requests_per_second'
},
slices: {
type: 'number',
'default': 1
}
},
url: {
fmt: '/_reindex'
},
needBody: true,
method: 'POST'
});
/**
* Perform a [reindexRethrottle](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/docs-reindex.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-number,`Number`>>} params.requestsPerSecond - The throttle to set on this request in floating sub-requests per second. -1 means set no throttle.
* @param {<<api-param-type-string,`String`>>} params.taskId - The task id to rethrottle
*/
api.reindexRethrottle = ca({
params: {
requestsPerSecond: {
type: 'number',
required: true,
name: 'requests_per_second'
}
},
url: {
fmt: '/_reindex/<%=taskId%>/_rethrottle',
req: {
taskId: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [renderSearchTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/search-template.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.id - The id of the stored search template
*/
api.renderSearchTemplate = ca({
urls: [{
fmt: '/_render/template/<%=id%>',
req: {
id: {
type: 'string'
}
}
}, {
fmt: '/_render/template'
}],
method: 'POST'
});
/**
* Perform a [scroll](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/search-request-scroll.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.scrollId - The scroll ID
*/
api.scroll = ca({
params: {
scroll: {
type: 'time'
},
scrollId: {
type: 'string',
name: 'scroll_id'
}
},
urls: [{
fmt: '/_search/scroll/<%=scrollId%>',
req: {
scrollId: {
type: 'string'
}
}
}, {
fmt: '/_search/scroll'
}],
paramAsBody: {
param: 'scrollId',
body: 'scroll_id'
},
method: 'POST'
});
/**
* Perform a [search](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/search-search.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - Specify whether to return detailed information about score computation as part of a hit
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return as part of a hit
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.docvalueFields - A comma-separated list of fields to return as the docvalue representation of a field for each hit
* @param {<<api-param-type-number,`Number`>>} params.from - Starting offset (default: 0)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-number,`Number`>>} params.size - Number of hits to return (default: 10)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.sort - A comma-separated list of <field>:<direction> pairs
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.terminateAfter - The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.stats - Specific 'tag' of the request for logging and statistical purposes
* @param {<<api-param-type-string,`String`>>} params.suggestField - Specify which field to use for suggestions
* @param {<<api-param-type-string,`String`>>} [params.suggestMode=missing] - Specify suggest mode
* @param {<<api-param-type-number,`Number`>>} params.suggestSize - How many suggestions to return in response
* @param {<<api-param-type-string,`String`>>} params.suggestText - The source text for which the suggestions should be returned
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.trackScores - Whether to calculate and return scores even if they are not used for sorting
* @param {<<api-param-type-boolean,`Boolean`>>} params.trackTotalHits - Indicate if the number of documents that match the query should be tracked
* @param {<<api-param-type-boolean,`Boolean`>>} params.typedKeys - Specify whether aggregation and suggester names should be prefixed by their respective types in the response
* @param {<<api-param-type-boolean,`Boolean`>>} params.version - Specify whether to return document version as part of a hit
* @param {<<api-param-type-boolean,`Boolean`>>} params.requestCache - Specify if request cache should be used for this request or not, defaults to index level setting
* @param {<<api-param-type-number,`Number`>>} [params.batchedReduceSize=512] - The number of shard results that should be reduced at once on the coordinating node. This value should be used as a protection mechanism to reduce the memory overhead per search request if the potential number of shards in the request can be large.
* @param {<<api-param-type-number,`Number`>>} [params.maxConcurrentShardRequests=The default grows with the number of nodes in the cluster but is at most 256.] - The number of concurrent shard requests this search executes concurrently. This value should be used to limit the impact of the search on the cluster in order to limit the number of concurrent shard requests
* @param {<<api-param-type-number,`Number`>>} [params.preFilterShardSize=128] - A threshold that enforces a pre-filter roundtrip to prefilter search shards based on query rewriting if the number of shards the search request expands to exceeds the threshold. This filter roundtrip can limit the number of shards significantly if for instance a shard can not match any documents based on it's rewrite method ie. if date filters are mandatory to match but the shard bounds and the query are disjoint.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to search; leave empty to perform the operation on all types
*/
api.search = 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'
},
storedFields: {
type: 'list',
name: 'stored_fields'
},
docvalueFields: {
type: 'list',
name: 'docvalue_fields'
},
from: {
type: 'number'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
lenient: {
type: 'boolean'
},
preference: {
type: 'string'
},
q: {
type: 'string'
},
routing: {
type: 'list'
},
scroll: {
type: 'time'
},
searchType: {
type: 'enum',
options: ['query_then_fetch', 'dfs_query_then_fetch'],
name: 'search_type'
},
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: 'string',
name: 'suggest_text'
},
timeout: {
type: 'time'
},
trackScores: {
type: 'boolean',
name: 'track_scores'
},
trackTotalHits: {
type: 'boolean',
name: 'track_total_hits'
},
typedKeys: {
type: 'boolean',
name: 'typed_keys'
},
version: {
type: 'boolean'
},
requestCache: {
type: 'boolean',
name: 'request_cache'
},
batchedReduceSize: {
type: 'number',
'default': 512,
name: 'batched_reduce_size'
},
maxConcurrentShardRequests: {
type: 'number',
'default': 'The default grows with the number of nodes in the cluster but is at most 256.',
name: 'max_concurrent_shard_requests'
},
preFilterShardSize: {
type: 'number',
'default': 128,
name: 'pre_filter_shard_size'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_search',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_search',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_search'
}],
method: 'POST'
});
/**
* Perform a [searchShards](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/search-shards.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices
*/
api.searchShards = ca({
params: {
preference: {
type: 'string'
},
routing: {
type: 'string'
},
local: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_search_shards',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_search_shards'
}],
method: 'POST'
});
/**
* Perform a [searchTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/search-template.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - Specify whether to return detailed information about score computation as part of a hit
* @param {<<api-param-type-boolean,`Boolean`>>} params.profile - Specify whether to profile the query execution
* @param {<<api-param-type-boolean,`Boolean`>>} params.typedKeys - Specify whether aggregation and suggester names should be prefixed by their respective types in the response
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to search; leave empty to perform the operation on all types
*/
api.searchTemplate = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
preference: {
type: 'string'
},
routing: {
type: 'list'
},
scroll: {
type: 'time'
},
searchType: {
type: 'enum',
options: ['query_then_fetch', 'query_and_fetch', 'dfs_query_then_fetch', 'dfs_query_and_fetch'],
name: 'search_type'
},
explain: {
type: 'boolean'
},
profile: {
type: 'boolean'
},
typedKeys: {
type: 'boolean',
name: 'typed_keys'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_search/template',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_search/template',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_search/template'
}],
needBody: true,
method: 'POST'
});
api.snapshot = namespace();
/**
* Perform a [snapshot.create](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Should this request wait until the operation has completed before returning
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>} params.snapshot - A snapshot name
*/
api.snapshot.prototype.create = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForCompletion: {
type: 'boolean',
'default': false,
name: 'wait_for_completion'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [snapshot.createRepository](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.verify - Whether to verify the repository after creation
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
*/
api.snapshot.prototype.createRepository = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
},
verify: {
type: 'boolean'
}
},
url: {
fmt: '/_snapshot/<%=repository%>',
req: {
repository: {
type: 'string'
}
}
},
needBody: true,
method: 'POST'
});
/**
* Perform a [snapshot.delete](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>} params.snapshot - A snapshot name
*/
api.snapshot.prototype['delete'] = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [snapshot.deleteRepository](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.repository - A comma-separated list of repository names
*/
api.snapshot.prototype.deleteRepository = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_snapshot/<%=repository%>',
req: {
repository: {
type: 'list'
}
}
},
method: 'DELETE'
});
/**
* Perform a [snapshot.get](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether to ignore unavailable snapshots, defaults to false which means a SnapshotMissingException is thrown
* @param {<<api-param-type-boolean,`Boolean`>>} params.verbose - Whether to show verbose snapshot info or only show the basic info found in the repository index blob
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.snapshot - A comma-separated list of snapshot names
*/
api.snapshot.prototype.get = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
verbose: {
type: 'boolean'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'list'
}
}
}
});
/**
* Perform a [snapshot.getRepository](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.repository - A comma-separated list of repository names
*/
api.snapshot.prototype.getRepository = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/_snapshot/<%=repository%>',
req: {
repository: {
type: 'list'
}
}
}, {
fmt: '/_snapshot'
}]
});
/**
* Perform a [snapshot.restore](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Should this request wait until the operation has completed before returning
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>} params.snapshot - A snapshot name
*/
api.snapshot.prototype.restore = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForCompletion: {
type: 'boolean',
'default': false,
name: 'wait_for_completion'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>/_restore',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [snapshot.status](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether to ignore unavailable snapshots, defaults to false which means a SnapshotMissingException is thrown
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.snapshot - A comma-separated list of snapshot names
*/
api.snapshot.prototype.status = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
}
},
urls: [{
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>/_status',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'list'
}
}
}, {
fmt: '/_snapshot/<%=repository%>/_status',
req: {
repository: {
type: 'string'
}
}
}, {
fmt: '/_snapshot/_status'
}]
});
/**
* Perform a [snapshot.verifyRepository](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
*/
api.snapshot.prototype.verifyRepository = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/_verify',
req: {
repository: {
type: 'string'
}
}
},
method: 'POST'
});
api.tasks = namespace();
/**
* Perform a [tasks.cancel](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodes - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.actions - A comma-separated list of actions that should be cancelled. Leave empty to cancel all.
* @param {<<api-param-type-string,`String`>>} params.parentNode - Cancel tasks with specified parent node.
* @param {<<api-param-type-string,`String`>>} params.parentTaskId - Cancel tasks with specified parent task id (node_id:task_number). Set to -1 to cancel all.
* @param {<<api-param-type-string,`String`>>} params.taskId - Cancel the task with specified task id (node_id:task_number)
*/
api.tasks.prototype.cancel = ca({
params: {
nodes: {
type: 'list'
},
actions: {
type: 'list'
},
parentNode: {
type: 'string',
name: 'parent_node'
},
parentTaskId: {
type: 'string',
name: 'parent_task_id'
}
},
urls: [{
fmt: '/_tasks/<%=taskId%>/_cancel',
req: {
taskId: {
type: 'string'
}
}
}, {
fmt: '/_tasks/_cancel'
}],
method: 'POST'
});
/**
* Perform a [tasks.get](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Wait for the matching tasks to complete (default: false)
* @param {<<api-param-type-string,`String`>>} params.taskId - Return the task with specified id (node_id:task_number)
*/
api.tasks.prototype.get = ca({
params: {
waitForCompletion: {
type: 'boolean',
name: 'wait_for_completion'
}
},
url: {
fmt: '/_tasks/<%=taskId%>',
req: {
taskId: {
type: 'string'
}
}
}
});
/**
* Perform a [tasks.list](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodes - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.actions - A comma-separated list of actions that should be returned. Leave empty to return all.
* @param {<<api-param-type-boolean,`Boolean`>>} params.detailed - Return detailed task information (default: false)
* @param {<<api-param-type-string,`String`>>} params.parentNode - Return tasks with specified parent node.
* @param {<<api-param-type-string,`String`>>} params.parentTaskId - Return tasks with specified parent task id (node_id:task_number). Set to -1 to return all.
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Wait for the matching tasks to complete (default: false)
* @param {<<api-param-type-string,`String`>>} [params.groupBy=nodes] - Group tasks by nodes or parent/child relationships
*/
api.tasks.prototype.list = ca({
params: {
nodes: {
type: 'list'
},
actions: {
type: 'list'
},
detailed: {
type: 'boolean'
},
parentNode: {
type: 'string',
name: 'parent_node'
},
parentTaskId: {
type: 'string',
name: 'parent_task_id'
},
waitForCompletion: {
type: 'boolean',
name: 'wait_for_completion'
},
groupBy: {
type: 'enum',
'default': 'nodes',
options: ['nodes', 'parents'],
name: 'group_by'
}
},
url: {
fmt: '/_tasks'
}
});
/**
* Perform a [termvectors](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/docs-termvectors.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.termStatistics - Specifies if total term frequency and document frequency should be returned.
* @param {<<api-param-type-boolean,`Boolean`>>} [params.fieldStatistics=true] - Specifies if document count, sum of document frequencies and sum of total term frequencies should be returned.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to return.
* @param {<<api-param-type-boolean,`Boolean`>>} [params.offsets=true] - Specifies if term offsets should be returned.
* @param {<<api-param-type-boolean,`Boolean`>>} [params.positions=true] - Specifies if term positions should be returned.
* @param {<<api-param-type-boolean,`Boolean`>>} [params.payloads=true] - Specifies if term payloads should be returned.
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random).
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value.
* @param {<<api-param-type-string,`String`>>} params.parent - Parent id of documents.
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specifies if request is real-time as opposed to near-real-time (default: true).
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.index - The index in which the document resides.
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document.
* @param {<<api-param-type-string,`String`>>} params.id - The id of the document, when not specified a doc param should be supplied.
*/
api.termvectors = ca({
params: {
termStatistics: {
type: 'boolean',
'default': false,
required: false,
name: 'term_statistics'
},
fieldStatistics: {
type: 'boolean',
'default': true,
required: false,
name: 'field_statistics'
},
fields: {
type: 'list',
required: false
},
offsets: {
type: 'boolean',
'default': true,
required: false
},
positions: {
type: 'boolean',
'default': true,
required: false
},
payloads: {
type: 'boolean',
'default': true,
required: false
},
preference: {
type: 'string',
required: false
},
routing: {
type: 'string',
required: false
},
parent: {
type: 'string',
required: false
},
realtime: {
type: 'boolean',
required: false
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/<%=id%>/_termvectors',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/<%=type%>/_termvectors',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}],
method: 'POST'
});
/**
* Perform a [update](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/docs-update.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the update operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to return in the response
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-string,`String`>>} params.lang - The script language (default: painless)
* @param {<<api-param-type-string,`String`>>} params.parent - ID of the parent document. Is is only used for routing and when for the upsert request
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the effected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-number,`Number`>>} params.retryOnConflict - Specify how many times should the operation be retried when a conflict occurs (default: 0)
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - Document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.update = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
fields: {
type: 'list'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
lang: {
type: 'string'
},
parent: {
type: 'string'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
retryOnConflict: {
type: 'number',
name: 'retry_on_conflict'
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_update',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
needBody: true,
method: 'POST'
});
/**
* Perform a [updateByQuery](https://www.elastic.co/guide/en/elasticsearch/reference/6.1/docs-update-by-query.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-number,`Number`>>} params.from - Starting offset (default: 0)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.conflicts=abort] - What to do when the update by query hits version conflicts?
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-string,`String`>>} params.pipeline - Ingest pipeline to set on index requests made by this action. (default: none)
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-duration-string,`DurationString`>>} params.searchTimeout - Explicit timeout for each search request. Defaults to no timeout.
* @param {<<api-param-type-number,`Number`>>} params.size - Number of hits to return (default: 10)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.sort - A comma-separated list of <field>:<direction> pairs
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.terminateAfter - The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.stats - Specific 'tag' of the request for logging and statistical purposes
* @param {<<api-param-type-boolean,`Boolean`>>} params.version - Specify whether to return document version as part of a hit
* @param {<<api-param-type-boolean,`Boolean`>>} params.versionType - Should the document increment the version number (internal) on hit or not (reindex)
* @param {<<api-param-type-boolean,`Boolean`>>} params.requestCache - Specify if request cache should be used for this request or not, defaults to index level setting
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Should the effected indexes be refreshed?
* @param {<<api-param-type-duration-string,`DurationString`>>} [params.timeout=1m] - Time each individual bulk request should wait for shards that are unavailable.
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the update by query operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-number,`Number`>>} params.scrollSize - Size on the scroll request powering the update_by_query
* @param {<<api-param-type-boolean,`Boolean`>>} [params.waitForCompletion=true] - Should the request should block until the update by query operation is complete.
* @param {<<api-param-type-number,`Number`>>} params.requestsPerSecond - The throttle to set on this request in sub-requests per second. -1 means no throttle.
* @param {<<api-param-type-number,`Number`>>} [params.slices=1] - The number of slices this task should be divided into. Defaults to 1 meaning the task isn't sliced into subtasks.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to search; leave empty to perform the operation on all types
*/
api.updateByQuery = 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'
},
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'
},
pipeline: {
type: 'string'
},
preference: {
type: 'string'
},
q: {
type: 'string'
},
routing: {
type: 'list'
},
scroll: {
type: 'time'
},
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'
},
version: {
type: 'boolean'
},
versionType: {
type: 'boolean',
name: 'version_type'
},
requestCache: {
type: 'boolean',
name: 'request_cache'
},
refresh: {
type: 'boolean'
},
timeout: {
type: 'time',
'default': '1m'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
scrollSize: {
type: 'number',
name: 'scroll_size'
},
waitForCompletion: {
type: 'boolean',
'default': true,
name: 'wait_for_completion'
},
requestsPerSecond: {
type: 'number',
'default': 0,
name: 'requests_per_second'
},
slices: {
type: 'number',
'default': 1
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_update_by_query',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_update_by_query',
req: {
index: {
type: 'list'
}
}
}],
method: 'POST'
});
/***/ }),
/* 47 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var ca = __webpack_require__(1).makeFactoryWithModifier(function (spec) {
return __webpack_require__(0).merge(spec, {
params: {
filterPath: {
type: 'list',
name: 'filter_path'
}
}
});
});
var namespace = __webpack_require__(1).namespaceFactory;
var api = module.exports = {};
api._namespaces = ['cat', 'cluster', 'indices', 'ingest', 'nodes', 'snapshot', 'tasks'];
/**
* Perform a [bulk](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/docs-bulk.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the bulk operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the effected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.type - Default document type for items which don't provide one
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - Default comma-separated list of fields to return in the response for updates, can be overridden on each sub-request
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or default list of fields to return, can be overridden on each sub-request
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - Default list of fields to exclude from the returned _source field, can be overridden on each sub-request
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - Default list of fields to extract and return from the _source field, can be overridden on each sub-request
* @param {<<api-param-type-string,`String`>>} params.pipeline - The pipeline id to preprocess incoming documents with
* @param {<<api-param-type-string,`String`>>} params.index - Default index for items which don't provide one
*/
api.bulk = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
type: {
type: 'string'
},
fields: {
type: 'list'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
pipeline: {
type: 'string'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_bulk',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/_bulk',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_bulk'
}],
needBody: true,
bulkBody: true,
method: 'POST'
});
api.cat = namespace();
/**
* Perform a [cat.aliases](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cat.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - A comma-separated list of alias names to return
*/
api.cat.prototype.aliases = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/aliases/<%=name%>',
req: {
name: {
type: 'list'
}
}
}, {
fmt: '/_cat/aliases'
}]
});
/**
* Perform a [cat.allocation](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cat-allocation.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information
*/
api.cat.prototype.allocation = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/allocation/<%=nodeId%>',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_cat/allocation'
}]
});
/**
* Perform a [cat.count](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cat-count.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.count = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/count/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/count'
}]
});
/**
* Perform a [cat.fielddata](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cat-fielddata.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to return the fielddata size
*/
api.cat.prototype.fielddata = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
},
fields: {
type: 'list'
}
},
urls: [{
fmt: '/_cat/fielddata/<%=fields%>',
req: {
fields: {
type: 'list'
}
}
}, {
fmt: '/_cat/fielddata'
}]
});
/**
* Perform a [cat.health](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cat-health.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} [params.ts=true] - Set to false to disable timestamping
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.health = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
ts: {
type: 'boolean',
'default': true
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/health'
}
});
/**
* Perform a [cat.help](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cat.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
*/
api.cat.prototype.help = ca({
params: {
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
}
},
url: {
fmt: '/_cat'
}
});
/**
* Perform a [cat.indices](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cat-indices.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-string,`String`>>} params.health - A health status ("green", "yellow", or "red" to filter only indices matching the specified health status
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-boolean,`Boolean`>>} params.pri - Set to true to return stats only for primary shards
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.indices = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'm', 'g']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
health: {
type: 'enum',
'default': null,
options: ['green', 'yellow', 'red']
},
help: {
type: 'boolean',
'default': false
},
pri: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/indices/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/indices'
}]
});
/**
* Perform a [cat.master](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cat-master.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.master = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/master'
}
});
/**
* Perform a [cat.nodeattrs](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cat-nodeattrs.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.nodeattrs = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/nodeattrs'
}
});
/**
* Perform a [cat.nodes](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cat-nodes.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.fullId - Return the full node ID instead of the shortened version (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.nodes = ca({
params: {
format: {
type: 'string'
},
fullId: {
type: 'boolean',
name: 'full_id'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/nodes'
}
});
/**
* Perform a [cat.pendingTasks](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cat-pending-tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.pendingTasks = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/pending_tasks'
}
});
/**
* Perform a [cat.plugins](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cat-plugins.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.plugins = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/plugins'
}
});
/**
* Perform a [cat.recovery](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cat-recovery.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.recovery = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/recovery/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/recovery'
}]
});
/**
* Perform a [cat.repositories](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cat-repositories.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.repositories = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean',
'default': false
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/repositories'
}
});
/**
* Perform a [cat.segments](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cat-segments.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.segments = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/segments/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/segments'
}]
});
/**
* Perform a [cat.shards](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cat-shards.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.shards = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/shards/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/shards'
}]
});
/**
* Perform a [cat.snapshots](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cat-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Set to true to ignore unavailable snapshots
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.repository - Name of repository from which to fetch the snapshot information
*/
api.cat.prototype.snapshots = ca({
params: {
format: {
type: 'string'
},
ignoreUnavailable: {
type: 'boolean',
'default': false,
name: 'ignore_unavailable'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/snapshots/<%=repository%>',
req: {
repository: {
type: 'list'
}
}
}, {
fmt: '/_cat/snapshots'
}]
});
/**
* Perform a [cat.tasks](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.actions - A comma-separated list of actions that should be returned. Leave empty to return all.
* @param {<<api-param-type-boolean,`Boolean`>>} params.detailed - Return detailed task information (default: false)
* @param {<<api-param-type-string,`String`>>} params.parentNode - Return tasks with specified parent node.
* @param {<<api-param-type-number,`Number`>>} params.parentTask - Return tasks with specified parent task id. Set to -1 to return all.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.tasks = ca({
params: {
format: {
type: 'string'
},
nodeId: {
type: 'list',
name: 'node_id'
},
actions: {
type: 'list'
},
detailed: {
type: 'boolean'
},
parentNode: {
type: 'string',
name: 'parent_node'
},
parentTask: {
type: 'number',
name: 'parent_task'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/tasks'
}
});
/**
* Perform a [cat.templates](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cat-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>} params.name - A pattern that returned template names must match
*/
api.cat.prototype.templates = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/templates/<%=name%>',
req: {
name: {
type: 'string'
}
}
}, {
fmt: '/_cat/templates'
}]
});
/**
* Perform a [cat.threadPool](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cat-thread-pool.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.size - The multiplier in which to display values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.threadPoolPatterns - A comma-separated list of regular-expressions to filter the thread pools in the output
*/
api.cat.prototype.threadPool = ca({
params: {
format: {
type: 'string'
},
size: {
type: 'enum',
options: ['', 'k', 'm', 'g', 't', 'p']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/thread_pool/<%=threadPoolPatterns%>',
req: {
threadPoolPatterns: {
type: 'list'
}
}
}, {
fmt: '/_cat/thread_pool'
}]
});
/**
* Perform a [clearScroll](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/search-request-scroll.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.scrollId - A comma-separated list of scroll IDs to clear
*/
api.clearScroll = ca({
urls: [{
fmt: '/_search/scroll/<%=scrollId%>',
req: {
scrollId: {
type: 'list'
}
}
}, {
fmt: '/_search/scroll'
}],
paramAsBody: {
param: 'scrollId',
body: 'scroll_id'
},
method: 'DELETE'
});
api.cluster = namespace();
/**
* Perform a [cluster.allocationExplain](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cluster-allocation-explain.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeYesDecisions - Return 'YES' decisions in explanation (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDiskInfo - Return information about disk usage and shard sizes (default: false)
*/
api.cluster.prototype.allocationExplain = ca({
params: {
includeYesDecisions: {
type: 'boolean',
name: 'include_yes_decisions'
},
includeDiskInfo: {
type: 'boolean',
name: 'include_disk_info'
}
},
url: {
fmt: '/_cluster/allocation/explain'
},
method: 'POST'
});
/**
* Perform a [cluster.getSettings](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cluster-update-settings.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether to return all default clusters setting.
*/
api.cluster.prototype.getSettings = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
},
includeDefaults: {
type: 'boolean',
'default': false,
name: 'include_defaults'
}
},
url: {
fmt: '/_cluster/settings'
}
});
/**
* Perform a [cluster.health](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cluster-health.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} [params.level=cluster] - Specify the level of detail for returned information
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Wait until the specified number of shards is active
* @param {<<api-param-type-string,`String`>>} params.waitForNodes - Wait until the specified number of nodes is available
* @param {<<api-param-type-string,`String`>>} params.waitForEvents - Wait until all currently queued events with the given priority are processed
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForNoRelocatingShards - Whether to wait until there are no relocating shards in the cluster
* @param {<<api-param-type-string,`String`>>} params.waitForStatus - Wait until cluster is in a specific state
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - Limit the information returned to a specific index
*/
api.cluster.prototype.health = ca({
params: {
level: {
type: 'enum',
'default': 'cluster',
options: ['cluster', 'indices', 'shards']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
waitForNodes: {
type: 'string',
name: 'wait_for_nodes'
},
waitForEvents: {
type: 'enum',
options: ['immediate', 'urgent', 'high', 'normal', 'low', 'languid'],
name: 'wait_for_events'
},
waitForNoRelocatingShards: {
type: 'boolean',
name: 'wait_for_no_relocating_shards'
},
waitForStatus: {
type: 'enum',
'default': null,
options: ['green', 'yellow', 'red'],
name: 'wait_for_status'
}
},
urls: [{
fmt: '/_cluster/health/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cluster/health'
}]
});
/**
* Perform a [cluster.pendingTasks](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cluster-pending.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
*/
api.cluster.prototype.pendingTasks = ca({
params: {
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_cluster/pending_tasks'
}
});
/**
* Perform a [cluster.putSettings](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cluster-update-settings.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
*/
api.cluster.prototype.putSettings = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_cluster/settings'
},
method: 'PUT'
});
/**
* Perform a [cluster.remoteInfo](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cluster-remote-info.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
*/
api.cluster.prototype.remoteInfo = ca({
url: {
fmt: '/_remote/info'
}
});
/**
* Perform a [cluster.reroute](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cluster-reroute.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.dryRun - Simulate the operation only and return the resulting state
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - Return an explanation of why the commands can or cannot be executed
* @param {<<api-param-type-boolean,`Boolean`>>} params.retryFailed - Retries allocation of shards that are blocked due to too many subsequent allocation failures
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned to the specified metrics. Defaults to all but metadata
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
*/
api.cluster.prototype.reroute = ca({
params: {
dryRun: {
type: 'boolean',
name: 'dry_run'
},
explain: {
type: 'boolean'
},
retryFailed: {
type: 'boolean',
name: 'retry_failed'
},
metric: {
type: 'list',
options: ['_all', 'blocks', 'metadata', 'nodes', 'routing_table', 'master_node', 'version']
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_cluster/reroute'
},
method: 'POST'
});
/**
* Perform a [cluster.state](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cluster-state.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned to the specified metrics
*/
api.cluster.prototype.state = ca({
params: {
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/_cluster/state/<%=metric%>/<%=index%>',
req: {
metric: {
type: 'list',
options: ['_all', 'blocks', 'metadata', 'nodes', 'routing_table', 'routing_nodes', 'master_node', 'version']
},
index: {
type: 'list'
}
}
}, {
fmt: '/_cluster/state/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'blocks', 'metadata', 'nodes', 'routing_table', 'routing_nodes', 'master_node', 'version']
}
}
}, {
fmt: '/_cluster/state'
}]
});
/**
* Perform a [cluster.stats](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cluster-stats.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
*/
api.cluster.prototype.stats = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
timeout: {
type: 'time'
}
},
urls: [{
fmt: '/_cluster/stats/nodes/<%=nodeId%>',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_cluster/stats'
}]
});
/**
* Perform a [count](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/search-count.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-number,`Number`>>} params.minScore - Include only documents with a specific `_score` value in the result
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-number,`Number`>>} params.terminateAfter - The maximum count for each shard, upon reaching which the query execution will terminate early
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of indices to restrict the results
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of types to restrict the results
*/
api.count = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
minScore: {
type: 'number',
name: 'min_score'
},
preference: {
type: 'string'
},
routing: {
type: 'list'
},
q: {
type: 'string'
},
analyzer: {
type: 'string'
},
analyzeWildcard: {
type: 'boolean',
name: 'analyze_wildcard'
},
defaultOperator: {
type: 'enum',
'default': 'OR',
options: ['AND', 'OR'],
name: 'default_operator'
},
df: {
type: 'string'
},
lenient: {
type: 'boolean'
},
terminateAfter: {
type: 'number',
name: 'terminate_after'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_count',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_count',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_count'
}],
method: 'POST'
});
/**
* Perform a [create](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/docs-index_.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the index operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>} params.parent - ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.pipeline - The pipeline id to preprocess incoming documents with
* @param {<<api-param-type-string,`String`>>} params.id - Document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.create = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
parent: {
type: 'string'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
},
pipeline: {
type: 'string'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_create',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
needBody: true,
method: 'POST'
});
/**
* Perform a [delete](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/docs-delete.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the delete operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>} params.parent - ID of parent document
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the effected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api['delete'] = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
parent: {
type: 'string'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [deleteByQuery](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/docs-delete-by-query.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-number,`Number`>>} params.from - Starting offset (default: 0)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.conflicts=abort] - What to do when the delete-by-query hits version conflicts?
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-duration-string,`DurationString`>>} params.searchTimeout - Explicit timeout for each search request. Defaults to no timeout.
* @param {<<api-param-type-number,`Number`>>} params.size - Number of hits to return (default: 10)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.sort - A comma-separated list of <field>:<direction> pairs
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.terminateAfter - The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.stats - Specific 'tag' of the request for logging and statistical purposes
* @param {<<api-param-type-boolean,`Boolean`>>} params.version - Specify whether to return document version as part of a hit
* @param {<<api-param-type-boolean,`Boolean`>>} params.requestCache - Specify if request cache should be used for this request or not, defaults to index level setting
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Should the effected indexes be refreshed?
* @param {<<api-param-type-duration-string,`DurationString`>>} [params.timeout=1m] - Time each individual bulk request should wait for shards that are unavailable.
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the delete by query operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-number,`Number`>>} params.scrollSize - Size on the scroll request powering the update_by_query
* @param {<<api-param-type-boolean,`Boolean`>>} [params.waitForCompletion=true] - Should the request should block until the delete-by-query is complete.
* @param {<<api-param-type-number,`Number`>>} params.requestsPerSecond - The throttle for this request in sub-requests per second. -1 means no throttle.
* @param {<<api-param-type-number,`Number`>>} [params.slices=1] - The number of slices this task should be divided into. Defaults to 1 meaning the task isn't sliced into subtasks.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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'
},
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'
},
preference: {
type: 'string'
},
q: {
type: 'string'
},
routing: {
type: 'list'
},
scroll: {
type: 'time'
},
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'
},
version: {
type: 'boolean'
},
requestCache: {
type: 'boolean',
name: 'request_cache'
},
refresh: {
type: 'boolean'
},
timeout: {
type: 'time',
'default': '1m'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
scrollSize: {
type: 'number',
name: 'scroll_size'
},
waitForCompletion: {
type: 'boolean',
'default': true,
name: 'wait_for_completion'
},
requestsPerSecond: {
type: 'number',
'default': 0,
name: 'requests_per_second'
},
slices: {
type: 'number',
'default': 1
}
},
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](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/modules-scripting.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.id - Script ID
*/
api.deleteScript = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_scripts/<%=id%>',
req: {
id: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [exists](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/docs-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return in the response
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document (use `_all` to fetch the first document matching the ID across all types)
*/
api.exists = ca({
params: {
storedFields: {
type: 'list',
name: 'stored_fields'
},
parent: {
type: 'string'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'HEAD'
});
/**
* Perform a [existsSource](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/docs-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document; use `_all` to fetch the first document matching the ID across all types
*/
api.existsSource = ca({
params: {
parent: {
type: 'string'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_source',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'HEAD'
});
/**
* Perform a [explain](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/search-explain.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcards and prefix queries in the query string query should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer for the query string query
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The default field for query string query (default: _all)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return in the response
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.explain = ca({
params: {
analyzeWildcard: {
type: 'boolean',
name: 'analyze_wildcard'
},
analyzer: {
type: 'string'
},
defaultOperator: {
type: 'enum',
'default': 'OR',
options: ['AND', 'OR'],
name: 'default_operator'
},
df: {
type: 'string'
},
storedFields: {
type: 'list',
name: 'stored_fields'
},
lenient: {
type: 'boolean'
},
parent: {
type: 'string'
},
preference: {
type: 'string'
},
q: {
type: 'string'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_explain',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [fieldCaps](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/search-field-caps.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of field names
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.fieldCaps = ca({
params: {
fields: {
type: 'list'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_field_caps',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_field_caps'
}],
method: 'POST'
});
/**
* Perform a [get](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/docs-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return in the response
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document (use `_all` to fetch the first document matching the ID across all types)
*/
api.get = ca({
params: {
storedFields: {
type: 'list',
name: 'stored_fields'
},
parent: {
type: 'string'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}
});
/**
* Perform a [getScript](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/modules-scripting.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.id - Script ID
*/
api.getScript = ca({
url: {
fmt: '/_scripts/<%=id%>',
req: {
id: {
type: 'string'
}
}
}
});
/**
* Perform a [getSource](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/docs-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document; use `_all` to fetch the first document matching the ID across all types
*/
api.getSource = ca({
params: {
parent: {
type: 'string'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_source',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}
});
/**
* Perform a [index](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/docs-index_.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the index operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>} [params.opType=index] - Explicit operation type
* @param {<<api-param-type-string,`String`>>} params.parent - ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.pipeline - The pipeline id to preprocess incoming documents with
* @param {<<api-param-type-string,`String`>>} params.id - Document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.index = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
opType: {
type: 'enum',
'default': 'index',
options: ['index', 'create'],
name: 'op_type'
},
parent: {
type: 'string'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
},
pipeline: {
type: 'string'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/<%=id%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/<%=type%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}],
needBody: true,
method: 'POST'
});
api.indices = namespace();
/**
* Perform a [indices.analyze](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-analyze.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index to scope the operation
* @param {<<api-param-type-boolean,`Boolean`>>} params.preferLocal - With `true`, specify that a local shard should be used if available, with `false`, use a random shard (default: true)
* @param {<<api-param-type-string,`String`>>} [params.format=detailed] - Format of the output
*/
api.indices.prototype.analyze = ca({
params: {
index: {
type: 'string'
},
preferLocal: {
type: 'boolean',
name: 'prefer_local'
},
format: {
type: 'enum',
'default': 'detailed',
options: ['detailed', 'text']
}
},
urls: [{
fmt: '/<%=index%>/_analyze',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_analyze'
}],
method: 'POST'
});
/**
* Perform a [indices.clearCache](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-clearcache.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.fieldData - Clear field data
* @param {<<api-param-type-boolean,`Boolean`>>} params.fielddata - Clear field data
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to clear when using the `field_data` parameter (default: all)
* @param {<<api-param-type-boolean,`Boolean`>>} params.query - Clear query caches
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index name to limit the operation
* @param {<<api-param-type-boolean,`Boolean`>>} params.recycler - Clear the recycler cache
* @param {<<api-param-type-boolean,`Boolean`>>} params.requestCache - Clear request cache
* @param {<<api-param-type-boolean,`Boolean`>>} params.request - Clear request cache
*/
api.indices.prototype.clearCache = ca({
params: {
fieldData: {
type: 'boolean',
name: 'field_data'
},
fielddata: {
type: 'boolean'
},
fields: {
type: 'list'
},
query: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
index: {
type: 'list'
},
recycler: {
type: 'boolean'
},
requestCache: {
type: 'boolean',
name: 'request_cache'
},
request: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_cache/clear',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cache/clear'
}],
method: 'POST'
});
/**
* Perform a [indices.close](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-open-close.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma separated list of indices to close
*/
api.indices.prototype.close = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
url: {
fmt: '/<%=index%>/_close',
req: {
index: {
type: 'list'
}
}
},
method: 'POST'
});
/**
* Perform a [indices.create](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-create-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Set the number of active shards to wait for before the operation returns.
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.updateAllTypes - Whether to update the mapping for all fields with the same name across all types or not
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
*/
api.indices.prototype.create = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
updateAllTypes: {
type: 'boolean',
name: 'update_all_types'
}
},
url: {
fmt: '/<%=index%>',
req: {
index: {
type: 'string'
}
}
},
method: 'PUT'
});
/**
* Perform a [indices.delete](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-delete-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Ignore unavailable indexes (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.allowNoIndices - Ignore if a wildcard expression resolves to no concrete indices (default: false)
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether wildcard expressions should get expanded to open or closed indices (default: open)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of indices to delete; use `_all` or `*` string to delete all indices
*/
api.indices.prototype['delete'] = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
url: {
fmt: '/<%=index%>',
req: {
index: {
type: 'list'
}
}
},
method: 'DELETE'
});
/**
* Perform a [indices.deleteAlias](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit timestamp for the document
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names (supports wildcards); use `_all` for all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - A comma-separated list of aliases to delete (supports wildcards); use `_all` to delete all aliases for the specified indices.
*/
api.indices.prototype.deleteAlias = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/<%=index%>/_alias/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'list'
}
}
},
method: 'DELETE'
});
/**
* Perform a [indices.deleteTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.name - The name of the template
*/
api.indices.prototype.deleteTemplate = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_template/<%=name%>',
req: {
name: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [indices.exists](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-exists.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Ignore unavailable indexes (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.allowNoIndices - Ignore if a wildcard expression resolves to no concrete indices (default: false)
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether wildcard expressions should get expanded to open or closed indices (default: open)
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether to return all default setting for each of the indices.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names
*/
api.indices.prototype.exists = ca({
params: {
local: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
includeDefaults: {
type: 'boolean',
'default': false,
name: 'include_defaults'
}
},
url: {
fmt: '/<%=index%>',
req: {
index: {
type: 'list'
}
}
},
method: 'HEAD'
});
/**
* Perform a [indices.existsAlias](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=all] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to filter aliases
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - A comma-separated list of alias names to return
*/
api.indices.prototype.existsAlias = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'all',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_alias/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'list'
}
}
}, {
fmt: '/_alias/<%=name%>',
req: {
name: {
type: 'list'
}
}
}],
method: 'HEAD'
});
/**
* Perform a [indices.existsTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - The comma separated names of the index templates
*/
api.indices.prototype.existsTemplate = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
local: {
type: 'boolean'
}
},
url: {
fmt: '/_template/<%=name%>',
req: {
name: {
type: 'list'
}
}
},
method: 'HEAD'
});
/**
* Perform a [indices.existsType](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-types-exists.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` to check the types across all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to check
*/
api.indices.prototype.existsType = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
url: {
fmt: '/<%=index%>/_mapping/<%=type%>',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
},
method: 'HEAD'
});
/**
* Perform a [indices.flush](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-flush.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.force - Whether a flush should be forced even if it is not necessarily needed ie. if no changes will be committed to the index. This is useful if transaction log IDs should be incremented even if no uncommitted changes are present. (This setting can be considered as internal)
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitIfOngoing - If set to true the flush operation will block until the flush can be executed if another flush operation is already executing. The default is true. If set to false the flush will be skipped iff if another flush operation is already running.
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string for all indices
*/
api.indices.prototype.flush = ca({
params: {
force: {
type: 'boolean'
},
waitIfOngoing: {
type: 'boolean',
name: 'wait_if_ongoing'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_flush',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_flush'
}],
method: 'POST'
});
/**
* Perform a [indices.flushSynced](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-synced-flush.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string for all indices
*/
api.indices.prototype.flushSynced = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_flush/synced',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_flush/synced'
}],
method: 'POST'
});
/**
* Perform a [indices.forcemerge](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-forcemerge.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flush - Specify whether the index should be flushed after performing the operation (default: true)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-number,`Number`>>} params.maxNumSegments - The number of segments the index should be merged into (default: dynamic)
* @param {<<api-param-type-boolean,`Boolean`>>} params.onlyExpungeDeletes - Specify whether the operation should only expunge deleted documents
* @param {anything} params.operationThreading - TODO: ?
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForMerge - Specify whether the request should block until the merge process is finished (default: true)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.forcemerge = ca({
params: {
flush: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
maxNumSegments: {
type: 'number',
name: 'max_num_segments'
},
onlyExpungeDeletes: {
type: 'boolean',
name: 'only_expunge_deletes'
},
operationThreading: {
name: 'operation_threading'
},
waitForMerge: {
type: 'boolean',
name: 'wait_for_merge'
}
},
urls: [{
fmt: '/<%=index%>/_forcemerge',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_forcemerge'
}],
method: 'POST'
});
/**
* Perform a [indices.get](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-get-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Ignore unavailable indexes (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.allowNoIndices - Ignore if a wildcard expression resolves to no concrete indices (default: false)
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether wildcard expressions should get expanded to open or closed indices (default: open)
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether to return all default setting for each of the indices.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names
*/
api.indices.prototype.get = ca({
params: {
local: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
includeDefaults: {
type: 'boolean',
'default': false,
name: 'include_defaults'
}
},
url: {
fmt: '/<%=index%>',
req: {
index: {
type: 'list'
}
}
}
});
/**
* Perform a [indices.getAlias](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=all] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to filter aliases
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - A comma-separated list of alias names to return
*/
api.indices.prototype.getAlias = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'all',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_alias/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'list'
}
}
}, {
fmt: '/_alias/<%=name%>',
req: {
name: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_alias',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_alias'
}]
});
/**
* Perform a [indices.getFieldMapping](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-get-field-mapping.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether the default mapping values should be returned as well
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields
*/
api.indices.prototype.getFieldMapping = ca({
params: {
includeDefaults: {
type: 'boolean',
name: 'include_defaults'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_mapping/<%=type%>/field/<%=fields%>',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
},
fields: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_mapping/field/<%=fields%>',
req: {
index: {
type: 'list'
},
fields: {
type: 'list'
}
}
}, {
fmt: '/_mapping/<%=type%>/field/<%=fields%>',
req: {
type: {
type: 'list'
},
fields: {
type: 'list'
}
}
}, {
fmt: '/_mapping/field/<%=fields%>',
req: {
fields: {
type: 'list'
}
}
}]
});
/**
* Perform a [indices.getMapping](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-get-mapping.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types
*/
api.indices.prototype.getMapping = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_mapping/<%=type%>',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_mapping',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_mapping/<%=type%>',
req: {
type: {
type: 'list'
}
}
}, {
fmt: '/_mapping'
}]
});
/**
* Perform a [indices.getSettings](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-get-settings.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open,closed] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether to return all default setting for each of the indices.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - The name of the settings that should be included
*/
api.indices.prototype.getSettings = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': ['open', 'closed'],
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
local: {
type: 'boolean'
},
includeDefaults: {
type: 'boolean',
'default': false,
name: 'include_defaults'
}
},
urls: [{
fmt: '/<%=index%>/_settings/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_settings',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_settings/<%=name%>',
req: {
name: {
type: 'list'
}
}
}, {
fmt: '/_settings'
}]
});
/**
* Perform a [indices.getTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - The comma separated names of the index templates
*/
api.indices.prototype.getTemplate = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/_template/<%=name%>',
req: {
name: {
type: 'list'
}
}
}, {
fmt: '/_template'
}]
});
/**
* Perform a [indices.getUpgrade](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-upgrade.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.getUpgrade = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_upgrade',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_upgrade'
}]
});
/**
* Perform a [indices.open](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-open-close.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=closed] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma separated list of indices to open
*/
api.indices.prototype.open = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'closed',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
url: {
fmt: '/<%=index%>/_open',
req: {
index: {
type: 'list'
}
}
},
method: 'POST'
});
/**
* Perform a [indices.putAlias](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit timestamp for the document
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names the alias should point to (supports wildcards); use `_all` to perform the operation on all indices.
* @param {<<api-param-type-string,`String`>>} params.name - The name of the alias to be created or updated
*/
api.indices.prototype.putAlias = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/<%=index%>/_alias/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'string'
}
}
},
method: 'PUT'
});
/**
* Perform a [indices.putMapping](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-put-mapping.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.updateAllTypes - Whether to update the mapping for all fields with the same name across all types or not
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices.
* @param {<<api-param-type-string,`String`>>} params.type - The name of the document type
*/
api.indices.prototype.putMapping = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
updateAllTypes: {
type: 'boolean',
name: 'update_all_types'
}
},
urls: [{
fmt: '/<%=index%>/_mapping/<%=type%>',
req: {
index: {
type: 'list'
},
type: {
type: 'string'
}
}
}, {
fmt: '/_mapping/<%=type%>',
req: {
type: {
type: 'string'
}
}
}],
needBody: true,
method: 'PUT'
});
/**
* Perform a [indices.putSettings](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-update-settings.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.preserveExisting - Whether to update existing settings. If set to `true` existing settings on an index remain unchanged, the default is `false`
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.putSettings = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
preserveExisting: {
type: 'boolean',
name: 'preserve_existing'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
}
},
urls: [{
fmt: '/<%=index%>/_settings',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_settings'
}],
needBody: true,
method: 'PUT'
});
/**
* Perform a [indices.putTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-number,`Number`>>} params.order - The order for this template when merging multiple matching ones (higher numbers are merged later, overriding the lower numbers)
* @param {<<api-param-type-boolean,`Boolean`>>} params.create - Whether the index template should only be added if new or can also replace an existing one
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-string,`String`>>} params.name - The name of the template
*/
api.indices.prototype.putTemplate = ca({
params: {
order: {
type: 'number'
},
create: {
type: 'boolean',
'default': false
},
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
}
},
url: {
fmt: '/_template/<%=name%>',
req: {
name: {
type: 'string'
}
}
},
needBody: true,
method: 'PUT'
});
/**
* Perform a [indices.recovery](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-recovery.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.detailed - Whether to display detailed information about shard recovery
* @param {<<api-param-type-boolean,`Boolean`>>} params.activeOnly - Display only those recoveries that are currently on-going
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.recovery = ca({
params: {
detailed: {
type: 'boolean',
'default': false
},
activeOnly: {
type: 'boolean',
'default': false,
name: 'active_only'
}
},
urls: [{
fmt: '/<%=index%>/_recovery',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_recovery'
}]
});
/**
* Perform a [indices.refresh](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-refresh.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.refresh = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_refresh',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_refresh'
}],
method: 'POST'
});
/**
* Perform a [indices.rollover](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-rollover-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.dryRun - If set to true the rollover action will only be validated but not actually performed even if a condition matches. The default is false
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Set the number of active shards to wait for on the newly created rollover index before the operation returns.
* @param {<<api-param-type-string,`String`>>} params.alias - The name of the alias to rollover
* @param {<<api-param-type-string,`String`>>} params.newIndex - The name of the rollover index
*/
api.indices.prototype.rollover = ca({
params: {
timeout: {
type: 'time'
},
dryRun: {
type: 'boolean',
name: 'dry_run'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
}
},
urls: [{
fmt: '/<%=alias%>/_rollover/<%=newIndex%>',
req: {
alias: {
type: 'string'
},
newIndex: {
type: 'string'
}
}
}, {
fmt: '/<%=alias%>/_rollover',
req: {
alias: {
type: 'string'
}
}
}],
method: 'POST'
});
/**
* Perform a [indices.segments](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-segments.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {anything} params.operationThreading - TODO: ?
* @param {<<api-param-type-boolean,`Boolean`>>} params.verbose - Includes detailed memory usage by Lucene.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.segments = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
operationThreading: {
name: 'operation_threading'
},
verbose: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/<%=index%>/_segments',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_segments'
}]
});
/**
* Perform a [indices.shardStores](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-shards-stores.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.status - A comma-separated list of statuses used to filter on shards to get store information for
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {anything} params.operationThreading - TODO: ?
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.shardStores = ca({
params: {
status: {
type: 'list',
options: ['green', 'yellow', 'red', 'all']
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
operationThreading: {
name: 'operation_threading'
}
},
urls: [{
fmt: '/<%=index%>/_shard_stores',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_shard_stores'
}]
});
/**
* Perform a [indices.shrink](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-shrink-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Set the number of active shards to wait for on the shrunken index before the operation returns.
* @param {<<api-param-type-string,`String`>>} params.index - The name of the source index to shrink
* @param {<<api-param-type-string,`String`>>} params.target - The name of the target index to shrink into
*/
api.indices.prototype.shrink = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
}
},
url: {
fmt: '/<%=index%>/_shrink/<%=target%>',
req: {
index: {
type: 'string'
},
target: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [indices.stats](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-stats.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.completionFields - A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fielddataFields - A comma-separated list of fields for `fielddata` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.groups - A comma-separated list of search groups for `search` index metric
* @param {<<api-param-type-string,`String`>>} [params.level=indices] - Return stats aggregated at cluster, index or shard level
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.types - A comma-separated list of document types for the `indexing` index metric
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeSegmentFileSizes - Whether to report the aggregated disk usage of each one of the Lucene index files (only applies if segment stats are requested)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned the specific metrics.
*/
api.indices.prototype.stats = ca({
params: {
completionFields: {
type: 'list',
name: 'completion_fields'
},
fielddataFields: {
type: 'list',
name: 'fielddata_fields'
},
fields: {
type: 'list'
},
groups: {
type: 'list'
},
level: {
type: 'enum',
'default': 'indices',
options: ['cluster', 'indices', 'shards']
},
types: {
type: 'list'
},
includeSegmentFileSizes: {
type: 'boolean',
'default': false,
name: 'include_segment_file_sizes'
}
},
urls: [{
fmt: '/<%=index%>/_stats/<%=metric%>',
req: {
index: {
type: 'list'
},
metric: {
type: 'list',
options: ['_all', 'completion', 'docs', 'fielddata', 'query_cache', 'flush', 'get', 'indexing', 'merge', 'request_cache', 'refresh', 'search', 'segments', 'store', 'warmer', 'suggest']
}
}
}, {
fmt: '/_stats/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'completion', 'docs', 'fielddata', 'query_cache', 'flush', 'get', 'indexing', 'merge', 'request_cache', 'refresh', 'search', 'segments', 'store', 'warmer', 'suggest']
}
}
}, {
fmt: '/<%=index%>/_stats',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_stats'
}]
});
/**
* Perform a [indices.updateAliases](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Request timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
*/
api.indices.prototype.updateAliases = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_aliases'
},
needBody: true,
method: 'POST'
});
/**
* Perform a [indices.upgrade](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/indices-upgrade.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Specify whether the request should block until the all segments are upgraded (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.onlyAncientSegments - If true, only ancient (an older Lucene major release) segments will be upgraded
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.upgrade = ca({
params: {
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
waitForCompletion: {
type: 'boolean',
name: 'wait_for_completion'
},
onlyAncientSegments: {
type: 'boolean',
name: 'only_ancient_segments'
}
},
urls: [{
fmt: '/<%=index%>/_upgrade',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_upgrade'
}],
method: 'POST'
});
/**
* Perform a [indices.validateQuery](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/search-validate.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - Return detailed information about the error
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {anything} params.operationThreading - TODO: ?
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-boolean,`Boolean`>>} params.rewrite - Provide a more detailed explanation showing the actual Lucene query that will be executed.
* @param {<<api-param-type-boolean,`Boolean`>>} params.allShards - Execute validation on all shards instead of one random shard per index
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types
*/
api.indices.prototype.validateQuery = ca({
params: {
explain: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
operationThreading: {
name: 'operation_threading'
},
q: {
type: 'string'
},
analyzer: {
type: 'string'
},
analyzeWildcard: {
type: 'boolean',
name: 'analyze_wildcard'
},
defaultOperator: {
type: 'enum',
'default': 'OR',
options: ['AND', 'OR'],
name: 'default_operator'
},
df: {
type: 'string'
},
lenient: {
type: 'boolean'
},
rewrite: {
type: 'boolean'
},
allShards: {
type: 'boolean',
name: 'all_shards'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_validate/query',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_validate/query',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_validate/query'
}],
method: 'POST'
});
/**
* Perform a [info](http://www.elastic.co/guide/) request
*
* @param {Object} params - An object with parameters used to carry out this action
*/
api.info = ca({
url: {
fmt: '/'
}
});
api.ingest = namespace();
/**
* Perform a [ingest.deletePipeline](https://www.elastic.co/guide/en/elasticsearch/plugins/6.0/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.id - Pipeline ID
*/
api.ingest.prototype.deletePipeline = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_ingest/pipeline/<%=id%>',
req: {
id: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [ingest.getPipeline](https://www.elastic.co/guide/en/elasticsearch/plugins/6.0/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>} params.id - Comma separated list of pipeline ids. Wildcards supported
*/
api.ingest.prototype.getPipeline = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
urls: [{
fmt: '/_ingest/pipeline/<%=id%>',
req: {
id: {
type: 'string'
}
}
}, {
fmt: '/_ingest/pipeline'
}]
});
/**
* Perform a [ingest.processorGrok](https://www.elastic.co/guide/en/elasticsearch/plugins/6.0/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
*/
api.ingest.prototype.processorGrok = ca({
url: {
fmt: '/_ingest/processor/grok'
}
});
/**
* Perform a [ingest.putPipeline](https://www.elastic.co/guide/en/elasticsearch/plugins/6.0/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.id - Pipeline ID
*/
api.ingest.prototype.putPipeline = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_ingest/pipeline/<%=id%>',
req: {
id: {
type: 'string'
}
}
},
needBody: true,
method: 'PUT'
});
/**
* Perform a [ingest.simulate](https://www.elastic.co/guide/en/elasticsearch/plugins/6.0/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.verbose - Verbose mode. Display data output for each processor in executed pipeline
* @param {<<api-param-type-string,`String`>>} params.id - Pipeline ID
*/
api.ingest.prototype.simulate = ca({
params: {
verbose: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_ingest/pipeline/<%=id%>/_simulate',
req: {
id: {
type: 'string'
}
}
}, {
fmt: '/_ingest/pipeline/_simulate'
}],
needBody: true,
method: 'POST'
});
/**
* Perform a [mget](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/docs-multi-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return in the response
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.mget = ca({
params: {
storedFields: {
type: 'list',
name: 'stored_fields'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_mget',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/_mget',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_mget'
}],
needBody: true,
method: 'POST'
});
/**
* Perform a [msearch](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/search-multi-search.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-number,`Number`>>} params.maxConcurrentSearches - Controls the maximum number of concurrent searches the multi search api will execute
* @param {<<api-param-type-boolean,`Boolean`>>} params.typedKeys - Specify whether aggregation and suggester names should be prefixed by their respective types in the response
* @param {<<api-param-type-number,`Number`>>} [params.preFilterShardSize=128] - A threshold that enforces a pre-filter roundtrip to prefilter search shards based on query rewriting if the number of shards the search request expands to exceeds the threshold. This filter roundtrip can limit the number of shards significantly if for instance a shard can not match any documents based on it's rewrite method ie. if date filters are mandatory to match but the shard bounds and the query are disjoint.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to use as default
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to use as default
*/
api.msearch = ca({
params: {
searchType: {
type: 'enum',
options: ['query_then_fetch', 'query_and_fetch', 'dfs_query_then_fetch', 'dfs_query_and_fetch'],
name: 'search_type'
},
maxConcurrentSearches: {
type: 'number',
name: 'max_concurrent_searches'
},
typedKeys: {
type: 'boolean',
name: 'typed_keys'
},
preFilterShardSize: {
type: 'number',
'default': 128,
name: 'pre_filter_shard_size'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_msearch',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_msearch',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_msearch'
}],
needBody: true,
bulkBody: true,
method: 'POST'
});
/**
* Perform a [msearchTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/search-multi-search.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-boolean,`Boolean`>>} params.typedKeys - Specify whether aggregation and suggester names should be prefixed by their respective types in the response
* @param {<<api-param-type-number,`Number`>>} params.maxConcurrentSearches - Controls the maximum number of concurrent searches the multi search api will execute
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to use as default
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to use as default
*/
api.msearchTemplate = ca({
params: {
searchType: {
type: 'enum',
options: ['query_then_fetch', 'query_and_fetch', 'dfs_query_then_fetch', 'dfs_query_and_fetch'],
name: 'search_type'
},
typedKeys: {
type: 'boolean',
name: 'typed_keys'
},
maxConcurrentSearches: {
type: 'number',
name: 'max_concurrent_searches'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_msearch/template',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_msearch/template',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_msearch/template'
}],
needBody: true,
bulkBody: true,
method: 'POST'
});
/**
* Perform a [mtermvectors](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/docs-multi-termvectors.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.ids - A comma-separated list of documents ids. You must define ids as parameter or set "ids" or "docs" in the request body
* @param {<<api-param-type-boolean,`Boolean`>>} params.termStatistics - Specifies if total term frequency and document frequency should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} [params.fieldStatistics=true] - Specifies if document count, sum of document frequencies and sum of total term frequencies should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to return. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} [params.offsets=true] - Specifies if term offsets should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} [params.positions=true] - Specifies if term positions should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} [params.payloads=true] - Specifies if term payloads should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random) .Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-string,`String`>>} params.parent - Parent id of documents. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specifies if requests are real-time as opposed to near-real-time (default: true).
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.index - The index in which the document resides.
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document.
*/
api.mtermvectors = ca({
params: {
ids: {
type: 'list',
required: false
},
termStatistics: {
type: 'boolean',
'default': false,
required: false,
name: 'term_statistics'
},
fieldStatistics: {
type: 'boolean',
'default': true,
required: false,
name: 'field_statistics'
},
fields: {
type: 'list',
required: false
},
offsets: {
type: 'boolean',
'default': true,
required: false
},
positions: {
type: 'boolean',
'default': true,
required: false
},
payloads: {
type: 'boolean',
'default': true,
required: false
},
preference: {
type: 'string',
required: false
},
routing: {
type: 'string',
required: false
},
parent: {
type: 'string',
required: false
},
realtime: {
type: 'boolean',
required: false
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_mtermvectors',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/_mtermvectors',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_mtermvectors'
}],
method: 'POST'
});
api.nodes = namespace();
/**
* Perform a [nodes.hotThreads](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cluster-nodes-hot-threads.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.interval - The interval for the second sampling of threads
* @param {<<api-param-type-number,`Number`>>} params.snapshots - Number of samples of thread stacktrace (default: 10)
* @param {<<api-param-type-number,`Number`>>} params.threads - Specify the number of threads to provide information for (default: 3)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreIdleThreads - Don't show threads that are in known-idle places, such as waiting on a socket select or pulling from an empty task queue (default: true)
* @param {<<api-param-type-string,`String`>>} params.type - The type to sample (default: cpu)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
*/
api.nodes.prototype.hotThreads = ca({
params: {
interval: {
type: 'time'
},
snapshots: {
type: 'number'
},
threads: {
type: 'number'
},
ignoreIdleThreads: {
type: 'boolean',
name: 'ignore_idle_threads'
},
type: {
type: 'enum',
options: ['cpu', 'wait', 'block']
},
timeout: {
type: 'time'
}
},
urls: [{
fmt: '/_nodes/<%=nodeId%>/hotthreads',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_nodes/hotthreads'
}]
});
/**
* Perform a [nodes.info](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cluster-nodes-info.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - A comma-separated list of metrics you wish returned. Leave empty to return all.
*/
api.nodes.prototype.info = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
timeout: {
type: 'time'
}
},
urls: [{
fmt: '/_nodes/<%=nodeId%>/<%=metric%>',
req: {
nodeId: {
type: 'list'
},
metric: {
type: 'list',
options: ['settings', 'os', 'process', 'jvm', 'thread_pool', 'transport', 'http', 'plugins', 'ingest']
}
}
}, {
fmt: '/_nodes/<%=nodeId%>',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_nodes/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['settings', 'os', 'process', 'jvm', 'thread_pool', 'transport', 'http', 'plugins', 'ingest']
}
}
}, {
fmt: '/_nodes'
}]
});
/**
* Perform a [nodes.stats](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cluster-nodes-stats.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.completionFields - A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fielddataFields - A comma-separated list of fields for `fielddata` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards)
* @param {<<api-param-type-boolean,`Boolean`>>} params.groups - A comma-separated list of search groups for `search` index metric
* @param {<<api-param-type-string,`String`>>} [params.level=node] - Return indices stats aggregated at index, node or shard level
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.types - A comma-separated list of document types for the `indexing` index metric
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeSegmentFileSizes - Whether to report the aggregated disk usage of each one of the Lucene index files (only applies if segment stats are requested)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned to the specified metrics
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.indexMetric - Limit the information returned for `indices` metric to the specific index metrics. Isn't used if `indices` (or `all`) metric isn't specified.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
*/
api.nodes.prototype.stats = ca({
params: {
completionFields: {
type: 'list',
name: 'completion_fields'
},
fielddataFields: {
type: 'list',
name: 'fielddata_fields'
},
fields: {
type: 'list'
},
groups: {
type: 'boolean'
},
level: {
type: 'enum',
'default': 'node',
options: ['indices', 'node', 'shards']
},
types: {
type: 'list'
},
timeout: {
type: 'time'
},
includeSegmentFileSizes: {
type: 'boolean',
'default': false,
name: 'include_segment_file_sizes'
}
},
urls: [{
fmt: '/_nodes/<%=nodeId%>/stats/<%=metric%>/<%=indexMetric%>',
req: {
nodeId: {
type: 'list'
},
metric: {
type: 'list',
options: ['_all', 'breaker', 'fs', 'http', 'indices', 'jvm', 'os', 'process', 'thread_pool', 'transport', 'discovery']
},
indexMetric: {
type: 'list',
options: ['_all', 'completion', 'docs', 'fielddata', 'query_cache', 'flush', 'get', 'indexing', 'merge', 'request_cache', 'refresh', 'search', 'segments', 'store', 'warmer', 'suggest']
}
}
}, {
fmt: '/_nodes/<%=nodeId%>/stats/<%=metric%>',
req: {
nodeId: {
type: 'list'
},
metric: {
type: 'list',
options: ['_all', 'breaker', 'fs', 'http', 'indices', 'jvm', 'os', 'process', 'thread_pool', 'transport', 'discovery']
}
}
}, {
fmt: '/_nodes/stats/<%=metric%>/<%=indexMetric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'breaker', 'fs', 'http', 'indices', 'jvm', 'os', 'process', 'thread_pool', 'transport', 'discovery']
},
indexMetric: {
type: 'list',
options: ['_all', 'completion', 'docs', 'fielddata', 'query_cache', 'flush', 'get', 'indexing', 'merge', 'request_cache', 'refresh', 'search', 'segments', 'store', 'warmer', 'suggest']
}
}
}, {
fmt: '/_nodes/<%=nodeId%>/stats',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_nodes/stats/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'breaker', 'fs', 'http', 'indices', 'jvm', 'os', 'process', 'thread_pool', 'transport', 'discovery']
}
}
}, {
fmt: '/_nodes/stats'
}]
});
/**
* Perform a [nodes.usage](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/cluster-nodes-usage.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.human - Whether to return time and byte values in human-readable format.
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned to the specified metrics
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
*/
api.nodes.prototype.usage = ca({
params: {
human: {
type: 'boolean',
'default': false
},
timeout: {
type: 'time'
}
},
urls: [{
fmt: '/_nodes/<%=nodeId%>/usage/<%=metric%>',
req: {
nodeId: {
type: 'list'
},
metric: {
type: 'list',
options: ['_all', 'rest_actions']
}
}
}, {
fmt: '/_nodes/<%=nodeId%>/usage',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_nodes/usage/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'rest_actions']
}
}
}, {
fmt: '/_nodes/usage'
}]
});
/**
* Perform a [ping](http://www.elastic.co/guide/) request
*
* @param {Object} params - An object with parameters used to carry out this action
*/
api.ping = ca({
url: {
fmt: '/'
},
requestTimeout: 3000,
method: 'HEAD'
});
/**
* Perform a [putScript](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/modules-scripting.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.context - Script context
* @param {<<api-param-type-string,`String`>>} params.id - Script ID
*/
api.putScript = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
context: {
type: 'string'
}
},
urls: [{
fmt: '/_scripts/<%=id%>/<%=context%>',
req: {
id: {
type: 'string'
},
context: {
type: 'string'
}
}
}, {
fmt: '/_scripts/<%=id%>',
req: {
id: {
type: 'string'
}
}
}],
needBody: true,
method: 'PUT'
});
/**
* Perform a [reindex](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/docs-reindex.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Should the effected indexes be refreshed?
* @param {<<api-param-type-duration-string,`DurationString`>>} [params.timeout=1m] - Time each individual bulk request should wait for shards that are unavailable.
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the reindex operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-boolean,`Boolean`>>} [params.waitForCompletion=true] - Should the request should block until the reindex is complete.
* @param {<<api-param-type-number,`Number`>>} params.requestsPerSecond - The throttle to set on this request in sub-requests per second. -1 means no throttle.
* @param {<<api-param-type-number,`Number`>>} [params.slices=1] - The number of slices this task should be divided into. Defaults to 1 meaning the task isn't sliced into subtasks.
*/
api.reindex = ca({
params: {
refresh: {
type: 'boolean'
},
timeout: {
type: 'time',
'default': '1m'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
waitForCompletion: {
type: 'boolean',
'default': true,
name: 'wait_for_completion'
},
requestsPerSecond: {
type: 'number',
'default': 0,
name: 'requests_per_second'
},
slices: {
type: 'number',
'default': 1
}
},
url: {
fmt: '/_reindex'
},
needBody: true,
method: 'POST'
});
/**
* Perform a [reindexRethrottle](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/docs-reindex.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-number,`Number`>>} params.requestsPerSecond - The throttle to set on this request in floating sub-requests per second. -1 means set no throttle.
* @param {<<api-param-type-string,`String`>>} params.taskId - The task id to rethrottle
*/
api.reindexRethrottle = ca({
params: {
requestsPerSecond: {
type: 'number',
required: true,
name: 'requests_per_second'
}
},
url: {
fmt: '/_reindex/<%=taskId%>/_rethrottle',
req: {
taskId: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [renderSearchTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/search-template.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.id - The id of the stored search template
*/
api.renderSearchTemplate = ca({
urls: [{
fmt: '/_render/template/<%=id%>',
req: {
id: {
type: 'string'
}
}
}, {
fmt: '/_render/template'
}],
method: 'POST'
});
/**
* Perform a [scroll](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/search-request-scroll.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.scrollId - The scroll ID
*/
api.scroll = ca({
params: {
scroll: {
type: 'time'
},
scrollId: {
type: 'string',
name: 'scroll_id'
}
},
urls: [{
fmt: '/_search/scroll/<%=scrollId%>',
req: {
scrollId: {
type: 'string'
}
}
}, {
fmt: '/_search/scroll'
}],
paramAsBody: {
param: 'scrollId',
body: 'scroll_id'
},
method: 'POST'
});
/**
* Perform a [search](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/search-search.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - Specify whether to return detailed information about score computation as part of a hit
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return as part of a hit
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.docvalueFields - A comma-separated list of fields to return as the docvalue representation of a field for each hit
* @param {<<api-param-type-number,`Number`>>} params.from - Starting offset (default: 0)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-number,`Number`>>} params.size - Number of hits to return (default: 10)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.sort - A comma-separated list of <field>:<direction> pairs
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.terminateAfter - The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.stats - Specific 'tag' of the request for logging and statistical purposes
* @param {<<api-param-type-string,`String`>>} params.suggestField - Specify which field to use for suggestions
* @param {<<api-param-type-string,`String`>>} [params.suggestMode=missing] - Specify suggest mode
* @param {<<api-param-type-number,`Number`>>} params.suggestSize - How many suggestions to return in response
* @param {<<api-param-type-string,`String`>>} params.suggestText - The source text for which the suggestions should be returned
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.trackScores - Whether to calculate and return scores even if they are not used for sorting
* @param {<<api-param-type-boolean,`Boolean`>>} params.trackTotalHits - Indicate if the number of documents that match the query should be tracked
* @param {<<api-param-type-boolean,`Boolean`>>} params.typedKeys - Specify whether aggregation and suggester names should be prefixed by their respective types in the response
* @param {<<api-param-type-boolean,`Boolean`>>} params.version - Specify whether to return document version as part of a hit
* @param {<<api-param-type-boolean,`Boolean`>>} params.requestCache - Specify if request cache should be used for this request or not, defaults to index level setting
* @param {<<api-param-type-number,`Number`>>} [params.batchedReduceSize=512] - The number of shard results that should be reduced at once on the coordinating node. This value should be used as a protection mechanism to reduce the memory overhead per search request if the potential number of shards in the request can be large.
* @param {<<api-param-type-number,`Number`>>} [params.maxConcurrentShardRequests=The default grows with the number of nodes in the cluster but is at most 256.] - The number of concurrent shard requests this search executes concurrently. This value should be used to limit the impact of the search on the cluster in order to limit the number of concurrent shard requests
* @param {<<api-param-type-number,`Number`>>} [params.preFilterShardSize=128] - A threshold that enforces a pre-filter roundtrip to prefilter search shards based on query rewriting if the number of shards the search request expands to exceeds the threshold. This filter roundtrip can limit the number of shards significantly if for instance a shard can not match any documents based on it's rewrite method ie. if date filters are mandatory to match but the shard bounds and the query are disjoint.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to search; leave empty to perform the operation on all types
*/
api.search = 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'
},
storedFields: {
type: 'list',
name: 'stored_fields'
},
docvalueFields: {
type: 'list',
name: 'docvalue_fields'
},
from: {
type: 'number'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
lenient: {
type: 'boolean'
},
preference: {
type: 'string'
},
q: {
type: 'string'
},
routing: {
type: 'list'
},
scroll: {
type: 'time'
},
searchType: {
type: 'enum',
options: ['query_then_fetch', 'dfs_query_then_fetch'],
name: 'search_type'
},
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: 'string',
name: 'suggest_text'
},
timeout: {
type: 'time'
},
trackScores: {
type: 'boolean',
name: 'track_scores'
},
trackTotalHits: {
type: 'boolean',
name: 'track_total_hits'
},
typedKeys: {
type: 'boolean',
name: 'typed_keys'
},
version: {
type: 'boolean'
},
requestCache: {
type: 'boolean',
name: 'request_cache'
},
batchedReduceSize: {
type: 'number',
'default': 512,
name: 'batched_reduce_size'
},
maxConcurrentShardRequests: {
type: 'number',
'default': 'The default grows with the number of nodes in the cluster but is at most 256.',
name: 'max_concurrent_shard_requests'
},
preFilterShardSize: {
type: 'number',
'default': 128,
name: 'pre_filter_shard_size'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_search',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_search',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_search'
}],
method: 'POST'
});
/**
* Perform a [searchShards](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/search-shards.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices
*/
api.searchShards = ca({
params: {
preference: {
type: 'string'
},
routing: {
type: 'string'
},
local: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_search_shards',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_search_shards'
}],
method: 'POST'
});
/**
* Perform a [searchTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/search-template.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - Specify whether to return detailed information about score computation as part of a hit
* @param {<<api-param-type-boolean,`Boolean`>>} params.profile - Specify whether to profile the query execution
* @param {<<api-param-type-boolean,`Boolean`>>} params.typedKeys - Specify whether aggregation and suggester names should be prefixed by their respective types in the response
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to search; leave empty to perform the operation on all types
*/
api.searchTemplate = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
preference: {
type: 'string'
},
routing: {
type: 'list'
},
scroll: {
type: 'time'
},
searchType: {
type: 'enum',
options: ['query_then_fetch', 'query_and_fetch', 'dfs_query_then_fetch', 'dfs_query_and_fetch'],
name: 'search_type'
},
explain: {
type: 'boolean'
},
profile: {
type: 'boolean'
},
typedKeys: {
type: 'boolean',
name: 'typed_keys'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_search/template',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_search/template',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_search/template'
}],
method: 'POST'
});
api.snapshot = namespace();
/**
* Perform a [snapshot.create](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Should this request wait until the operation has completed before returning
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>} params.snapshot - A snapshot name
*/
api.snapshot.prototype.create = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForCompletion: {
type: 'boolean',
'default': false,
name: 'wait_for_completion'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [snapshot.createRepository](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.verify - Whether to verify the repository after creation
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
*/
api.snapshot.prototype.createRepository = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
},
verify: {
type: 'boolean'
}
},
url: {
fmt: '/_snapshot/<%=repository%>',
req: {
repository: {
type: 'string'
}
}
},
needBody: true,
method: 'POST'
});
/**
* Perform a [snapshot.delete](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>} params.snapshot - A snapshot name
*/
api.snapshot.prototype['delete'] = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [snapshot.deleteRepository](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.repository - A comma-separated list of repository names
*/
api.snapshot.prototype.deleteRepository = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_snapshot/<%=repository%>',
req: {
repository: {
type: 'list'
}
}
},
method: 'DELETE'
});
/**
* Perform a [snapshot.get](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether to ignore unavailable snapshots, defaults to false which means a SnapshotMissingException is thrown
* @param {<<api-param-type-boolean,`Boolean`>>} params.verbose - Whether to show verbose snapshot info or only show the basic info found in the repository index blob
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.snapshot - A comma-separated list of snapshot names
*/
api.snapshot.prototype.get = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
verbose: {
type: 'boolean'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'list'
}
}
}
});
/**
* Perform a [snapshot.getRepository](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.repository - A comma-separated list of repository names
*/
api.snapshot.prototype.getRepository = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/_snapshot/<%=repository%>',
req: {
repository: {
type: 'list'
}
}
}, {
fmt: '/_snapshot'
}]
});
/**
* Perform a [snapshot.restore](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Should this request wait until the operation has completed before returning
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>} params.snapshot - A snapshot name
*/
api.snapshot.prototype.restore = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForCompletion: {
type: 'boolean',
'default': false,
name: 'wait_for_completion'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>/_restore',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [snapshot.status](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether to ignore unavailable snapshots, defaults to false which means a SnapshotMissingException is thrown
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.snapshot - A comma-separated list of snapshot names
*/
api.snapshot.prototype.status = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
}
},
urls: [{
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>/_status',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'list'
}
}
}, {
fmt: '/_snapshot/<%=repository%>/_status',
req: {
repository: {
type: 'string'
}
}
}, {
fmt: '/_snapshot/_status'
}]
});
/**
* Perform a [snapshot.verifyRepository](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
*/
api.snapshot.prototype.verifyRepository = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/_verify',
req: {
repository: {
type: 'string'
}
}
},
method: 'POST'
});
api.tasks = namespace();
/**
* Perform a [tasks.cancel](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodes - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.actions - A comma-separated list of actions that should be cancelled. Leave empty to cancel all.
* @param {<<api-param-type-string,`String`>>} params.parentNode - Cancel tasks with specified parent node.
* @param {<<api-param-type-string,`String`>>} params.parentTaskId - Cancel tasks with specified parent task id (node_id:task_number). Set to -1 to cancel all.
* @param {<<api-param-type-string,`String`>>} params.taskId - Cancel the task with specified task id (node_id:task_number)
*/
api.tasks.prototype.cancel = ca({
params: {
nodes: {
type: 'list'
},
actions: {
type: 'list'
},
parentNode: {
type: 'string',
name: 'parent_node'
},
parentTaskId: {
type: 'string',
name: 'parent_task_id'
}
},
urls: [{
fmt: '/_tasks/<%=taskId%>/_cancel',
req: {
taskId: {
type: 'string'
}
}
}, {
fmt: '/_tasks/_cancel'
}],
method: 'POST'
});
/**
* Perform a [tasks.get](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Wait for the matching tasks to complete (default: false)
* @param {<<api-param-type-string,`String`>>} params.taskId - Return the task with specified id (node_id:task_number)
*/
api.tasks.prototype.get = ca({
params: {
waitForCompletion: {
type: 'boolean',
name: 'wait_for_completion'
}
},
url: {
fmt: '/_tasks/<%=taskId%>',
req: {
taskId: {
type: 'string'
}
}
}
});
/**
* Perform a [tasks.list](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodes - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.actions - A comma-separated list of actions that should be returned. Leave empty to return all.
* @param {<<api-param-type-boolean,`Boolean`>>} params.detailed - Return detailed task information (default: false)
* @param {<<api-param-type-string,`String`>>} params.parentNode - Return tasks with specified parent node.
* @param {<<api-param-type-string,`String`>>} params.parentTaskId - Return tasks with specified parent task id (node_id:task_number). Set to -1 to return all.
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Wait for the matching tasks to complete (default: false)
* @param {<<api-param-type-string,`String`>>} [params.groupBy=nodes] - Group tasks by nodes or parent/child relationships
*/
api.tasks.prototype.list = ca({
params: {
nodes: {
type: 'list'
},
actions: {
type: 'list'
},
detailed: {
type: 'boolean'
},
parentNode: {
type: 'string',
name: 'parent_node'
},
parentTaskId: {
type: 'string',
name: 'parent_task_id'
},
waitForCompletion: {
type: 'boolean',
name: 'wait_for_completion'
},
groupBy: {
type: 'enum',
'default': 'nodes',
options: ['nodes', 'parents'],
name: 'group_by'
}
},
url: {
fmt: '/_tasks'
}
});
/**
* Perform a [termvectors](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/docs-termvectors.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.termStatistics - Specifies if total term frequency and document frequency should be returned.
* @param {<<api-param-type-boolean,`Boolean`>>} [params.fieldStatistics=true] - Specifies if document count, sum of document frequencies and sum of total term frequencies should be returned.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to return.
* @param {<<api-param-type-boolean,`Boolean`>>} [params.offsets=true] - Specifies if term offsets should be returned.
* @param {<<api-param-type-boolean,`Boolean`>>} [params.positions=true] - Specifies if term positions should be returned.
* @param {<<api-param-type-boolean,`Boolean`>>} [params.payloads=true] - Specifies if term payloads should be returned.
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random).
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value.
* @param {<<api-param-type-string,`String`>>} params.parent - Parent id of documents.
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specifies if request is real-time as opposed to near-real-time (default: true).
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.index - The index in which the document resides.
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document.
* @param {<<api-param-type-string,`String`>>} params.id - The id of the document, when not specified a doc param should be supplied.
*/
api.termvectors = ca({
params: {
termStatistics: {
type: 'boolean',
'default': false,
required: false,
name: 'term_statistics'
},
fieldStatistics: {
type: 'boolean',
'default': true,
required: false,
name: 'field_statistics'
},
fields: {
type: 'list',
required: false
},
offsets: {
type: 'boolean',
'default': true,
required: false
},
positions: {
type: 'boolean',
'default': true,
required: false
},
payloads: {
type: 'boolean',
'default': true,
required: false
},
preference: {
type: 'string',
required: false
},
routing: {
type: 'string',
required: false
},
parent: {
type: 'string',
required: false
},
realtime: {
type: 'boolean',
required: false
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/<%=id%>/_termvectors',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/<%=type%>/_termvectors',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}],
method: 'POST'
});
/**
* Perform a [update](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/docs-update.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the update operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to return in the response
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-string,`String`>>} params.lang - The script language (default: painless)
* @param {<<api-param-type-string,`String`>>} params.parent - ID of the parent document. Is is only used for routing and when for the upsert request
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the effected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-number,`Number`>>} params.retryOnConflict - Specify how many times should the operation be retried when a conflict occurs (default: 0)
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - Document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.update = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
fields: {
type: 'list'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
lang: {
type: 'string'
},
parent: {
type: 'string'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
retryOnConflict: {
type: 'number',
name: 'retry_on_conflict'
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_update',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [updateByQuery](https://www.elastic.co/guide/en/elasticsearch/reference/6.0/docs-update-by-query.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-number,`Number`>>} params.from - Starting offset (default: 0)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.conflicts=abort] - What to do when the update by query hits version conflicts?
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-string,`String`>>} params.pipeline - Ingest pipeline to set on index requests made by this action. (default: none)
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-duration-string,`DurationString`>>} params.searchTimeout - Explicit timeout for each search request. Defaults to no timeout.
* @param {<<api-param-type-number,`Number`>>} params.size - Number of hits to return (default: 10)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.sort - A comma-separated list of <field>:<direction> pairs
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.terminateAfter - The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.stats - Specific 'tag' of the request for logging and statistical purposes
* @param {<<api-param-type-boolean,`Boolean`>>} params.version - Specify whether to return document version as part of a hit
* @param {<<api-param-type-boolean,`Boolean`>>} params.versionType - Should the document increment the version number (internal) on hit or not (reindex)
* @param {<<api-param-type-boolean,`Boolean`>>} params.requestCache - Specify if request cache should be used for this request or not, defaults to index level setting
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Should the effected indexes be refreshed?
* @param {<<api-param-type-duration-string,`DurationString`>>} [params.timeout=1m] - Time each individual bulk request should wait for shards that are unavailable.
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the update by query operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-number,`Number`>>} params.scrollSize - Size on the scroll request powering the update_by_query
* @param {<<api-param-type-boolean,`Boolean`>>} [params.waitForCompletion=true] - Should the request should block until the update by query operation is complete.
* @param {<<api-param-type-number,`Number`>>} params.requestsPerSecond - The throttle to set on this request in sub-requests per second. -1 means no throttle.
* @param {<<api-param-type-number,`Number`>>} [params.slices=1] - The number of slices this task should be divided into. Defaults to 1 meaning the task isn't sliced into subtasks.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to search; leave empty to perform the operation on all types
*/
api.updateByQuery = 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'
},
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'
},
pipeline: {
type: 'string'
},
preference: {
type: 'string'
},
q: {
type: 'string'
},
routing: {
type: 'list'
},
scroll: {
type: 'time'
},
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'
},
version: {
type: 'boolean'
},
versionType: {
type: 'boolean',
name: 'version_type'
},
requestCache: {
type: 'boolean',
name: 'request_cache'
},
refresh: {
type: 'boolean'
},
timeout: {
type: 'time',
'default': '1m'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
scrollSize: {
type: 'number',
name: 'scroll_size'
},
waitForCompletion: {
type: 'boolean',
'default': true,
name: 'wait_for_completion'
},
requestsPerSecond: {
type: 'number',
'default': 0,
name: 'requests_per_second'
},
slices: {
type: 'number',
'default': 1
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_update_by_query',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_update_by_query',
req: {
index: {
type: 'list'
}
}
}],
method: 'POST'
});
/***/ }),
/* 48 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var ca = __webpack_require__(1).makeFactoryWithModifier(function (spec) {
return __webpack_require__(0).merge(spec, {
params: {
filterPath: {
type: 'list',
name: 'filter_path'
}
}
});
});
var namespace = __webpack_require__(1).namespaceFactory;
var api = module.exports = {};
api._namespaces = ['cat', 'cluster', 'indices', 'ingest', 'nodes', 'snapshot', 'tasks'];
/**
* Perform a [bulk](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/docs-bulk.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the bulk operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the effected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.type - Default document type for items which don't provide one
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - Default comma-separated list of fields to return in the response for updates, can be overridden on each sub-request
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or default list of fields to return, can be overridden on each sub-request
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - Default list of fields to exclude from the returned _source field, can be overridden on each sub-request
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - Default list of fields to extract and return from the _source field, can be overridden on each sub-request
* @param {<<api-param-type-string,`String`>>} params.pipeline - The pipeline id to preprocess incoming documents with
* @param {<<api-param-type-string,`String`>>} params.index - Default index for items which don't provide one
*/
api.bulk = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
type: {
type: 'string'
},
fields: {
type: 'list'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
pipeline: {
type: 'string'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_bulk',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/_bulk',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_bulk'
}],
needBody: true,
bulkBody: true,
method: 'POST'
});
api.cat = namespace();
/**
* Perform a [cat.aliases](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cat.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - A comma-separated list of alias names to return
*/
api.cat.prototype.aliases = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/aliases/<%=name%>',
req: {
name: {
type: 'list'
}
}
}, {
fmt: '/_cat/aliases'
}]
});
/**
* Perform a [cat.allocation](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cat-allocation.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information
*/
api.cat.prototype.allocation = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/allocation/<%=nodeId%>',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_cat/allocation'
}]
});
/**
* Perform a [cat.count](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cat-count.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.count = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/count/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/count'
}]
});
/**
* Perform a [cat.fielddata](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cat-fielddata.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to return the fielddata size
*/
api.cat.prototype.fielddata = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
},
fields: {
type: 'list'
}
},
urls: [{
fmt: '/_cat/fielddata/<%=fields%>',
req: {
fields: {
type: 'list'
}
}
}, {
fmt: '/_cat/fielddata'
}]
});
/**
* Perform a [cat.health](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cat-health.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} [params.ts=true] - Set to false to disable timestamping
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.health = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
ts: {
type: 'boolean',
'default': true
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/health'
}
});
/**
* Perform a [cat.help](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cat.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
*/
api.cat.prototype.help = ca({
params: {
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
}
},
url: {
fmt: '/_cat'
}
});
/**
* Perform a [cat.indices](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cat-indices.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-string,`String`>>} params.health - A health status ("green", "yellow", or "red" to filter only indices matching the specified health status
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-boolean,`Boolean`>>} params.pri - Set to true to return stats only for primary shards
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.indices = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'm', 'g']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
health: {
type: 'enum',
'default': null,
options: ['green', 'yellow', 'red']
},
help: {
type: 'boolean',
'default': false
},
pri: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/indices/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/indices'
}]
});
/**
* Perform a [cat.master](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cat-master.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.master = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/master'
}
});
/**
* Perform a [cat.nodeattrs](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cat-nodeattrs.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.nodeattrs = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/nodeattrs'
}
});
/**
* Perform a [cat.nodes](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cat-nodes.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.fullId - Return the full node ID instead of the shortened version (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.nodes = ca({
params: {
format: {
type: 'string'
},
fullId: {
type: 'boolean',
name: 'full_id'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/nodes'
}
});
/**
* Perform a [cat.pendingTasks](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cat-pending-tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.pendingTasks = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/pending_tasks'
}
});
/**
* Perform a [cat.plugins](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cat-plugins.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.plugins = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/plugins'
}
});
/**
* Perform a [cat.recovery](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cat-recovery.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.recovery = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/recovery/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/recovery'
}]
});
/**
* Perform a [cat.repositories](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cat-repositories.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.repositories = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean',
'default': false
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/repositories'
}
});
/**
* Perform a [cat.segments](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cat-segments.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.segments = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/segments/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/segments'
}]
});
/**
* Perform a [cat.shards](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cat-shards.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.shards = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/shards/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/shards'
}]
});
/**
* Perform a [cat.snapshots](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cat-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Set to true to ignore unavailable snapshots
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.repository - Name of repository from which to fetch the snapshot information
*/
api.cat.prototype.snapshots = ca({
params: {
format: {
type: 'string'
},
ignoreUnavailable: {
type: 'boolean',
'default': false,
name: 'ignore_unavailable'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/snapshots/<%=repository%>',
req: {
repository: {
type: 'list'
}
}
}, {
fmt: '/_cat/snapshots'
}]
});
/**
* Perform a [cat.tasks](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.actions - A comma-separated list of actions that should be returned. Leave empty to return all.
* @param {<<api-param-type-boolean,`Boolean`>>} params.detailed - Return detailed task information (default: false)
* @param {<<api-param-type-string,`String`>>} params.parentNode - Return tasks with specified parent node.
* @param {<<api-param-type-number,`Number`>>} params.parentTask - Return tasks with specified parent task id. Set to -1 to return all.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.tasks = ca({
params: {
format: {
type: 'string'
},
nodeId: {
type: 'list',
name: 'node_id'
},
actions: {
type: 'list'
},
detailed: {
type: 'boolean'
},
parentNode: {
type: 'string',
name: 'parent_node'
},
parentTask: {
type: 'number',
name: 'parent_task'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/tasks'
}
});
/**
* Perform a [cat.templates](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cat-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>} params.name - A pattern that returned template names must match
*/
api.cat.prototype.templates = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/templates/<%=name%>',
req: {
name: {
type: 'string'
}
}
}, {
fmt: '/_cat/templates'
}]
});
/**
* Perform a [cat.threadPool](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cat-thread-pool.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.size - The multiplier in which to display values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.threadPoolPatterns - A comma-separated list of regular-expressions to filter the thread pools in the output
*/
api.cat.prototype.threadPool = ca({
params: {
format: {
type: 'string'
},
size: {
type: 'enum',
options: ['', 'k', 'm', 'g', 't', 'p']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/thread_pool/<%=threadPoolPatterns%>',
req: {
threadPoolPatterns: {
type: 'list'
}
}
}, {
fmt: '/_cat/thread_pool'
}]
});
/**
* Perform a [clearScroll](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/search-request-scroll.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.scrollId - A comma-separated list of scroll IDs to clear
*/
api.clearScroll = ca({
urls: [{
fmt: '/_search/scroll/<%=scrollId%>',
req: {
scrollId: {
type: 'list'
}
}
}, {
fmt: '/_search/scroll'
}],
paramAsBody: {
param: 'scrollId',
body: 'scroll_id'
},
method: 'DELETE'
});
api.cluster = namespace();
/**
* Perform a [cluster.allocationExplain](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cluster-allocation-explain.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeYesDecisions - Return 'YES' decisions in explanation (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDiskInfo - Return information about disk usage and shard sizes (default: false)
*/
api.cluster.prototype.allocationExplain = ca({
params: {
includeYesDecisions: {
type: 'boolean',
name: 'include_yes_decisions'
},
includeDiskInfo: {
type: 'boolean',
name: 'include_disk_info'
}
},
url: {
fmt: '/_cluster/allocation/explain'
},
method: 'POST'
});
/**
* Perform a [cluster.getSettings](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cluster-update-settings.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether to return all default clusters setting.
*/
api.cluster.prototype.getSettings = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
},
includeDefaults: {
type: 'boolean',
'default': false,
name: 'include_defaults'
}
},
url: {
fmt: '/_cluster/settings'
}
});
/**
* Perform a [cluster.health](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cluster-health.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} [params.level=cluster] - Specify the level of detail for returned information
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Wait until the specified number of shards is active
* @param {<<api-param-type-string,`String`>>} params.waitForNodes - Wait until the specified number of nodes is available
* @param {<<api-param-type-string,`String`>>} params.waitForEvents - Wait until all currently queued events with the given priority are processed
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForNoRelocatingShards - Whether to wait until there are no relocating shards in the cluster
* @param {<<api-param-type-string,`String`>>} params.waitForStatus - Wait until cluster is in a specific state
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - Limit the information returned to a specific index
*/
api.cluster.prototype.health = ca({
params: {
level: {
type: 'enum',
'default': 'cluster',
options: ['cluster', 'indices', 'shards']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
waitForNodes: {
type: 'string',
name: 'wait_for_nodes'
},
waitForEvents: {
type: 'enum',
options: ['immediate', 'urgent', 'high', 'normal', 'low', 'languid'],
name: 'wait_for_events'
},
waitForNoRelocatingShards: {
type: 'boolean',
name: 'wait_for_no_relocating_shards'
},
waitForStatus: {
type: 'enum',
'default': null,
options: ['green', 'yellow', 'red'],
name: 'wait_for_status'
}
},
urls: [{
fmt: '/_cluster/health/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cluster/health'
}]
});
/**
* Perform a [cluster.pendingTasks](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cluster-pending.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
*/
api.cluster.prototype.pendingTasks = ca({
params: {
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_cluster/pending_tasks'
}
});
/**
* Perform a [cluster.putSettings](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cluster-update-settings.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
*/
api.cluster.prototype.putSettings = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_cluster/settings'
},
method: 'PUT'
});
/**
* Perform a [cluster.remoteInfo](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cluster-remote-info.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
*/
api.cluster.prototype.remoteInfo = ca({
url: {
fmt: '/_remote/info'
}
});
/**
* Perform a [cluster.reroute](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cluster-reroute.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.dryRun - Simulate the operation only and return the resulting state
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - Return an explanation of why the commands can or cannot be executed
* @param {<<api-param-type-boolean,`Boolean`>>} params.retryFailed - Retries allocation of shards that are blocked due to too many subsequent allocation failures
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned to the specified metrics. Defaults to all but metadata
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
*/
api.cluster.prototype.reroute = ca({
params: {
dryRun: {
type: 'boolean',
name: 'dry_run'
},
explain: {
type: 'boolean'
},
retryFailed: {
type: 'boolean',
name: 'retry_failed'
},
metric: {
type: 'list',
options: ['_all', 'blocks', 'metadata', 'nodes', 'routing_table', 'master_node', 'version']
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_cluster/reroute'
},
method: 'POST'
});
/**
* Perform a [cluster.state](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cluster-state.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned to the specified metrics
*/
api.cluster.prototype.state = ca({
params: {
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/_cluster/state/<%=metric%>/<%=index%>',
req: {
metric: {
type: 'list',
options: ['_all', 'blocks', 'metadata', 'nodes', 'routing_table', 'routing_nodes', 'master_node', 'version']
},
index: {
type: 'list'
}
}
}, {
fmt: '/_cluster/state/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'blocks', 'metadata', 'nodes', 'routing_table', 'routing_nodes', 'master_node', 'version']
}
}
}, {
fmt: '/_cluster/state'
}]
});
/**
* Perform a [cluster.stats](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cluster-stats.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
*/
api.cluster.prototype.stats = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
timeout: {
type: 'time'
}
},
urls: [{
fmt: '/_cluster/stats/nodes/<%=nodeId%>',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_cluster/stats'
}]
});
/**
* Perform a [count](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/search-count.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-number,`Number`>>} params.minScore - Include only documents with a specific `_score` value in the result
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-number,`Number`>>} params.terminateAfter - The maximum count for each shard, upon reaching which the query execution will terminate early
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of indices to restrict the results
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of types to restrict the results
*/
api.count = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
minScore: {
type: 'number',
name: 'min_score'
},
preference: {
type: 'string'
},
routing: {
type: 'list'
},
q: {
type: 'string'
},
analyzer: {
type: 'string'
},
analyzeWildcard: {
type: 'boolean',
name: 'analyze_wildcard'
},
defaultOperator: {
type: 'enum',
'default': 'OR',
options: ['AND', 'OR'],
name: 'default_operator'
},
df: {
type: 'string'
},
lenient: {
type: 'boolean'
},
terminateAfter: {
type: 'number',
name: 'terminate_after'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_count',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_count',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_count'
}],
method: 'POST'
});
/**
* Perform a [countPercolate](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/search-percolate.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>} params.percolateIndex - The index to count percolate the document into. Defaults to index.
* @param {<<api-param-type-string,`String`>>} params.percolateType - The type to count percolate document into. Defaults to type.
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.index - The index of the document being count percolated.
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document being count percolated.
* @param {<<api-param-type-string,`String`>>} params.id - Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.
*/
api.countPercolate = ca({
params: {
routing: {
type: 'list'
},
preference: {
type: 'string'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
percolateIndex: {
type: 'string',
name: 'percolate_index'
},
percolateType: {
type: 'string',
name: 'percolate_type'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/<%=id%>/_percolate/count',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/<%=type%>/_percolate/count',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}],
method: 'POST'
});
/**
* Perform a [create](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/docs-index_.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the index operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>} params.parent - ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timestamp - Explicit timestamp for the document
* @param {<<api-param-type-duration-string,`DurationString`>>} params.ttl - Expiration time for the document
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.pipeline - The pipeline id to preprocess incoming documents with
* @param {<<api-param-type-string,`String`>>} params.id - Document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.create = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
parent: {
type: 'string'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
timestamp: {
type: 'time'
},
ttl: {
type: 'time'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
},
pipeline: {
type: 'string'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_create',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
needBody: true,
method: 'POST'
});
/**
* Perform a [delete](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/docs-delete.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the delete operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>} params.parent - ID of parent document
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the effected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api['delete'] = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
parent: {
type: 'string'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [deleteByQuery](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/docs-delete-by-query.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-number,`Number`>>} params.from - Starting offset (default: 0)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.conflicts=abort] - What to do when the delete-by-query hits version conflicts?
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-duration-string,`DurationString`>>} params.searchTimeout - Explicit timeout for each search request. Defaults to no timeout.
* @param {<<api-param-type-number,`Number`>>} params.size - Number of hits to return (default: 10)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.sort - A comma-separated list of <field>:<direction> pairs
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.terminateAfter - The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.stats - Specific 'tag' of the request for logging and statistical purposes
* @param {<<api-param-type-boolean,`Boolean`>>} params.version - Specify whether to return document version as part of a hit
* @param {<<api-param-type-boolean,`Boolean`>>} params.requestCache - Specify if request cache should be used for this request or not, defaults to index level setting
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Should the effected indexes be refreshed?
* @param {<<api-param-type-duration-string,`DurationString`>>} [params.timeout=1m] - Time each individual bulk request should wait for shards that are unavailable.
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the delete by query operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-number,`Number`>>} params.scrollSize - Size on the scroll request powering the update_by_query
* @param {<<api-param-type-boolean,`Boolean`>>} [params.waitForCompletion=true] - Should the request should block until the delete-by-query is complete.
* @param {<<api-param-type-number,`Number`>>} params.requestsPerSecond - The throttle for this request in sub-requests per second. -1 means no throttle.
* @param {<<api-param-type-number,`Number`>>} [params.slices=1] - The number of slices this task should be divided into. Defaults to 1 meaning the task isn't sliced into subtasks.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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'
},
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'
},
preference: {
type: 'string'
},
q: {
type: 'string'
},
routing: {
type: 'list'
},
scroll: {
type: 'time'
},
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'
},
version: {
type: 'boolean'
},
requestCache: {
type: 'boolean',
name: 'request_cache'
},
refresh: {
type: 'boolean'
},
timeout: {
type: 'time',
'default': '1m'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
scrollSize: {
type: 'number',
name: 'scroll_size'
},
waitForCompletion: {
type: 'boolean',
'default': true,
name: 'wait_for_completion'
},
requestsPerSecond: {
type: 'number',
'default': 0,
name: 'requests_per_second'
},
slices: {
type: 'number',
'default': 1
}
},
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](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/modules-scripting.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.id - Script ID
* @param {<<api-param-type-string,`String`>>} params.lang - Script language
*/
api.deleteScript = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
urls: [{
fmt: '/_scripts/<%=lang%>/<%=id%>',
req: {
lang: {
type: 'string'
},
id: {
type: 'string'
}
}
}, {
fmt: '/_scripts/<%=lang%>',
req: {
lang: {
type: 'string'
}
}
}],
method: 'DELETE'
});
/**
* Perform a [deleteTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/search-template.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.id - Template ID
*/
api.deleteTemplate = ca({
url: {
fmt: '/_search/template/<%=id%>',
req: {
id: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [exists](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/docs-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return in the response
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document (use `_all` to fetch the first document matching the ID across all types)
*/
api.exists = ca({
params: {
storedFields: {
type: 'list',
name: 'stored_fields'
},
parent: {
type: 'string'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'HEAD'
});
/**
* Perform a [existsSource](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/docs-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document; use `_all` to fetch the first document matching the ID across all types
*/
api.existsSource = ca({
params: {
parent: {
type: 'string'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_source',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'HEAD'
});
/**
* Perform a [explain](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/search-explain.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcards and prefix queries in the query string query should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer for the query string query
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The default field for query string query (default: _all)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return in the response
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.explain = ca({
params: {
analyzeWildcard: {
type: 'boolean',
name: 'analyze_wildcard'
},
analyzer: {
type: 'string'
},
defaultOperator: {
type: 'enum',
'default': 'OR',
options: ['AND', 'OR'],
name: 'default_operator'
},
df: {
type: 'string'
},
storedFields: {
type: 'list',
name: 'stored_fields'
},
lenient: {
type: 'boolean'
},
parent: {
type: 'string'
},
preference: {
type: 'string'
},
q: {
type: 'string'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_explain',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [fieldCaps](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/search-field-caps.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of field names
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.fieldCaps = ca({
params: {
fields: {
type: 'list'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_field_caps',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_field_caps'
}],
method: 'POST'
});
/**
* Perform a [fieldStats](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/search-field-stats.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields for to get field statistics for (min value, max value, and more)
* @param {<<api-param-type-string,`String`>>} [params.level=cluster] - Defines if field stats should be returned on a per index level or on a cluster wide level
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.fieldStats = ca({
params: {
fields: {
type: 'list'
},
level: {
type: 'enum',
'default': 'cluster',
options: ['indices', 'cluster']
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_field_stats',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_field_stats'
}],
method: 'POST'
});
/**
* Perform a [get](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/docs-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return in the response
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document (use `_all` to fetch the first document matching the ID across all types)
*/
api.get = ca({
params: {
storedFields: {
type: 'list',
name: 'stored_fields'
},
parent: {
type: 'string'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}
});
/**
* Perform a [getScript](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/modules-scripting.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.id - Script ID
* @param {<<api-param-type-string,`String`>>} params.lang - Script language
*/
api.getScript = ca({
urls: [{
fmt: '/_scripts/<%=lang%>/<%=id%>',
req: {
lang: {
type: 'string'
},
id: {
type: 'string'
}
}
}, {
fmt: '/_scripts/<%=lang%>',
req: {
lang: {
type: 'string'
}
}
}]
});
/**
* Perform a [getSource](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/docs-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document; use `_all` to fetch the first document matching the ID across all types
*/
api.getSource = ca({
params: {
parent: {
type: 'string'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_source',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}
});
/**
* Perform a [getTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/search-template.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.id - Template ID
*/
api.getTemplate = ca({
url: {
fmt: '/_search/template/<%=id%>',
req: {
id: {
type: 'string'
}
}
}
});
/**
* Perform a [index](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/docs-index_.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the index operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>} [params.opType=index] - Explicit operation type
* @param {<<api-param-type-string,`String`>>} params.parent - ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timestamp - Explicit timestamp for the document
* @param {<<api-param-type-duration-string,`DurationString`>>} params.ttl - Expiration time for the document
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.pipeline - The pipeline id to preprocess incoming documents with
* @param {<<api-param-type-string,`String`>>} params.id - Document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.index = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
opType: {
type: 'enum',
'default': 'index',
options: ['index', 'create'],
name: 'op_type'
},
parent: {
type: 'string'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
timestamp: {
type: 'time'
},
ttl: {
type: 'time'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
},
pipeline: {
type: 'string'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/<%=id%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/<%=type%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}],
needBody: true,
method: 'POST'
});
api.indices = namespace();
/**
* Perform a [indices.analyze](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-analyze.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.analyzer - The name of the analyzer to use
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.charFilter - A comma-separated list of character filters to use for the analysis
* @param {<<api-param-type-string,`String`>>} params.field - Use the analyzer configured for this field (instead of passing the analyzer name)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.filter - A comma-separated list of filters to use for the analysis
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index to scope the operation
* @param {<<api-param-type-boolean,`Boolean`>>} params.preferLocal - With `true`, specify that a local shard should be used if available, with `false`, use a random shard (default: true)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.text - The text on which the analysis should be performed (when request body is not used)
* @param {<<api-param-type-string,`String`>>} params.tokenizer - The name of the tokenizer to use for the analysis
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - With `true`, outputs more advanced details. (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.attributes - A comma-separated list of token attributes to output, this parameter works only with `explain=true`
* @param {<<api-param-type-string,`String`>>} [params.format=detailed] - Format of the output
*/
api.indices.prototype.analyze = ca({
params: {
analyzer: {
type: 'string'
},
charFilter: {
type: 'list',
name: 'char_filter'
},
field: {
type: 'string'
},
filter: {
type: 'list'
},
index: {
type: 'string'
},
preferLocal: {
type: 'boolean',
name: 'prefer_local'
},
text: {
type: 'list'
},
tokenizer: {
type: 'string'
},
explain: {
type: 'boolean'
},
attributes: {
type: 'list'
},
format: {
type: 'enum',
'default': 'detailed',
options: ['detailed', 'text']
}
},
urls: [{
fmt: '/<%=index%>/_analyze',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_analyze'
}],
method: 'POST'
});
/**
* Perform a [indices.clearCache](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-clearcache.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.fieldData - Clear field data
* @param {<<api-param-type-boolean,`Boolean`>>} params.fielddata - Clear field data
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to clear when using the `field_data` parameter (default: all)
* @param {<<api-param-type-boolean,`Boolean`>>} params.query - Clear query caches
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index name to limit the operation
* @param {<<api-param-type-boolean,`Boolean`>>} params.recycler - Clear the recycler cache
* @param {<<api-param-type-boolean,`Boolean`>>} params.requestCache - Clear request cache
* @param {<<api-param-type-boolean,`Boolean`>>} params.request - Clear request cache
*/
api.indices.prototype.clearCache = ca({
params: {
fieldData: {
type: 'boolean',
name: 'field_data'
},
fielddata: {
type: 'boolean'
},
fields: {
type: 'list'
},
query: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
index: {
type: 'list'
},
recycler: {
type: 'boolean'
},
requestCache: {
type: 'boolean',
name: 'request_cache'
},
request: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_cache/clear',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cache/clear'
}],
method: 'POST'
});
/**
* Perform a [indices.close](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-open-close.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma separated list of indices to close
*/
api.indices.prototype.close = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
url: {
fmt: '/<%=index%>/_close',
req: {
index: {
type: 'list'
}
}
},
method: 'POST'
});
/**
* Perform a [indices.create](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-create-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Set the number of active shards to wait for before the operation returns.
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.updateAllTypes - Whether to update the mapping for all fields with the same name across all types or not
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
*/
api.indices.prototype.create = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
updateAllTypes: {
type: 'boolean',
name: 'update_all_types'
}
},
url: {
fmt: '/<%=index%>',
req: {
index: {
type: 'string'
}
}
},
method: 'PUT'
});
/**
* Perform a [indices.delete](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-delete-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of indices to delete; use `_all` or `*` string to delete all indices
*/
api.indices.prototype['delete'] = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/<%=index%>',
req: {
index: {
type: 'list'
}
}
},
method: 'DELETE'
});
/**
* Perform a [indices.deleteAlias](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit timestamp for the document
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names (supports wildcards); use `_all` for all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - A comma-separated list of aliases to delete (supports wildcards); use `_all` to delete all aliases for the specified indices.
*/
api.indices.prototype.deleteAlias = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/<%=index%>/_alias/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'list'
}
}
},
method: 'DELETE'
});
/**
* Perform a [indices.deleteTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.name - The name of the template
*/
api.indices.prototype.deleteTemplate = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_template/<%=name%>',
req: {
name: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [indices.exists](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-exists.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Ignore unavailable indexes (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.allowNoIndices - Ignore if a wildcard expression resolves to no concrete indices (default: false)
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether wildcard expressions should get expanded to open or closed indices (default: open)
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether to return all default setting for each of the indices.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names
*/
api.indices.prototype.exists = ca({
params: {
local: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
includeDefaults: {
type: 'boolean',
'default': false,
name: 'include_defaults'
}
},
url: {
fmt: '/<%=index%>',
req: {
index: {
type: 'list'
}
}
},
method: 'HEAD'
});
/**
* Perform a [indices.existsAlias](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=all] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to filter aliases
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - A comma-separated list of alias names to return
*/
api.indices.prototype.existsAlias = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'all',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_alias/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'list'
}
}
}, {
fmt: '/_alias/<%=name%>',
req: {
name: {
type: 'list'
}
}
}],
method: 'HEAD'
});
/**
* Perform a [indices.existsTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - The comma separated names of the index templates
*/
api.indices.prototype.existsTemplate = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
local: {
type: 'boolean'
}
},
url: {
fmt: '/_template/<%=name%>',
req: {
name: {
type: 'list'
}
}
},
method: 'HEAD'
});
/**
* Perform a [indices.existsType](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-types-exists.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` to check the types across all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to check
*/
api.indices.prototype.existsType = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
url: {
fmt: '/<%=index%>/_mapping/<%=type%>',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
},
method: 'HEAD'
});
/**
* Perform a [indices.flush](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-flush.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.force - Whether a flush should be forced even if it is not necessarily needed ie. if no changes will be committed to the index. This is useful if transaction log IDs should be incremented even if no uncommitted changes are present. (This setting can be considered as internal)
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitIfOngoing - If set to true the flush operation will block until the flush can be executed if another flush operation is already executing. The default is true. If set to false the flush will be skipped iff if another flush operation is already running.
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string for all indices
*/
api.indices.prototype.flush = ca({
params: {
force: {
type: 'boolean'
},
waitIfOngoing: {
type: 'boolean',
name: 'wait_if_ongoing'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_flush',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_flush'
}],
method: 'POST'
});
/**
* Perform a [indices.flushSynced](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-synced-flush.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string for all indices
*/
api.indices.prototype.flushSynced = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_flush/synced',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_flush/synced'
}],
method: 'POST'
});
/**
* Perform a [indices.forcemerge](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-forcemerge.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flush - Specify whether the index should be flushed after performing the operation (default: true)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-number,`Number`>>} params.maxNumSegments - The number of segments the index should be merged into (default: dynamic)
* @param {<<api-param-type-boolean,`Boolean`>>} params.onlyExpungeDeletes - Specify whether the operation should only expunge deleted documents
* @param {anything} params.operationThreading - TODO: ?
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForMerge - Specify whether the request should block until the merge process is finished (default: true)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.forcemerge = ca({
params: {
flush: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
maxNumSegments: {
type: 'number',
name: 'max_num_segments'
},
onlyExpungeDeletes: {
type: 'boolean',
name: 'only_expunge_deletes'
},
operationThreading: {
name: 'operation_threading'
},
waitForMerge: {
type: 'boolean',
name: 'wait_for_merge'
}
},
urls: [{
fmt: '/<%=index%>/_forcemerge',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_forcemerge'
}],
method: 'POST'
});
/**
* Perform a [indices.get](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-get-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Ignore unavailable indexes (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.allowNoIndices - Ignore if a wildcard expression resolves to no concrete indices (default: false)
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether wildcard expressions should get expanded to open or closed indices (default: open)
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether to return all default setting for each of the indices.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.feature - A comma-separated list of features
*/
api.indices.prototype.get = ca({
params: {
local: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
includeDefaults: {
type: 'boolean',
'default': false,
name: 'include_defaults'
}
},
urls: [{
fmt: '/<%=index%>/<%=feature%>',
req: {
index: {
type: 'list'
},
feature: {
type: 'list',
options: ['_settings', '_mappings', '_aliases']
}
}
}, {
fmt: '/<%=index%>',
req: {
index: {
type: 'list'
}
}
}]
});
/**
* Perform a [indices.getAlias](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=all] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to filter aliases
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - A comma-separated list of alias names to return
*/
api.indices.prototype.getAlias = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'all',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_alias/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'list'
}
}
}, {
fmt: '/_alias/<%=name%>',
req: {
name: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_alias',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_alias'
}]
});
/**
* Perform a [indices.getFieldMapping](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-get-field-mapping.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether the default mapping values should be returned as well
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields
*/
api.indices.prototype.getFieldMapping = ca({
params: {
includeDefaults: {
type: 'boolean',
name: 'include_defaults'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_mapping/<%=type%>/field/<%=fields%>',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
},
fields: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_mapping/field/<%=fields%>',
req: {
index: {
type: 'list'
},
fields: {
type: 'list'
}
}
}, {
fmt: '/_mapping/<%=type%>/field/<%=fields%>',
req: {
type: {
type: 'list'
},
fields: {
type: 'list'
}
}
}, {
fmt: '/_mapping/field/<%=fields%>',
req: {
fields: {
type: 'list'
}
}
}]
});
/**
* Perform a [indices.getMapping](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-get-mapping.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types
*/
api.indices.prototype.getMapping = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_mapping/<%=type%>',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_mapping',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_mapping/<%=type%>',
req: {
type: {
type: 'list'
}
}
}, {
fmt: '/_mapping'
}]
});
/**
* Perform a [indices.getSettings](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-get-settings.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open,closed] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether to return all default setting for each of the indices.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - The name of the settings that should be included
*/
api.indices.prototype.getSettings = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': ['open', 'closed'],
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
local: {
type: 'boolean'
},
includeDefaults: {
type: 'boolean',
'default': false,
name: 'include_defaults'
}
},
urls: [{
fmt: '/<%=index%>/_settings/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_settings',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_settings/<%=name%>',
req: {
name: {
type: 'list'
}
}
}, {
fmt: '/_settings'
}]
});
/**
* Perform a [indices.getTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - The comma separated names of the index templates
*/
api.indices.prototype.getTemplate = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/_template/<%=name%>',
req: {
name: {
type: 'list'
}
}
}, {
fmt: '/_template'
}]
});
/**
* Perform a [indices.getUpgrade](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-upgrade.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.getUpgrade = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_upgrade',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_upgrade'
}]
});
/**
* Perform a [indices.open](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-open-close.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=closed] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma separated list of indices to open
*/
api.indices.prototype.open = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'closed',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
url: {
fmt: '/<%=index%>/_open',
req: {
index: {
type: 'list'
}
}
},
method: 'POST'
});
/**
* Perform a [indices.putAlias](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit timestamp for the document
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names the alias should point to (supports wildcards); use `_all` to perform the operation on all indices.
* @param {<<api-param-type-string,`String`>>} params.name - The name of the alias to be created or updated
*/
api.indices.prototype.putAlias = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/<%=index%>/_alias/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'string'
}
}
},
method: 'PUT'
});
/**
* Perform a [indices.putMapping](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-put-mapping.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.updateAllTypes - Whether to update the mapping for all fields with the same name across all types or not
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices.
* @param {<<api-param-type-string,`String`>>} params.type - The name of the document type
*/
api.indices.prototype.putMapping = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
updateAllTypes: {
type: 'boolean',
name: 'update_all_types'
}
},
urls: [{
fmt: '/<%=index%>/_mapping/<%=type%>',
req: {
index: {
type: 'list'
},
type: {
type: 'string'
}
}
}, {
fmt: '/_mapping/<%=type%>',
req: {
type: {
type: 'string'
}
}
}],
needBody: true,
method: 'PUT'
});
/**
* Perform a [indices.putSettings](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-update-settings.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.preserveExisting - Whether to update existing settings. If set to `true` existing settings on an index remain unchanged, the default is `false`
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.putSettings = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
preserveExisting: {
type: 'boolean',
name: 'preserve_existing'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
}
},
urls: [{
fmt: '/<%=index%>/_settings',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_settings'
}],
needBody: true,
method: 'PUT'
});
/**
* Perform a [indices.putTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-number,`Number`>>} params.order - The order for this template when merging multiple matching ones (higher numbers are merged later, overriding the lower numbers)
* @param {<<api-param-type-boolean,`Boolean`>>} params.create - Whether the index template should only be added if new or can also replace an existing one
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-string,`String`>>} params.name - The name of the template
*/
api.indices.prototype.putTemplate = ca({
params: {
order: {
type: 'number'
},
create: {
type: 'boolean',
'default': false
},
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
}
},
url: {
fmt: '/_template/<%=name%>',
req: {
name: {
type: 'string'
}
}
},
needBody: true,
method: 'PUT'
});
/**
* Perform a [indices.recovery](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-recovery.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.detailed - Whether to display detailed information about shard recovery
* @param {<<api-param-type-boolean,`Boolean`>>} params.activeOnly - Display only those recoveries that are currently on-going
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.recovery = ca({
params: {
detailed: {
type: 'boolean',
'default': false
},
activeOnly: {
type: 'boolean',
'default': false,
name: 'active_only'
}
},
urls: [{
fmt: '/<%=index%>/_recovery',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_recovery'
}]
});
/**
* Perform a [indices.refresh](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-refresh.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.refresh = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_refresh',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_refresh'
}],
method: 'POST'
});
/**
* Perform a [indices.rollover](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-rollover-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.dryRun - If set to true the rollover action will only be validated but not actually performed even if a condition matches. The default is false
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Set the number of active shards to wait for on the newly created rollover index before the operation returns.
* @param {<<api-param-type-string,`String`>>} params.alias - The name of the alias to rollover
* @param {<<api-param-type-string,`String`>>} params.newIndex - The name of the rollover index
*/
api.indices.prototype.rollover = ca({
params: {
timeout: {
type: 'time'
},
dryRun: {
type: 'boolean',
name: 'dry_run'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
}
},
urls: [{
fmt: '/<%=alias%>/_rollover/<%=newIndex%>',
req: {
alias: {
type: 'string'
},
newIndex: {
type: 'string'
}
}
}, {
fmt: '/<%=alias%>/_rollover',
req: {
alias: {
type: 'string'
}
}
}],
method: 'POST'
});
/**
* Perform a [indices.segments](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-segments.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {anything} params.operationThreading - TODO: ?
* @param {<<api-param-type-boolean,`Boolean`>>} params.verbose - Includes detailed memory usage by Lucene.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.segments = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
operationThreading: {
name: 'operation_threading'
},
verbose: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/<%=index%>/_segments',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_segments'
}]
});
/**
* Perform a [indices.shardStores](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-shards-stores.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.status - A comma-separated list of statuses used to filter on shards to get store information for
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {anything} params.operationThreading - TODO: ?
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.shardStores = ca({
params: {
status: {
type: 'list',
options: ['green', 'yellow', 'red', 'all']
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
operationThreading: {
name: 'operation_threading'
}
},
urls: [{
fmt: '/<%=index%>/_shard_stores',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_shard_stores'
}]
});
/**
* Perform a [indices.shrink](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-shrink-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Set the number of active shards to wait for on the shrunken index before the operation returns.
* @param {<<api-param-type-string,`String`>>} params.index - The name of the source index to shrink
* @param {<<api-param-type-string,`String`>>} params.target - The name of the target index to shrink into
*/
api.indices.prototype.shrink = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
}
},
url: {
fmt: '/<%=index%>/_shrink/<%=target%>',
req: {
index: {
type: 'string'
},
target: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [indices.stats](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-stats.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.completionFields - A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fielddataFields - A comma-separated list of fields for `fielddata` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.groups - A comma-separated list of search groups for `search` index metric
* @param {<<api-param-type-string,`String`>>} [params.level=indices] - Return stats aggregated at cluster, index or shard level
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.types - A comma-separated list of document types for the `indexing` index metric
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeSegmentFileSizes - Whether to report the aggregated disk usage of each one of the Lucene index files (only applies if segment stats are requested)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned the specific metrics.
*/
api.indices.prototype.stats = ca({
params: {
completionFields: {
type: 'list',
name: 'completion_fields'
},
fielddataFields: {
type: 'list',
name: 'fielddata_fields'
},
fields: {
type: 'list'
},
groups: {
type: 'list'
},
level: {
type: 'enum',
'default': 'indices',
options: ['cluster', 'indices', 'shards']
},
types: {
type: 'list'
},
includeSegmentFileSizes: {
type: 'boolean',
'default': false,
name: 'include_segment_file_sizes'
}
},
urls: [{
fmt: '/<%=index%>/_stats/<%=metric%>',
req: {
index: {
type: 'list'
},
metric: {
type: 'list',
options: ['_all', 'completion', 'docs', 'fielddata', 'query_cache', 'flush', 'get', 'indexing', 'merge', 'percolate', 'request_cache', 'refresh', 'search', 'segments', 'store', 'warmer', 'suggest']
}
}
}, {
fmt: '/_stats/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'completion', 'docs', 'fielddata', 'query_cache', 'flush', 'get', 'indexing', 'merge', 'percolate', 'request_cache', 'refresh', 'search', 'segments', 'store', 'warmer', 'suggest']
}
}
}, {
fmt: '/<%=index%>/_stats',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_stats'
}]
});
/**
* Perform a [indices.updateAliases](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Request timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
*/
api.indices.prototype.updateAliases = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_aliases'
},
needBody: true,
method: 'POST'
});
/**
* Perform a [indices.upgrade](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/indices-upgrade.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Specify whether the request should block until the all segments are upgraded (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.onlyAncientSegments - If true, only ancient (an older Lucene major release) segments will be upgraded
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.upgrade = ca({
params: {
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
waitForCompletion: {
type: 'boolean',
name: 'wait_for_completion'
},
onlyAncientSegments: {
type: 'boolean',
name: 'only_ancient_segments'
}
},
urls: [{
fmt: '/<%=index%>/_upgrade',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_upgrade'
}],
method: 'POST'
});
/**
* Perform a [indices.validateQuery](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/search-validate.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - Return detailed information about the error
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {anything} params.operationThreading - TODO: ?
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-boolean,`Boolean`>>} params.rewrite - Provide a more detailed explanation showing the actual Lucene query that will be executed.
* @param {<<api-param-type-boolean,`Boolean`>>} params.allShards - Execute validation on all shards instead of one random shard per index
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types
*/
api.indices.prototype.validateQuery = ca({
params: {
explain: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
operationThreading: {
name: 'operation_threading'
},
q: {
type: 'string'
},
analyzer: {
type: 'string'
},
analyzeWildcard: {
type: 'boolean',
name: 'analyze_wildcard'
},
defaultOperator: {
type: 'enum',
'default': 'OR',
options: ['AND', 'OR'],
name: 'default_operator'
},
df: {
type: 'string'
},
lenient: {
type: 'boolean'
},
rewrite: {
type: 'boolean'
},
allShards: {
type: 'boolean',
name: 'all_shards'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_validate/query',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_validate/query',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_validate/query'
}],
method: 'POST'
});
/**
* Perform a [info](https://www.elastic.co/guide/) request
*
* @param {Object} params - An object with parameters used to carry out this action
*/
api.info = ca({
url: {
fmt: '/'
}
});
api.ingest = namespace();
/**
* Perform a [ingest.deletePipeline](https://www.elastic.co/guide/en/elasticsearch/plugins/5.6/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.id - Pipeline ID
*/
api.ingest.prototype.deletePipeline = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_ingest/pipeline/<%=id%>',
req: {
id: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [ingest.getPipeline](https://www.elastic.co/guide/en/elasticsearch/plugins/5.6/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>} params.id - Comma separated list of pipeline ids. Wildcards supported
*/
api.ingest.prototype.getPipeline = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
urls: [{
fmt: '/_ingest/pipeline/<%=id%>',
req: {
id: {
type: 'string'
}
}
}, {
fmt: '/_ingest/pipeline'
}]
});
/**
* Perform a [ingest.processorGrok](https://www.elastic.co/guide/en/elasticsearch/plugins/5.6/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
*/
api.ingest.prototype.processorGrok = ca({
url: {
fmt: '/_ingest/processor/grok'
}
});
/**
* Perform a [ingest.putPipeline](https://www.elastic.co/guide/en/elasticsearch/plugins/5.6/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.id - Pipeline ID
*/
api.ingest.prototype.putPipeline = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_ingest/pipeline/<%=id%>',
req: {
id: {
type: 'string'
}
}
},
needBody: true,
method: 'PUT'
});
/**
* Perform a [ingest.simulate](https://www.elastic.co/guide/en/elasticsearch/plugins/5.6/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.verbose - Verbose mode. Display data output for each processor in executed pipeline
* @param {<<api-param-type-string,`String`>>} params.id - Pipeline ID
*/
api.ingest.prototype.simulate = ca({
params: {
verbose: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_ingest/pipeline/<%=id%>/_simulate',
req: {
id: {
type: 'string'
}
}
}, {
fmt: '/_ingest/pipeline/_simulate'
}],
needBody: true,
method: 'POST'
});
/**
* Perform a [mget](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/docs-multi-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return in the response
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.mget = ca({
params: {
storedFields: {
type: 'list',
name: 'stored_fields'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_mget',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/_mget',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_mget'
}],
needBody: true,
method: 'POST'
});
/**
* Perform a [mpercolate](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/search-percolate.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>} params.index - The index of the document being count percolated to use as default
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document being percolated to use as default.
*/
api.mpercolate = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_mpercolate',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/_mpercolate',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_mpercolate'
}],
needBody: true,
bulkBody: true,
method: 'POST'
});
/**
* Perform a [msearch](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/search-multi-search.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-number,`Number`>>} params.maxConcurrentSearches - Controls the maximum number of concurrent searches the multi search api will execute
* @param {<<api-param-type-boolean,`Boolean`>>} params.typedKeys - Specify whether aggregation and suggester names should be prefixed by their respective types in the response
* @param {<<api-param-type-number,`Number`>>} [params.preFilterShardSize=128] - A threshold that enforces a pre-filter roundtrip to prefilter search shards based on query rewriting if the number of shards the search request expands to exceeds the threshold. This filter roundtrip can limit the number of shards significantly if for instance a shard can not match any documents based on it's rewrite method ie. if date filters are mandatory to match but the shard bounds and the query are disjoint.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to use as default
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to use as default
*/
api.msearch = ca({
params: {
searchType: {
type: 'enum',
options: ['query_then_fetch', 'query_and_fetch', 'dfs_query_then_fetch', 'dfs_query_and_fetch'],
name: 'search_type'
},
maxConcurrentSearches: {
type: 'number',
name: 'max_concurrent_searches'
},
typedKeys: {
type: 'boolean',
name: 'typed_keys'
},
preFilterShardSize: {
type: 'number',
'default': 128,
name: 'pre_filter_shard_size'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_msearch',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_msearch',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_msearch'
}],
needBody: true,
bulkBody: true,
method: 'POST'
});
/**
* Perform a [msearchTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/search-template.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-boolean,`Boolean`>>} params.typedKeys - Specify whether aggregation and suggester names should be prefixed by their respective types in the response
* @param {<<api-param-type-number,`Number`>>} params.maxConcurrentSearches - Controls the maximum number of concurrent searches the multi search api will execute
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to use as default
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to use as default
*/
api.msearchTemplate = ca({
params: {
searchType: {
type: 'enum',
options: ['query_then_fetch', 'query_and_fetch', 'dfs_query_then_fetch', 'dfs_query_and_fetch'],
name: 'search_type'
},
typedKeys: {
type: 'boolean',
name: 'typed_keys'
},
maxConcurrentSearches: {
type: 'number',
name: 'max_concurrent_searches'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_msearch/template',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_msearch/template',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_msearch/template'
}],
needBody: true,
bulkBody: true,
method: 'POST'
});
/**
* Perform a [mtermvectors](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/docs-multi-termvectors.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.ids - A comma-separated list of documents ids. You must define ids as parameter or set "ids" or "docs" in the request body
* @param {<<api-param-type-boolean,`Boolean`>>} params.termStatistics - Specifies if total term frequency and document frequency should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} [params.fieldStatistics=true] - Specifies if document count, sum of document frequencies and sum of total term frequencies should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to return. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} [params.offsets=true] - Specifies if term offsets should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} [params.positions=true] - Specifies if term positions should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} [params.payloads=true] - Specifies if term payloads should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random) .Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-string,`String`>>} params.parent - Parent id of documents. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specifies if requests are real-time as opposed to near-real-time (default: true).
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.index - The index in which the document resides.
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document.
*/
api.mtermvectors = ca({
params: {
ids: {
type: 'list',
required: false
},
termStatistics: {
type: 'boolean',
'default': false,
required: false,
name: 'term_statistics'
},
fieldStatistics: {
type: 'boolean',
'default': true,
required: false,
name: 'field_statistics'
},
fields: {
type: 'list',
required: false
},
offsets: {
type: 'boolean',
'default': true,
required: false
},
positions: {
type: 'boolean',
'default': true,
required: false
},
payloads: {
type: 'boolean',
'default': true,
required: false
},
preference: {
type: 'string',
required: false
},
routing: {
type: 'string',
required: false
},
parent: {
type: 'string',
required: false
},
realtime: {
type: 'boolean',
required: false
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_mtermvectors',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/_mtermvectors',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_mtermvectors'
}],
method: 'POST'
});
api.nodes = namespace();
/**
* Perform a [nodes.hotThreads](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cluster-nodes-hot-threads.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.interval - The interval for the second sampling of threads
* @param {<<api-param-type-number,`Number`>>} params.snapshots - Number of samples of thread stacktrace (default: 10)
* @param {<<api-param-type-number,`Number`>>} params.threads - Specify the number of threads to provide information for (default: 3)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreIdleThreads - Don't show threads that are in known-idle places, such as waiting on a socket select or pulling from an empty task queue (default: true)
* @param {<<api-param-type-string,`String`>>} params.type - The type to sample (default: cpu)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
*/
api.nodes.prototype.hotThreads = ca({
params: {
interval: {
type: 'time'
},
snapshots: {
type: 'number'
},
threads: {
type: 'number'
},
ignoreIdleThreads: {
type: 'boolean',
name: 'ignore_idle_threads'
},
type: {
type: 'enum',
options: ['cpu', 'wait', 'block']
},
timeout: {
type: 'time'
}
},
urls: [{
fmt: '/_nodes/<%=nodeId%>/hotthreads',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_nodes/hotthreads'
}]
});
/**
* Perform a [nodes.info](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cluster-nodes-info.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - A comma-separated list of metrics you wish returned. Leave empty to return all.
*/
api.nodes.prototype.info = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
timeout: {
type: 'time'
}
},
urls: [{
fmt: '/_nodes/<%=nodeId%>/<%=metric%>',
req: {
nodeId: {
type: 'list'
},
metric: {
type: 'list',
options: ['settings', 'os', 'process', 'jvm', 'thread_pool', 'transport', 'http', 'plugins', 'ingest']
}
}
}, {
fmt: '/_nodes/<%=nodeId%>',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_nodes/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['settings', 'os', 'process', 'jvm', 'thread_pool', 'transport', 'http', 'plugins', 'ingest']
}
}
}, {
fmt: '/_nodes'
}]
});
/**
* Perform a [nodes.stats](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/cluster-nodes-stats.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.completionFields - A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fielddataFields - A comma-separated list of fields for `fielddata` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards)
* @param {<<api-param-type-boolean,`Boolean`>>} params.groups - A comma-separated list of search groups for `search` index metric
* @param {<<api-param-type-string,`String`>>} [params.level=node] - Return indices stats aggregated at index, node or shard level
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.types - A comma-separated list of document types for the `indexing` index metric
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeSegmentFileSizes - Whether to report the aggregated disk usage of each one of the Lucene index files (only applies if segment stats are requested)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned to the specified metrics
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.indexMetric - Limit the information returned for `indices` metric to the specific index metrics. Isn't used if `indices` (or `all`) metric isn't specified.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
*/
api.nodes.prototype.stats = ca({
params: {
completionFields: {
type: 'list',
name: 'completion_fields'
},
fielddataFields: {
type: 'list',
name: 'fielddata_fields'
},
fields: {
type: 'list'
},
groups: {
type: 'boolean'
},
level: {
type: 'enum',
'default': 'node',
options: ['indices', 'node', 'shards']
},
types: {
type: 'list'
},
timeout: {
type: 'time'
},
includeSegmentFileSizes: {
type: 'boolean',
'default': false,
name: 'include_segment_file_sizes'
}
},
urls: [{
fmt: '/_nodes/<%=nodeId%>/stats/<%=metric%>/<%=indexMetric%>',
req: {
nodeId: {
type: 'list'
},
metric: {
type: 'list',
options: ['_all', 'breaker', 'fs', 'http', 'indices', 'jvm', 'os', 'process', 'thread_pool', 'transport', 'discovery']
},
indexMetric: {
type: 'list',
options: ['_all', 'completion', 'docs', 'fielddata', 'query_cache', 'flush', 'get', 'indexing', 'merge', 'percolate', 'request_cache', 'refresh', 'search', 'segments', 'store', 'warmer', 'suggest']
}
}
}, {
fmt: '/_nodes/<%=nodeId%>/stats/<%=metric%>',
req: {
nodeId: {
type: 'list'
},
metric: {
type: 'list',
options: ['_all', 'breaker', 'fs', 'http', 'indices', 'jvm', 'os', 'process', 'thread_pool', 'transport', 'discovery']
}
}
}, {
fmt: '/_nodes/stats/<%=metric%>/<%=indexMetric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'breaker', 'fs', 'http', 'indices', 'jvm', 'os', 'process', 'thread_pool', 'transport', 'discovery']
},
indexMetric: {
type: 'list',
options: ['_all', 'completion', 'docs', 'fielddata', 'query_cache', 'flush', 'get', 'indexing', 'merge', 'percolate', 'request_cache', 'refresh', 'search', 'segments', 'store', 'warmer', 'suggest']
}
}
}, {
fmt: '/_nodes/<%=nodeId%>/stats',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_nodes/stats/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'breaker', 'fs', 'http', 'indices', 'jvm', 'os', 'process', 'thread_pool', 'transport', 'discovery']
}
}
}, {
fmt: '/_nodes/stats'
}]
});
/**
* Perform a [percolate](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/search-percolate.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>} params.percolateIndex - The index to percolate the document into. Defaults to index.
* @param {<<api-param-type-string,`String`>>} params.percolateType - The type to percolate document into. Defaults to type.
* @param {<<api-param-type-string,`String`>>} params.percolateRouting - The routing value to use when percolating the existing document.
* @param {<<api-param-type-string,`String`>>} params.percolatePreference - Which shard to prefer when executing the percolate request.
* @param {<<api-param-type-string,`String`>>} params.percolateFormat - Return an array of matching query IDs instead of objects
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.index - The index of the document being percolated.
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document being percolated.
* @param {<<api-param-type-string,`String`>>} params.id - Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.
*/
api.percolate = ca({
params: {
routing: {
type: 'list'
},
preference: {
type: 'string'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
percolateIndex: {
type: 'string',
name: 'percolate_index'
},
percolateType: {
type: 'string',
name: 'percolate_type'
},
percolateRouting: {
type: 'string',
name: 'percolate_routing'
},
percolatePreference: {
type: 'string',
name: 'percolate_preference'
},
percolateFormat: {
type: 'enum',
options: ['ids'],
name: 'percolate_format'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/<%=id%>/_percolate',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/<%=type%>/_percolate',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}],
method: 'POST'
});
/**
* Perform a [ping](https://www.elastic.co/guide/) request
*
* @param {Object} params - An object with parameters used to carry out this action
*/
api.ping = ca({
url: {
fmt: '/'
},
requestTimeout: 3000,
method: 'HEAD'
});
/**
* Perform a [putScript](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/modules-scripting.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.id - Script ID
* @param {<<api-param-type-string,`String`>>} params.lang - Script language
*/
api.putScript = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
urls: [{
fmt: '/_scripts/<%=lang%>/<%=id%>',
req: {
lang: {
type: 'string'
},
id: {
type: 'string'
}
}
}, {
fmt: '/_scripts/<%=lang%>',
req: {
lang: {
type: 'string'
}
}
}],
needBody: true,
method: 'PUT'
});
/**
* Perform a [putTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/search-template.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.id - Template ID
*/
api.putTemplate = ca({
url: {
fmt: '/_search/template/<%=id%>',
req: {
id: {
type: 'string'
}
}
},
needBody: true,
method: 'PUT'
});
/**
* Perform a [reindex](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/docs-reindex.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Should the effected indexes be refreshed?
* @param {<<api-param-type-duration-string,`DurationString`>>} [params.timeout=1m] - Time each individual bulk request should wait for shards that are unavailable.
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the reindex operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-boolean,`Boolean`>>} [params.waitForCompletion=true] - Should the request should block until the reindex is complete.
* @param {<<api-param-type-number,`Number`>>} params.requestsPerSecond - The throttle to set on this request in sub-requests per second. -1 means no throttle.
* @param {<<api-param-type-number,`Number`>>} [params.slices=1] - The number of slices this task should be divided into. Defaults to 1 meaning the task isn't sliced into subtasks.
*/
api.reindex = ca({
params: {
refresh: {
type: 'boolean'
},
timeout: {
type: 'time',
'default': '1m'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
waitForCompletion: {
type: 'boolean',
'default': true,
name: 'wait_for_completion'
},
requestsPerSecond: {
type: 'number',
'default': 0,
name: 'requests_per_second'
},
slices: {
type: 'number',
'default': 1
}
},
url: {
fmt: '/_reindex'
},
needBody: true,
method: 'POST'
});
/**
* Perform a [reindexRethrottle](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/docs-reindex.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-number,`Number`>>} params.requestsPerSecond - The throttle to set on this request in floating sub-requests per second. -1 means set no throttle.
* @param {<<api-param-type-string,`String`>>} params.taskId - The task id to rethrottle
*/
api.reindexRethrottle = ca({
params: {
requestsPerSecond: {
type: 'number',
required: true,
name: 'requests_per_second'
}
},
url: {
fmt: '/_reindex/<%=taskId%>/_rethrottle',
req: {
taskId: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [renderSearchTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/search-template.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.id - The id of the stored search template
*/
api.renderSearchTemplate = ca({
urls: [{
fmt: '/_render/template/<%=id%>',
req: {
id: {
type: 'string'
}
}
}, {
fmt: '/_render/template'
}],
method: 'POST'
});
/**
* Perform a [scroll](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/search-request-scroll.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.scrollId - The scroll ID
*/
api.scroll = ca({
params: {
scroll: {
type: 'time'
},
scrollId: {
type: 'string',
name: 'scroll_id'
}
},
urls: [{
fmt: '/_search/scroll/<%=scrollId%>',
req: {
scrollId: {
type: 'string'
}
}
}, {
fmt: '/_search/scroll'
}],
paramAsBody: {
param: 'scrollId',
body: 'scroll_id'
},
method: 'POST'
});
/**
* Perform a [search](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/search-search.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - Specify whether to return detailed information about score computation as part of a hit
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return as part of a hit
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.docvalueFields - A comma-separated list of fields to return as the docvalue representation of a field for each hit
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fielddataFields - A comma-separated list of fields to return as the docvalue representation of a field for each hit
* @param {<<api-param-type-number,`Number`>>} params.from - Starting offset (default: 0)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-number,`Number`>>} params.size - Number of hits to return (default: 10)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.sort - A comma-separated list of <field>:<direction> pairs
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.terminateAfter - The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.stats - Specific 'tag' of the request for logging and statistical purposes
* @param {<<api-param-type-string,`String`>>} params.suggestField - Specify which field to use for suggestions
* @param {<<api-param-type-string,`String`>>} [params.suggestMode=missing] - Specify suggest mode
* @param {<<api-param-type-number,`Number`>>} params.suggestSize - How many suggestions to return in response
* @param {<<api-param-type-string,`String`>>} params.suggestText - The source text for which the suggestions should be returned
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.trackScores - Whether to calculate and return scores even if they are not used for sorting
* @param {<<api-param-type-boolean,`Boolean`>>} params.typedKeys - Specify whether aggregation and suggester names should be prefixed by their respective types in the response
* @param {<<api-param-type-boolean,`Boolean`>>} params.version - Specify whether to return document version as part of a hit
* @param {<<api-param-type-boolean,`Boolean`>>} params.requestCache - Specify if request cache should be used for this request or not, defaults to index level setting
* @param {<<api-param-type-number,`Number`>>} [params.batchedReduceSize=512] - The number of shard results that should be reduced at once on the coordinating node. This value should be used as a protection mechanism to reduce the memory overhead per search request if the potential number of shards in the request can be large.
* @param {<<api-param-type-number,`Number`>>} [params.maxConcurrentShardRequests=The default grows with the number of nodes in the cluster but is at most 256.] - The number of concurrent shard requests this search executes concurrently. This value should be used to limit the impact of the search on the cluster in order to limit the number of concurrent shard requests
* @param {<<api-param-type-number,`Number`>>} [params.preFilterShardSize=128] - A threshold that enforces a pre-filter roundtrip to prefilter search shards based on query rewriting if the number of shards the search request expands to exceeds the threshold. This filter roundtrip can limit the number of shards significantly if for instance a shard can not match any documents based on it's rewrite method ie. if date filters are mandatory to match but the shard bounds and the query are disjoint.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to search; leave empty to perform the operation on all types
*/
api.search = 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'
},
storedFields: {
type: 'list',
name: 'stored_fields'
},
docvalueFields: {
type: 'list',
name: 'docvalue_fields'
},
fielddataFields: {
type: 'list',
name: 'fielddata_fields'
},
from: {
type: 'number'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
lenient: {
type: 'boolean'
},
preference: {
type: 'string'
},
q: {
type: 'string'
},
routing: {
type: 'list'
},
scroll: {
type: 'time'
},
searchType: {
type: 'enum',
options: ['query_then_fetch', 'dfs_query_then_fetch'],
name: 'search_type'
},
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: 'string',
name: 'suggest_text'
},
timeout: {
type: 'time'
},
trackScores: {
type: 'boolean',
name: 'track_scores'
},
typedKeys: {
type: 'boolean',
name: 'typed_keys'
},
version: {
type: 'boolean'
},
requestCache: {
type: 'boolean',
name: 'request_cache'
},
batchedReduceSize: {
type: 'number',
'default': 512,
name: 'batched_reduce_size'
},
maxConcurrentShardRequests: {
type: 'number',
'default': 'The default grows with the number of nodes in the cluster but is at most 256.',
name: 'max_concurrent_shard_requests'
},
preFilterShardSize: {
type: 'number',
'default': 128,
name: 'pre_filter_shard_size'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_search',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_search',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_search'
}],
method: 'POST'
});
/**
* Perform a [searchShards](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/search-shards.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to search; leave empty to perform the operation on all types
*/
api.searchShards = ca({
params: {
preference: {
type: 'string'
},
routing: {
type: 'string'
},
local: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_search_shards',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_search_shards',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_search_shards'
}],
method: 'POST'
});
/**
* Perform a [searchTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/search-template.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - Specify whether to return detailed information about score computation as part of a hit
* @param {<<api-param-type-boolean,`Boolean`>>} params.profile - Specify whether to profile the query execution
* @param {<<api-param-type-boolean,`Boolean`>>} params.typedKeys - Specify whether aggregation and suggester names should be prefixed by their respective types in the response
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to search; leave empty to perform the operation on all types
*/
api.searchTemplate = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
preference: {
type: 'string'
},
routing: {
type: 'list'
},
scroll: {
type: 'time'
},
searchType: {
type: 'enum',
options: ['query_then_fetch', 'query_and_fetch', 'dfs_query_then_fetch', 'dfs_query_and_fetch'],
name: 'search_type'
},
explain: {
type: 'boolean'
},
profile: {
type: 'boolean'
},
typedKeys: {
type: 'boolean',
name: 'typed_keys'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_search/template',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_search/template',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_search/template'
}],
method: 'POST'
});
api.snapshot = namespace();
/**
* Perform a [snapshot.create](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Should this request wait until the operation has completed before returning
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>} params.snapshot - A snapshot name
*/
api.snapshot.prototype.create = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForCompletion: {
type: 'boolean',
'default': false,
name: 'wait_for_completion'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [snapshot.createRepository](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.verify - Whether to verify the repository after creation
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
*/
api.snapshot.prototype.createRepository = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
},
verify: {
type: 'boolean'
}
},
url: {
fmt: '/_snapshot/<%=repository%>',
req: {
repository: {
type: 'string'
}
}
},
needBody: true,
method: 'POST'
});
/**
* Perform a [snapshot.delete](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>} params.snapshot - A snapshot name
*/
api.snapshot.prototype['delete'] = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [snapshot.deleteRepository](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.repository - A comma-separated list of repository names
*/
api.snapshot.prototype.deleteRepository = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_snapshot/<%=repository%>',
req: {
repository: {
type: 'list'
}
}
},
method: 'DELETE'
});
/**
* Perform a [snapshot.get](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether to ignore unavailable snapshots, defaults to false which means a SnapshotMissingException is thrown
* @param {<<api-param-type-boolean,`Boolean`>>} params.verbose - Whether to show verbose snapshot info or only show the basic info found in the repository index blob
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.snapshot - A comma-separated list of snapshot names
*/
api.snapshot.prototype.get = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
verbose: {
type: 'boolean'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'list'
}
}
}
});
/**
* Perform a [snapshot.getRepository](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.repository - A comma-separated list of repository names
*/
api.snapshot.prototype.getRepository = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/_snapshot/<%=repository%>',
req: {
repository: {
type: 'list'
}
}
}, {
fmt: '/_snapshot'
}]
});
/**
* Perform a [snapshot.restore](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Should this request wait until the operation has completed before returning
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>} params.snapshot - A snapshot name
*/
api.snapshot.prototype.restore = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForCompletion: {
type: 'boolean',
'default': false,
name: 'wait_for_completion'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>/_restore',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [snapshot.status](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether to ignore unavailable snapshots, defaults to false which means a SnapshotMissingException is thrown
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.snapshot - A comma-separated list of snapshot names
*/
api.snapshot.prototype.status = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
}
},
urls: [{
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>/_status',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'list'
}
}
}, {
fmt: '/_snapshot/<%=repository%>/_status',
req: {
repository: {
type: 'string'
}
}
}, {
fmt: '/_snapshot/_status'
}]
});
/**
* Perform a [snapshot.verifyRepository](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
*/
api.snapshot.prototype.verifyRepository = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/_verify',
req: {
repository: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [suggest](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/search-suggesters.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices
*/
api.suggest = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
preference: {
type: 'string'
},
routing: {
type: 'string'
}
},
urls: [{
fmt: '/<%=index%>/_suggest',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_suggest'
}],
needBody: true,
method: 'POST'
});
api.tasks = namespace();
/**
* Perform a [tasks.cancel](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodes - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.actions - A comma-separated list of actions that should be cancelled. Leave empty to cancel all.
* @param {<<api-param-type-string,`String`>>} params.parentNode - Cancel tasks with specified parent node.
* @param {<<api-param-type-string,`String`>>} params.parentTaskId - Cancel tasks with specified parent task id (node_id:task_number). Set to -1 to cancel all.
* @param {<<api-param-type-string,`String`>>} params.taskId - Cancel the task with specified task id (node_id:task_number)
*/
api.tasks.prototype.cancel = ca({
params: {
nodes: {
type: 'list'
},
actions: {
type: 'list'
},
parentNode: {
type: 'string',
name: 'parent_node'
},
parentTaskId: {
type: 'string',
name: 'parent_task_id'
}
},
urls: [{
fmt: '/_tasks/<%=taskId%>/_cancel',
req: {
taskId: {
type: 'string'
}
}
}, {
fmt: '/_tasks/_cancel'
}],
method: 'POST'
});
/**
* Perform a [tasks.get](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Wait for the matching tasks to complete (default: false)
* @param {<<api-param-type-string,`String`>>} params.taskId - Return the task with specified id (node_id:task_number)
*/
api.tasks.prototype.get = ca({
params: {
waitForCompletion: {
type: 'boolean',
name: 'wait_for_completion'
}
},
url: {
fmt: '/_tasks/<%=taskId%>',
req: {
taskId: {
type: 'string'
}
}
}
});
/**
* Perform a [tasks.list](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodes - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.actions - A comma-separated list of actions that should be returned. Leave empty to return all.
* @param {<<api-param-type-boolean,`Boolean`>>} params.detailed - Return detailed task information (default: false)
* @param {<<api-param-type-string,`String`>>} params.parentNode - Return tasks with specified parent node.
* @param {<<api-param-type-string,`String`>>} params.parentTaskId - Return tasks with specified parent task id (node_id:task_number). Set to -1 to return all.
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Wait for the matching tasks to complete (default: false)
* @param {<<api-param-type-string,`String`>>} [params.groupBy=nodes] - Group tasks by nodes or parent/child relationships
*/
api.tasks.prototype.list = ca({
params: {
nodes: {
type: 'list'
},
actions: {
type: 'list'
},
detailed: {
type: 'boolean'
},
parentNode: {
type: 'string',
name: 'parent_node'
},
parentTaskId: {
type: 'string',
name: 'parent_task_id'
},
waitForCompletion: {
type: 'boolean',
name: 'wait_for_completion'
},
groupBy: {
type: 'enum',
'default': 'nodes',
options: ['nodes', 'parents'],
name: 'group_by'
}
},
url: {
fmt: '/_tasks'
}
});
/**
* Perform a [termvectors](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/docs-termvectors.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.termStatistics - Specifies if total term frequency and document frequency should be returned.
* @param {<<api-param-type-boolean,`Boolean`>>} [params.fieldStatistics=true] - Specifies if document count, sum of document frequencies and sum of total term frequencies should be returned.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to return.
* @param {<<api-param-type-boolean,`Boolean`>>} [params.offsets=true] - Specifies if term offsets should be returned.
* @param {<<api-param-type-boolean,`Boolean`>>} [params.positions=true] - Specifies if term positions should be returned.
* @param {<<api-param-type-boolean,`Boolean`>>} [params.payloads=true] - Specifies if term payloads should be returned.
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random).
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value.
* @param {<<api-param-type-string,`String`>>} params.parent - Parent id of documents.
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specifies if request is real-time as opposed to near-real-time (default: true).
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.index - The index in which the document resides.
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document.
* @param {<<api-param-type-string,`String`>>} params.id - The id of the document, when not specified a doc param should be supplied.
*/
api.termvectors = ca({
params: {
termStatistics: {
type: 'boolean',
'default': false,
required: false,
name: 'term_statistics'
},
fieldStatistics: {
type: 'boolean',
'default': true,
required: false,
name: 'field_statistics'
},
fields: {
type: 'list',
required: false
},
offsets: {
type: 'boolean',
'default': true,
required: false
},
positions: {
type: 'boolean',
'default': true,
required: false
},
payloads: {
type: 'boolean',
'default': true,
required: false
},
preference: {
type: 'string',
required: false
},
routing: {
type: 'string',
required: false
},
parent: {
type: 'string',
required: false
},
realtime: {
type: 'boolean',
required: false
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/<%=id%>/_termvectors',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/<%=type%>/_termvectors',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}],
method: 'POST'
});
/**
* Perform a [update](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/docs-update.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the update operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to return in the response
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-string,`String`>>} params.lang - The script language (default: painless)
* @param {<<api-param-type-string,`String`>>} params.parent - ID of the parent document. Is is only used for routing and when for the upsert request
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the effected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-number,`Number`>>} params.retryOnConflict - Specify how many times should the operation be retried when a conflict occurs (default: 0)
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timestamp - Explicit timestamp for the document
* @param {<<api-param-type-duration-string,`DurationString`>>} params.ttl - Expiration time for the document
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - Document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.update = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
fields: {
type: 'list'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
lang: {
type: 'string'
},
parent: {
type: 'string'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
retryOnConflict: {
type: 'number',
name: 'retry_on_conflict'
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
timestamp: {
type: 'time'
},
ttl: {
type: 'time'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_update',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [updateByQuery](https://www.elastic.co/guide/en/elasticsearch/reference/5.6/docs-update-by-query.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-number,`Number`>>} params.from - Starting offset (default: 0)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.conflicts=abort] - What to do when the update by query hits version conflicts?
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-string,`String`>>} params.pipeline - Ingest pipeline to set on index requests made by this action. (default: none)
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-duration-string,`DurationString`>>} params.searchTimeout - Explicit timeout for each search request. Defaults to no timeout.
* @param {<<api-param-type-number,`Number`>>} params.size - Number of hits to return (default: 10)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.sort - A comma-separated list of <field>:<direction> pairs
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.terminateAfter - The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.stats - Specific 'tag' of the request for logging and statistical purposes
* @param {<<api-param-type-boolean,`Boolean`>>} params.version - Specify whether to return document version as part of a hit
* @param {<<api-param-type-boolean,`Boolean`>>} params.versionType - Should the document increment the version number (internal) on hit or not (reindex)
* @param {<<api-param-type-boolean,`Boolean`>>} params.requestCache - Specify if request cache should be used for this request or not, defaults to index level setting
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Should the effected indexes be refreshed?
* @param {<<api-param-type-duration-string,`DurationString`>>} [params.timeout=1m] - Time each individual bulk request should wait for shards that are unavailable.
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the update by query operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-number,`Number`>>} params.scrollSize - Size on the scroll request powering the update_by_query
* @param {<<api-param-type-boolean,`Boolean`>>} [params.waitForCompletion=true] - Should the request should block until the update by query operation is complete.
* @param {<<api-param-type-number,`Number`>>} params.requestsPerSecond - The throttle to set on this request in sub-requests per second. -1 means no throttle.
* @param {<<api-param-type-number,`Number`>>} [params.slices=1] - The number of slices this task should be divided into. Defaults to 1 meaning the task isn't sliced into subtasks.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to search; leave empty to perform the operation on all types
*/
api.updateByQuery = 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'
},
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'
},
pipeline: {
type: 'string'
},
preference: {
type: 'string'
},
q: {
type: 'string'
},
routing: {
type: 'list'
},
scroll: {
type: 'time'
},
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'
},
version: {
type: 'boolean'
},
versionType: {
type: 'boolean',
name: 'version_type'
},
requestCache: {
type: 'boolean',
name: 'request_cache'
},
refresh: {
type: 'boolean'
},
timeout: {
type: 'time',
'default': '1m'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
scrollSize: {
type: 'number',
name: 'scroll_size'
},
waitForCompletion: {
type: 'boolean',
'default': true,
name: 'wait_for_completion'
},
requestsPerSecond: {
type: 'number',
'default': 0,
name: 'requests_per_second'
},
slices: {
type: 'number',
'default': 1
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_update_by_query',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_update_by_query',
req: {
index: {
type: 'list'
}
}
}],
method: 'POST'
});
/***/ }),
/* 49 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var ca = __webpack_require__(1).makeFactoryWithModifier(function (spec) {
return __webpack_require__(0).merge(spec, {
params: {
filterPath: {
type: 'list',
name: 'filter_path'
}
}
});
});
var namespace = __webpack_require__(1).namespaceFactory;
var api = module.exports = {};
api._namespaces = ['cat', 'cluster', 'indices', 'ingest', 'nodes', 'remote', 'snapshot', 'tasks'];
/**
* Perform a [bulk](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/docs-bulk.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the bulk operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the effected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.type - Default document type for items which don't provide one
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - Default comma-separated list of fields to return in the response for updates, can be overridden on each sub-request
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or default list of fields to return, can be overridden on each sub-request
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - Default list of fields to exclude from the returned _source field, can be overridden on each sub-request
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - Default list of fields to extract and return from the _source field, can be overridden on each sub-request
* @param {<<api-param-type-string,`String`>>} params.pipeline - The pipeline id to preprocess incoming documents with
* @param {<<api-param-type-string,`String`>>} params.index - Default index for items which don't provide one
*/
api.bulk = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
type: {
type: 'string'
},
fields: {
type: 'list'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
pipeline: {
type: 'string'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_bulk',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/_bulk',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_bulk'
}],
needBody: true,
bulkBody: true,
method: 'POST'
});
api.cat = namespace();
/**
* Perform a [cat.aliases](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cat.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - A comma-separated list of alias names to return
*/
api.cat.prototype.aliases = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/aliases/<%=name%>',
req: {
name: {
type: 'list'
}
}
}, {
fmt: '/_cat/aliases'
}]
});
/**
* Perform a [cat.allocation](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cat-allocation.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information
*/
api.cat.prototype.allocation = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/allocation/<%=nodeId%>',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_cat/allocation'
}]
});
/**
* Perform a [cat.count](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cat-count.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.count = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/count/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/count'
}]
});
/**
* Perform a [cat.fielddata](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cat-fielddata.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to return the fielddata size
*/
api.cat.prototype.fielddata = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
},
fields: {
type: 'list'
}
},
urls: [{
fmt: '/_cat/fielddata/<%=fields%>',
req: {
fields: {
type: 'list'
}
}
}, {
fmt: '/_cat/fielddata'
}]
});
/**
* Perform a [cat.health](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cat-health.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} [params.ts=true] - Set to false to disable timestamping
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.health = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
ts: {
type: 'boolean',
'default': true
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/health'
}
});
/**
* Perform a [cat.help](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cat.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
*/
api.cat.prototype.help = ca({
params: {
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
}
},
url: {
fmt: '/_cat'
}
});
/**
* Perform a [cat.indices](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cat-indices.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-string,`String`>>} params.health - A health status ("green", "yellow", or "red" to filter only indices matching the specified health status
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-boolean,`Boolean`>>} params.pri - Set to true to return stats only for primary shards
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.indices = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'm', 'g']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
health: {
type: 'enum',
'default': null,
options: ['green', 'yellow', 'red']
},
help: {
type: 'boolean',
'default': false
},
pri: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/indices/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/indices'
}]
});
/**
* Perform a [cat.master](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cat-master.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.master = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/master'
}
});
/**
* Perform a [cat.nodeattrs](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cat-nodeattrs.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.nodeattrs = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/nodeattrs'
}
});
/**
* Perform a [cat.nodes](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cat-nodes.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.fullId - Return the full node ID instead of the shortened version (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.nodes = ca({
params: {
format: {
type: 'string'
},
fullId: {
type: 'boolean',
name: 'full_id'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/nodes'
}
});
/**
* Perform a [cat.pendingTasks](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cat-pending-tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.pendingTasks = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/pending_tasks'
}
});
/**
* Perform a [cat.plugins](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cat-plugins.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.plugins = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/plugins'
}
});
/**
* Perform a [cat.recovery](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cat-recovery.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.recovery = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/recovery/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/recovery'
}]
});
/**
* Perform a [cat.repositories](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cat-repositories.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.repositories = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean',
'default': false
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/repositories'
}
});
/**
* Perform a [cat.segments](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cat-segments.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.segments = ca({
params: {
format: {
type: 'string'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/segments/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/segments'
}]
});
/**
* Perform a [cat.shards](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cat-shards.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.shards = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/shards/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/shards'
}]
});
/**
* Perform a [cat.snapshots](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cat-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Set to true to ignore unavailable snapshots
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.repository - Name of repository from which to fetch the snapshot information
*/
api.cat.prototype.snapshots = ca({
params: {
format: {
type: 'string'
},
ignoreUnavailable: {
type: 'boolean',
'default': false,
name: 'ignore_unavailable'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/snapshots/<%=repository%>',
req: {
repository: {
type: 'list'
}
}
}, {
fmt: '/_cat/snapshots'
}]
});
/**
* Perform a [cat.tasks](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.actions - A comma-separated list of actions that should be returned. Leave empty to return all.
* @param {<<api-param-type-boolean,`Boolean`>>} params.detailed - Return detailed task information (default: false)
* @param {<<api-param-type-string,`String`>>} params.parentNode - Return tasks with specified parent node.
* @param {<<api-param-type-number,`Number`>>} params.parentTask - Return tasks with specified parent task id. Set to -1 to return all.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.tasks = ca({
params: {
format: {
type: 'string'
},
nodeId: {
type: 'list',
name: 'node_id'
},
actions: {
type: 'list'
},
detailed: {
type: 'boolean'
},
parentNode: {
type: 'string',
name: 'parent_node'
},
parentTask: {
type: 'number',
name: 'parent_task'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/tasks'
}
});
/**
* Perform a [cat.templates](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cat-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>} params.name - A pattern that returned template names must match
*/
api.cat.prototype.templates = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/templates/<%=name%>',
req: {
name: {
type: 'string'
}
}
}, {
fmt: '/_cat/templates'
}]
});
/**
* Perform a [cat.threadPool](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cat-thread-pool.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.size - The multiplier in which to display values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.threadPoolPatterns - A comma-separated list of regular-expressions to filter the thread pools in the output
*/
api.cat.prototype.threadPool = ca({
params: {
format: {
type: 'string'
},
size: {
type: 'enum',
options: ['', 'k', 'm', 'g', 't', 'p']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/thread_pool/<%=threadPoolPatterns%>',
req: {
threadPoolPatterns: {
type: 'list'
}
}
}, {
fmt: '/_cat/thread_pool'
}]
});
/**
* Perform a [clearScroll](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/search-request-scroll.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.scrollId - A comma-separated list of scroll IDs to clear
*/
api.clearScroll = ca({
urls: [{
fmt: '/_search/scroll/<%=scrollId%>',
req: {
scrollId: {
type: 'list'
}
}
}, {
fmt: '/_search/scroll'
}],
paramAsBody: {
param: 'scrollId',
body: 'scroll_id'
},
method: 'DELETE'
});
api.cluster = namespace();
/**
* Perform a [cluster.allocationExplain](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cluster-allocation-explain.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeYesDecisions - Return 'YES' decisions in explanation (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDiskInfo - Return information about disk usage and shard sizes (default: false)
*/
api.cluster.prototype.allocationExplain = ca({
params: {
includeYesDecisions: {
type: 'boolean',
name: 'include_yes_decisions'
},
includeDiskInfo: {
type: 'boolean',
name: 'include_disk_info'
}
},
url: {
fmt: '/_cluster/allocation/explain'
},
method: 'POST'
});
/**
* Perform a [cluster.getSettings](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cluster-update-settings.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether to return all default clusters setting.
*/
api.cluster.prototype.getSettings = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
},
includeDefaults: {
type: 'boolean',
'default': false,
name: 'include_defaults'
}
},
url: {
fmt: '/_cluster/settings'
}
});
/**
* Perform a [cluster.health](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cluster-health.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} [params.level=cluster] - Specify the level of detail for returned information
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Wait until the specified number of shards is active
* @param {<<api-param-type-string,`String`>>} params.waitForNodes - Wait until the specified number of nodes is available
* @param {<<api-param-type-string,`String`>>} params.waitForEvents - Wait until all currently queued events with the given priority are processed
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForNoRelocatingShards - Whether to wait until there are no relocating shards in the cluster
* @param {<<api-param-type-string,`String`>>} params.waitForStatus - Wait until cluster is in a specific state
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - Limit the information returned to a specific index
*/
api.cluster.prototype.health = ca({
params: {
level: {
type: 'enum',
'default': 'cluster',
options: ['cluster', 'indices', 'shards']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
waitForNodes: {
type: 'string',
name: 'wait_for_nodes'
},
waitForEvents: {
type: 'enum',
options: ['immediate', 'urgent', 'high', 'normal', 'low', 'languid'],
name: 'wait_for_events'
},
waitForNoRelocatingShards: {
type: 'boolean',
name: 'wait_for_no_relocating_shards'
},
waitForStatus: {
type: 'enum',
'default': null,
options: ['green', 'yellow', 'red'],
name: 'wait_for_status'
}
},
urls: [{
fmt: '/_cluster/health/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cluster/health'
}]
});
/**
* Perform a [cluster.pendingTasks](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cluster-pending.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
*/
api.cluster.prototype.pendingTasks = ca({
params: {
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_cluster/pending_tasks'
}
});
/**
* Perform a [cluster.putSettings](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cluster-update-settings.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
*/
api.cluster.prototype.putSettings = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_cluster/settings'
},
method: 'PUT'
});
/**
* Perform a [cluster.reroute](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cluster-reroute.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.dryRun - Simulate the operation only and return the resulting state
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - Return an explanation of why the commands can or cannot be executed
* @param {<<api-param-type-boolean,`Boolean`>>} params.retryFailed - Retries allocation of shards that are blocked due to too many subsequent allocation failures
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned to the specified metrics. Defaults to all but metadata
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
*/
api.cluster.prototype.reroute = ca({
params: {
dryRun: {
type: 'boolean',
name: 'dry_run'
},
explain: {
type: 'boolean'
},
retryFailed: {
type: 'boolean',
name: 'retry_failed'
},
metric: {
type: 'list',
options: ['_all', 'blocks', 'metadata', 'nodes', 'routing_table', 'master_node', 'version']
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_cluster/reroute'
},
method: 'POST'
});
/**
* Perform a [cluster.state](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cluster-state.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned to the specified metrics
*/
api.cluster.prototype.state = ca({
params: {
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/_cluster/state/<%=metric%>/<%=index%>',
req: {
metric: {
type: 'list',
options: ['_all', 'blocks', 'metadata', 'nodes', 'routing_table', 'routing_nodes', 'master_node', 'version']
},
index: {
type: 'list'
}
}
}, {
fmt: '/_cluster/state/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'blocks', 'metadata', 'nodes', 'routing_table', 'routing_nodes', 'master_node', 'version']
}
}
}, {
fmt: '/_cluster/state'
}]
});
/**
* Perform a [cluster.stats](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cluster-stats.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
*/
api.cluster.prototype.stats = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
timeout: {
type: 'time'
}
},
urls: [{
fmt: '/_cluster/stats/nodes/<%=nodeId%>',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_cluster/stats'
}]
});
/**
* Perform a [count](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/search-count.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-number,`Number`>>} params.minScore - Include only documents with a specific `_score` value in the result
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of indices to restrict the results
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of types to restrict the results
*/
api.count = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
minScore: {
type: 'number',
name: 'min_score'
},
preference: {
type: 'string'
},
routing: {
type: 'string'
},
q: {
type: 'string'
},
analyzer: {
type: 'string'
},
analyzeWildcard: {
type: 'boolean',
name: 'analyze_wildcard'
},
defaultOperator: {
type: 'enum',
'default': 'OR',
options: ['AND', 'OR'],
name: 'default_operator'
},
df: {
type: 'string'
},
lenient: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_count',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_count',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_count'
}],
method: 'POST'
});
/**
* Perform a [countPercolate](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/search-percolate.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>} params.percolateIndex - The index to count percolate the document into. Defaults to index.
* @param {<<api-param-type-string,`String`>>} params.percolateType - The type to count percolate document into. Defaults to type.
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.index - The index of the document being count percolated.
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document being count percolated.
* @param {<<api-param-type-string,`String`>>} params.id - Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.
*/
api.countPercolate = ca({
params: {
routing: {
type: 'list'
},
preference: {
type: 'string'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
percolateIndex: {
type: 'string',
name: 'percolate_index'
},
percolateType: {
type: 'string',
name: 'percolate_type'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/<%=id%>/_percolate/count',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/<%=type%>/_percolate/count',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}],
method: 'POST'
});
/**
* Perform a [create](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/docs-index_.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the index operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>} params.parent - ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timestamp - Explicit timestamp for the document
* @param {<<api-param-type-duration-string,`DurationString`>>} params.ttl - Expiration time for the document
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.pipeline - The pipeline id to preprocess incoming documents with
* @param {<<api-param-type-string,`String`>>} params.id - Document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.create = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
parent: {
type: 'string'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
timestamp: {
type: 'time'
},
ttl: {
type: 'time'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
},
pipeline: {
type: 'string'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_create',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
needBody: true,
method: 'POST'
});
/**
* Perform a [delete](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/docs-delete.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the delete operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>} params.parent - ID of parent document
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the effected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api['delete'] = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
parent: {
type: 'string'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [deleteByQuery](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/docs-delete-by-query.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-number,`Number`>>} params.from - Starting offset (default: 0)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.conflicts=abort] - What to do when the delete-by-query hits version conflicts?
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-duration-string,`DurationString`>>} params.searchTimeout - Explicit timeout for each search request. Defaults to no timeout.
* @param {<<api-param-type-number,`Number`>>} params.size - Number of hits to return (default: 10)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.sort - A comma-separated list of <field>:<direction> pairs
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.terminateAfter - The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.stats - Specific 'tag' of the request for logging and statistical purposes
* @param {<<api-param-type-boolean,`Boolean`>>} params.version - Specify whether to return document version as part of a hit
* @param {<<api-param-type-boolean,`Boolean`>>} params.requestCache - Specify if request cache should be used for this request or not, defaults to index level setting
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Should the effected indexes be refreshed?
* @param {<<api-param-type-duration-string,`DurationString`>>} [params.timeout=1m] - Time each individual bulk request should wait for shards that are unavailable.
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the delete by query operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-number,`Number`>>} params.scrollSize - Size on the scroll request powering the update_by_query
* @param {<<api-param-type-boolean,`Boolean`>>} [params.waitForCompletion=true] - Should the request should block until the delete-by-query is complete.
* @param {<<api-param-type-number,`Number`>>} params.requestsPerSecond - The throttle for this request in sub-requests per second. -1 means no throttle.
* @param {<<api-param-type-number,`Number`>>} [params.slices=1] - The number of slices this task should be divided into. Defaults to 1 meaning the task isn't sliced into subtasks.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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'
},
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'
},
preference: {
type: 'string'
},
q: {
type: 'string'
},
routing: {
type: 'list'
},
scroll: {
type: 'time'
},
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'
},
version: {
type: 'boolean'
},
requestCache: {
type: 'boolean',
name: 'request_cache'
},
refresh: {
type: 'boolean'
},
timeout: {
type: 'time',
'default': '1m'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
scrollSize: {
type: 'number',
name: 'scroll_size'
},
waitForCompletion: {
type: 'boolean',
'default': true,
name: 'wait_for_completion'
},
requestsPerSecond: {
type: 'number',
'default': 0,
name: 'requests_per_second'
},
slices: {
type: 'number',
'default': 1
}
},
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](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/modules-scripting.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.id - Script ID
* @param {<<api-param-type-string,`String`>>} params.lang - Script language
*/
api.deleteScript = ca({
urls: [{
fmt: '/_scripts/<%=lang%>/<%=id%>',
req: {
lang: {
type: 'string'
},
id: {
type: 'string'
}
}
}, {
fmt: '/_scripts/<%=lang%>',
req: {
lang: {
type: 'string'
}
}
}],
method: 'DELETE'
});
/**
* Perform a [deleteTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/search-template.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.id - Template ID
*/
api.deleteTemplate = ca({
url: {
fmt: '/_search/template/<%=id%>',
req: {
id: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [exists](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/docs-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return in the response
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document (use `_all` to fetch the first document matching the ID across all types)
*/
api.exists = ca({
params: {
storedFields: {
type: 'list',
name: 'stored_fields'
},
parent: {
type: 'string'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'HEAD'
});
/**
* Perform a [existsSource](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/docs-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document; use `_all` to fetch the first document matching the ID across all types
*/
api.existsSource = ca({
params: {
parent: {
type: 'string'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_source',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'HEAD'
});
/**
* Perform a [explain](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/search-explain.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcards and prefix queries in the query string query should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer for the query string query
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The default field for query string query (default: _all)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return in the response
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.explain = ca({
params: {
analyzeWildcard: {
type: 'boolean',
name: 'analyze_wildcard'
},
analyzer: {
type: 'string'
},
defaultOperator: {
type: 'enum',
'default': 'OR',
options: ['AND', 'OR'],
name: 'default_operator'
},
df: {
type: 'string'
},
storedFields: {
type: 'list',
name: 'stored_fields'
},
lenient: {
type: 'boolean'
},
parent: {
type: 'string'
},
preference: {
type: 'string'
},
q: {
type: 'string'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_explain',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [fieldCaps](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/search-field-caps.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of field names
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.fieldCaps = ca({
params: {
fields: {
type: 'list'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_field_caps',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_field_caps'
}],
method: 'POST'
});
/**
* Perform a [fieldStats](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/search-field-stats.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields for to get field statistics for (min value, max value, and more)
* @param {<<api-param-type-string,`String`>>} [params.level=cluster] - Defines if field stats should be returned on a per index level or on a cluster wide level
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.fieldStats = ca({
params: {
fields: {
type: 'list'
},
level: {
type: 'enum',
'default': 'cluster',
options: ['indices', 'cluster']
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_field_stats',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_field_stats'
}],
method: 'POST'
});
/**
* Perform a [get](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/docs-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return in the response
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document (use `_all` to fetch the first document matching the ID across all types)
*/
api.get = ca({
params: {
storedFields: {
type: 'list',
name: 'stored_fields'
},
parent: {
type: 'string'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}
});
/**
* Perform a [getScript](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/modules-scripting.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.id - Script ID
* @param {<<api-param-type-string,`String`>>} params.lang - Script language
*/
api.getScript = ca({
urls: [{
fmt: '/_scripts/<%=lang%>/<%=id%>',
req: {
lang: {
type: 'string'
},
id: {
type: 'string'
}
}
}, {
fmt: '/_scripts/<%=lang%>',
req: {
lang: {
type: 'string'
}
}
}]
});
/**
* Perform a [getSource](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/docs-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document; use `_all` to fetch the first document matching the ID across all types
*/
api.getSource = ca({
params: {
parent: {
type: 'string'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_source',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}
});
/**
* Perform a [getTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/search-template.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.id - Template ID
*/
api.getTemplate = ca({
url: {
fmt: '/_search/template/<%=id%>',
req: {
id: {
type: 'string'
}
}
}
});
/**
* Perform a [index](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/docs-index_.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the index operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>} [params.opType=index] - Explicit operation type
* @param {<<api-param-type-string,`String`>>} params.parent - ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timestamp - Explicit timestamp for the document
* @param {<<api-param-type-duration-string,`DurationString`>>} params.ttl - Expiration time for the document
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.pipeline - The pipeline id to preprocess incoming documents with
* @param {<<api-param-type-string,`String`>>} params.id - Document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.index = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
opType: {
type: 'enum',
'default': 'index',
options: ['index', 'create'],
name: 'op_type'
},
parent: {
type: 'string'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
timestamp: {
type: 'time'
},
ttl: {
type: 'time'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
},
pipeline: {
type: 'string'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/<%=id%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/<%=type%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}],
needBody: true,
method: 'POST'
});
api.indices = namespace();
/**
* Perform a [indices.analyze](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-analyze.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.analyzer - The name of the analyzer to use
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.charFilter - A comma-separated list of character filters to use for the analysis
* @param {<<api-param-type-string,`String`>>} params.field - Use the analyzer configured for this field (instead of passing the analyzer name)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.filter - A comma-separated list of filters to use for the analysis
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index to scope the operation
* @param {<<api-param-type-boolean,`Boolean`>>} params.preferLocal - With `true`, specify that a local shard should be used if available, with `false`, use a random shard (default: true)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.text - The text on which the analysis should be performed (when request body is not used)
* @param {<<api-param-type-string,`String`>>} params.tokenizer - The name of the tokenizer to use for the analysis
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - With `true`, outputs more advanced details. (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.attributes - A comma-separated list of token attributes to output, this parameter works only with `explain=true`
* @param {<<api-param-type-string,`String`>>} [params.format=detailed] - Format of the output
*/
api.indices.prototype.analyze = ca({
params: {
analyzer: {
type: 'string'
},
charFilter: {
type: 'list',
name: 'char_filter'
},
field: {
type: 'string'
},
filter: {
type: 'list'
},
index: {
type: 'string'
},
preferLocal: {
type: 'boolean',
name: 'prefer_local'
},
text: {
type: 'list'
},
tokenizer: {
type: 'string'
},
explain: {
type: 'boolean'
},
attributes: {
type: 'list'
},
format: {
type: 'enum',
'default': 'detailed',
options: ['detailed', 'text']
}
},
urls: [{
fmt: '/<%=index%>/_analyze',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_analyze'
}],
method: 'POST'
});
/**
* Perform a [indices.clearCache](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-clearcache.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.fieldData - Clear field data
* @param {<<api-param-type-boolean,`Boolean`>>} params.fielddata - Clear field data
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to clear when using the `field_data` parameter (default: all)
* @param {<<api-param-type-boolean,`Boolean`>>} params.query - Clear query caches
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index name to limit the operation
* @param {<<api-param-type-boolean,`Boolean`>>} params.recycler - Clear the recycler cache
* @param {<<api-param-type-boolean,`Boolean`>>} params.requestCache - Clear request cache
* @param {<<api-param-type-boolean,`Boolean`>>} params.request - Clear request cache
*/
api.indices.prototype.clearCache = ca({
params: {
fieldData: {
type: 'boolean',
name: 'field_data'
},
fielddata: {
type: 'boolean'
},
fields: {
type: 'list'
},
query: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
index: {
type: 'list'
},
recycler: {
type: 'boolean'
},
requestCache: {
type: 'boolean',
name: 'request_cache'
},
request: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_cache/clear',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cache/clear'
}],
method: 'POST'
});
/**
* Perform a [indices.close](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-open-close.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma separated list of indices to close
*/
api.indices.prototype.close = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
url: {
fmt: '/<%=index%>/_close',
req: {
index: {
type: 'list'
}
}
},
method: 'POST'
});
/**
* Perform a [indices.create](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-create-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Set the number of active shards to wait for before the operation returns.
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.updateAllTypes - Whether to update the mapping for all fields with the same name across all types or not
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
*/
api.indices.prototype.create = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
updateAllTypes: {
type: 'boolean',
name: 'update_all_types'
}
},
url: {
fmt: '/<%=index%>',
req: {
index: {
type: 'string'
}
}
},
method: 'PUT'
});
/**
* Perform a [indices.delete](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-delete-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of indices to delete; use `_all` or `*` string to delete all indices
*/
api.indices.prototype['delete'] = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/<%=index%>',
req: {
index: {
type: 'list'
}
}
},
method: 'DELETE'
});
/**
* Perform a [indices.deleteAlias](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit timestamp for the document
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names (supports wildcards); use `_all` for all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - A comma-separated list of aliases to delete (supports wildcards); use `_all` to delete all aliases for the specified indices.
*/
api.indices.prototype.deleteAlias = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/<%=index%>/_alias/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'list'
}
}
},
method: 'DELETE'
});
/**
* Perform a [indices.deleteTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.name - The name of the template
*/
api.indices.prototype.deleteTemplate = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_template/<%=name%>',
req: {
name: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [indices.exists](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-exists.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Ignore unavailable indexes (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.allowNoIndices - Ignore if a wildcard expression resolves to no concrete indices (default: false)
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether wildcard expressions should get expanded to open or closed indices (default: open)
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether to return all default setting for each of the indices.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names
*/
api.indices.prototype.exists = ca({
params: {
local: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
includeDefaults: {
type: 'boolean',
'default': false,
name: 'include_defaults'
}
},
url: {
fmt: '/<%=index%>',
req: {
index: {
type: 'list'
}
}
},
method: 'HEAD'
});
/**
* Perform a [indices.existsAlias](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=all] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to filter aliases
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - A comma-separated list of alias names to return
*/
api.indices.prototype.existsAlias = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'all',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_alias/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'list'
}
}
}, {
fmt: '/_alias/<%=name%>',
req: {
name: {
type: 'list'
}
}
}],
method: 'HEAD'
});
/**
* Perform a [indices.existsTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - The comma separated names of the index templates
*/
api.indices.prototype.existsTemplate = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
local: {
type: 'boolean'
}
},
url: {
fmt: '/_template/<%=name%>',
req: {
name: {
type: 'list'
}
}
},
method: 'HEAD'
});
/**
* Perform a [indices.existsType](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-types-exists.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` to check the types across all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to check
*/
api.indices.prototype.existsType = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
url: {
fmt: '/<%=index%>/_mapping/<%=type%>',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
},
method: 'HEAD'
});
/**
* Perform a [indices.flush](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-flush.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.force - Whether a flush should be forced even if it is not necessarily needed ie. if no changes will be committed to the index. This is useful if transaction log IDs should be incremented even if no uncommitted changes are present. (This setting can be considered as internal)
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitIfOngoing - If set to true the flush operation will block until the flush can be executed if another flush operation is already executing. The default is true. If set to false the flush will be skipped iff if another flush operation is already running.
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string for all indices
*/
api.indices.prototype.flush = ca({
params: {
force: {
type: 'boolean'
},
waitIfOngoing: {
type: 'boolean',
name: 'wait_if_ongoing'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_flush',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_flush'
}],
method: 'POST'
});
/**
* Perform a [indices.flushSynced](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-synced-flush.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string for all indices
*/
api.indices.prototype.flushSynced = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_flush/synced',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_flush/synced'
}],
method: 'POST'
});
/**
* Perform a [indices.forcemerge](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-forcemerge.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flush - Specify whether the index should be flushed after performing the operation (default: true)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-number,`Number`>>} params.maxNumSegments - The number of segments the index should be merged into (default: dynamic)
* @param {<<api-param-type-boolean,`Boolean`>>} params.onlyExpungeDeletes - Specify whether the operation should only expunge deleted documents
* @param {anything} params.operationThreading - TODO: ?
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForMerge - Specify whether the request should block until the merge process is finished (default: true)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.forcemerge = ca({
params: {
flush: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
maxNumSegments: {
type: 'number',
name: 'max_num_segments'
},
onlyExpungeDeletes: {
type: 'boolean',
name: 'only_expunge_deletes'
},
operationThreading: {
name: 'operation_threading'
},
waitForMerge: {
type: 'boolean',
name: 'wait_for_merge'
}
},
urls: [{
fmt: '/<%=index%>/_forcemerge',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_forcemerge'
}],
method: 'POST'
});
/**
* Perform a [indices.get](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-get-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Ignore unavailable indexes (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.allowNoIndices - Ignore if a wildcard expression resolves to no concrete indices (default: false)
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether wildcard expressions should get expanded to open or closed indices (default: open)
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether to return all default setting for each of the indices.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.feature - A comma-separated list of features
*/
api.indices.prototype.get = ca({
params: {
local: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
includeDefaults: {
type: 'boolean',
'default': false,
name: 'include_defaults'
}
},
urls: [{
fmt: '/<%=index%>/<%=feature%>',
req: {
index: {
type: 'list'
},
feature: {
type: 'list',
options: ['_settings', '_mappings', '_aliases']
}
}
}, {
fmt: '/<%=index%>',
req: {
index: {
type: 'list'
}
}
}]
});
/**
* Perform a [indices.getAlias](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=all] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to filter aliases
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - A comma-separated list of alias names to return
*/
api.indices.prototype.getAlias = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'all',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_alias/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'list'
}
}
}, {
fmt: '/_alias/<%=name%>',
req: {
name: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_alias',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_alias'
}]
});
/**
* Perform a [indices.getFieldMapping](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-get-field-mapping.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether the default mapping values should be returned as well
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields
*/
api.indices.prototype.getFieldMapping = ca({
params: {
includeDefaults: {
type: 'boolean',
name: 'include_defaults'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_mapping/<%=type%>/field/<%=fields%>',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
},
fields: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_mapping/field/<%=fields%>',
req: {
index: {
type: 'list'
},
fields: {
type: 'list'
}
}
}, {
fmt: '/_mapping/<%=type%>/field/<%=fields%>',
req: {
type: {
type: 'list'
},
fields: {
type: 'list'
}
}
}, {
fmt: '/_mapping/field/<%=fields%>',
req: {
fields: {
type: 'list'
}
}
}]
});
/**
* Perform a [indices.getMapping](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-get-mapping.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types
*/
api.indices.prototype.getMapping = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_mapping/<%=type%>',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_mapping',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_mapping/<%=type%>',
req: {
type: {
type: 'list'
}
}
}, {
fmt: '/_mapping'
}]
});
/**
* Perform a [indices.getSettings](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-get-settings.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open,closed] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether to return all default setting for each of the indices.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - The name of the settings that should be included
*/
api.indices.prototype.getSettings = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': ['open', 'closed'],
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
local: {
type: 'boolean'
},
includeDefaults: {
type: 'boolean',
'default': false,
name: 'include_defaults'
}
},
urls: [{
fmt: '/<%=index%>/_settings/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_settings',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_settings/<%=name%>',
req: {
name: {
type: 'list'
}
}
}, {
fmt: '/_settings'
}]
});
/**
* Perform a [indices.getTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - The comma separated names of the index templates
*/
api.indices.prototype.getTemplate = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/_template/<%=name%>',
req: {
name: {
type: 'list'
}
}
}, {
fmt: '/_template'
}]
});
/**
* Perform a [indices.getUpgrade](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-upgrade.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.getUpgrade = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_upgrade',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_upgrade'
}]
});
/**
* Perform a [indices.open](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-open-close.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=closed] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma separated list of indices to open
*/
api.indices.prototype.open = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'closed',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
url: {
fmt: '/<%=index%>/_open',
req: {
index: {
type: 'list'
}
}
},
method: 'POST'
});
/**
* Perform a [indices.putAlias](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit timestamp for the document
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names the alias should point to (supports wildcards); use `_all` to perform the operation on all indices.
* @param {<<api-param-type-string,`String`>>} params.name - The name of the alias to be created or updated
*/
api.indices.prototype.putAlias = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/<%=index%>/_alias/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'string'
}
}
},
method: 'PUT'
});
/**
* Perform a [indices.putMapping](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-put-mapping.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.updateAllTypes - Whether to update the mapping for all fields with the same name across all types or not
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices.
* @param {<<api-param-type-string,`String`>>} params.type - The name of the document type
*/
api.indices.prototype.putMapping = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
updateAllTypes: {
type: 'boolean',
name: 'update_all_types'
}
},
urls: [{
fmt: '/<%=index%>/_mapping/<%=type%>',
req: {
index: {
type: 'list'
},
type: {
type: 'string'
}
}
}, {
fmt: '/_mapping/<%=type%>',
req: {
type: {
type: 'string'
}
}
}],
needBody: true,
method: 'PUT'
});
/**
* Perform a [indices.putSettings](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-update-settings.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.preserveExisting - Whether to update existing settings. If set to `true` existing settings on an index remain unchanged, the default is `false`
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.putSettings = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
preserveExisting: {
type: 'boolean',
name: 'preserve_existing'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
}
},
urls: [{
fmt: '/<%=index%>/_settings',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_settings'
}],
needBody: true,
method: 'PUT'
});
/**
* Perform a [indices.putTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-number,`Number`>>} params.order - The order for this template when merging multiple matching ones (higher numbers are merged later, overriding the lower numbers)
* @param {<<api-param-type-boolean,`Boolean`>>} params.create - Whether the index template should only be added if new or can also replace an existing one
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-string,`String`>>} params.name - The name of the template
*/
api.indices.prototype.putTemplate = ca({
params: {
order: {
type: 'number'
},
create: {
type: 'boolean',
'default': false
},
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
}
},
url: {
fmt: '/_template/<%=name%>',
req: {
name: {
type: 'string'
}
}
},
needBody: true,
method: 'PUT'
});
/**
* Perform a [indices.recovery](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-recovery.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.detailed - Whether to display detailed information about shard recovery
* @param {<<api-param-type-boolean,`Boolean`>>} params.activeOnly - Display only those recoveries that are currently on-going
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.recovery = ca({
params: {
detailed: {
type: 'boolean',
'default': false
},
activeOnly: {
type: 'boolean',
'default': false,
name: 'active_only'
}
},
urls: [{
fmt: '/<%=index%>/_recovery',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_recovery'
}]
});
/**
* Perform a [indices.refresh](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-refresh.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.refresh = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_refresh',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_refresh'
}],
method: 'POST'
});
/**
* Perform a [indices.rollover](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-rollover-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.dryRun - If set to true the rollover action will only be validated but not actually performed even if a condition matches. The default is false
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Set the number of active shards to wait for on the newly created rollover index before the operation returns.
* @param {<<api-param-type-string,`String`>>} params.alias - The name of the alias to rollover
* @param {<<api-param-type-string,`String`>>} params.newIndex - The name of the rollover index
*/
api.indices.prototype.rollover = ca({
params: {
timeout: {
type: 'time'
},
dryRun: {
type: 'boolean',
name: 'dry_run'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
}
},
urls: [{
fmt: '/<%=alias%>/_rollover/<%=newIndex%>',
req: {
alias: {
type: 'string'
},
newIndex: {
type: 'string'
}
}
}, {
fmt: '/<%=alias%>/_rollover',
req: {
alias: {
type: 'string'
}
}
}],
method: 'POST'
});
/**
* Perform a [indices.segments](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-segments.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {anything} params.operationThreading - TODO: ?
* @param {<<api-param-type-boolean,`Boolean`>>} params.verbose - Includes detailed memory usage by Lucene.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.segments = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
operationThreading: {
name: 'operation_threading'
},
verbose: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/<%=index%>/_segments',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_segments'
}]
});
/**
* Perform a [indices.shardStores](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-shards-stores.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.status - A comma-separated list of statuses used to filter on shards to get store information for
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {anything} params.operationThreading - TODO: ?
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.shardStores = ca({
params: {
status: {
type: 'list',
options: ['green', 'yellow', 'red', 'all']
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
operationThreading: {
name: 'operation_threading'
}
},
urls: [{
fmt: '/<%=index%>/_shard_stores',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_shard_stores'
}]
});
/**
* Perform a [indices.shrink](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-shrink-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Set the number of active shards to wait for on the shrunken index before the operation returns.
* @param {<<api-param-type-string,`String`>>} params.index - The name of the source index to shrink
* @param {<<api-param-type-string,`String`>>} params.target - The name of the target index to shrink into
*/
api.indices.prototype.shrink = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
}
},
url: {
fmt: '/<%=index%>/_shrink/<%=target%>',
req: {
index: {
type: 'string'
},
target: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [indices.stats](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-stats.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.completionFields - A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fielddataFields - A comma-separated list of fields for `fielddata` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.groups - A comma-separated list of search groups for `search` index metric
* @param {<<api-param-type-string,`String`>>} [params.level=indices] - Return stats aggregated at cluster, index or shard level
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.types - A comma-separated list of document types for the `indexing` index metric
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeSegmentFileSizes - Whether to report the aggregated disk usage of each one of the Lucene index files (only applies if segment stats are requested)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned the specific metrics.
*/
api.indices.prototype.stats = ca({
params: {
completionFields: {
type: 'list',
name: 'completion_fields'
},
fielddataFields: {
type: 'list',
name: 'fielddata_fields'
},
fields: {
type: 'list'
},
groups: {
type: 'list'
},
level: {
type: 'enum',
'default': 'indices',
options: ['cluster', 'indices', 'shards']
},
types: {
type: 'list'
},
includeSegmentFileSizes: {
type: 'boolean',
'default': false,
name: 'include_segment_file_sizes'
}
},
urls: [{
fmt: '/<%=index%>/_stats/<%=metric%>',
req: {
index: {
type: 'list'
},
metric: {
type: 'list',
options: ['_all', 'completion', 'docs', 'fielddata', 'query_cache', 'flush', 'get', 'indexing', 'merge', 'percolate', 'request_cache', 'refresh', 'search', 'segments', 'store', 'warmer', 'suggest']
}
}
}, {
fmt: '/_stats/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'completion', 'docs', 'fielddata', 'query_cache', 'flush', 'get', 'indexing', 'merge', 'percolate', 'request_cache', 'refresh', 'search', 'segments', 'store', 'warmer', 'suggest']
}
}
}, {
fmt: '/<%=index%>/_stats',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_stats'
}]
});
/**
* Perform a [indices.updateAliases](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Request timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
*/
api.indices.prototype.updateAliases = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_aliases'
},
needBody: true,
method: 'POST'
});
/**
* Perform a [indices.upgrade](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/indices-upgrade.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Specify whether the request should block until the all segments are upgraded (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.onlyAncientSegments - If true, only ancient (an older Lucene major release) segments will be upgraded
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.upgrade = ca({
params: {
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
waitForCompletion: {
type: 'boolean',
name: 'wait_for_completion'
},
onlyAncientSegments: {
type: 'boolean',
name: 'only_ancient_segments'
}
},
urls: [{
fmt: '/<%=index%>/_upgrade',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_upgrade'
}],
method: 'POST'
});
/**
* Perform a [indices.validateQuery](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/search-validate.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - Return detailed information about the error
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {anything} params.operationThreading - TODO: ?
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-boolean,`Boolean`>>} params.rewrite - Provide a more detailed explanation showing the actual Lucene query that will be executed.
* @param {<<api-param-type-boolean,`Boolean`>>} params.allShards - Execute validation on all shards instead of one random shard per index
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types
*/
api.indices.prototype.validateQuery = ca({
params: {
explain: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
operationThreading: {
name: 'operation_threading'
},
q: {
type: 'string'
},
analyzer: {
type: 'string'
},
analyzeWildcard: {
type: 'boolean',
name: 'analyze_wildcard'
},
defaultOperator: {
type: 'enum',
'default': 'OR',
options: ['AND', 'OR'],
name: 'default_operator'
},
df: {
type: 'string'
},
lenient: {
type: 'boolean'
},
rewrite: {
type: 'boolean'
},
allShards: {
type: 'boolean',
name: 'all_shards'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_validate/query',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_validate/query',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_validate/query'
}],
method: 'POST'
});
/**
* Perform a [info](https://www.elastic.co/guide/) request
*
* @param {Object} params - An object with parameters used to carry out this action
*/
api.info = ca({
url: {
fmt: '/'
}
});
api.ingest = namespace();
/**
* Perform a [ingest.deletePipeline](https://www.elastic.co/guide/en/elasticsearch/plugins/5.5/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.id - Pipeline ID
*/
api.ingest.prototype.deletePipeline = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_ingest/pipeline/<%=id%>',
req: {
id: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [ingest.getPipeline](https://www.elastic.co/guide/en/elasticsearch/plugins/5.5/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>} params.id - Comma separated list of pipeline ids. Wildcards supported
*/
api.ingest.prototype.getPipeline = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
urls: [{
fmt: '/_ingest/pipeline/<%=id%>',
req: {
id: {
type: 'string'
}
}
}, {
fmt: '/_ingest/pipeline'
}]
});
/**
* Perform a [ingest.putPipeline](https://www.elastic.co/guide/en/elasticsearch/plugins/5.5/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.id - Pipeline ID
*/
api.ingest.prototype.putPipeline = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_ingest/pipeline/<%=id%>',
req: {
id: {
type: 'string'
}
}
},
needBody: true,
method: 'PUT'
});
/**
* Perform a [ingest.simulate](https://www.elastic.co/guide/en/elasticsearch/plugins/5.5/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.verbose - Verbose mode. Display data output for each processor in executed pipeline
* @param {<<api-param-type-string,`String`>>} params.id - Pipeline ID
*/
api.ingest.prototype.simulate = ca({
params: {
verbose: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_ingest/pipeline/<%=id%>/_simulate',
req: {
id: {
type: 'string'
}
}
}, {
fmt: '/_ingest/pipeline/_simulate'
}],
needBody: true,
method: 'POST'
});
/**
* Perform a [mget](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/docs-multi-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return in the response
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.mget = ca({
params: {
storedFields: {
type: 'list',
name: 'stored_fields'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_mget',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/_mget',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_mget'
}],
needBody: true,
method: 'POST'
});
/**
* Perform a [mpercolate](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/search-percolate.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>} params.index - The index of the document being count percolated to use as default
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document being percolated to use as default.
*/
api.mpercolate = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_mpercolate',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/_mpercolate',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_mpercolate'
}],
needBody: true,
bulkBody: true,
method: 'POST'
});
/**
* Perform a [msearch](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/search-multi-search.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-number,`Number`>>} params.maxConcurrentSearches - Controls the maximum number of concurrent searches the multi search api will execute
* @param {<<api-param-type-boolean,`Boolean`>>} params.typedKeys - Specify whether aggregation and suggester names should be prefixed by their respective types in the response
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to use as default
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to use as default
*/
api.msearch = ca({
params: {
searchType: {
type: 'enum',
options: ['query_then_fetch', 'query_and_fetch', 'dfs_query_then_fetch', 'dfs_query_and_fetch'],
name: 'search_type'
},
maxConcurrentSearches: {
type: 'number',
name: 'max_concurrent_searches'
},
typedKeys: {
type: 'boolean',
name: 'typed_keys'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_msearch',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_msearch',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_msearch'
}],
needBody: true,
bulkBody: true,
method: 'POST'
});
/**
* Perform a [msearchTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/search-template.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-boolean,`Boolean`>>} params.typedKeys - Specify whether aggregation and suggester names should be prefixed by their respective types in the response
* @param {<<api-param-type-number,`Number`>>} params.maxConcurrentSearches - Controls the maximum number of concurrent searches the multi search api will execute
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to use as default
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to use as default
*/
api.msearchTemplate = ca({
params: {
searchType: {
type: 'enum',
options: ['query_then_fetch', 'query_and_fetch', 'dfs_query_then_fetch', 'dfs_query_and_fetch'],
name: 'search_type'
},
typedKeys: {
type: 'boolean',
name: 'typed_keys'
},
maxConcurrentSearches: {
type: 'number',
name: 'max_concurrent_searches'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_msearch/template',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_msearch/template',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_msearch/template'
}],
needBody: true,
bulkBody: true,
method: 'POST'
});
/**
* Perform a [mtermvectors](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/docs-multi-termvectors.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.ids - A comma-separated list of documents ids. You must define ids as parameter or set "ids" or "docs" in the request body
* @param {<<api-param-type-boolean,`Boolean`>>} params.termStatistics - Specifies if total term frequency and document frequency should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} [params.fieldStatistics=true] - Specifies if document count, sum of document frequencies and sum of total term frequencies should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to return. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} [params.offsets=true] - Specifies if term offsets should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} [params.positions=true] - Specifies if term positions should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} [params.payloads=true] - Specifies if term payloads should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random) .Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-string,`String`>>} params.parent - Parent id of documents. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specifies if requests are real-time as opposed to near-real-time (default: true).
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.index - The index in which the document resides.
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document.
*/
api.mtermvectors = ca({
params: {
ids: {
type: 'list',
required: false
},
termStatistics: {
type: 'boolean',
'default': false,
required: false,
name: 'term_statistics'
},
fieldStatistics: {
type: 'boolean',
'default': true,
required: false,
name: 'field_statistics'
},
fields: {
type: 'list',
required: false
},
offsets: {
type: 'boolean',
'default': true,
required: false
},
positions: {
type: 'boolean',
'default': true,
required: false
},
payloads: {
type: 'boolean',
'default': true,
required: false
},
preference: {
type: 'string',
required: false
},
routing: {
type: 'string',
required: false
},
parent: {
type: 'string',
required: false
},
realtime: {
type: 'boolean',
required: false
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_mtermvectors',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/_mtermvectors',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_mtermvectors'
}],
method: 'POST'
});
api.nodes = namespace();
/**
* Perform a [nodes.hotThreads](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cluster-nodes-hot-threads.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.interval - The interval for the second sampling of threads
* @param {<<api-param-type-number,`Number`>>} params.snapshots - Number of samples of thread stacktrace (default: 10)
* @param {<<api-param-type-number,`Number`>>} params.threads - Specify the number of threads to provide information for (default: 3)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreIdleThreads - Don't show threads that are in known-idle places, such as waiting on a socket select or pulling from an empty task queue (default: true)
* @param {<<api-param-type-string,`String`>>} params.type - The type to sample (default: cpu)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
*/
api.nodes.prototype.hotThreads = ca({
params: {
interval: {
type: 'time'
},
snapshots: {
type: 'number'
},
threads: {
type: 'number'
},
ignoreIdleThreads: {
type: 'boolean',
name: 'ignore_idle_threads'
},
type: {
type: 'enum',
options: ['cpu', 'wait', 'block']
},
timeout: {
type: 'time'
}
},
urls: [{
fmt: '/_nodes/<%=nodeId%>/hotthreads',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_nodes/hotthreads'
}]
});
/**
* Perform a [nodes.info](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cluster-nodes-info.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - A comma-separated list of metrics you wish returned. Leave empty to return all.
*/
api.nodes.prototype.info = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
timeout: {
type: 'time'
}
},
urls: [{
fmt: '/_nodes/<%=nodeId%>/<%=metric%>',
req: {
nodeId: {
type: 'list'
},
metric: {
type: 'list',
options: ['settings', 'os', 'process', 'jvm', 'thread_pool', 'transport', 'http', 'plugins', 'ingest']
}
}
}, {
fmt: '/_nodes/<%=nodeId%>',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_nodes/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['settings', 'os', 'process', 'jvm', 'thread_pool', 'transport', 'http', 'plugins', 'ingest']
}
}
}, {
fmt: '/_nodes'
}]
});
/**
* Perform a [nodes.stats](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cluster-nodes-stats.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.completionFields - A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fielddataFields - A comma-separated list of fields for `fielddata` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards)
* @param {<<api-param-type-boolean,`Boolean`>>} params.groups - A comma-separated list of search groups for `search` index metric
* @param {<<api-param-type-string,`String`>>} [params.level=node] - Return indices stats aggregated at index, node or shard level
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.types - A comma-separated list of document types for the `indexing` index metric
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeSegmentFileSizes - Whether to report the aggregated disk usage of each one of the Lucene index files (only applies if segment stats are requested)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned to the specified metrics
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.indexMetric - Limit the information returned for `indices` metric to the specific index metrics. Isn't used if `indices` (or `all`) metric isn't specified.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
*/
api.nodes.prototype.stats = ca({
params: {
completionFields: {
type: 'list',
name: 'completion_fields'
},
fielddataFields: {
type: 'list',
name: 'fielddata_fields'
},
fields: {
type: 'list'
},
groups: {
type: 'boolean'
},
level: {
type: 'enum',
'default': 'node',
options: ['indices', 'node', 'shards']
},
types: {
type: 'list'
},
timeout: {
type: 'time'
},
includeSegmentFileSizes: {
type: 'boolean',
'default': false,
name: 'include_segment_file_sizes'
}
},
urls: [{
fmt: '/_nodes/<%=nodeId%>/stats/<%=metric%>/<%=indexMetric%>',
req: {
nodeId: {
type: 'list'
},
metric: {
type: 'list',
options: ['_all', 'breaker', 'fs', 'http', 'indices', 'jvm', 'os', 'process', 'thread_pool', 'transport', 'discovery']
},
indexMetric: {
type: 'list',
options: ['_all', 'completion', 'docs', 'fielddata', 'query_cache', 'flush', 'get', 'indexing', 'merge', 'percolate', 'request_cache', 'refresh', 'search', 'segments', 'store', 'warmer', 'suggest']
}
}
}, {
fmt: '/_nodes/<%=nodeId%>/stats/<%=metric%>',
req: {
nodeId: {
type: 'list'
},
metric: {
type: 'list',
options: ['_all', 'breaker', 'fs', 'http', 'indices', 'jvm', 'os', 'process', 'thread_pool', 'transport', 'discovery']
}
}
}, {
fmt: '/_nodes/stats/<%=metric%>/<%=indexMetric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'breaker', 'fs', 'http', 'indices', 'jvm', 'os', 'process', 'thread_pool', 'transport', 'discovery']
},
indexMetric: {
type: 'list',
options: ['_all', 'completion', 'docs', 'fielddata', 'query_cache', 'flush', 'get', 'indexing', 'merge', 'percolate', 'request_cache', 'refresh', 'search', 'segments', 'store', 'warmer', 'suggest']
}
}
}, {
fmt: '/_nodes/<%=nodeId%>/stats',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_nodes/stats/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'breaker', 'fs', 'http', 'indices', 'jvm', 'os', 'process', 'thread_pool', 'transport', 'discovery']
}
}
}, {
fmt: '/_nodes/stats'
}]
});
/**
* Perform a [percolate](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/search-percolate.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>} params.percolateIndex - The index to percolate the document into. Defaults to index.
* @param {<<api-param-type-string,`String`>>} params.percolateType - The type to percolate document into. Defaults to type.
* @param {<<api-param-type-string,`String`>>} params.percolateRouting - The routing value to use when percolating the existing document.
* @param {<<api-param-type-string,`String`>>} params.percolatePreference - Which shard to prefer when executing the percolate request.
* @param {<<api-param-type-string,`String`>>} params.percolateFormat - Return an array of matching query IDs instead of objects
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.index - The index of the document being percolated.
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document being percolated.
* @param {<<api-param-type-string,`String`>>} params.id - Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.
*/
api.percolate = ca({
params: {
routing: {
type: 'list'
},
preference: {
type: 'string'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
percolateIndex: {
type: 'string',
name: 'percolate_index'
},
percolateType: {
type: 'string',
name: 'percolate_type'
},
percolateRouting: {
type: 'string',
name: 'percolate_routing'
},
percolatePreference: {
type: 'string',
name: 'percolate_preference'
},
percolateFormat: {
type: 'enum',
options: ['ids'],
name: 'percolate_format'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/<%=id%>/_percolate',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/<%=type%>/_percolate',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}],
method: 'POST'
});
/**
* Perform a [ping](https://www.elastic.co/guide/) request
*
* @param {Object} params - An object with parameters used to carry out this action
*/
api.ping = ca({
url: {
fmt: '/'
},
requestTimeout: 3000,
method: 'HEAD'
});
/**
* Perform a [putScript](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/modules-scripting.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.id - Script ID
* @param {<<api-param-type-string,`String`>>} params.lang - Script language
*/
api.putScript = ca({
urls: [{
fmt: '/_scripts/<%=lang%>/<%=id%>',
req: {
lang: {
type: 'string'
},
id: {
type: 'string'
}
}
}, {
fmt: '/_scripts/<%=lang%>',
req: {
lang: {
type: 'string'
}
}
}],
needBody: true,
method: 'PUT'
});
/**
* Perform a [putTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/search-template.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.id - Template ID
*/
api.putTemplate = ca({
url: {
fmt: '/_search/template/<%=id%>',
req: {
id: {
type: 'string'
}
}
},
needBody: true,
method: 'PUT'
});
/**
* Perform a [reindex](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/docs-reindex.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Should the effected indexes be refreshed?
* @param {<<api-param-type-duration-string,`DurationString`>>} [params.timeout=1m] - Time each individual bulk request should wait for shards that are unavailable.
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the reindex operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-boolean,`Boolean`>>} [params.waitForCompletion=true] - Should the request should block until the reindex is complete.
* @param {<<api-param-type-number,`Number`>>} params.requestsPerSecond - The throttle to set on this request in sub-requests per second. -1 means no throttle.
* @param {<<api-param-type-number,`Number`>>} [params.slices=1] - The number of slices this task should be divided into. Defaults to 1 meaning the task isn't sliced into subtasks.
*/
api.reindex = ca({
params: {
refresh: {
type: 'boolean'
},
timeout: {
type: 'time',
'default': '1m'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
waitForCompletion: {
type: 'boolean',
'default': true,
name: 'wait_for_completion'
},
requestsPerSecond: {
type: 'number',
'default': 0,
name: 'requests_per_second'
},
slices: {
type: 'number',
'default': 1
}
},
url: {
fmt: '/_reindex'
},
needBody: true,
method: 'POST'
});
/**
* Perform a [reindexRethrottle](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/docs-reindex.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-number,`Number`>>} params.requestsPerSecond - The throttle to set on this request in floating sub-requests per second. -1 means set no throttle.
* @param {<<api-param-type-string,`String`>>} params.taskId - The task id to rethrottle
*/
api.reindexRethrottle = ca({
params: {
requestsPerSecond: {
type: 'number',
required: true,
name: 'requests_per_second'
}
},
url: {
fmt: '/_reindex/<%=taskId%>/_rethrottle',
req: {
taskId: {
type: 'string'
}
}
},
method: 'POST'
});
api.remote = namespace();
/**
* Perform a [remote.info](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/cluster-remote-info.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
*/
api.remote.prototype.info = ca({
url: {
fmt: '/_remote/info'
}
});
/**
* Perform a [renderSearchTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/search-template.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.id - The id of the stored search template
*/
api.renderSearchTemplate = ca({
urls: [{
fmt: '/_render/template/<%=id%>',
req: {
id: {
type: 'string'
}
}
}, {
fmt: '/_render/template'
}],
method: 'POST'
});
/**
* Perform a [scroll](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/search-request-scroll.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.scrollId - The scroll ID
*/
api.scroll = ca({
params: {
scroll: {
type: 'time'
},
scrollId: {
type: 'string',
name: 'scroll_id'
}
},
urls: [{
fmt: '/_search/scroll/<%=scrollId%>',
req: {
scrollId: {
type: 'string'
}
}
}, {
fmt: '/_search/scroll'
}],
paramAsBody: {
param: 'scrollId',
body: 'scroll_id'
},
method: 'POST'
});
/**
* Perform a [search](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/search-search.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - Specify whether to return detailed information about score computation as part of a hit
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return as part of a hit
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.docvalueFields - A comma-separated list of fields to return as the docvalue representation of a field for each hit
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fielddataFields - A comma-separated list of fields to return as the docvalue representation of a field for each hit
* @param {<<api-param-type-number,`Number`>>} params.from - Starting offset (default: 0)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-number,`Number`>>} params.size - Number of hits to return (default: 10)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.sort - A comma-separated list of <field>:<direction> pairs
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.terminateAfter - The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.stats - Specific 'tag' of the request for logging and statistical purposes
* @param {<<api-param-type-string,`String`>>} params.suggestField - Specify which field to use for suggestions
* @param {<<api-param-type-string,`String`>>} [params.suggestMode=missing] - Specify suggest mode
* @param {<<api-param-type-number,`Number`>>} params.suggestSize - How many suggestions to return in response
* @param {<<api-param-type-string,`String`>>} params.suggestText - The source text for which the suggestions should be returned
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.trackScores - Whether to calculate and return scores even if they are not used for sorting
* @param {<<api-param-type-boolean,`Boolean`>>} params.typedKeys - Specify whether aggregation and suggester names should be prefixed by their respective types in the response
* @param {<<api-param-type-boolean,`Boolean`>>} params.version - Specify whether to return document version as part of a hit
* @param {<<api-param-type-boolean,`Boolean`>>} params.requestCache - Specify if request cache should be used for this request or not, defaults to index level setting
* @param {<<api-param-type-number,`Number`>>} [params.batchedReduceSize=512] - The number of shard results that should be reduced at once on the coordinating node. This value should be used as a protection mechanism to reduce the memory overhead per search request if the potential number of shards in the request can be large.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to search; leave empty to perform the operation on all types
*/
api.search = 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'
},
storedFields: {
type: 'list',
name: 'stored_fields'
},
docvalueFields: {
type: 'list',
name: 'docvalue_fields'
},
fielddataFields: {
type: 'list',
name: 'fielddata_fields'
},
from: {
type: 'number'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
lenient: {
type: 'boolean'
},
preference: {
type: 'string'
},
q: {
type: 'string'
},
routing: {
type: 'list'
},
scroll: {
type: 'time'
},
searchType: {
type: 'enum',
options: ['query_then_fetch', 'dfs_query_then_fetch'],
name: 'search_type'
},
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: 'string',
name: 'suggest_text'
},
timeout: {
type: 'time'
},
trackScores: {
type: 'boolean',
name: 'track_scores'
},
typedKeys: {
type: 'boolean',
name: 'typed_keys'
},
version: {
type: 'boolean'
},
requestCache: {
type: 'boolean',
name: 'request_cache'
},
batchedReduceSize: {
type: 'number',
'default': 512,
name: 'batched_reduce_size'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_search',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_search',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_search'
}],
method: 'POST'
});
/**
* Perform a [searchShards](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/search-shards.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to search; leave empty to perform the operation on all types
*/
api.searchShards = ca({
params: {
preference: {
type: 'string'
},
routing: {
type: 'string'
},
local: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_search_shards',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_search_shards',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_search_shards'
}],
method: 'POST'
});
/**
* Perform a [searchTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/search-template.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - Specify whether to return detailed information about score computation as part of a hit
* @param {<<api-param-type-boolean,`Boolean`>>} params.profile - Specify whether to profile the query execution
* @param {<<api-param-type-boolean,`Boolean`>>} params.typedKeys - Specify whether aggregation and suggester names should be prefixed by their respective types in the response
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to search; leave empty to perform the operation on all types
*/
api.searchTemplate = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
preference: {
type: 'string'
},
routing: {
type: 'list'
},
scroll: {
type: 'time'
},
searchType: {
type: 'enum',
options: ['query_then_fetch', 'query_and_fetch', 'dfs_query_then_fetch', 'dfs_query_and_fetch'],
name: 'search_type'
},
explain: {
type: 'boolean'
},
profile: {
type: 'boolean'
},
typedKeys: {
type: 'boolean',
name: 'typed_keys'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_search/template',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_search/template',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_search/template'
}],
method: 'POST'
});
api.snapshot = namespace();
/**
* Perform a [snapshot.create](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Should this request wait until the operation has completed before returning
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>} params.snapshot - A snapshot name
*/
api.snapshot.prototype.create = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForCompletion: {
type: 'boolean',
'default': false,
name: 'wait_for_completion'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [snapshot.createRepository](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.verify - Whether to verify the repository after creation
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
*/
api.snapshot.prototype.createRepository = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
},
verify: {
type: 'boolean'
}
},
url: {
fmt: '/_snapshot/<%=repository%>',
req: {
repository: {
type: 'string'
}
}
},
needBody: true,
method: 'POST'
});
/**
* Perform a [snapshot.delete](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>} params.snapshot - A snapshot name
*/
api.snapshot.prototype['delete'] = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [snapshot.deleteRepository](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.repository - A comma-separated list of repository names
*/
api.snapshot.prototype.deleteRepository = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_snapshot/<%=repository%>',
req: {
repository: {
type: 'list'
}
}
},
method: 'DELETE'
});
/**
* Perform a [snapshot.get](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether to ignore unavailable snapshots, defaults to false which means a SnapshotMissingException is thrown
* @param {<<api-param-type-boolean,`Boolean`>>} params.verbose - Whether to show verbose snapshot info or only show the basic info found in the repository index blob
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.snapshot - A comma-separated list of snapshot names
*/
api.snapshot.prototype.get = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
verbose: {
type: 'boolean'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'list'
}
}
}
});
/**
* Perform a [snapshot.getRepository](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.repository - A comma-separated list of repository names
*/
api.snapshot.prototype.getRepository = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/_snapshot/<%=repository%>',
req: {
repository: {
type: 'list'
}
}
}, {
fmt: '/_snapshot'
}]
});
/**
* Perform a [snapshot.restore](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Should this request wait until the operation has completed before returning
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>} params.snapshot - A snapshot name
*/
api.snapshot.prototype.restore = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForCompletion: {
type: 'boolean',
'default': false,
name: 'wait_for_completion'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>/_restore',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [snapshot.status](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether to ignore unavailable snapshots, defaults to false which means a SnapshotMissingException is thrown
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.snapshot - A comma-separated list of snapshot names
*/
api.snapshot.prototype.status = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
}
},
urls: [{
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>/_status',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'list'
}
}
}, {
fmt: '/_snapshot/<%=repository%>/_status',
req: {
repository: {
type: 'string'
}
}
}, {
fmt: '/_snapshot/_status'
}]
});
/**
* Perform a [snapshot.verifyRepository](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
*/
api.snapshot.prototype.verifyRepository = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/_verify',
req: {
repository: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [suggest](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/search-suggesters.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices
*/
api.suggest = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
preference: {
type: 'string'
},
routing: {
type: 'string'
}
},
urls: [{
fmt: '/<%=index%>/_suggest',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_suggest'
}],
needBody: true,
method: 'POST'
});
api.tasks = namespace();
/**
* Perform a [tasks.cancel](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.actions - A comma-separated list of actions that should be cancelled. Leave empty to cancel all.
* @param {<<api-param-type-string,`String`>>} params.parentNode - Cancel tasks with specified parent node.
* @param {<<api-param-type-string,`String`>>} params.parentTask - Cancel tasks with specified parent task id (node_id:task_number). Set to -1 to cancel all.
* @param {<<api-param-type-string,`String`>>} params.taskId - Cancel the task with specified task id (node_id:task_number)
*/
api.tasks.prototype.cancel = ca({
params: {
nodeId: {
type: 'list',
name: 'node_id'
},
actions: {
type: 'list'
},
parentNode: {
type: 'string',
name: 'parent_node'
},
parentTask: {
type: 'string',
name: 'parent_task'
}
},
urls: [{
fmt: '/_tasks/<%=taskId%>/_cancel',
req: {
taskId: {
type: 'string'
}
}
}, {
fmt: '/_tasks/_cancel'
}],
method: 'POST'
});
/**
* Perform a [tasks.get](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Wait for the matching tasks to complete (default: false)
* @param {<<api-param-type-string,`String`>>} params.taskId - Return the task with specified id (node_id:task_number)
*/
api.tasks.prototype.get = ca({
params: {
waitForCompletion: {
type: 'boolean',
name: 'wait_for_completion'
}
},
url: {
fmt: '/_tasks/<%=taskId%>',
req: {
taskId: {
type: 'string'
}
}
}
});
/**
* Perform a [tasks.list](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.actions - A comma-separated list of actions that should be returned. Leave empty to return all.
* @param {<<api-param-type-boolean,`Boolean`>>} params.detailed - Return detailed task information (default: false)
* @param {<<api-param-type-string,`String`>>} params.parentNode - Return tasks with specified parent node.
* @param {<<api-param-type-string,`String`>>} params.parentTask - Return tasks with specified parent task id (node_id:task_number). Set to -1 to return all.
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Wait for the matching tasks to complete (default: false)
* @param {<<api-param-type-string,`String`>>} [params.groupBy=nodes] - Group tasks by nodes or parent/child relationships
*/
api.tasks.prototype.list = ca({
params: {
nodeId: {
type: 'list',
name: 'node_id'
},
actions: {
type: 'list'
},
detailed: {
type: 'boolean'
},
parentNode: {
type: 'string',
name: 'parent_node'
},
parentTask: {
type: 'string',
name: 'parent_task'
},
waitForCompletion: {
type: 'boolean',
name: 'wait_for_completion'
},
groupBy: {
type: 'enum',
'default': 'nodes',
options: ['nodes', 'parents'],
name: 'group_by'
}
},
url: {
fmt: '/_tasks'
}
});
/**
* Perform a [termvectors](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/docs-termvectors.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.termStatistics - Specifies if total term frequency and document frequency should be returned.
* @param {<<api-param-type-boolean,`Boolean`>>} [params.fieldStatistics=true] - Specifies if document count, sum of document frequencies and sum of total term frequencies should be returned.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to return.
* @param {<<api-param-type-boolean,`Boolean`>>} [params.offsets=true] - Specifies if term offsets should be returned.
* @param {<<api-param-type-boolean,`Boolean`>>} [params.positions=true] - Specifies if term positions should be returned.
* @param {<<api-param-type-boolean,`Boolean`>>} [params.payloads=true] - Specifies if term payloads should be returned.
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random).
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value.
* @param {<<api-param-type-string,`String`>>} params.parent - Parent id of documents.
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specifies if request is real-time as opposed to near-real-time (default: true).
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.index - The index in which the document resides.
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document.
* @param {<<api-param-type-string,`String`>>} params.id - The id of the document, when not specified a doc param should be supplied.
*/
api.termvectors = ca({
params: {
termStatistics: {
type: 'boolean',
'default': false,
required: false,
name: 'term_statistics'
},
fieldStatistics: {
type: 'boolean',
'default': true,
required: false,
name: 'field_statistics'
},
fields: {
type: 'list',
required: false
},
offsets: {
type: 'boolean',
'default': true,
required: false
},
positions: {
type: 'boolean',
'default': true,
required: false
},
payloads: {
type: 'boolean',
'default': true,
required: false
},
preference: {
type: 'string',
required: false
},
routing: {
type: 'string',
required: false
},
parent: {
type: 'string',
required: false
},
realtime: {
type: 'boolean',
required: false
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/<%=id%>/_termvectors',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/<%=type%>/_termvectors',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}],
method: 'POST'
});
/**
* Perform a [update](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/docs-update.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the update operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to return in the response
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-string,`String`>>} params.lang - The script language (default: painless)
* @param {<<api-param-type-string,`String`>>} params.parent - ID of the parent document. Is is only used for routing and when for the upsert request
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the effected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-number,`Number`>>} params.retryOnConflict - Specify how many times should the operation be retried when a conflict occurs (default: 0)
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timestamp - Explicit timestamp for the document
* @param {<<api-param-type-duration-string,`DurationString`>>} params.ttl - Expiration time for the document
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - Document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.update = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
fields: {
type: 'list'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
lang: {
type: 'string'
},
parent: {
type: 'string'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
retryOnConflict: {
type: 'number',
name: 'retry_on_conflict'
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
timestamp: {
type: 'time'
},
ttl: {
type: 'time'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_update',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [updateByQuery](https://www.elastic.co/guide/en/elasticsearch/reference/5.5/docs-update-by-query.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-number,`Number`>>} params.from - Starting offset (default: 0)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.conflicts=abort] - What to do when the update by query hits version conflicts?
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-string,`String`>>} params.pipeline - Ingest pipeline to set on index requests made by this action. (default: none)
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-duration-string,`DurationString`>>} params.searchTimeout - Explicit timeout for each search request. Defaults to no timeout.
* @param {<<api-param-type-number,`Number`>>} params.size - Number of hits to return (default: 10)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.sort - A comma-separated list of <field>:<direction> pairs
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.terminateAfter - The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.stats - Specific 'tag' of the request for logging and statistical purposes
* @param {<<api-param-type-boolean,`Boolean`>>} params.version - Specify whether to return document version as part of a hit
* @param {<<api-param-type-boolean,`Boolean`>>} params.versionType - Should the document increment the version number (internal) on hit or not (reindex)
* @param {<<api-param-type-boolean,`Boolean`>>} params.requestCache - Specify if request cache should be used for this request or not, defaults to index level setting
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Should the effected indexes be refreshed?
* @param {<<api-param-type-duration-string,`DurationString`>>} [params.timeout=1m] - Time each individual bulk request should wait for shards that are unavailable.
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the update by query operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-number,`Number`>>} params.scrollSize - Size on the scroll request powering the update_by_query
* @param {<<api-param-type-boolean,`Boolean`>>} [params.waitForCompletion=true] - Should the request should block until the update by query operation is complete.
* @param {<<api-param-type-number,`Number`>>} params.requestsPerSecond - The throttle to set on this request in sub-requests per second. -1 means no throttle.
* @param {<<api-param-type-number,`Number`>>} [params.slices=1] - The number of slices this task should be divided into. Defaults to 1 meaning the task isn't sliced into subtasks.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to search; leave empty to perform the operation on all types
*/
api.updateByQuery = 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'
},
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'
},
pipeline: {
type: 'string'
},
preference: {
type: 'string'
},
q: {
type: 'string'
},
routing: {
type: 'list'
},
scroll: {
type: 'time'
},
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'
},
version: {
type: 'boolean'
},
versionType: {
type: 'boolean',
name: 'version_type'
},
requestCache: {
type: 'boolean',
name: 'request_cache'
},
refresh: {
type: 'boolean'
},
timeout: {
type: 'time',
'default': '1m'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
scrollSize: {
type: 'number',
name: 'scroll_size'
},
waitForCompletion: {
type: 'boolean',
'default': true,
name: 'wait_for_completion'
},
requestsPerSecond: {
type: 'number',
'default': 0,
name: 'requests_per_second'
},
slices: {
type: 'number',
'default': 1
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_update_by_query',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_update_by_query',
req: {
index: {
type: 'list'
}
}
}],
method: 'POST'
});
/***/ }),
/* 50 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var ca = __webpack_require__(1).makeFactoryWithModifier(function (spec) {
return __webpack_require__(0).merge(spec, {
params: {
filterPath: {
type: 'list',
name: 'filter_path'
}
}
});
});
var namespace = __webpack_require__(1).namespaceFactory;
var api = module.exports = {};
api._namespaces = ['cat', 'cluster', 'indices', 'ingest', 'nodes', 'snapshot', 'tasks'];
/**
* Perform a [bulk](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/docs-bulk.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the bulk operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the effected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.type - Default document type for items which don't provide one
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - Default comma-separated list of fields to return in the response for updates, can be overridden on each sub-request
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or default list of fields to return, can be overridden on each sub-request
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - Default list of fields to exclude from the returned _source field, can be overridden on each sub-request
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - Default list of fields to extract and return from the _source field, can be overridden on each sub-request
* @param {<<api-param-type-string,`String`>>} params.pipeline - The pipeline id to preprocess incoming documents with
* @param {<<api-param-type-string,`String`>>} params.index - Default index for items which don't provide one
*/
api.bulk = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
type: {
type: 'string'
},
fields: {
type: 'list'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
pipeline: {
type: 'string'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_bulk',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/_bulk',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_bulk'
}],
needBody: true,
bulkBody: true,
method: 'POST'
});
api.cat = namespace();
/**
* Perform a [cat.aliases](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cat.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - A comma-separated list of alias names to return
*/
api.cat.prototype.aliases = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/aliases/<%=name%>',
req: {
name: {
type: 'list'
}
}
}, {
fmt: '/_cat/aliases'
}]
});
/**
* Perform a [cat.allocation](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cat-allocation.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information
*/
api.cat.prototype.allocation = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/allocation/<%=nodeId%>',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_cat/allocation'
}]
});
/**
* Perform a [cat.count](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cat-count.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.count = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/count/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/count'
}]
});
/**
* Perform a [cat.fielddata](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cat-fielddata.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to return the fielddata size
*/
api.cat.prototype.fielddata = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
},
fields: {
type: 'list'
}
},
urls: [{
fmt: '/_cat/fielddata/<%=fields%>',
req: {
fields: {
type: 'list'
}
}
}, {
fmt: '/_cat/fielddata'
}]
});
/**
* Perform a [cat.health](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cat-health.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} [params.ts=true] - Set to false to disable timestamping
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.health = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
ts: {
type: 'boolean',
'default': true
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/health'
}
});
/**
* Perform a [cat.help](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cat.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
*/
api.cat.prototype.help = ca({
params: {
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
}
},
url: {
fmt: '/_cat'
}
});
/**
* Perform a [cat.indices](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cat-indices.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-string,`String`>>} params.health - A health status ("green", "yellow", or "red" to filter only indices matching the specified health status
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-boolean,`Boolean`>>} params.pri - Set to true to return stats only for primary shards
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.indices = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'm', 'g']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
health: {
type: 'enum',
'default': null,
options: ['green', 'yellow', 'red']
},
help: {
type: 'boolean',
'default': false
},
pri: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/indices/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/indices'
}]
});
/**
* Perform a [cat.master](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cat-master.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.master = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/master'
}
});
/**
* Perform a [cat.nodeattrs](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cat-nodeattrs.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.nodeattrs = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/nodeattrs'
}
});
/**
* Perform a [cat.nodes](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cat-nodes.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.fullId - Return the full node ID instead of the shortened version (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.nodes = ca({
params: {
format: {
type: 'string'
},
fullId: {
type: 'boolean',
name: 'full_id'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/nodes'
}
});
/**
* Perform a [cat.pendingTasks](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cat-pending-tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.pendingTasks = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/pending_tasks'
}
});
/**
* Perform a [cat.plugins](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cat-plugins.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.plugins = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/plugins'
}
});
/**
* Perform a [cat.recovery](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cat-recovery.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.recovery = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/recovery/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/recovery'
}]
});
/**
* Perform a [cat.repositories](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cat-repositories.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.repositories = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean',
'default': false
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/repositories'
}
});
/**
* Perform a [cat.segments](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cat-segments.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.segments = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/segments/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/segments'
}]
});
/**
* Perform a [cat.shards](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cat-shards.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.shards = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/shards/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/shards'
}]
});
/**
* Perform a [cat.snapshots](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cat-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Set to true to ignore unavailable snapshots
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.repository - Name of repository from which to fetch the snapshot information
*/
api.cat.prototype.snapshots = ca({
params: {
format: {
type: 'string'
},
ignoreUnavailable: {
type: 'boolean',
'default': false,
name: 'ignore_unavailable'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/snapshots/<%=repository%>',
req: {
repository: {
type: 'list'
}
}
}, {
fmt: '/_cat/snapshots'
}]
});
/**
* Perform a [cat.tasks](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.actions - A comma-separated list of actions that should be returned. Leave empty to return all.
* @param {<<api-param-type-boolean,`Boolean`>>} params.detailed - Return detailed task information (default: false)
* @param {<<api-param-type-number,`Number`>>} params.parentTask - Return tasks with specified parent task id. Set to -1 to return all.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.tasks = ca({
params: {
format: {
type: 'string'
},
nodeId: {
type: 'list',
name: 'node_id'
},
actions: {
type: 'list'
},
detailed: {
type: 'boolean'
},
parentTask: {
type: 'number',
name: 'parent_task'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/tasks'
}
});
/**
* Perform a [cat.templates](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cat-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>} params.name - A pattern that returned template names must match
*/
api.cat.prototype.templates = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/templates/<%=name%>',
req: {
name: {
type: 'string'
}
}
}, {
fmt: '/_cat/templates'
}]
});
/**
* Perform a [cat.threadPool](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cat-thread-pool.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.size - The multiplier in which to display values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.threadPoolPatterns - A comma-separated list of regular-expressions to filter the thread pools in the output
*/
api.cat.prototype.threadPool = ca({
params: {
format: {
type: 'string'
},
size: {
type: 'enum',
options: ['', 'k', 'm', 'g', 't', 'p']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/thread_pool/<%=threadPoolPatterns%>',
req: {
threadPoolPatterns: {
type: 'list'
}
}
}, {
fmt: '/_cat/thread_pool'
}]
});
/**
* Perform a [clearScroll](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/search-request-scroll.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.scrollId - A comma-separated list of scroll IDs to clear
*/
api.clearScroll = ca({
urls: [{
fmt: '/_search/scroll/<%=scrollId%>',
req: {
scrollId: {
type: 'list'
}
}
}, {
fmt: '/_search/scroll'
}],
paramAsBody: {
param: 'scrollId',
body: 'scroll_id'
},
method: 'DELETE'
});
api.cluster = namespace();
/**
* Perform a [cluster.allocationExplain](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cluster-allocation-explain.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeYesDecisions - Return 'YES' decisions in explanation (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDiskInfo - Return information about disk usage and shard sizes (default: false)
*/
api.cluster.prototype.allocationExplain = ca({
params: {
includeYesDecisions: {
type: 'boolean',
name: 'include_yes_decisions'
},
includeDiskInfo: {
type: 'boolean',
name: 'include_disk_info'
}
},
url: {
fmt: '/_cluster/allocation/explain'
},
method: 'POST'
});
/**
* Perform a [cluster.getSettings](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cluster-update-settings.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether to return all default clusters setting.
*/
api.cluster.prototype.getSettings = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
},
includeDefaults: {
type: 'boolean',
'default': false,
name: 'include_defaults'
}
},
url: {
fmt: '/_cluster/settings'
}
});
/**
* Perform a [cluster.health](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cluster-health.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} [params.level=cluster] - Specify the level of detail for returned information
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Wait until the specified number of shards is active
* @param {<<api-param-type-string,`String`>>} params.waitForNodes - Wait until the specified number of nodes is available
* @param {<<api-param-type-string,`String`>>} params.waitForEvents - Wait until all currently queued events with the given priority are processed
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForNoRelocatingShards - Whether to wait until there are no relocating shards in the cluster
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForNoInitializingShards - Whether to wait until there are no initializing shards in the cluster
* @param {<<api-param-type-string,`String`>>} params.waitForStatus - Wait until cluster is in a specific state
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - Limit the information returned to a specific index
*/
api.cluster.prototype.health = ca({
params: {
level: {
type: 'enum',
'default': 'cluster',
options: ['cluster', 'indices', 'shards']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
waitForNodes: {
type: 'string',
name: 'wait_for_nodes'
},
waitForEvents: {
type: 'enum',
options: ['immediate', 'urgent', 'high', 'normal', 'low', 'languid'],
name: 'wait_for_events'
},
waitForNoRelocatingShards: {
type: 'boolean',
name: 'wait_for_no_relocating_shards'
},
waitForNoInitializingShards: {
type: 'boolean',
name: 'wait_for_no_initializing_shards'
},
waitForStatus: {
type: 'enum',
'default': null,
options: ['green', 'yellow', 'red'],
name: 'wait_for_status'
}
},
urls: [{
fmt: '/_cluster/health/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cluster/health'
}]
});
/**
* Perform a [cluster.pendingTasks](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cluster-pending.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
*/
api.cluster.prototype.pendingTasks = ca({
params: {
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_cluster/pending_tasks'
}
});
/**
* Perform a [cluster.putSettings](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cluster-update-settings.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
*/
api.cluster.prototype.putSettings = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_cluster/settings'
},
needBody: true,
method: 'PUT'
});
/**
* Perform a [cluster.remoteInfo](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cluster-remote-info.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
*/
api.cluster.prototype.remoteInfo = ca({
url: {
fmt: '/_remote/info'
}
});
/**
* Perform a [cluster.reroute](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cluster-reroute.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.dryRun - Simulate the operation only and return the resulting state
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - Return an explanation of why the commands can or cannot be executed
* @param {<<api-param-type-boolean,`Boolean`>>} params.retryFailed - Retries allocation of shards that are blocked due to too many subsequent allocation failures
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned to the specified metrics. Defaults to all but metadata
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
*/
api.cluster.prototype.reroute = ca({
params: {
dryRun: {
type: 'boolean',
name: 'dry_run'
},
explain: {
type: 'boolean'
},
retryFailed: {
type: 'boolean',
name: 'retry_failed'
},
metric: {
type: 'list',
options: ['_all', 'blocks', 'metadata', 'nodes', 'routing_table', 'master_node', 'version']
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_cluster/reroute'
},
method: 'POST'
});
/**
* Perform a [cluster.state](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cluster-state.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned to the specified metrics
*/
api.cluster.prototype.state = ca({
params: {
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/_cluster/state/<%=metric%>/<%=index%>',
req: {
metric: {
type: 'list',
options: ['_all', 'blocks', 'metadata', 'nodes', 'routing_table', 'routing_nodes', 'master_node', 'version']
},
index: {
type: 'list'
}
}
}, {
fmt: '/_cluster/state/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'blocks', 'metadata', 'nodes', 'routing_table', 'routing_nodes', 'master_node', 'version']
}
}
}, {
fmt: '/_cluster/state'
}]
});
/**
* Perform a [cluster.stats](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cluster-stats.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
*/
api.cluster.prototype.stats = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
timeout: {
type: 'time'
}
},
urls: [{
fmt: '/_cluster/stats/nodes/<%=nodeId%>',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_cluster/stats'
}]
});
/**
* Perform a [count](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/search-count.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-number,`Number`>>} params.minScore - Include only documents with a specific `_score` value in the result
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-number,`Number`>>} params.terminateAfter - The maximum count for each shard, upon reaching which the query execution will terminate early
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of indices to restrict the results
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of types to restrict the results
*/
api.count = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
minScore: {
type: 'number',
name: 'min_score'
},
preference: {
type: 'string'
},
routing: {
type: 'list'
},
q: {
type: 'string'
},
analyzer: {
type: 'string'
},
analyzeWildcard: {
type: 'boolean',
name: 'analyze_wildcard'
},
defaultOperator: {
type: 'enum',
'default': 'OR',
options: ['AND', 'OR'],
name: 'default_operator'
},
df: {
type: 'string'
},
lenient: {
type: 'boolean'
},
terminateAfter: {
type: 'number',
name: 'terminate_after'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_count',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_count',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_count'
}],
method: 'POST'
});
/**
* Perform a [create](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/docs-index_.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the index operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>} params.parent - ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.pipeline - The pipeline id to preprocess incoming documents with
* @param {<<api-param-type-string,`String`>>} params.id - Document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.create = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
parent: {
type: 'string'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
},
pipeline: {
type: 'string'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_create',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
needBody: true,
method: 'POST'
});
/**
* Perform a [delete](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/docs-delete.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the delete operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>} params.parent - ID of parent document
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the effected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api['delete'] = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
parent: {
type: 'string'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [deleteByQuery](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/docs-delete-by-query.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-number,`Number`>>} params.from - Starting offset (default: 0)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.conflicts=abort] - What to do when the delete by query hits version conflicts?
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-duration-string,`DurationString`>>} params.searchTimeout - Explicit timeout for each search request. Defaults to no timeout.
* @param {<<api-param-type-number,`Number`>>} params.size - Number of hits to return (default: 10)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.sort - A comma-separated list of <field>:<direction> pairs
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.terminateAfter - The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.stats - Specific 'tag' of the request for logging and statistical purposes
* @param {<<api-param-type-boolean,`Boolean`>>} params.version - Specify whether to return document version as part of a hit
* @param {<<api-param-type-boolean,`Boolean`>>} params.requestCache - Specify if request cache should be used for this request or not, defaults to index level setting
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Should the effected indexes be refreshed?
* @param {<<api-param-type-duration-string,`DurationString`>>} [params.timeout=1m] - Time each individual bulk request should wait for shards that are unavailable.
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the delete by query operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-number,`Number`>>} params.scrollSize - Size on the scroll request powering the delete by query
* @param {<<api-param-type-boolean,`Boolean`>>} [params.waitForCompletion=true] - Should the request should block until the delete by query is complete.
* @param {<<api-param-type-number,`Number`>>} params.requestsPerSecond - The throttle for this request in sub-requests per second. -1 means no throttle.
* @param {<<api-param-type-number,`Number`>>} [params.slices=1] - The number of slices this task should be divided into. Defaults to 1 meaning the task isn't sliced into subtasks.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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'
},
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'
},
preference: {
type: 'string'
},
q: {
type: 'string'
},
routing: {
type: 'list'
},
scroll: {
type: 'time'
},
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'
},
version: {
type: 'boolean'
},
requestCache: {
type: 'boolean',
name: 'request_cache'
},
refresh: {
type: 'boolean'
},
timeout: {
type: 'time',
'default': '1m'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
scrollSize: {
type: 'number',
name: 'scroll_size'
},
waitForCompletion: {
type: 'boolean',
'default': true,
name: 'wait_for_completion'
},
requestsPerSecond: {
type: 'number',
'default': 0,
name: 'requests_per_second'
},
slices: {
type: 'number',
'default': 1
}
},
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](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/modules-scripting.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.id - Script ID
*/
api.deleteScript = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_scripts/<%=id%>',
req: {
id: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [exists](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/docs-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return in the response
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document (use `_all` to fetch the first document matching the ID across all types)
*/
api.exists = ca({
params: {
storedFields: {
type: 'list',
name: 'stored_fields'
},
parent: {
type: 'string'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'HEAD'
});
/**
* Perform a [existsSource](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/docs-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document; use `_all` to fetch the first document matching the ID across all types
*/
api.existsSource = ca({
params: {
parent: {
type: 'string'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_source',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'HEAD'
});
/**
* Perform a [explain](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/search-explain.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcards and prefix queries in the query string query should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer for the query string query
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The default field for query string query (default: _all)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return in the response
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.explain = ca({
params: {
analyzeWildcard: {
type: 'boolean',
name: 'analyze_wildcard'
},
analyzer: {
type: 'string'
},
defaultOperator: {
type: 'enum',
'default': 'OR',
options: ['AND', 'OR'],
name: 'default_operator'
},
df: {
type: 'string'
},
storedFields: {
type: 'list',
name: 'stored_fields'
},
lenient: {
type: 'boolean'
},
parent: {
type: 'string'
},
preference: {
type: 'string'
},
q: {
type: 'string'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_explain',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [fieldCaps](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/search-field-caps.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of field names
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.fieldCaps = ca({
params: {
fields: {
type: 'list'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_field_caps',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_field_caps'
}],
method: 'POST'
});
/**
* Perform a [get](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/docs-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return in the response
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document (use `_all` to fetch the first document matching the ID across all types)
*/
api.get = ca({
params: {
storedFields: {
type: 'list',
name: 'stored_fields'
},
parent: {
type: 'string'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}
});
/**
* Perform a [getScript](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/modules-scripting.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.id - Script ID
*/
api.getScript = ca({
url: {
fmt: '/_scripts/<%=id%>',
req: {
id: {
type: 'string'
}
}
}
});
/**
* Perform a [getSource](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/docs-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document; use `_all` to fetch the first document matching the ID across all types
*/
api.getSource = ca({
params: {
parent: {
type: 'string'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_source',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}
});
/**
* Perform a [index](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/docs-index_.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the index operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>} [params.opType=index] - Explicit operation type
* @param {<<api-param-type-string,`String`>>} params.parent - ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.pipeline - The pipeline id to preprocess incoming documents with
* @param {<<api-param-type-string,`String`>>} params.id - Document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.index = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
opType: {
type: 'enum',
'default': 'index',
options: ['index', 'create'],
name: 'op_type'
},
parent: {
type: 'string'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
},
pipeline: {
type: 'string'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/<%=id%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/<%=type%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}],
needBody: true,
method: 'POST'
});
api.indices = namespace();
/**
* Perform a [indices.analyze](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-analyze.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index to scope the operation
* @param {<<api-param-type-boolean,`Boolean`>>} params.preferLocal - With `true`, specify that a local shard should be used if available, with `false`, use a random shard (default: true)
* @param {<<api-param-type-string,`String`>>} [params.format=detailed] - Format of the output
*/
api.indices.prototype.analyze = ca({
params: {
index: {
type: 'string'
},
preferLocal: {
type: 'boolean',
name: 'prefer_local'
},
format: {
type: 'enum',
'default': 'detailed',
options: ['detailed', 'text']
}
},
urls: [{
fmt: '/<%=index%>/_analyze',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_analyze'
}],
method: 'POST'
});
/**
* Perform a [indices.clearCache](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-clearcache.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.fieldData - Clear field data. This is deprecated. Prefer `fielddata`.
* @param {<<api-param-type-boolean,`Boolean`>>} params.fielddata - Clear field data
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to clear when using the `fielddata` parameter (default: all)
* @param {<<api-param-type-boolean,`Boolean`>>} params.query - Clear query caches
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index name to limit the operation
* @param {<<api-param-type-boolean,`Boolean`>>} params.requestCache - Clear request cache
* @param {<<api-param-type-boolean,`Boolean`>>} params.request - Clear request cache
*/
api.indices.prototype.clearCache = ca({
params: {
fieldData: {
type: 'boolean',
name: 'field_data'
},
fielddata: {
type: 'boolean'
},
fields: {
type: 'list'
},
query: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
index: {
type: 'list'
},
requestCache: {
type: 'boolean',
name: 'request_cache'
},
request: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_cache/clear',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cache/clear'
}],
method: 'POST'
});
/**
* Perform a [indices.close](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-open-close.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma separated list of indices to close
*/
api.indices.prototype.close = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
url: {
fmt: '/<%=index%>/_close',
req: {
index: {
type: 'list'
}
}
},
method: 'POST'
});
/**
* Perform a [indices.create](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-create-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Set the number of active shards to wait for before the operation returns.
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.updateAllTypes - Whether to update the mapping for all fields with the same name across all types or not
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
*/
api.indices.prototype.create = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
updateAllTypes: {
type: 'boolean',
name: 'update_all_types'
}
},
url: {
fmt: '/<%=index%>',
req: {
index: {
type: 'string'
}
}
},
method: 'PUT'
});
/**
* Perform a [indices.delete](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-delete-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Ignore unavailable indexes (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.allowNoIndices - Ignore if a wildcard expression resolves to no concrete indices (default: false)
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether wildcard expressions should get expanded to open or closed indices (default: open)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of indices to delete; use `_all` or `*` string to delete all indices
*/
api.indices.prototype['delete'] = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
url: {
fmt: '/<%=index%>',
req: {
index: {
type: 'list'
}
}
},
method: 'DELETE'
});
/**
* Perform a [indices.deleteAlias](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit timestamp for the document
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names (supports wildcards); use `_all` for all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - A comma-separated list of aliases to delete (supports wildcards); use `_all` to delete all aliases for the specified indices.
*/
api.indices.prototype.deleteAlias = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/<%=index%>/_alias/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'list'
}
}
},
method: 'DELETE'
});
/**
* Perform a [indices.deleteTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.name - The name of the template
*/
api.indices.prototype.deleteTemplate = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_template/<%=name%>',
req: {
name: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [indices.exists](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-exists.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Ignore unavailable indexes (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.allowNoIndices - Ignore if a wildcard expression resolves to no concrete indices (default: false)
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether wildcard expressions should get expanded to open or closed indices (default: open)
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether to return all default setting for each of the indices.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names
*/
api.indices.prototype.exists = ca({
params: {
local: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
includeDefaults: {
type: 'boolean',
'default': false,
name: 'include_defaults'
}
},
url: {
fmt: '/<%=index%>',
req: {
index: {
type: 'list'
}
}
},
method: 'HEAD'
});
/**
* Perform a [indices.existsAlias](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=all] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to filter aliases
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - A comma-separated list of alias names to return
*/
api.indices.prototype.existsAlias = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'all',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_alias/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'list'
}
}
}, {
fmt: '/_alias/<%=name%>',
req: {
name: {
type: 'list'
}
}
}],
method: 'HEAD'
});
/**
* Perform a [indices.existsTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - The comma separated names of the index templates
*/
api.indices.prototype.existsTemplate = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
local: {
type: 'boolean'
}
},
url: {
fmt: '/_template/<%=name%>',
req: {
name: {
type: 'list'
}
}
},
method: 'HEAD'
});
/**
* Perform a [indices.existsType](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-types-exists.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` to check the types across all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to check
*/
api.indices.prototype.existsType = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
url: {
fmt: '/<%=index%>/_mapping/<%=type%>',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
},
method: 'HEAD'
});
/**
* Perform a [indices.flush](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-flush.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.force - Whether a flush should be forced even if it is not necessarily needed ie. if no changes will be committed to the index. This is useful if transaction log IDs should be incremented even if no uncommitted changes are present. (This setting can be considered as internal)
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitIfOngoing - If set to true the flush operation will block until the flush can be executed if another flush operation is already executing. The default is true. If set to false the flush will be skipped iff if another flush operation is already running.
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string for all indices
*/
api.indices.prototype.flush = ca({
params: {
force: {
type: 'boolean'
},
waitIfOngoing: {
type: 'boolean',
name: 'wait_if_ongoing'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_flush',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_flush'
}],
method: 'POST'
});
/**
* Perform a [indices.flushSynced](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-synced-flush.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string for all indices
*/
api.indices.prototype.flushSynced = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_flush/synced',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_flush/synced'
}],
method: 'POST'
});
/**
* Perform a [indices.forcemerge](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-forcemerge.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flush - Specify whether the index should be flushed after performing the operation (default: true)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-number,`Number`>>} params.maxNumSegments - The number of segments the index should be merged into (default: dynamic)
* @param {<<api-param-type-boolean,`Boolean`>>} params.onlyExpungeDeletes - Specify whether the operation should only expunge deleted documents
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.forcemerge = ca({
params: {
flush: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
maxNumSegments: {
type: 'number',
name: 'max_num_segments'
},
onlyExpungeDeletes: {
type: 'boolean',
name: 'only_expunge_deletes'
}
},
urls: [{
fmt: '/<%=index%>/_forcemerge',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_forcemerge'
}],
method: 'POST'
});
/**
* Perform a [indices.get](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-get-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Ignore unavailable indexes (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.allowNoIndices - Ignore if a wildcard expression resolves to no concrete indices (default: false)
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether wildcard expressions should get expanded to open or closed indices (default: open)
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether to return all default setting for each of the indices.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names
*/
api.indices.prototype.get = ca({
params: {
local: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
includeDefaults: {
type: 'boolean',
'default': false,
name: 'include_defaults'
}
},
url: {
fmt: '/<%=index%>',
req: {
index: {
type: 'list'
}
}
}
});
/**
* Perform a [indices.getAlias](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=all] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to filter aliases
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - A comma-separated list of alias names to return
*/
api.indices.prototype.getAlias = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'all',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_alias/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'list'
}
}
}, {
fmt: '/_alias/<%=name%>',
req: {
name: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_alias',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_alias'
}]
});
/**
* Perform a [indices.getFieldMapping](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-get-field-mapping.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether the default mapping values should be returned as well
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields
*/
api.indices.prototype.getFieldMapping = ca({
params: {
includeDefaults: {
type: 'boolean',
name: 'include_defaults'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_mapping/<%=type%>/field/<%=fields%>',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
},
fields: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_mapping/field/<%=fields%>',
req: {
index: {
type: 'list'
},
fields: {
type: 'list'
}
}
}, {
fmt: '/_mapping/<%=type%>/field/<%=fields%>',
req: {
type: {
type: 'list'
},
fields: {
type: 'list'
}
}
}, {
fmt: '/_mapping/field/<%=fields%>',
req: {
fields: {
type: 'list'
}
}
}]
});
/**
* Perform a [indices.getMapping](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-get-mapping.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types
*/
api.indices.prototype.getMapping = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_mapping/<%=type%>',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_mapping',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_mapping/<%=type%>',
req: {
type: {
type: 'list'
}
}
}, {
fmt: '/_mapping'
}]
});
/**
* Perform a [indices.getSettings](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-get-settings.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open,closed] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether to return all default setting for each of the indices.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - The name of the settings that should be included
*/
api.indices.prototype.getSettings = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': ['open', 'closed'],
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
local: {
type: 'boolean'
},
includeDefaults: {
type: 'boolean',
'default': false,
name: 'include_defaults'
}
},
urls: [{
fmt: '/<%=index%>/_settings/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_settings',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_settings/<%=name%>',
req: {
name: {
type: 'list'
}
}
}, {
fmt: '/_settings'
}]
});
/**
* Perform a [indices.getTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - The comma separated names of the index templates
*/
api.indices.prototype.getTemplate = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/_template/<%=name%>',
req: {
name: {
type: 'list'
}
}
}, {
fmt: '/_template'
}]
});
/**
* Perform a [indices.getUpgrade](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-upgrade.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.getUpgrade = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_upgrade',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_upgrade'
}]
});
/**
* Perform a [indices.open](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-open-close.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=closed] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of active shards to wait for before the operation returns.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma separated list of indices to open
*/
api.indices.prototype.open = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'closed',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
}
},
url: {
fmt: '/<%=index%>/_open',
req: {
index: {
type: 'list'
}
}
},
method: 'POST'
});
/**
* Perform a [indices.putAlias](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit timestamp for the document
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names the alias should point to (supports wildcards); use `_all` to perform the operation on all indices.
* @param {<<api-param-type-string,`String`>>} params.name - The name of the alias to be created or updated
*/
api.indices.prototype.putAlias = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/<%=index%>/_alias/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'string'
}
}
},
method: 'PUT'
});
/**
* Perform a [indices.putMapping](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-put-mapping.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.updateAllTypes - Whether to update the mapping for all fields with the same name across all types or not
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices.
* @param {<<api-param-type-string,`String`>>} params.type - The name of the document type
*/
api.indices.prototype.putMapping = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
updateAllTypes: {
type: 'boolean',
name: 'update_all_types'
}
},
urls: [{
fmt: '/<%=index%>/_mapping/<%=type%>',
req: {
index: {
type: 'list'
},
type: {
type: 'string'
}
}
}, {
fmt: '/_mapping/<%=type%>',
req: {
type: {
type: 'string'
}
}
}],
needBody: true,
method: 'PUT'
});
/**
* Perform a [indices.putSettings](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-update-settings.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.preserveExisting - Whether to update existing settings. If set to `true` existing settings on an index remain unchanged, the default is `false`
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.putSettings = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
},
preserveExisting: {
type: 'boolean',
name: 'preserve_existing'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
}
},
urls: [{
fmt: '/<%=index%>/_settings',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_settings'
}],
needBody: true,
method: 'PUT'
});
/**
* Perform a [indices.putTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-number,`Number`>>} params.order - The order for this template when merging multiple matching ones (higher numbers are merged later, overriding the lower numbers)
* @param {<<api-param-type-boolean,`Boolean`>>} params.create - Whether the index template should only be added if new or can also replace an existing one
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-string,`String`>>} params.name - The name of the template
*/
api.indices.prototype.putTemplate = ca({
params: {
order: {
type: 'number'
},
create: {
type: 'boolean',
'default': false
},
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
}
},
url: {
fmt: '/_template/<%=name%>',
req: {
name: {
type: 'string'
}
}
},
needBody: true,
method: 'PUT'
});
/**
* Perform a [indices.recovery](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-recovery.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.detailed - Whether to display detailed information about shard recovery
* @param {<<api-param-type-boolean,`Boolean`>>} params.activeOnly - Display only those recoveries that are currently on-going
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.recovery = ca({
params: {
detailed: {
type: 'boolean',
'default': false
},
activeOnly: {
type: 'boolean',
'default': false,
name: 'active_only'
}
},
urls: [{
fmt: '/<%=index%>/_recovery',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_recovery'
}]
});
/**
* Perform a [indices.refresh](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-refresh.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.refresh = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_refresh',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_refresh'
}],
method: 'POST'
});
/**
* Perform a [indices.rollover](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-rollover-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.dryRun - If set to true the rollover action will only be validated but not actually performed even if a condition matches. The default is false
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Set the number of active shards to wait for on the newly created rollover index before the operation returns.
* @param {<<api-param-type-string,`String`>>} params.alias - The name of the alias to rollover
* @param {<<api-param-type-string,`String`>>} params.newIndex - The name of the rollover index
*/
api.indices.prototype.rollover = ca({
params: {
timeout: {
type: 'time'
},
dryRun: {
type: 'boolean',
name: 'dry_run'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
}
},
urls: [{
fmt: '/<%=alias%>/_rollover/<%=newIndex%>',
req: {
alias: {
type: 'string'
},
newIndex: {
type: 'string'
}
}
}, {
fmt: '/<%=alias%>/_rollover',
req: {
alias: {
type: 'string'
}
}
}],
method: 'POST'
});
/**
* Perform a [indices.segments](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-segments.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.verbose - Includes detailed memory usage by Lucene.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.segments = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
verbose: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/<%=index%>/_segments',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_segments'
}]
});
/**
* Perform a [indices.shardStores](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-shards-stores.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.status - A comma-separated list of statuses used to filter on shards to get store information for
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.shardStores = ca({
params: {
status: {
type: 'list',
options: ['green', 'yellow', 'red', 'all']
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_shard_stores',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_shard_stores'
}]
});
/**
* Perform a [indices.shrink](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-shrink-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.copySettings - whether or not to copy settings from the source index (defaults to false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Set the number of active shards to wait for on the shrunken index before the operation returns.
* @param {<<api-param-type-string,`String`>>} params.index - The name of the source index to shrink
* @param {<<api-param-type-string,`String`>>} params.target - The name of the target index to shrink into
*/
api.indices.prototype.shrink = ca({
params: {
copySettings: {
type: 'boolean',
name: 'copy_settings'
},
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
}
},
url: {
fmt: '/<%=index%>/_shrink/<%=target%>',
req: {
index: {
type: 'string'
},
target: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [indices.split](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-split-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.copySettings - whether or not to copy settings from the source index (defaults to false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Set the number of active shards to wait for on the shrunken index before the operation returns.
* @param {<<api-param-type-string,`String`>>} params.index - The name of the source index to split
* @param {<<api-param-type-string,`String`>>} params.target - The name of the target index to split into
*/
api.indices.prototype.split = ca({
params: {
copySettings: {
type: 'boolean',
name: 'copy_settings'
},
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
}
},
url: {
fmt: '/<%=index%>/_split/<%=target%>',
req: {
index: {
type: 'string'
},
target: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [indices.stats](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-stats.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.completionFields - A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fielddataFields - A comma-separated list of fields for `fielddata` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.groups - A comma-separated list of search groups for `search` index metric
* @param {<<api-param-type-string,`String`>>} [params.level=indices] - Return stats aggregated at cluster, index or shard level
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.types - A comma-separated list of document types for the `indexing` index metric
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeSegmentFileSizes - Whether to report the aggregated disk usage of each one of the Lucene index files (only applies if segment stats are requested)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned the specific metrics.
*/
api.indices.prototype.stats = ca({
params: {
completionFields: {
type: 'list',
name: 'completion_fields'
},
fielddataFields: {
type: 'list',
name: 'fielddata_fields'
},
fields: {
type: 'list'
},
groups: {
type: 'list'
},
level: {
type: 'enum',
'default': 'indices',
options: ['cluster', 'indices', 'shards']
},
types: {
type: 'list'
},
includeSegmentFileSizes: {
type: 'boolean',
'default': false,
name: 'include_segment_file_sizes'
}
},
urls: [{
fmt: '/<%=index%>/_stats/<%=metric%>',
req: {
index: {
type: 'list'
},
metric: {
type: 'list',
options: ['_all', 'completion', 'docs', 'fielddata', 'query_cache', 'flush', 'get', 'indexing', 'merge', 'request_cache', 'refresh', 'search', 'segments', 'store', 'warmer', 'suggest']
}
}
}, {
fmt: '/_stats/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'completion', 'docs', 'fielddata', 'query_cache', 'flush', 'get', 'indexing', 'merge', 'request_cache', 'refresh', 'search', 'segments', 'store', 'warmer', 'suggest']
}
}
}, {
fmt: '/<%=index%>/_stats',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_stats'
}]
});
/**
* Perform a [indices.updateAliases](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Request timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
*/
api.indices.prototype.updateAliases = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_aliases'
},
needBody: true,
method: 'POST'
});
/**
* Perform a [indices.upgrade](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/indices-upgrade.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Specify whether the request should block until the all segments are upgraded (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.onlyAncientSegments - If true, only ancient (an older Lucene major release) segments will be upgraded
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.upgrade = ca({
params: {
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
waitForCompletion: {
type: 'boolean',
name: 'wait_for_completion'
},
onlyAncientSegments: {
type: 'boolean',
name: 'only_ancient_segments'
}
},
urls: [{
fmt: '/<%=index%>/_upgrade',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_upgrade'
}],
method: 'POST'
});
/**
* Perform a [indices.validateQuery](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/search-validate.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - Return detailed information about the error
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-boolean,`Boolean`>>} params.rewrite - Provide a more detailed explanation showing the actual Lucene query that will be executed.
* @param {<<api-param-type-boolean,`Boolean`>>} params.allShards - Execute validation on all shards instead of one random shard per index
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types
*/
api.indices.prototype.validateQuery = ca({
params: {
explain: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
q: {
type: 'string'
},
analyzer: {
type: 'string'
},
analyzeWildcard: {
type: 'boolean',
name: 'analyze_wildcard'
},
defaultOperator: {
type: 'enum',
'default': 'OR',
options: ['AND', 'OR'],
name: 'default_operator'
},
df: {
type: 'string'
},
lenient: {
type: 'boolean'
},
rewrite: {
type: 'boolean'
},
allShards: {
type: 'boolean',
name: 'all_shards'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_validate/query',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_validate/query',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_validate/query'
}],
method: 'POST'
});
/**
* Perform a [info](http://www.elastic.co/guide/) request
*
* @param {Object} params - An object with parameters used to carry out this action
*/
api.info = ca({
url: {
fmt: '/'
}
});
api.ingest = namespace();
/**
* Perform a [ingest.deletePipeline](https://www.elastic.co/guide/en/elasticsearch/plugins/6.x/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.id - Pipeline ID
*/
api.ingest.prototype.deletePipeline = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_ingest/pipeline/<%=id%>',
req: {
id: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [ingest.getPipeline](https://www.elastic.co/guide/en/elasticsearch/plugins/6.x/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>} params.id - Comma separated list of pipeline ids. Wildcards supported
*/
api.ingest.prototype.getPipeline = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
urls: [{
fmt: '/_ingest/pipeline/<%=id%>',
req: {
id: {
type: 'string'
}
}
}, {
fmt: '/_ingest/pipeline'
}]
});
/**
* Perform a [ingest.processorGrok](https://www.elastic.co/guide/en/elasticsearch/plugins/6.x/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
*/
api.ingest.prototype.processorGrok = ca({
url: {
fmt: '/_ingest/processor/grok'
}
});
/**
* Perform a [ingest.putPipeline](https://www.elastic.co/guide/en/elasticsearch/plugins/6.x/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.id - Pipeline ID
*/
api.ingest.prototype.putPipeline = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_ingest/pipeline/<%=id%>',
req: {
id: {
type: 'string'
}
}
},
needBody: true,
method: 'PUT'
});
/**
* Perform a [ingest.simulate](https://www.elastic.co/guide/en/elasticsearch/plugins/6.x/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.verbose - Verbose mode. Display data output for each processor in executed pipeline
* @param {<<api-param-type-string,`String`>>} params.id - Pipeline ID
*/
api.ingest.prototype.simulate = ca({
params: {
verbose: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_ingest/pipeline/<%=id%>/_simulate',
req: {
id: {
type: 'string'
}
}
}, {
fmt: '/_ingest/pipeline/_simulate'
}],
needBody: true,
method: 'POST'
});
/**
* Perform a [mget](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/docs-multi-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return in the response
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.mget = ca({
params: {
storedFields: {
type: 'list',
name: 'stored_fields'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_mget',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/_mget',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_mget'
}],
needBody: true,
method: 'POST'
});
/**
* Perform a [msearch](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/search-multi-search.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-number,`Number`>>} params.maxConcurrentSearches - Controls the maximum number of concurrent searches the multi search api will execute
* @param {<<api-param-type-boolean,`Boolean`>>} params.typedKeys - Specify whether aggregation and suggester names should be prefixed by their respective types in the response
* @param {<<api-param-type-number,`Number`>>} [params.preFilterShardSize=128] - A threshold that enforces a pre-filter roundtrip to prefilter search shards based on query rewriting if the number of shards the search request expands to exceeds the threshold. This filter roundtrip can limit the number of shards significantly if for instance a shard can not match any documents based on it's rewrite method ie. if date filters are mandatory to match but the shard bounds and the query are disjoint.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to use as default
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to use as default
*/
api.msearch = ca({
params: {
searchType: {
type: 'enum',
options: ['query_then_fetch', 'query_and_fetch', 'dfs_query_then_fetch', 'dfs_query_and_fetch'],
name: 'search_type'
},
maxConcurrentSearches: {
type: 'number',
name: 'max_concurrent_searches'
},
typedKeys: {
type: 'boolean',
name: 'typed_keys'
},
preFilterShardSize: {
type: 'number',
'default': 128,
name: 'pre_filter_shard_size'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_msearch',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_msearch',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_msearch'
}],
needBody: true,
bulkBody: true,
method: 'POST'
});
/**
* Perform a [msearchTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/search-multi-search.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-boolean,`Boolean`>>} params.typedKeys - Specify whether aggregation and suggester names should be prefixed by their respective types in the response
* @param {<<api-param-type-number,`Number`>>} params.maxConcurrentSearches - Controls the maximum number of concurrent searches the multi search api will execute
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to use as default
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to use as default
*/
api.msearchTemplate = ca({
params: {
searchType: {
type: 'enum',
options: ['query_then_fetch', 'query_and_fetch', 'dfs_query_then_fetch', 'dfs_query_and_fetch'],
name: 'search_type'
},
typedKeys: {
type: 'boolean',
name: 'typed_keys'
},
maxConcurrentSearches: {
type: 'number',
name: 'max_concurrent_searches'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_msearch/template',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_msearch/template',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_msearch/template'
}],
needBody: true,
bulkBody: true,
method: 'POST'
});
/**
* Perform a [mtermvectors](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/docs-multi-termvectors.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.ids - A comma-separated list of documents ids. You must define ids as parameter or set "ids" or "docs" in the request body
* @param {<<api-param-type-boolean,`Boolean`>>} params.termStatistics - Specifies if total term frequency and document frequency should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} [params.fieldStatistics=true] - Specifies if document count, sum of document frequencies and sum of total term frequencies should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to return. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} [params.offsets=true] - Specifies if term offsets should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} [params.positions=true] - Specifies if term positions should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} [params.payloads=true] - Specifies if term payloads should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random) .Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-string,`String`>>} params.parent - Parent id of documents. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specifies if requests are real-time as opposed to near-real-time (default: true).
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.index - The index in which the document resides.
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document.
*/
api.mtermvectors = ca({
params: {
ids: {
type: 'list',
required: false
},
termStatistics: {
type: 'boolean',
'default': false,
required: false,
name: 'term_statistics'
},
fieldStatistics: {
type: 'boolean',
'default': true,
required: false,
name: 'field_statistics'
},
fields: {
type: 'list',
required: false
},
offsets: {
type: 'boolean',
'default': true,
required: false
},
positions: {
type: 'boolean',
'default': true,
required: false
},
payloads: {
type: 'boolean',
'default': true,
required: false
},
preference: {
type: 'string',
required: false
},
routing: {
type: 'string',
required: false
},
parent: {
type: 'string',
required: false
},
realtime: {
type: 'boolean',
required: false
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_mtermvectors',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/_mtermvectors',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_mtermvectors'
}],
method: 'POST'
});
api.nodes = namespace();
/**
* Perform a [nodes.hotThreads](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cluster-nodes-hot-threads.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.interval - The interval for the second sampling of threads
* @param {<<api-param-type-number,`Number`>>} params.snapshots - Number of samples of thread stacktrace (default: 10)
* @param {<<api-param-type-number,`Number`>>} params.threads - Specify the number of threads to provide information for (default: 3)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreIdleThreads - Don't show threads that are in known-idle places, such as waiting on a socket select or pulling from an empty task queue (default: true)
* @param {<<api-param-type-string,`String`>>} params.type - The type to sample (default: cpu)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
*/
api.nodes.prototype.hotThreads = ca({
params: {
interval: {
type: 'time'
},
snapshots: {
type: 'number'
},
threads: {
type: 'number'
},
ignoreIdleThreads: {
type: 'boolean',
name: 'ignore_idle_threads'
},
type: {
type: 'enum',
options: ['cpu', 'wait', 'block']
},
timeout: {
type: 'time'
}
},
urls: [{
fmt: '/_nodes/<%=nodeId%>/hotthreads',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_nodes/hotthreads'
}]
});
/**
* Perform a [nodes.info](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cluster-nodes-info.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - A comma-separated list of metrics you wish returned. Leave empty to return all.
*/
api.nodes.prototype.info = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
timeout: {
type: 'time'
}
},
urls: [{
fmt: '/_nodes/<%=nodeId%>/<%=metric%>',
req: {
nodeId: {
type: 'list'
},
metric: {
type: 'list',
options: ['settings', 'os', 'process', 'jvm', 'thread_pool', 'transport', 'http', 'plugins', 'ingest']
}
}
}, {
fmt: '/_nodes/<%=nodeId%>',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_nodes/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['settings', 'os', 'process', 'jvm', 'thread_pool', 'transport', 'http', 'plugins', 'ingest']
}
}
}, {
fmt: '/_nodes'
}]
});
/**
* Perform a [nodes.stats](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cluster-nodes-stats.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.completionFields - A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fielddataFields - A comma-separated list of fields for `fielddata` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards)
* @param {<<api-param-type-boolean,`Boolean`>>} params.groups - A comma-separated list of search groups for `search` index metric
* @param {<<api-param-type-string,`String`>>} [params.level=node] - Return indices stats aggregated at index, node or shard level
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.types - A comma-separated list of document types for the `indexing` index metric
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeSegmentFileSizes - Whether to report the aggregated disk usage of each one of the Lucene index files (only applies if segment stats are requested)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned to the specified metrics
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.indexMetric - Limit the information returned for `indices` metric to the specific index metrics. Isn't used if `indices` (or `all`) metric isn't specified.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
*/
api.nodes.prototype.stats = ca({
params: {
completionFields: {
type: 'list',
name: 'completion_fields'
},
fielddataFields: {
type: 'list',
name: 'fielddata_fields'
},
fields: {
type: 'list'
},
groups: {
type: 'boolean'
},
level: {
type: 'enum',
'default': 'node',
options: ['indices', 'node', 'shards']
},
types: {
type: 'list'
},
timeout: {
type: 'time'
},
includeSegmentFileSizes: {
type: 'boolean',
'default': false,
name: 'include_segment_file_sizes'
}
},
urls: [{
fmt: '/_nodes/<%=nodeId%>/stats/<%=metric%>/<%=indexMetric%>',
req: {
nodeId: {
type: 'list'
},
metric: {
type: 'list',
options: ['_all', 'breaker', 'fs', 'http', 'indices', 'jvm', 'os', 'process', 'thread_pool', 'transport', 'discovery']
},
indexMetric: {
type: 'list',
options: ['_all', 'completion', 'docs', 'fielddata', 'query_cache', 'flush', 'get', 'indexing', 'merge', 'request_cache', 'refresh', 'search', 'segments', 'store', 'warmer', 'suggest']
}
}
}, {
fmt: '/_nodes/<%=nodeId%>/stats/<%=metric%>',
req: {
nodeId: {
type: 'list'
},
metric: {
type: 'list',
options: ['_all', 'breaker', 'fs', 'http', 'indices', 'jvm', 'os', 'process', 'thread_pool', 'transport', 'discovery']
}
}
}, {
fmt: '/_nodes/stats/<%=metric%>/<%=indexMetric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'breaker', 'fs', 'http', 'indices', 'jvm', 'os', 'process', 'thread_pool', 'transport', 'discovery']
},
indexMetric: {
type: 'list',
options: ['_all', 'completion', 'docs', 'fielddata', 'query_cache', 'flush', 'get', 'indexing', 'merge', 'request_cache', 'refresh', 'search', 'segments', 'store', 'warmer', 'suggest']
}
}
}, {
fmt: '/_nodes/<%=nodeId%>/stats',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_nodes/stats/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'breaker', 'fs', 'http', 'indices', 'jvm', 'os', 'process', 'thread_pool', 'transport', 'discovery']
}
}
}, {
fmt: '/_nodes/stats'
}]
});
/**
* Perform a [nodes.usage](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/cluster-nodes-usage.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned to the specified metrics
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
*/
api.nodes.prototype.usage = ca({
params: {
timeout: {
type: 'time'
}
},
urls: [{
fmt: '/_nodes/<%=nodeId%>/usage/<%=metric%>',
req: {
nodeId: {
type: 'list'
},
metric: {
type: 'list',
options: ['_all', 'rest_actions']
}
}
}, {
fmt: '/_nodes/<%=nodeId%>/usage',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_nodes/usage/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'rest_actions']
}
}
}, {
fmt: '/_nodes/usage'
}]
});
/**
* Perform a [ping](http://www.elastic.co/guide/) request
*
* @param {Object} params - An object with parameters used to carry out this action
*/
api.ping = ca({
url: {
fmt: '/'
},
requestTimeout: 3000,
method: 'HEAD'
});
/**
* Perform a [putScript](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/modules-scripting.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.context - Script context
* @param {<<api-param-type-string,`String`>>} params.id - Script ID
*/
api.putScript = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
context: {
type: 'string'
}
},
urls: [{
fmt: '/_scripts/<%=id%>/<%=context%>',
req: {
id: {
type: 'string'
},
context: {
type: 'string'
}
}
}, {
fmt: '/_scripts/<%=id%>',
req: {
id: {
type: 'string'
}
}
}],
needBody: true,
method: 'PUT'
});
/**
* Perform a [rankEval](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/search-rank-eval.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices
*/
api.rankEval = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_rank_eval',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_rank_eval'
}],
needBody: true,
method: 'POST'
});
/**
* Perform a [reindex](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/docs-reindex.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Should the effected indexes be refreshed?
* @param {<<api-param-type-duration-string,`DurationString`>>} [params.timeout=1m] - Time each individual bulk request should wait for shards that are unavailable.
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the reindex operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-boolean,`Boolean`>>} [params.waitForCompletion=true] - Should the request should block until the reindex is complete.
* @param {<<api-param-type-number,`Number`>>} params.requestsPerSecond - The throttle to set on this request in sub-requests per second. -1 means no throttle.
* @param {<<api-param-type-number,`Number`>>} [params.slices=1] - The number of slices this task should be divided into. Defaults to 1 meaning the task isn't sliced into subtasks.
*/
api.reindex = ca({
params: {
refresh: {
type: 'boolean'
},
timeout: {
type: 'time',
'default': '1m'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
waitForCompletion: {
type: 'boolean',
'default': true,
name: 'wait_for_completion'
},
requestsPerSecond: {
type: 'number',
'default': 0,
name: 'requests_per_second'
},
slices: {
type: 'number',
'default': 1
}
},
url: {
fmt: '/_reindex'
},
needBody: true,
method: 'POST'
});
/**
* Perform a [reindexRethrottle](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/docs-reindex.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-number,`Number`>>} params.requestsPerSecond - The throttle to set on this request in floating sub-requests per second. -1 means set no throttle.
* @param {<<api-param-type-string,`String`>>} params.taskId - The task id to rethrottle
*/
api.reindexRethrottle = ca({
params: {
requestsPerSecond: {
type: 'number',
required: true,
name: 'requests_per_second'
}
},
url: {
fmt: '/_reindex/<%=taskId%>/_rethrottle',
req: {
taskId: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [renderSearchTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/search-template.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.id - The id of the stored search template
*/
api.renderSearchTemplate = ca({
urls: [{
fmt: '/_render/template/<%=id%>',
req: {
id: {
type: 'string'
}
}
}, {
fmt: '/_render/template'
}],
method: 'POST'
});
/**
* Perform a [scriptsPainlessExecute](https://www.elastic.co/guide/en/elasticsearch/painless/6.x/painless-execute-api.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
*/
api.scriptsPainlessExecute = ca({
url: {
fmt: '/_scripts/painless/_execute'
},
method: 'POST'
});
/**
* Perform a [scroll](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/search-request-scroll.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.scrollId - The scroll ID
*/
api.scroll = ca({
params: {
scroll: {
type: 'time'
},
scrollId: {
type: 'string',
name: 'scroll_id'
}
},
urls: [{
fmt: '/_search/scroll/<%=scrollId%>',
req: {
scrollId: {
type: 'string'
}
}
}, {
fmt: '/_search/scroll'
}],
paramAsBody: {
param: 'scrollId',
body: 'scroll_id'
},
method: 'POST'
});
/**
* Perform a [search](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/search-search.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - Specify whether to return detailed information about score computation as part of a hit
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return as part of a hit
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.docvalueFields - A comma-separated list of fields to return as the docvalue representation of a field for each hit
* @param {<<api-param-type-number,`Number`>>} params.from - Starting offset (default: 0)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-number,`Number`>>} params.size - Number of hits to return (default: 10)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.sort - A comma-separated list of <field>:<direction> pairs
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.terminateAfter - The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.stats - Specific 'tag' of the request for logging and statistical purposes
* @param {<<api-param-type-string,`String`>>} params.suggestField - Specify which field to use for suggestions
* @param {<<api-param-type-string,`String`>>} [params.suggestMode=missing] - Specify suggest mode
* @param {<<api-param-type-number,`Number`>>} params.suggestSize - How many suggestions to return in response
* @param {<<api-param-type-string,`String`>>} params.suggestText - The source text for which the suggestions should be returned
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.trackScores - Whether to calculate and return scores even if they are not used for sorting
* @param {<<api-param-type-boolean,`Boolean`>>} params.trackTotalHits - Indicate if the number of documents that match the query should be tracked
* @param {<<api-param-type-boolean,`Boolean`>>} [params.allowPartialSearchResults=true] - Indicate if an error should be returned if there is a partial search failure or timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.typedKeys - Specify whether aggregation and suggester names should be prefixed by their respective types in the response
* @param {<<api-param-type-boolean,`Boolean`>>} params.version - Specify whether to return document version as part of a hit
* @param {<<api-param-type-boolean,`Boolean`>>} params.requestCache - Specify if request cache should be used for this request or not, defaults to index level setting
* @param {<<api-param-type-number,`Number`>>} [params.batchedReduceSize=512] - The number of shard results that should be reduced at once on the coordinating node. This value should be used as a protection mechanism to reduce the memory overhead per search request if the potential number of shards in the request can be large.
* @param {<<api-param-type-number,`Number`>>} [params.maxConcurrentShardRequests=The default grows with the number of nodes in the cluster but is at most 256.] - The number of concurrent shard requests this search executes concurrently. This value should be used to limit the impact of the search on the cluster in order to limit the number of concurrent shard requests
* @param {<<api-param-type-number,`Number`>>} [params.preFilterShardSize=128] - A threshold that enforces a pre-filter roundtrip to prefilter search shards based on query rewriting if the number of shards the search request expands to exceeds the threshold. This filter roundtrip can limit the number of shards significantly if for instance a shard can not match any documents based on it's rewrite method ie. if date filters are mandatory to match but the shard bounds and the query are disjoint.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to search; leave empty to perform the operation on all types
*/
api.search = 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'
},
storedFields: {
type: 'list',
name: 'stored_fields'
},
docvalueFields: {
type: 'list',
name: 'docvalue_fields'
},
from: {
type: 'number'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
lenient: {
type: 'boolean'
},
preference: {
type: 'string'
},
q: {
type: 'string'
},
routing: {
type: 'list'
},
scroll: {
type: 'time'
},
searchType: {
type: 'enum',
options: ['query_then_fetch', 'dfs_query_then_fetch'],
name: 'search_type'
},
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: 'string',
name: 'suggest_text'
},
timeout: {
type: 'time'
},
trackScores: {
type: 'boolean',
name: 'track_scores'
},
trackTotalHits: {
type: 'boolean',
name: 'track_total_hits'
},
allowPartialSearchResults: {
type: 'boolean',
'default': true,
name: 'allow_partial_search_results'
},
typedKeys: {
type: 'boolean',
name: 'typed_keys'
},
version: {
type: 'boolean'
},
requestCache: {
type: 'boolean',
name: 'request_cache'
},
batchedReduceSize: {
type: 'number',
'default': 512,
name: 'batched_reduce_size'
},
maxConcurrentShardRequests: {
type: 'number',
'default': 'The default grows with the number of nodes in the cluster but is at most 256.',
name: 'max_concurrent_shard_requests'
},
preFilterShardSize: {
type: 'number',
'default': 128,
name: 'pre_filter_shard_size'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_search',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_search',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_search'
}],
method: 'POST'
});
/**
* Perform a [searchShards](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/search-shards.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices
*/
api.searchShards = ca({
params: {
preference: {
type: 'string'
},
routing: {
type: 'string'
},
local: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_search_shards',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_search_shards'
}],
method: 'POST'
});
/**
* Perform a [searchTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/search-template.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - Specify whether to return detailed information about score computation as part of a hit
* @param {<<api-param-type-boolean,`Boolean`>>} params.profile - Specify whether to profile the query execution
* @param {<<api-param-type-boolean,`Boolean`>>} params.typedKeys - Specify whether aggregation and suggester names should be prefixed by their respective types in the response
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to search; leave empty to perform the operation on all types
*/
api.searchTemplate = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
preference: {
type: 'string'
},
routing: {
type: 'list'
},
scroll: {
type: 'time'
},
searchType: {
type: 'enum',
options: ['query_then_fetch', 'query_and_fetch', 'dfs_query_then_fetch', 'dfs_query_and_fetch'],
name: 'search_type'
},
explain: {
type: 'boolean'
},
profile: {
type: 'boolean'
},
typedKeys: {
type: 'boolean',
name: 'typed_keys'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_search/template',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_search/template',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_search/template'
}],
needBody: true,
method: 'POST'
});
api.snapshot = namespace();
/**
* Perform a [snapshot.create](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Should this request wait until the operation has completed before returning
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>} params.snapshot - A snapshot name
*/
api.snapshot.prototype.create = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForCompletion: {
type: 'boolean',
'default': false,
name: 'wait_for_completion'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [snapshot.createRepository](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.verify - Whether to verify the repository after creation
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
*/
api.snapshot.prototype.createRepository = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
},
verify: {
type: 'boolean'
}
},
url: {
fmt: '/_snapshot/<%=repository%>',
req: {
repository: {
type: 'string'
}
}
},
needBody: true,
method: 'POST'
});
/**
* Perform a [snapshot.delete](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>} params.snapshot - A snapshot name
*/
api.snapshot.prototype['delete'] = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [snapshot.deleteRepository](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.repository - A comma-separated list of repository names
*/
api.snapshot.prototype.deleteRepository = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_snapshot/<%=repository%>',
req: {
repository: {
type: 'list'
}
}
},
method: 'DELETE'
});
/**
* Perform a [snapshot.get](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether to ignore unavailable snapshots, defaults to false which means a SnapshotMissingException is thrown
* @param {<<api-param-type-boolean,`Boolean`>>} params.verbose - Whether to show verbose snapshot info or only show the basic info found in the repository index blob
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.snapshot - A comma-separated list of snapshot names
*/
api.snapshot.prototype.get = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
verbose: {
type: 'boolean'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'list'
}
}
}
});
/**
* Perform a [snapshot.getRepository](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.repository - A comma-separated list of repository names
*/
api.snapshot.prototype.getRepository = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/_snapshot/<%=repository%>',
req: {
repository: {
type: 'list'
}
}
}, {
fmt: '/_snapshot'
}]
});
/**
* Perform a [snapshot.restore](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Should this request wait until the operation has completed before returning
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>} params.snapshot - A snapshot name
*/
api.snapshot.prototype.restore = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForCompletion: {
type: 'boolean',
'default': false,
name: 'wait_for_completion'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>/_restore',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [snapshot.status](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether to ignore unavailable snapshots, defaults to false which means a SnapshotMissingException is thrown
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.snapshot - A comma-separated list of snapshot names
*/
api.snapshot.prototype.status = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
}
},
urls: [{
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>/_status',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'list'
}
}
}, {
fmt: '/_snapshot/<%=repository%>/_status',
req: {
repository: {
type: 'string'
}
}
}, {
fmt: '/_snapshot/_status'
}]
});
/**
* Perform a [snapshot.verifyRepository](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
*/
api.snapshot.prototype.verifyRepository = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/_verify',
req: {
repository: {
type: 'string'
}
}
},
method: 'POST'
});
api.tasks = namespace();
/**
* Perform a [tasks.cancel](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodes - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.actions - A comma-separated list of actions that should be cancelled. Leave empty to cancel all.
* @param {<<api-param-type-string,`String`>>} params.parentTaskId - Cancel tasks with specified parent task id (node_id:task_number). Set to -1 to cancel all.
* @param {<<api-param-type-string,`String`>>} params.taskId - Cancel the task with specified task id (node_id:task_number)
*/
api.tasks.prototype.cancel = ca({
params: {
nodes: {
type: 'list'
},
actions: {
type: 'list'
},
parentTaskId: {
type: 'string',
name: 'parent_task_id'
}
},
urls: [{
fmt: '/_tasks/<%=taskId%>/_cancel',
req: {
taskId: {
type: 'string'
}
}
}, {
fmt: '/_tasks/_cancel'
}],
method: 'POST'
});
/**
* Perform a [tasks.get](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Wait for the matching tasks to complete (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.taskId - Return the task with specified id (node_id:task_number)
*/
api.tasks.prototype.get = ca({
params: {
waitForCompletion: {
type: 'boolean',
name: 'wait_for_completion'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_tasks/<%=taskId%>',
req: {
taskId: {
type: 'string'
}
}
}
});
/**
* Perform a [tasks.list](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodes - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.actions - A comma-separated list of actions that should be returned. Leave empty to return all.
* @param {<<api-param-type-boolean,`Boolean`>>} params.detailed - Return detailed task information (default: false)
* @param {<<api-param-type-string,`String`>>} params.parentTaskId - Return tasks with specified parent task id (node_id:task_number). Set to -1 to return all.
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Wait for the matching tasks to complete (default: false)
* @param {<<api-param-type-string,`String`>>} [params.groupBy=nodes] - Group tasks by nodes or parent/child relationships
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
*/
api.tasks.prototype.list = ca({
params: {
nodes: {
type: 'list'
},
actions: {
type: 'list'
},
detailed: {
type: 'boolean'
},
parentTaskId: {
type: 'string',
name: 'parent_task_id'
},
waitForCompletion: {
type: 'boolean',
name: 'wait_for_completion'
},
groupBy: {
type: 'enum',
'default': 'nodes',
options: ['nodes', 'parents', 'none'],
name: 'group_by'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_tasks'
}
});
/**
* Perform a [termvectors](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/docs-termvectors.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.termStatistics - Specifies if total term frequency and document frequency should be returned.
* @param {<<api-param-type-boolean,`Boolean`>>} [params.fieldStatistics=true] - Specifies if document count, sum of document frequencies and sum of total term frequencies should be returned.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to return.
* @param {<<api-param-type-boolean,`Boolean`>>} [params.offsets=true] - Specifies if term offsets should be returned.
* @param {<<api-param-type-boolean,`Boolean`>>} [params.positions=true] - Specifies if term positions should be returned.
* @param {<<api-param-type-boolean,`Boolean`>>} [params.payloads=true] - Specifies if term payloads should be returned.
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random).
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value.
* @param {<<api-param-type-string,`String`>>} params.parent - Parent id of documents.
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specifies if request is real-time as opposed to near-real-time (default: true).
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.index - The index in which the document resides.
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document.
* @param {<<api-param-type-string,`String`>>} params.id - The id of the document, when not specified a doc param should be supplied.
*/
api.termvectors = ca({
params: {
termStatistics: {
type: 'boolean',
'default': false,
required: false,
name: 'term_statistics'
},
fieldStatistics: {
type: 'boolean',
'default': true,
required: false,
name: 'field_statistics'
},
fields: {
type: 'list',
required: false
},
offsets: {
type: 'boolean',
'default': true,
required: false
},
positions: {
type: 'boolean',
'default': true,
required: false
},
payloads: {
type: 'boolean',
'default': true,
required: false
},
preference: {
type: 'string',
required: false
},
routing: {
type: 'string',
required: false
},
parent: {
type: 'string',
required: false
},
realtime: {
type: 'boolean',
required: false
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/<%=id%>/_termvectors',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/<%=type%>/_termvectors',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}],
method: 'POST'
});
/**
* Perform a [update](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/docs-update.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the update operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to return in the response
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-string,`String`>>} params.lang - The script language (default: painless)
* @param {<<api-param-type-string,`String`>>} params.parent - ID of the parent document. Is is only used for routing and when for the upsert request
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the effected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-number,`Number`>>} params.retryOnConflict - Specify how many times should the operation be retried when a conflict occurs (default: 0)
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - Document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.update = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
fields: {
type: 'list'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
lang: {
type: 'string'
},
parent: {
type: 'string'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
retryOnConflict: {
type: 'number',
name: 'retry_on_conflict'
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_update',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
needBody: true,
method: 'POST'
});
/**
* Perform a [updateByQuery](https://www.elastic.co/guide/en/elasticsearch/reference/6.x/docs-update-by-query.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-number,`Number`>>} params.from - Starting offset (default: 0)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.conflicts=abort] - What to do when the update by query hits version conflicts?
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-string,`String`>>} params.pipeline - Ingest pipeline to set on index requests made by this action. (default: none)
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-duration-string,`DurationString`>>} params.searchTimeout - Explicit timeout for each search request. Defaults to no timeout.
* @param {<<api-param-type-number,`Number`>>} params.size - Number of hits to return (default: 10)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.sort - A comma-separated list of <field>:<direction> pairs
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.terminateAfter - The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.stats - Specific 'tag' of the request for logging and statistical purposes
* @param {<<api-param-type-boolean,`Boolean`>>} params.version - Specify whether to return document version as part of a hit
* @param {<<api-param-type-boolean,`Boolean`>>} params.versionType - Should the document increment the version number (internal) on hit or not (reindex)
* @param {<<api-param-type-boolean,`Boolean`>>} params.requestCache - Specify if request cache should be used for this request or not, defaults to index level setting
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Should the effected indexes be refreshed?
* @param {<<api-param-type-duration-string,`DurationString`>>} [params.timeout=1m] - Time each individual bulk request should wait for shards that are unavailable.
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the update by query operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-number,`Number`>>} params.scrollSize - Size on the scroll request powering the update by query
* @param {<<api-param-type-boolean,`Boolean`>>} [params.waitForCompletion=true] - Should the request should block until the update by query operation is complete.
* @param {<<api-param-type-number,`Number`>>} params.requestsPerSecond - The throttle to set on this request in sub-requests per second. -1 means no throttle.
* @param {<<api-param-type-number,`Number`>>} [params.slices=1] - The number of slices this task should be divided into. Defaults to 1 meaning the task isn't sliced into subtasks.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to search; leave empty to perform the operation on all types
*/
api.updateByQuery = 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'
},
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'
},
pipeline: {
type: 'string'
},
preference: {
type: 'string'
},
q: {
type: 'string'
},
routing: {
type: 'list'
},
scroll: {
type: 'time'
},
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'
},
version: {
type: 'boolean'
},
versionType: {
type: 'boolean',
name: 'version_type'
},
requestCache: {
type: 'boolean',
name: 'request_cache'
},
refresh: {
type: 'boolean'
},
timeout: {
type: 'time',
'default': '1m'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
scrollSize: {
type: 'number',
name: 'scroll_size'
},
waitForCompletion: {
type: 'boolean',
'default': true,
name: 'wait_for_completion'
},
requestsPerSecond: {
type: 'number',
'default': 0,
name: 'requests_per_second'
},
slices: {
type: 'number',
'default': 1
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_update_by_query',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_update_by_query',
req: {
index: {
type: 'list'
}
}
}],
method: 'POST'
});
/***/ }),
/* 51 */
/***/ (function(module, exports, __webpack_require__) {
"use strict";
var ca = __webpack_require__(1).makeFactoryWithModifier(function (spec) {
return __webpack_require__(0).merge(spec, {
params: {
filterPath: {
type: 'list',
name: 'filter_path'
}
}
});
});
var namespace = __webpack_require__(1).namespaceFactory;
var api = module.exports = {};
api._namespaces = ['cat', 'cluster', 'indices', 'ingest', 'nodes', 'snapshot', 'tasks'];
/**
* Perform a [bulk](https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-bulk.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.includeTypeName - Whether to add the type name to the response
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the bulk operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the effected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.type - Default document type for items which don't provide one
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or default list of fields to return, can be overridden on each sub-request
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - Default list of fields to exclude from the returned _source field, can be overridden on each sub-request
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - Default list of fields to extract and return from the _source field, can be overridden on each sub-request
* @param {<<api-param-type-string,`String`>>} params.pipeline - The pipeline id to preprocess incoming documents with
* @param {<<api-param-type-string,`String`>>} params.index - Default index for items which don't provide one
*/
api.bulk = ca({
params: {
includeTypeName: {
type: 'string',
name: 'include_type_name'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
type: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
pipeline: {
type: 'string'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_bulk',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/_bulk',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_bulk'
}],
needBody: true,
bulkBody: true,
method: 'POST'
});
api.cat = namespace();
/**
* Perform a [cat.aliases](https://www.elastic.co/guide/en/elasticsearch/reference/master/cat.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - A comma-separated list of alias names to return
*/
api.cat.prototype.aliases = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/aliases/<%=name%>',
req: {
name: {
type: 'list'
}
}
}, {
fmt: '/_cat/aliases'
}]
});
/**
* Perform a [cat.allocation](https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-allocation.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information
*/
api.cat.prototype.allocation = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/allocation/<%=nodeId%>',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_cat/allocation'
}]
});
/**
* Perform a [cat.count](https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-count.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.count = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/count/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/count'
}]
});
/**
* Perform a [cat.fielddata](https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-fielddata.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to return the fielddata size
*/
api.cat.prototype.fielddata = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
},
fields: {
type: 'list'
}
},
urls: [{
fmt: '/_cat/fielddata/<%=fields%>',
req: {
fields: {
type: 'list'
}
}
}, {
fmt: '/_cat/fielddata'
}]
});
/**
* Perform a [cat.health](https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-health.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} [params.ts=true] - Set to false to disable timestamping
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.health = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
ts: {
type: 'boolean',
'default': true
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/health'
}
});
/**
* Perform a [cat.help](https://www.elastic.co/guide/en/elasticsearch/reference/master/cat.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
*/
api.cat.prototype.help = ca({
params: {
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
}
},
url: {
fmt: '/_cat'
}
});
/**
* Perform a [cat.indices](https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-indices.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-string,`String`>>} params.health - A health status ("green", "yellow", or "red" to filter only indices matching the specified health status
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-boolean,`Boolean`>>} params.pri - Set to true to return stats only for primary shards
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.indices = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'm', 'g']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
health: {
type: 'enum',
'default': null,
options: ['green', 'yellow', 'red']
},
help: {
type: 'boolean',
'default': false
},
pri: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/indices/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/indices'
}]
});
/**
* Perform a [cat.master](https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-master.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.master = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/master'
}
});
/**
* Perform a [cat.nodeattrs](https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-nodeattrs.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.nodeattrs = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/nodeattrs'
}
});
/**
* Perform a [cat.nodes](https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-nodes.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.fullId - Return the full node ID instead of the shortened version (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.nodes = ca({
params: {
format: {
type: 'string'
},
fullId: {
type: 'boolean',
name: 'full_id'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/nodes'
}
});
/**
* Perform a [cat.pendingTasks](https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-pending-tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.pendingTasks = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/pending_tasks'
}
});
/**
* Perform a [cat.plugins](https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-plugins.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.plugins = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/plugins'
}
});
/**
* Perform a [cat.recovery](https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-recovery.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.recovery = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/recovery/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/recovery'
}]
});
/**
* Perform a [cat.repositories](https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-repositories.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.repositories = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean',
'default': false
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/repositories'
}
});
/**
* Perform a [cat.segments](https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-segments.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.segments = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/segments/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/segments'
}]
});
/**
* Perform a [cat.shards](https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-shards.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.bytes - The unit in which to display byte values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to limit the returned information
*/
api.cat.prototype.shards = ca({
params: {
format: {
type: 'string'
},
bytes: {
type: 'enum',
options: ['b', 'k', 'kb', 'm', 'mb', 'g', 'gb', 't', 'tb', 'p', 'pb']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/shards/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cat/shards'
}]
});
/**
* Perform a [cat.snapshots](https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Set to true to ignore unavailable snapshots
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.repository - Name of repository from which to fetch the snapshot information
*/
api.cat.prototype.snapshots = ca({
params: {
format: {
type: 'string'
},
ignoreUnavailable: {
type: 'boolean',
'default': false,
name: 'ignore_unavailable'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/snapshots/<%=repository%>',
req: {
repository: {
type: 'list'
}
}
}, {
fmt: '/_cat/snapshots'
}]
});
/**
* Perform a [cat.tasks](https://www.elastic.co/guide/en/elasticsearch/reference/master/tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.actions - A comma-separated list of actions that should be returned. Leave empty to return all.
* @param {<<api-param-type-boolean,`Boolean`>>} params.detailed - Return detailed task information (default: false)
* @param {<<api-param-type-number,`Number`>>} params.parentTask - Return tasks with specified parent task id. Set to -1 to return all.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
*/
api.cat.prototype.tasks = ca({
params: {
format: {
type: 'string'
},
nodeId: {
type: 'list',
name: 'node_id'
},
actions: {
type: 'list'
},
detailed: {
type: 'boolean'
},
parentTask: {
type: 'number',
name: 'parent_task'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
url: {
fmt: '/_cat/tasks'
}
});
/**
* Perform a [cat.templates](https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>} params.name - A pattern that returned template names must match
*/
api.cat.prototype.templates = ca({
params: {
format: {
type: 'string'
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/templates/<%=name%>',
req: {
name: {
type: 'string'
}
}
}, {
fmt: '/_cat/templates'
}]
});
/**
* Perform a [cat.threadPool](https://www.elastic.co/guide/en/elasticsearch/reference/master/cat-thread-pool.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.format - a short version of the Accept header, e.g. json, yaml
* @param {<<api-param-type-string,`String`>>} params.size - The multiplier in which to display values
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.h - Comma-separated list of column names to display
* @param {<<api-param-type-boolean,`Boolean`>>} params.help - Return help information
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.s - Comma-separated list of column names or column aliases to sort by
* @param {<<api-param-type-boolean,`Boolean`>>} params.v - Verbose mode. Display column headers
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.threadPoolPatterns - A comma-separated list of regular-expressions to filter the thread pools in the output
*/
api.cat.prototype.threadPool = ca({
params: {
format: {
type: 'string'
},
size: {
type: 'enum',
options: ['', 'k', 'm', 'g', 't', 'p']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
h: {
type: 'list'
},
help: {
type: 'boolean',
'default': false
},
s: {
type: 'list'
},
v: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_cat/thread_pool/<%=threadPoolPatterns%>',
req: {
threadPoolPatterns: {
type: 'list'
}
}
}, {
fmt: '/_cat/thread_pool'
}]
});
/**
* Perform a [clearScroll](https://www.elastic.co/guide/en/elasticsearch/reference/master/search-request-scroll.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.scrollId - A comma-separated list of scroll IDs to clear
*/
api.clearScroll = ca({
urls: [{
fmt: '/_search/scroll/<%=scrollId%>',
req: {
scrollId: {
type: 'list'
}
}
}, {
fmt: '/_search/scroll'
}],
paramAsBody: {
param: 'scrollId',
body: 'scroll_id'
},
method: 'DELETE'
});
api.cluster = namespace();
/**
* Perform a [cluster.allocationExplain](https://www.elastic.co/guide/en/elasticsearch/reference/master/cluster-allocation-explain.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeYesDecisions - Return 'YES' decisions in explanation (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDiskInfo - Return information about disk usage and shard sizes (default: false)
*/
api.cluster.prototype.allocationExplain = ca({
params: {
includeYesDecisions: {
type: 'boolean',
name: 'include_yes_decisions'
},
includeDiskInfo: {
type: 'boolean',
name: 'include_disk_info'
}
},
url: {
fmt: '/_cluster/allocation/explain'
},
method: 'POST'
});
/**
* Perform a [cluster.getSettings](https://www.elastic.co/guide/en/elasticsearch/reference/master/cluster-update-settings.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether to return all default clusters setting.
*/
api.cluster.prototype.getSettings = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
},
includeDefaults: {
type: 'boolean',
'default': false,
name: 'include_defaults'
}
},
url: {
fmt: '/_cluster/settings'
}
});
/**
* Perform a [cluster.health](https://www.elastic.co/guide/en/elasticsearch/reference/master/cluster-health.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} [params.level=cluster] - Specify the level of detail for returned information
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Wait until the specified number of shards is active
* @param {<<api-param-type-string,`String`>>} params.waitForNodes - Wait until the specified number of nodes is available
* @param {<<api-param-type-string,`String`>>} params.waitForEvents - Wait until all currently queued events with the given priority are processed
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForNoRelocatingShards - Whether to wait until there are no relocating shards in the cluster
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForNoInitializingShards - Whether to wait until there are no initializing shards in the cluster
* @param {<<api-param-type-string,`String`>>} params.waitForStatus - Wait until cluster is in a specific state
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - Limit the information returned to a specific index
*/
api.cluster.prototype.health = ca({
params: {
level: {
type: 'enum',
'default': 'cluster',
options: ['cluster', 'indices', 'shards']
},
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
waitForNodes: {
type: 'string',
name: 'wait_for_nodes'
},
waitForEvents: {
type: 'enum',
options: ['immediate', 'urgent', 'high', 'normal', 'low', 'languid'],
name: 'wait_for_events'
},
waitForNoRelocatingShards: {
type: 'boolean',
name: 'wait_for_no_relocating_shards'
},
waitForNoInitializingShards: {
type: 'boolean',
name: 'wait_for_no_initializing_shards'
},
waitForStatus: {
type: 'enum',
'default': null,
options: ['green', 'yellow', 'red'],
name: 'wait_for_status'
}
},
urls: [{
fmt: '/_cluster/health/<%=index%>',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cluster/health'
}]
});
/**
* Perform a [cluster.pendingTasks](https://www.elastic.co/guide/en/elasticsearch/reference/master/cluster-pending.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
*/
api.cluster.prototype.pendingTasks = ca({
params: {
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_cluster/pending_tasks'
}
});
/**
* Perform a [cluster.putSettings](https://www.elastic.co/guide/en/elasticsearch/reference/master/cluster-update-settings.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
*/
api.cluster.prototype.putSettings = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_cluster/settings'
},
needBody: true,
method: 'PUT'
});
/**
* Perform a [cluster.remoteInfo](https://www.elastic.co/guide/en/elasticsearch/reference/master/cluster-remote-info.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
*/
api.cluster.prototype.remoteInfo = ca({
url: {
fmt: '/_remote/info'
}
});
/**
* Perform a [cluster.reroute](https://www.elastic.co/guide/en/elasticsearch/reference/master/cluster-reroute.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.dryRun - Simulate the operation only and return the resulting state
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - Return an explanation of why the commands can or cannot be executed
* @param {<<api-param-type-boolean,`Boolean`>>} params.retryFailed - Retries allocation of shards that are blocked due to too many subsequent allocation failures
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned to the specified metrics. Defaults to all but metadata
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
*/
api.cluster.prototype.reroute = ca({
params: {
dryRun: {
type: 'boolean',
name: 'dry_run'
},
explain: {
type: 'boolean'
},
retryFailed: {
type: 'boolean',
name: 'retry_failed'
},
metric: {
type: 'list',
options: ['_all', 'blocks', 'metadata', 'nodes', 'routing_table', 'master_node', 'version']
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_cluster/reroute'
},
method: 'POST'
});
/**
* Perform a [cluster.state](https://www.elastic.co/guide/en/elasticsearch/reference/master/cluster-state.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned to the specified metrics
*/
api.cluster.prototype.state = ca({
params: {
local: {
type: 'boolean'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/_cluster/state/<%=metric%>/<%=index%>',
req: {
metric: {
type: 'list',
options: ['_all', 'blocks', 'metadata', 'nodes', 'routing_table', 'routing_nodes', 'master_node', 'version']
},
index: {
type: 'list'
}
}
}, {
fmt: '/_cluster/state/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'blocks', 'metadata', 'nodes', 'routing_table', 'routing_nodes', 'master_node', 'version']
}
}
}, {
fmt: '/_cluster/state'
}]
});
/**
* Perform a [cluster.stats](https://www.elastic.co/guide/en/elasticsearch/reference/master/cluster-stats.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
*/
api.cluster.prototype.stats = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
timeout: {
type: 'time'
}
},
urls: [{
fmt: '/_cluster/stats/nodes/<%=nodeId%>',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_cluster/stats'
}]
});
/**
* Perform a [count](https://www.elastic.co/guide/en/elasticsearch/reference/master/search-count.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-number,`Number`>>} params.minScore - Include only documents with a specific `_score` value in the result
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-number,`Number`>>} params.terminateAfter - The maximum count for each shard, upon reaching which the query execution will terminate early
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of indices to restrict the results
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of types to restrict the results
*/
api.count = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
minScore: {
type: 'number',
name: 'min_score'
},
preference: {
type: 'string'
},
routing: {
type: 'list'
},
q: {
type: 'string'
},
analyzer: {
type: 'string'
},
analyzeWildcard: {
type: 'boolean',
name: 'analyze_wildcard'
},
defaultOperator: {
type: 'enum',
'default': 'OR',
options: ['AND', 'OR'],
name: 'default_operator'
},
df: {
type: 'string'
},
lenient: {
type: 'boolean'
},
terminateAfter: {
type: 'number',
name: 'terminate_after'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_count',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_count',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_count'
}],
method: 'POST'
});
/**
* Perform a [create](https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-index_.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the index operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>} params.parent - ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.pipeline - The pipeline id to preprocess incoming documents with
* @param {<<api-param-type-string,`String`>>} params.id - Document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.create = ca({
params: {
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
parent: {
type: 'string'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
},
pipeline: {
type: 'string'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_create',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
needBody: true,
method: 'POST'
});
/**
* Perform a [delete](https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-delete.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.includeTypeName - Whether to add the type name to the response
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the delete operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>} params.parent - ID of parent document
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the effected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api['delete'] = ca({
params: {
includeTypeName: {
type: 'string',
name: 'include_type_name'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
parent: {
type: 'string'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/<%=id%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/_doc/<%=id%>',
req: {
index: {
type: 'string'
},
id: {
type: 'string'
}
}
}],
method: 'DELETE'
});
/**
* Perform a [deleteByQuery](https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-delete-by-query.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-number,`Number`>>} params.from - Starting offset (default: 0)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.conflicts=abort] - What to do when the delete by query hits version conflicts?
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-duration-string,`DurationString`>>} params.searchTimeout - Explicit timeout for each search request. Defaults to no timeout.
* @param {<<api-param-type-number,`Number`>>} params.size - Number of hits to return (default: 10)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.sort - A comma-separated list of <field>:<direction> pairs
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.terminateAfter - The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.stats - Specific 'tag' of the request for logging and statistical purposes
* @param {<<api-param-type-boolean,`Boolean`>>} params.version - Specify whether to return document version as part of a hit
* @param {<<api-param-type-boolean,`Boolean`>>} params.requestCache - Specify if request cache should be used for this request or not, defaults to index level setting
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Should the effected indexes be refreshed?
* @param {<<api-param-type-duration-string,`DurationString`>>} [params.timeout=1m] - Time each individual bulk request should wait for shards that are unavailable.
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the delete by query operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-number,`Number`>>} params.scrollSize - Size on the scroll request powering the delete by query
* @param {<<api-param-type-boolean,`Boolean`>>} [params.waitForCompletion=true] - Should the request should block until the delete by query is complete.
* @param {<<api-param-type-number,`Number`>>} params.requestsPerSecond - The throttle for this request in sub-requests per second. -1 means no throttle.
* @param {<<api-param-type-number,`Number`>>} [params.slices=1] - The number of slices this task should be divided into. Defaults to 1 meaning the task isn't sliced into subtasks.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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'
},
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'
},
preference: {
type: 'string'
},
q: {
type: 'string'
},
routing: {
type: 'list'
},
scroll: {
type: 'time'
},
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'
},
version: {
type: 'boolean'
},
requestCache: {
type: 'boolean',
name: 'request_cache'
},
refresh: {
type: 'boolean'
},
timeout: {
type: 'time',
'default': '1m'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
scrollSize: {
type: 'number',
name: 'scroll_size'
},
waitForCompletion: {
type: 'boolean',
'default': true,
name: 'wait_for_completion'
},
requestsPerSecond: {
type: 'number',
'default': 0,
name: 'requests_per_second'
},
slices: {
type: 'number',
'default': 1
}
},
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](https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-scripting.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.id - Script ID
*/
api.deleteScript = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_scripts/<%=id%>',
req: {
id: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [exists](https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return in the response
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document (use `_all` to fetch the first document matching the ID across all types)
*/
api.exists = ca({
params: {
storedFields: {
type: 'list',
name: 'stored_fields'
},
parent: {
type: 'string'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'HEAD'
});
/**
* Perform a [existsSource](https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document; use `_all` to fetch the first document matching the ID across all types
*/
api.existsSource = ca({
params: {
parent: {
type: 'string'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_source',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'HEAD'
});
/**
* Perform a [explain](https://www.elastic.co/guide/en/elasticsearch/reference/master/search-explain.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcards and prefix queries in the query string query should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer for the query string query
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The default field for query string query (default: _all)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return in the response
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.explain = ca({
params: {
analyzeWildcard: {
type: 'boolean',
name: 'analyze_wildcard'
},
analyzer: {
type: 'string'
},
defaultOperator: {
type: 'enum',
'default': 'OR',
options: ['AND', 'OR'],
name: 'default_operator'
},
df: {
type: 'string'
},
storedFields: {
type: 'list',
name: 'stored_fields'
},
lenient: {
type: 'boolean'
},
parent: {
type: 'string'
},
preference: {
type: 'string'
},
q: {
type: 'string'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_explain',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [fieldCaps](https://www.elastic.co/guide/en/elasticsearch/reference/master/search-field-caps.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of field names
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.fieldCaps = ca({
params: {
fields: {
type: 'list'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_field_caps',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_field_caps'
}],
method: 'POST'
});
/**
* Perform a [get](https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.includeTypeName - Whether to add the type name to the response
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return in the response
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document (use `_all` to fetch the first document matching the ID across all types)
*/
api.get = ca({
params: {
includeTypeName: {
type: 'string',
name: 'include_type_name'
},
storedFields: {
type: 'list',
name: 'stored_fields'
},
parent: {
type: 'string'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/<%=id%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/_doc/<%=id%>',
req: {
index: {
type: 'string'
},
id: {
type: 'string'
}
}
}]
});
/**
* Perform a [getScript](https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-scripting.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.id - Script ID
*/
api.getScript = ca({
url: {
fmt: '/_scripts/<%=id%>',
req: {
id: {
type: 'string'
}
}
}
});
/**
* Perform a [getSource](https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.parent - The ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - The document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document; use `_all` to fetch the first document matching the ID across all types
*/
api.getSource = ca({
params: {
parent: {
type: 'string'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
url: {
fmt: '/<%=index%>/<%=type%>/<%=id%>/_source',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}
});
/**
* Perform a [index](https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-index_.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.includeTypeName - Whether to add the type name to the response
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the index operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>} [params.opType=index] - Explicit operation type
* @param {<<api-param-type-string,`String`>>} params.parent - ID of the parent document
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.pipeline - The pipeline id to preprocess incoming documents with
* @param {<<api-param-type-string,`String`>>} params.id - Document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.index = ca({
params: {
includeTypeName: {
type: 'string',
name: 'include_type_name'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
opType: {
type: 'enum',
'default': 'index',
options: ['index', 'create'],
name: 'op_type'
},
parent: {
type: 'string'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
},
pipeline: {
type: 'string'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/<%=id%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/<%=type%>',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/_doc/<%=id%>',
req: {
index: {
type: 'string'
},
id: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/_doc',
req: {
index: {
type: 'string'
}
}
}],
needBody: true,
method: 'POST'
});
api.indices = namespace();
/**
* Perform a [indices.analyze](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-analyze.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index to scope the operation
* @param {<<api-param-type-boolean,`Boolean`>>} params.preferLocal - With `true`, specify that a local shard should be used if available, with `false`, use a random shard (default: true)
* @param {<<api-param-type-string,`String`>>} [params.format=detailed] - Format of the output
*/
api.indices.prototype.analyze = ca({
params: {
index: {
type: 'string'
},
preferLocal: {
type: 'boolean',
name: 'prefer_local'
},
format: {
type: 'enum',
'default': 'detailed',
options: ['detailed', 'text']
}
},
urls: [{
fmt: '/<%=index%>/_analyze',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_analyze'
}],
method: 'POST'
});
/**
* Perform a [indices.clearCache](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-clearcache.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.fielddata - Clear field data
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to clear when using the `fielddata` parameter (default: all)
* @param {<<api-param-type-boolean,`Boolean`>>} params.query - Clear query caches
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index name to limit the operation
* @param {<<api-param-type-boolean,`Boolean`>>} params.request - Clear request cache
*/
api.indices.prototype.clearCache = ca({
params: {
fielddata: {
type: 'boolean'
},
fields: {
type: 'list'
},
query: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
index: {
type: 'list'
},
request: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_cache/clear',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_cache/clear'
}],
method: 'POST'
});
/**
* Perform a [indices.close](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-open-close.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma separated list of indices to close
*/
api.indices.prototype.close = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
url: {
fmt: '/<%=index%>/_close',
req: {
index: {
type: 'list'
}
}
},
method: 'POST'
});
/**
* Perform a [indices.create](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-create-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.includeTypeName - Whether a type should be expected in the body of the mappings.
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Set the number of active shards to wait for before the operation returns.
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
*/
api.indices.prototype.create = ca({
params: {
includeTypeName: {
type: 'string',
name: 'include_type_name'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/<%=index%>',
req: {
index: {
type: 'string'
}
}
},
method: 'PUT'
});
/**
* Perform a [indices.delete](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-delete-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Ignore unavailable indexes (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.allowNoIndices - Ignore if a wildcard expression resolves to no concrete indices (default: false)
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether wildcard expressions should get expanded to open or closed indices (default: open)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of indices to delete; use `_all` or `*` string to delete all indices
*/
api.indices.prototype['delete'] = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
url: {
fmt: '/<%=index%>',
req: {
index: {
type: 'list'
}
}
},
method: 'DELETE'
});
/**
* Perform a [indices.deleteAlias](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit timestamp for the document
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names (supports wildcards); use `_all` for all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - A comma-separated list of aliases to delete (supports wildcards); use `_all` to delete all aliases for the specified indices.
*/
api.indices.prototype.deleteAlias = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/<%=index%>/_alias/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'list'
}
}
},
method: 'DELETE'
});
/**
* Perform a [indices.deleteTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.name - The name of the template
*/
api.indices.prototype.deleteTemplate = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_template/<%=name%>',
req: {
name: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [indices.exists](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-exists.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Ignore unavailable indexes (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.allowNoIndices - Ignore if a wildcard expression resolves to no concrete indices (default: false)
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether wildcard expressions should get expanded to open or closed indices (default: open)
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether to return all default setting for each of the indices.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names
*/
api.indices.prototype.exists = ca({
params: {
local: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
includeDefaults: {
type: 'boolean',
'default': false,
name: 'include_defaults'
}
},
url: {
fmt: '/<%=index%>',
req: {
index: {
type: 'list'
}
}
},
method: 'HEAD'
});
/**
* Perform a [indices.existsAlias](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=all] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to filter aliases
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - A comma-separated list of alias names to return
*/
api.indices.prototype.existsAlias = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'all',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_alias/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'list'
}
}
}, {
fmt: '/_alias/<%=name%>',
req: {
name: {
type: 'list'
}
}
}],
method: 'HEAD'
});
/**
* Perform a [indices.existsTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - The comma separated names of the index templates
*/
api.indices.prototype.existsTemplate = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
local: {
type: 'boolean'
}
},
url: {
fmt: '/_template/<%=name%>',
req: {
name: {
type: 'list'
}
}
},
method: 'HEAD'
});
/**
* Perform a [indices.existsType](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-types-exists.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` to check the types across all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to check
*/
api.indices.prototype.existsType = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
url: {
fmt: '/<%=index%>/_mapping/<%=type%>',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
},
method: 'HEAD'
});
/**
* Perform a [indices.flush](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-flush.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.force - Whether a flush should be forced even if it is not necessarily needed ie. if no changes will be committed to the index. This is useful if transaction log IDs should be incremented even if no uncommitted changes are present. (This setting can be considered as internal)
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitIfOngoing - If set to true the flush operation will block until the flush can be executed if another flush operation is already executing. The default is true. If set to false the flush will be skipped iff if another flush operation is already running.
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string for all indices
*/
api.indices.prototype.flush = ca({
params: {
force: {
type: 'boolean'
},
waitIfOngoing: {
type: 'boolean',
name: 'wait_if_ongoing'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_flush',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_flush'
}],
method: 'POST'
});
/**
* Perform a [indices.flushSynced](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-synced-flush.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string for all indices
*/
api.indices.prototype.flushSynced = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_flush/synced',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_flush/synced'
}],
method: 'POST'
});
/**
* Perform a [indices.forcemerge](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-forcemerge.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flush - Specify whether the index should be flushed after performing the operation (default: true)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-number,`Number`>>} params.maxNumSegments - The number of segments the index should be merged into (default: dynamic)
* @param {<<api-param-type-boolean,`Boolean`>>} params.onlyExpungeDeletes - Specify whether the operation should only expunge deleted documents
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.forcemerge = ca({
params: {
flush: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
maxNumSegments: {
type: 'number',
name: 'max_num_segments'
},
onlyExpungeDeletes: {
type: 'boolean',
name: 'only_expunge_deletes'
}
},
urls: [{
fmt: '/<%=index%>/_forcemerge',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_forcemerge'
}],
method: 'POST'
});
/**
* Perform a [indices.get](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-get-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Ignore unavailable indexes (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.allowNoIndices - Ignore if a wildcard expression resolves to no concrete indices (default: false)
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether wildcard expressions should get expanded to open or closed indices (default: open)
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether to return all default setting for each of the indices.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names
*/
api.indices.prototype.get = ca({
params: {
local: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
includeDefaults: {
type: 'boolean',
'default': false,
name: 'include_defaults'
}
},
url: {
fmt: '/<%=index%>',
req: {
index: {
type: 'list'
}
}
}
});
/**
* Perform a [indices.getAlias](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=all] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to filter aliases
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - A comma-separated list of alias names to return
*/
api.indices.prototype.getAlias = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'all',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_alias/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'list'
}
}
}, {
fmt: '/_alias/<%=name%>',
req: {
name: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_alias',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_alias'
}]
});
/**
* Perform a [indices.getFieldMapping](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-get-field-mapping.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether the default mapping values should be returned as well
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields
*/
api.indices.prototype.getFieldMapping = ca({
params: {
includeDefaults: {
type: 'boolean',
name: 'include_defaults'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_mapping/<%=type%>/field/<%=fields%>',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
},
fields: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_mapping/field/<%=fields%>',
req: {
index: {
type: 'list'
},
fields: {
type: 'list'
}
}
}, {
fmt: '/_mapping/<%=type%>/field/<%=fields%>',
req: {
type: {
type: 'list'
},
fields: {
type: 'list'
}
}
}, {
fmt: '/_mapping/field/<%=fields%>',
req: {
fields: {
type: 'list'
}
}
}]
});
/**
* Perform a [indices.getMapping](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-get-mapping.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.includeTypeName - Whether to add the type name to the response
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types
*/
api.indices.prototype.getMapping = ca({
params: {
includeTypeName: {
type: 'string',
name: 'include_type_name'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/<%=index%>/_mapping/<%=type%>',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_mapping',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_mapping/<%=type%>',
req: {
type: {
type: 'list'
}
}
}, {
fmt: '/_mapping'
}]
});
/**
* Perform a [indices.getSettings](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-get-settings.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open,closed] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeDefaults - Whether to return all default setting for each of the indices.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - The name of the settings that should be included
*/
api.indices.prototype.getSettings = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': ['open', 'closed'],
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
local: {
type: 'boolean'
},
includeDefaults: {
type: 'boolean',
'default': false,
name: 'include_defaults'
}
},
urls: [{
fmt: '/<%=index%>/_settings/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_settings',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_settings/<%=name%>',
req: {
name: {
type: 'list'
}
}
}, {
fmt: '/_settings'
}]
});
/**
* Perform a [indices.getTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.name - The comma separated names of the index templates
*/
api.indices.prototype.getTemplate = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/_template/<%=name%>',
req: {
name: {
type: 'list'
}
}
}, {
fmt: '/_template'
}]
});
/**
* Perform a [indices.getUpgrade](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-upgrade.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.getUpgrade = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_upgrade',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_upgrade'
}]
});
/**
* Perform a [indices.open](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-open-close.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=closed] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of active shards to wait for before the operation returns.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma separated list of indices to open
*/
api.indices.prototype.open = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'closed',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
}
},
url: {
fmt: '/<%=index%>/_open',
req: {
index: {
type: 'list'
}
}
},
method: 'POST'
});
/**
* Perform a [indices.putAlias](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit timestamp for the document
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names the alias should point to (supports wildcards); use `_all` to perform the operation on all indices.
* @param {<<api-param-type-string,`String`>>} params.name - The name of the alias to be created or updated
*/
api.indices.prototype.putAlias = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/<%=index%>/_alias/<%=name%>',
req: {
index: {
type: 'list'
},
name: {
type: 'string'
}
}
},
method: 'PUT'
});
/**
* Perform a [indices.putMapping](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-put-mapping.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.includeTypeName - Whether a type should be expected in the body of the mappings.
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices.
* @param {<<api-param-type-string,`String`>>} params.type - The name of the document type
*/
api.indices.prototype.putMapping = ca({
params: {
includeTypeName: {
type: 'string',
name: 'include_type_name'
},
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_mapping/<%=type%>',
req: {
index: {
type: 'list'
},
type: {
type: 'string'
}
}
}, {
fmt: '/_mapping/<%=type%>',
req: {
type: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/_mapping',
req: {
index: {
type: 'list'
}
}
}],
needBody: true,
method: 'PUT'
});
/**
* Perform a [indices.putSettings](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-update-settings.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.preserveExisting - Whether to update existing settings. If set to `true` existing settings on an index remain unchanged, the default is `false`
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.putSettings = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
},
preserveExisting: {
type: 'boolean',
name: 'preserve_existing'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
}
},
urls: [{
fmt: '/<%=index%>/_settings',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_settings'
}],
needBody: true,
method: 'PUT'
});
/**
* Perform a [indices.putTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-templates.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-number,`Number`>>} params.order - The order for this template when merging multiple matching ones (higher numbers are merged later, overriding the lower numbers)
* @param {<<api-param-type-boolean,`Boolean`>>} params.create - Whether the index template should only be added if new or can also replace an existing one
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-string,`String`>>} params.name - The name of the template
*/
api.indices.prototype.putTemplate = ca({
params: {
order: {
type: 'number'
},
create: {
type: 'boolean',
'default': false
},
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
flatSettings: {
type: 'boolean',
name: 'flat_settings'
}
},
url: {
fmt: '/_template/<%=name%>',
req: {
name: {
type: 'string'
}
}
},
needBody: true,
method: 'PUT'
});
/**
* Perform a [indices.recovery](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-recovery.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.detailed - Whether to display detailed information about shard recovery
* @param {<<api-param-type-boolean,`Boolean`>>} params.activeOnly - Display only those recoveries that are currently on-going
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.recovery = ca({
params: {
detailed: {
type: 'boolean',
'default': false
},
activeOnly: {
type: 'boolean',
'default': false,
name: 'active_only'
}
},
urls: [{
fmt: '/<%=index%>/_recovery',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_recovery'
}]
});
/**
* Perform a [indices.refresh](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-refresh.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.refresh = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_refresh',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_refresh'
}],
method: 'POST'
});
/**
* Perform a [indices.rollover](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-rollover-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.dryRun - If set to true the rollover action will only be validated but not actually performed even if a condition matches. The default is false
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Set the number of active shards to wait for on the newly created rollover index before the operation returns.
* @param {<<api-param-type-string,`String`>>} params.alias - The name of the alias to rollover
* @param {<<api-param-type-string,`String`>>} params.newIndex - The name of the rollover index
*/
api.indices.prototype.rollover = ca({
params: {
timeout: {
type: 'time'
},
dryRun: {
type: 'boolean',
name: 'dry_run'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
}
},
urls: [{
fmt: '/<%=alias%>/_rollover/<%=newIndex%>',
req: {
alias: {
type: 'string'
},
newIndex: {
type: 'string'
}
}
}, {
fmt: '/<%=alias%>/_rollover',
req: {
alias: {
type: 'string'
}
}
}],
method: 'POST'
});
/**
* Perform a [indices.segments](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-segments.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.verbose - Includes detailed memory usage by Lucene.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.segments = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
verbose: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/<%=index%>/_segments',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_segments'
}]
});
/**
* Perform a [indices.shardStores](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-shards-stores.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.status - A comma-separated list of statuses used to filter on shards to get store information for
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.shardStores = ca({
params: {
status: {
type: 'list',
options: ['green', 'yellow', 'red', 'all']
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_shard_stores',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_shard_stores'
}]
});
/**
* Perform a [indices.shrink](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-shrink-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.copySettings - whether or not to copy settings from the source index (defaults to false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Set the number of active shards to wait for on the shrunken index before the operation returns.
* @param {<<api-param-type-string,`String`>>} params.index - The name of the source index to shrink
* @param {<<api-param-type-string,`String`>>} params.target - The name of the target index to shrink into
*/
api.indices.prototype.shrink = ca({
params: {
copySettings: {
type: 'boolean',
name: 'copy_settings'
},
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
}
},
url: {
fmt: '/<%=index%>/_shrink/<%=target%>',
req: {
index: {
type: 'string'
},
target: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [indices.split](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-split-index.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.copySettings - whether or not to copy settings from the source index (defaults to false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Set the number of active shards to wait for on the shrunken index before the operation returns.
* @param {<<api-param-type-string,`String`>>} params.index - The name of the source index to split
* @param {<<api-param-type-string,`String`>>} params.target - The name of the target index to split into
*/
api.indices.prototype.split = ca({
params: {
copySettings: {
type: 'boolean',
name: 'copy_settings'
},
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
}
},
url: {
fmt: '/<%=index%>/_split/<%=target%>',
req: {
index: {
type: 'string'
},
target: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [indices.stats](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-stats.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.completionFields - A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fielddataFields - A comma-separated list of fields for `fielddata` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.groups - A comma-separated list of search groups for `search` index metric
* @param {<<api-param-type-string,`String`>>} [params.level=indices] - Return stats aggregated at cluster, index or shard level
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.types - A comma-separated list of document types for the `indexing` index metric
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeSegmentFileSizes - Whether to report the aggregated disk usage of each one of the Lucene index files (only applies if segment stats are requested)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned the specific metrics.
*/
api.indices.prototype.stats = ca({
params: {
completionFields: {
type: 'list',
name: 'completion_fields'
},
fielddataFields: {
type: 'list',
name: 'fielddata_fields'
},
fields: {
type: 'list'
},
groups: {
type: 'list'
},
level: {
type: 'enum',
'default': 'indices',
options: ['cluster', 'indices', 'shards']
},
types: {
type: 'list'
},
includeSegmentFileSizes: {
type: 'boolean',
'default': false,
name: 'include_segment_file_sizes'
}
},
urls: [{
fmt: '/<%=index%>/_stats/<%=metric%>',
req: {
index: {
type: 'list'
},
metric: {
type: 'list',
options: ['_all', 'completion', 'docs', 'fielddata', 'query_cache', 'flush', 'get', 'indexing', 'merge', 'request_cache', 'refresh', 'search', 'segments', 'store', 'warmer', 'suggest']
}
}
}, {
fmt: '/_stats/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'completion', 'docs', 'fielddata', 'query_cache', 'flush', 'get', 'indexing', 'merge', 'request_cache', 'refresh', 'search', 'segments', 'store', 'warmer', 'suggest']
}
}
}, {
fmt: '/<%=index%>/_stats',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_stats'
}]
});
/**
* Perform a [indices.updateAliases](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-aliases.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Request timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
*/
api.indices.prototype.updateAliases = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_aliases'
},
needBody: true,
method: 'POST'
});
/**
* Perform a [indices.upgrade](https://www.elastic.co/guide/en/elasticsearch/reference/master/indices-upgrade.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Specify whether the request should block until the all segments are upgraded (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.onlyAncientSegments - If true, only ancient (an older Lucene major release) segments will be upgraded
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
*/
api.indices.prototype.upgrade = ca({
params: {
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
waitForCompletion: {
type: 'boolean',
name: 'wait_for_completion'
},
onlyAncientSegments: {
type: 'boolean',
name: 'only_ancient_segments'
}
},
urls: [{
fmt: '/<%=index%>/_upgrade',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_upgrade'
}],
method: 'POST'
});
/**
* Perform a [indices.validateQuery](https://www.elastic.co/guide/en/elasticsearch/reference/master/search-validate.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - Return detailed information about the error
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-boolean,`Boolean`>>} params.rewrite - Provide a more detailed explanation showing the actual Lucene query that will be executed.
* @param {<<api-param-type-boolean,`Boolean`>>} params.allShards - Execute validation on all shards instead of one random shard per index
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types
*/
api.indices.prototype.validateQuery = ca({
params: {
explain: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
q: {
type: 'string'
},
analyzer: {
type: 'string'
},
analyzeWildcard: {
type: 'boolean',
name: 'analyze_wildcard'
},
defaultOperator: {
type: 'enum',
'default': 'OR',
options: ['AND', 'OR'],
name: 'default_operator'
},
df: {
type: 'string'
},
lenient: {
type: 'boolean'
},
rewrite: {
type: 'boolean'
},
allShards: {
type: 'boolean',
name: 'all_shards'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_validate/query',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_validate/query',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_validate/query'
}],
method: 'POST'
});
/**
* Perform a [info](http://www.elastic.co/guide/) request
*
* @param {Object} params - An object with parameters used to carry out this action
*/
api.info = ca({
url: {
fmt: '/'
}
});
api.ingest = namespace();
/**
* Perform a [ingest.deletePipeline](https://www.elastic.co/guide/en/elasticsearch/plugins/master/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.id - Pipeline ID
*/
api.ingest.prototype.deletePipeline = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_ingest/pipeline/<%=id%>',
req: {
id: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [ingest.getPipeline](https://www.elastic.co/guide/en/elasticsearch/plugins/master/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>} params.id - Comma separated list of pipeline ids. Wildcards supported
*/
api.ingest.prototype.getPipeline = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
urls: [{
fmt: '/_ingest/pipeline/<%=id%>',
req: {
id: {
type: 'string'
}
}
}, {
fmt: '/_ingest/pipeline'
}]
});
/**
* Perform a [ingest.processorGrok](https://www.elastic.co/guide/en/elasticsearch/plugins/master/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
*/
api.ingest.prototype.processorGrok = ca({
url: {
fmt: '/_ingest/processor/grok'
}
});
/**
* Perform a [ingest.putPipeline](https://www.elastic.co/guide/en/elasticsearch/plugins/master/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.id - Pipeline ID
*/
api.ingest.prototype.putPipeline = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_ingest/pipeline/<%=id%>',
req: {
id: {
type: 'string'
}
}
},
needBody: true,
method: 'PUT'
});
/**
* Perform a [ingest.simulate](https://www.elastic.co/guide/en/elasticsearch/plugins/master/ingest.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.verbose - Verbose mode. Display data output for each processor in executed pipeline
* @param {<<api-param-type-string,`String`>>} params.id - Pipeline ID
*/
api.ingest.prototype.simulate = ca({
params: {
verbose: {
type: 'boolean',
'default': false
}
},
urls: [{
fmt: '/_ingest/pipeline/<%=id%>/_simulate',
req: {
id: {
type: 'string'
}
}
}, {
fmt: '/_ingest/pipeline/_simulate'
}],
needBody: true,
method: 'POST'
});
/**
* Perform a [mget](https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-multi-get.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return in the response
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specify whether to perform the operation in realtime or search mode
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Refresh the shard containing the document before performing the operation
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.mget = ca({
params: {
storedFields: {
type: 'list',
name: 'stored_fields'
},
preference: {
type: 'string'
},
realtime: {
type: 'boolean'
},
refresh: {
type: 'boolean'
},
routing: {
type: 'string'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_mget',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/_mget',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_mget'
}],
needBody: true,
method: 'POST'
});
/**
* Perform a [msearch](https://www.elastic.co/guide/en/elasticsearch/reference/master/search-multi-search.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-number,`Number`>>} params.maxConcurrentSearches - Controls the maximum number of concurrent searches the multi search api will execute
* @param {<<api-param-type-boolean,`Boolean`>>} params.typedKeys - Specify whether aggregation and suggester names should be prefixed by their respective types in the response
* @param {<<api-param-type-number,`Number`>>} [params.preFilterShardSize=128] - A threshold that enforces a pre-filter roundtrip to prefilter search shards based on query rewriting if the number of shards the search request expands to exceeds the threshold. This filter roundtrip can limit the number of shards significantly if for instance a shard can not match any documents based on it's rewrite method ie. if date filters are mandatory to match but the shard bounds and the query are disjoint.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to use as default
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to use as default
*/
api.msearch = ca({
params: {
searchType: {
type: 'enum',
options: ['query_then_fetch', 'query_and_fetch', 'dfs_query_then_fetch', 'dfs_query_and_fetch'],
name: 'search_type'
},
maxConcurrentSearches: {
type: 'number',
name: 'max_concurrent_searches'
},
typedKeys: {
type: 'boolean',
name: 'typed_keys'
},
preFilterShardSize: {
type: 'number',
'default': 128,
name: 'pre_filter_shard_size'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_msearch',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_msearch',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_msearch'
}],
needBody: true,
bulkBody: true,
method: 'POST'
});
/**
* Perform a [msearchTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/master/search-multi-search.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-boolean,`Boolean`>>} params.typedKeys - Specify whether aggregation and suggester names should be prefixed by their respective types in the response
* @param {<<api-param-type-number,`Number`>>} params.maxConcurrentSearches - Controls the maximum number of concurrent searches the multi search api will execute
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to use as default
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to use as default
*/
api.msearchTemplate = ca({
params: {
searchType: {
type: 'enum',
options: ['query_then_fetch', 'query_and_fetch', 'dfs_query_then_fetch', 'dfs_query_and_fetch'],
name: 'search_type'
},
typedKeys: {
type: 'boolean',
name: 'typed_keys'
},
maxConcurrentSearches: {
type: 'number',
name: 'max_concurrent_searches'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_msearch/template',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_msearch/template',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_msearch/template'
}],
needBody: true,
bulkBody: true,
method: 'POST'
});
/**
* Perform a [mtermvectors](https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-multi-termvectors.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.ids - A comma-separated list of documents ids. You must define ids as parameter or set "ids" or "docs" in the request body
* @param {<<api-param-type-boolean,`Boolean`>>} params.termStatistics - Specifies if total term frequency and document frequency should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} [params.fieldStatistics=true] - Specifies if document count, sum of document frequencies and sum of total term frequencies should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to return. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} [params.offsets=true] - Specifies if term offsets should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} [params.positions=true] - Specifies if term positions should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} [params.payloads=true] - Specifies if term payloads should be returned. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random) .Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-string,`String`>>} params.parent - Parent id of documents. Applies to all returned documents unless otherwise specified in body "params" or "docs".
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specifies if requests are real-time as opposed to near-real-time (default: true).
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.index - The index in which the document resides.
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document.
*/
api.mtermvectors = ca({
params: {
ids: {
type: 'list',
required: false
},
termStatistics: {
type: 'boolean',
'default': false,
required: false,
name: 'term_statistics'
},
fieldStatistics: {
type: 'boolean',
'default': true,
required: false,
name: 'field_statistics'
},
fields: {
type: 'list',
required: false
},
offsets: {
type: 'boolean',
'default': true,
required: false
},
positions: {
type: 'boolean',
'default': true,
required: false
},
payloads: {
type: 'boolean',
'default': true,
required: false
},
preference: {
type: 'string',
required: false
},
routing: {
type: 'string',
required: false
},
parent: {
type: 'string',
required: false
},
realtime: {
type: 'boolean',
required: false
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_mtermvectors',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/_mtermvectors',
req: {
index: {
type: 'string'
}
}
}, {
fmt: '/_mtermvectors'
}],
method: 'POST'
});
api.nodes = namespace();
/**
* Perform a [nodes.hotThreads](https://www.elastic.co/guide/en/elasticsearch/reference/master/cluster-nodes-hot-threads.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.interval - The interval for the second sampling of threads
* @param {<<api-param-type-number,`Number`>>} params.snapshots - Number of samples of thread stacktrace (default: 10)
* @param {<<api-param-type-number,`Number`>>} params.threads - Specify the number of threads to provide information for (default: 3)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreIdleThreads - Don't show threads that are in known-idle places, such as waiting on a socket select or pulling from an empty task queue (default: true)
* @param {<<api-param-type-string,`String`>>} params.type - The type to sample (default: cpu)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
*/
api.nodes.prototype.hotThreads = ca({
params: {
interval: {
type: 'time'
},
snapshots: {
type: 'number'
},
threads: {
type: 'number'
},
ignoreIdleThreads: {
type: 'boolean',
name: 'ignore_idle_threads'
},
type: {
type: 'enum',
options: ['cpu', 'wait', 'block']
},
timeout: {
type: 'time'
}
},
urls: [{
fmt: '/_nodes/<%=nodeId%>/hotthreads',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_nodes/hotthreads'
}]
});
/**
* Perform a [nodes.info](https://www.elastic.co/guide/en/elasticsearch/reference/master/cluster-nodes-info.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.flatSettings - Return settings in flat format (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - A comma-separated list of metrics you wish returned. Leave empty to return all.
*/
api.nodes.prototype.info = ca({
params: {
flatSettings: {
type: 'boolean',
name: 'flat_settings'
},
timeout: {
type: 'time'
}
},
urls: [{
fmt: '/_nodes/<%=nodeId%>/<%=metric%>',
req: {
nodeId: {
type: 'list'
},
metric: {
type: 'list',
options: ['settings', 'os', 'process', 'jvm', 'thread_pool', 'transport', 'http', 'plugins', 'ingest']
}
}
}, {
fmt: '/_nodes/<%=nodeId%>',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_nodes/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['settings', 'os', 'process', 'jvm', 'thread_pool', 'transport', 'http', 'plugins', 'ingest']
}
}
}, {
fmt: '/_nodes'
}]
});
/**
* Perform a [nodes.stats](https://www.elastic.co/guide/en/elasticsearch/reference/master/cluster-nodes-stats.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.completionFields - A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fielddataFields - A comma-separated list of fields for `fielddata` index metric (supports wildcards)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards)
* @param {<<api-param-type-boolean,`Boolean`>>} params.groups - A comma-separated list of search groups for `search` index metric
* @param {<<api-param-type-string,`String`>>} [params.level=node] - Return indices stats aggregated at index, node or shard level
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.types - A comma-separated list of document types for the `indexing` index metric
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.includeSegmentFileSizes - Whether to report the aggregated disk usage of each one of the Lucene index files (only applies if segment stats are requested)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned to the specified metrics
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.indexMetric - Limit the information returned for `indices` metric to the specific index metrics. Isn't used if `indices` (or `all`) metric isn't specified.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
*/
api.nodes.prototype.stats = ca({
params: {
completionFields: {
type: 'list',
name: 'completion_fields'
},
fielddataFields: {
type: 'list',
name: 'fielddata_fields'
},
fields: {
type: 'list'
},
groups: {
type: 'boolean'
},
level: {
type: 'enum',
'default': 'node',
options: ['indices', 'node', 'shards']
},
types: {
type: 'list'
},
timeout: {
type: 'time'
},
includeSegmentFileSizes: {
type: 'boolean',
'default': false,
name: 'include_segment_file_sizes'
}
},
urls: [{
fmt: '/_nodes/<%=nodeId%>/stats/<%=metric%>/<%=indexMetric%>',
req: {
nodeId: {
type: 'list'
},
metric: {
type: 'list',
options: ['_all', 'breaker', 'fs', 'http', 'indices', 'jvm', 'os', 'process', 'thread_pool', 'transport', 'discovery']
},
indexMetric: {
type: 'list',
options: ['_all', 'completion', 'docs', 'fielddata', 'query_cache', 'flush', 'get', 'indexing', 'merge', 'request_cache', 'refresh', 'search', 'segments', 'store', 'warmer', 'suggest']
}
}
}, {
fmt: '/_nodes/<%=nodeId%>/stats/<%=metric%>',
req: {
nodeId: {
type: 'list'
},
metric: {
type: 'list',
options: ['_all', 'breaker', 'fs', 'http', 'indices', 'jvm', 'os', 'process', 'thread_pool', 'transport', 'discovery']
}
}
}, {
fmt: '/_nodes/stats/<%=metric%>/<%=indexMetric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'breaker', 'fs', 'http', 'indices', 'jvm', 'os', 'process', 'thread_pool', 'transport', 'discovery']
},
indexMetric: {
type: 'list',
options: ['_all', 'completion', 'docs', 'fielddata', 'query_cache', 'flush', 'get', 'indexing', 'merge', 'request_cache', 'refresh', 'search', 'segments', 'store', 'warmer', 'suggest']
}
}
}, {
fmt: '/_nodes/<%=nodeId%>/stats',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_nodes/stats/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'breaker', 'fs', 'http', 'indices', 'jvm', 'os', 'process', 'thread_pool', 'transport', 'discovery']
}
}
}, {
fmt: '/_nodes/stats'
}]
});
/**
* Perform a [nodes.usage](https://www.elastic.co/guide/en/elasticsearch/reference/master/cluster-nodes-usage.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.metric - Limit the information returned to the specified metrics
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodeId - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
*/
api.nodes.prototype.usage = ca({
params: {
timeout: {
type: 'time'
}
},
urls: [{
fmt: '/_nodes/<%=nodeId%>/usage/<%=metric%>',
req: {
nodeId: {
type: 'list'
},
metric: {
type: 'list',
options: ['_all', 'rest_actions']
}
}
}, {
fmt: '/_nodes/<%=nodeId%>/usage',
req: {
nodeId: {
type: 'list'
}
}
}, {
fmt: '/_nodes/usage/<%=metric%>',
req: {
metric: {
type: 'list',
options: ['_all', 'rest_actions']
}
}
}, {
fmt: '/_nodes/usage'
}]
});
/**
* Perform a [ping](http://www.elastic.co/guide/) request
*
* @param {Object} params - An object with parameters used to carry out this action
*/
api.ping = ca({
url: {
fmt: '/'
},
requestTimeout: 3000,
method: 'HEAD'
});
/**
* Perform a [putScript](https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-scripting.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Specify timeout for connection to master
* @param {<<api-param-type-string,`String`>>} params.context - Script context
* @param {<<api-param-type-string,`String`>>} params.id - Script ID
*/
api.putScript = ca({
params: {
timeout: {
type: 'time'
},
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
context: {
type: 'string'
}
},
urls: [{
fmt: '/_scripts/<%=id%>/<%=context%>',
req: {
id: {
type: 'string'
},
context: {
type: 'string'
}
}
}, {
fmt: '/_scripts/<%=id%>',
req: {
id: {
type: 'string'
}
}
}],
needBody: true,
method: 'PUT'
});
/**
* Perform a [rankEval](https://www.elastic.co/guide/en/elasticsearch/reference/master/search-rank-eval.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices
*/
api.rankEval = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_rank_eval',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_rank_eval'
}],
needBody: true,
method: 'POST'
});
/**
* Perform a [reindex](https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-reindex.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Should the effected indexes be refreshed?
* @param {<<api-param-type-duration-string,`DurationString`>>} [params.timeout=1m] - Time each individual bulk request should wait for shards that are unavailable.
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the reindex operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-boolean,`Boolean`>>} [params.waitForCompletion=true] - Should the request should block until the reindex is complete.
* @param {<<api-param-type-number,`Number`>>} params.requestsPerSecond - The throttle to set on this request in sub-requests per second. -1 means no throttle.
* @param {<<api-param-type-number,`Number`>>} [params.slices=1] - The number of slices this task should be divided into. Defaults to 1 meaning the task isn't sliced into subtasks.
*/
api.reindex = ca({
params: {
refresh: {
type: 'boolean'
},
timeout: {
type: 'time',
'default': '1m'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
waitForCompletion: {
type: 'boolean',
'default': true,
name: 'wait_for_completion'
},
requestsPerSecond: {
type: 'number',
'default': 0,
name: 'requests_per_second'
},
slices: {
type: 'number',
'default': 1
}
},
url: {
fmt: '/_reindex'
},
needBody: true,
method: 'POST'
});
/**
* Perform a [reindexRethrottle](https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-reindex.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-number,`Number`>>} params.requestsPerSecond - The throttle to set on this request in floating sub-requests per second. -1 means set no throttle.
* @param {<<api-param-type-string,`String`>>} params.taskId - The task id to rethrottle
*/
api.reindexRethrottle = ca({
params: {
requestsPerSecond: {
type: 'number',
required: true,
name: 'requests_per_second'
}
},
url: {
fmt: '/_reindex/<%=taskId%>/_rethrottle',
req: {
taskId: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [renderSearchTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/master/search-template.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.id - The id of the stored search template
*/
api.renderSearchTemplate = ca({
urls: [{
fmt: '/_render/template/<%=id%>',
req: {
id: {
type: 'string'
}
}
}, {
fmt: '/_render/template'
}],
method: 'POST'
});
/**
* Perform a [scriptsPainlessExecute](https://www.elastic.co/guide/en/elasticsearch/painless/master/painless-execute-api.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
*/
api.scriptsPainlessExecute = ca({
url: {
fmt: '/_scripts/painless/_execute'
},
method: 'POST'
});
/**
* Perform a [scroll](https://www.elastic.co/guide/en/elasticsearch/reference/master/search-request-scroll.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.scrollId - The scroll ID
*/
api.scroll = ca({
params: {
scroll: {
type: 'time'
},
scrollId: {
type: 'string',
name: 'scroll_id'
}
},
urls: [{
fmt: '/_search/scroll/<%=scrollId%>',
req: {
scrollId: {
type: 'string'
}
}
}, {
fmt: '/_search/scroll'
}],
paramAsBody: {
param: 'scrollId',
body: 'scroll_id'
},
method: 'POST'
});
/**
* Perform a [search](https://www.elastic.co/guide/en/elasticsearch/reference/master/search-search.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.includeTypeName - Whether to add the type name to the response
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - Specify whether to return detailed information about score computation as part of a hit
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.storedFields - A comma-separated list of stored fields to return as part of a hit
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.docvalueFields - A comma-separated list of fields to return as the docvalue representation of a field for each hit
* @param {<<api-param-type-number,`Number`>>} params.from - Starting offset (default: 0)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-number,`Number`>>} params.size - Number of hits to return (default: 10)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.sort - A comma-separated list of <field>:<direction> pairs
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.terminateAfter - The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.stats - Specific 'tag' of the request for logging and statistical purposes
* @param {<<api-param-type-string,`String`>>} params.suggestField - Specify which field to use for suggestions
* @param {<<api-param-type-string,`String`>>} [params.suggestMode=missing] - Specify suggest mode
* @param {<<api-param-type-number,`Number`>>} params.suggestSize - How many suggestions to return in response
* @param {<<api-param-type-string,`String`>>} params.suggestText - The source text for which the suggestions should be returned
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.trackScores - Whether to calculate and return scores even if they are not used for sorting
* @param {<<api-param-type-boolean,`Boolean`>>} params.trackTotalHits - Indicate if the number of documents that match the query should be tracked
* @param {<<api-param-type-boolean,`Boolean`>>} [params.allowPartialSearchResults=true] - Indicate if an error should be returned if there is a partial search failure or timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.typedKeys - Specify whether aggregation and suggester names should be prefixed by their respective types in the response
* @param {<<api-param-type-boolean,`Boolean`>>} params.version - Specify whether to return document version as part of a hit
* @param {<<api-param-type-boolean,`Boolean`>>} params.requestCache - Specify if request cache should be used for this request or not, defaults to index level setting
* @param {<<api-param-type-number,`Number`>>} [params.batchedReduceSize=512] - The number of shard results that should be reduced at once on the coordinating node. This value should be used as a protection mechanism to reduce the memory overhead per search request if the potential number of shards in the request can be large.
* @param {<<api-param-type-number,`Number`>>} [params.maxConcurrentShardRequests=The default grows with the number of nodes in the cluster but is at most 256.] - The number of concurrent shard requests this search executes concurrently. This value should be used to limit the impact of the search on the cluster in order to limit the number of concurrent shard requests
* @param {<<api-param-type-number,`Number`>>} [params.preFilterShardSize=128] - A threshold that enforces a pre-filter roundtrip to prefilter search shards based on query rewriting if the number of shards the search request expands to exceeds the threshold. This filter roundtrip can limit the number of shards significantly if for instance a shard can not match any documents based on it's rewrite method ie. if date filters are mandatory to match but the shard bounds and the query are disjoint.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to search; leave empty to perform the operation on all types
*/
api.search = ca({
params: {
includeTypeName: {
type: 'string',
name: 'include_type_name'
},
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'
},
storedFields: {
type: 'list',
name: 'stored_fields'
},
docvalueFields: {
type: 'list',
name: 'docvalue_fields'
},
from: {
type: 'number'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
lenient: {
type: 'boolean'
},
preference: {
type: 'string'
},
q: {
type: 'string'
},
routing: {
type: 'list'
},
scroll: {
type: 'time'
},
searchType: {
type: 'enum',
options: ['query_then_fetch', 'dfs_query_then_fetch'],
name: 'search_type'
},
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: 'string',
name: 'suggest_text'
},
timeout: {
type: 'time'
},
trackScores: {
type: 'boolean',
name: 'track_scores'
},
trackTotalHits: {
type: 'boolean',
name: 'track_total_hits'
},
allowPartialSearchResults: {
type: 'boolean',
'default': true,
name: 'allow_partial_search_results'
},
typedKeys: {
type: 'boolean',
name: 'typed_keys'
},
version: {
type: 'boolean'
},
requestCache: {
type: 'boolean',
name: 'request_cache'
},
batchedReduceSize: {
type: 'number',
'default': 512,
name: 'batched_reduce_size'
},
maxConcurrentShardRequests: {
type: 'number',
'default': 'The default grows with the number of nodes in the cluster but is at most 256.',
name: 'max_concurrent_shard_requests'
},
preFilterShardSize: {
type: 'number',
'default': 128,
name: 'pre_filter_shard_size'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_search',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_search',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_search'
}],
method: 'POST'
});
/**
* Perform a [searchShards](https://www.elastic.co/guide/en/elasticsearch/reference/master/search-shards.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.index - A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices
*/
api.searchShards = ca({
params: {
preference: {
type: 'string'
},
routing: {
type: 'string'
},
local: {
type: 'boolean'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
}
},
urls: [{
fmt: '/<%=index%>/_search_shards',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_search_shards'
}],
method: 'POST'
});
/**
* Perform a [searchTemplate](https://www.elastic.co/guide/en/elasticsearch/reference/master/search-template.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-boolean,`Boolean`>>} params.explain - Specify whether to return detailed information about score computation as part of a hit
* @param {<<api-param-type-boolean,`Boolean`>>} params.profile - Specify whether to profile the query execution
* @param {<<api-param-type-boolean,`Boolean`>>} params.typedKeys - Specify whether aggregation and suggester names should be prefixed by their respective types in the response
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to search; leave empty to perform the operation on all types
*/
api.searchTemplate = ca({
params: {
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
allowNoIndices: {
type: 'boolean',
name: 'allow_no_indices'
},
expandWildcards: {
type: 'enum',
'default': 'open',
options: ['open', 'closed', 'none', 'all'],
name: 'expand_wildcards'
},
preference: {
type: 'string'
},
routing: {
type: 'list'
},
scroll: {
type: 'time'
},
searchType: {
type: 'enum',
options: ['query_then_fetch', 'query_and_fetch', 'dfs_query_then_fetch', 'dfs_query_and_fetch'],
name: 'search_type'
},
explain: {
type: 'boolean'
},
profile: {
type: 'boolean'
},
typedKeys: {
type: 'boolean',
name: 'typed_keys'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_search/template',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_search/template',
req: {
index: {
type: 'list'
}
}
}, {
fmt: '/_search/template'
}],
needBody: true,
method: 'POST'
});
api.snapshot = namespace();
/**
* Perform a [snapshot.create](https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Should this request wait until the operation has completed before returning
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>} params.snapshot - A snapshot name
*/
api.snapshot.prototype.create = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForCompletion: {
type: 'boolean',
'default': false,
name: 'wait_for_completion'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [snapshot.createRepository](https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-boolean,`Boolean`>>} params.verify - Whether to verify the repository after creation
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
*/
api.snapshot.prototype.createRepository = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
},
verify: {
type: 'boolean'
}
},
url: {
fmt: '/_snapshot/<%=repository%>',
req: {
repository: {
type: 'string'
}
}
},
needBody: true,
method: 'POST'
});
/**
* Perform a [snapshot.delete](https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>} params.snapshot - A snapshot name
*/
api.snapshot.prototype['delete'] = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'string'
}
}
},
method: 'DELETE'
});
/**
* Perform a [snapshot.deleteRepository](https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.repository - A comma-separated list of repository names
*/
api.snapshot.prototype.deleteRepository = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_snapshot/<%=repository%>',
req: {
repository: {
type: 'list'
}
}
},
method: 'DELETE'
});
/**
* Perform a [snapshot.get](https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether to ignore unavailable snapshots, defaults to false which means a SnapshotMissingException is thrown
* @param {<<api-param-type-boolean,`Boolean`>>} params.verbose - Whether to show verbose snapshot info or only show the basic info found in the repository index blob
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.snapshot - A comma-separated list of snapshot names
*/
api.snapshot.prototype.get = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
},
verbose: {
type: 'boolean'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'list'
}
}
}
});
/**
* Perform a [snapshot.getRepository](https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.local - Return local information, do not retrieve the state from master node (default: false)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.repository - A comma-separated list of repository names
*/
api.snapshot.prototype.getRepository = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
local: {
type: 'boolean'
}
},
urls: [{
fmt: '/_snapshot/<%=repository%>',
req: {
repository: {
type: 'list'
}
}
}, {
fmt: '/_snapshot'
}]
});
/**
* Perform a [snapshot.restore](https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Should this request wait until the operation has completed before returning
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>} params.snapshot - A snapshot name
*/
api.snapshot.prototype.restore = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
waitForCompletion: {
type: 'boolean',
'default': false,
name: 'wait_for_completion'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>/_restore',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'string'
}
}
},
method: 'POST'
});
/**
* Perform a [snapshot.status](https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether to ignore unavailable snapshots, defaults to false which means a SnapshotMissingException is thrown
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.snapshot - A comma-separated list of snapshot names
*/
api.snapshot.prototype.status = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
ignoreUnavailable: {
type: 'boolean',
name: 'ignore_unavailable'
}
},
urls: [{
fmt: '/_snapshot/<%=repository%>/<%=snapshot%>/_status',
req: {
repository: {
type: 'string'
},
snapshot: {
type: 'list'
}
}
}, {
fmt: '/_snapshot/<%=repository%>/_status',
req: {
repository: {
type: 'string'
}
}
}, {
fmt: '/_snapshot/_status'
}]
});
/**
* Perform a [snapshot.verifyRepository](https://www.elastic.co/guide/en/elasticsearch/reference/master/modules-snapshots.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-duration-string,`DurationString`>>} params.masterTimeout - Explicit operation timeout for connection to master node
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.repository - A repository name
*/
api.snapshot.prototype.verifyRepository = ca({
params: {
masterTimeout: {
type: 'time',
name: 'master_timeout'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_snapshot/<%=repository%>/_verify',
req: {
repository: {
type: 'string'
}
}
},
method: 'POST'
});
api.tasks = namespace();
/**
* Perform a [tasks.cancel](https://www.elastic.co/guide/en/elasticsearch/reference/master/tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodes - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.actions - A comma-separated list of actions that should be cancelled. Leave empty to cancel all.
* @param {<<api-param-type-string,`String`>>} params.parentTaskId - Cancel tasks with specified parent task id (node_id:task_number). Set to -1 to cancel all.
* @param {<<api-param-type-string,`String`>>} params.taskId - Cancel the task with specified task id (node_id:task_number)
*/
api.tasks.prototype.cancel = ca({
params: {
nodes: {
type: 'list'
},
actions: {
type: 'list'
},
parentTaskId: {
type: 'string',
name: 'parent_task_id'
}
},
urls: [{
fmt: '/_tasks/<%=taskId%>/_cancel',
req: {
taskId: {
type: 'string'
}
}
}, {
fmt: '/_tasks/_cancel'
}],
method: 'POST'
});
/**
* Perform a [tasks.get](https://www.elastic.co/guide/en/elasticsearch/reference/master/tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Wait for the matching tasks to complete (default: false)
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-string,`String`>>} params.taskId - Return the task with specified id (node_id:task_number)
*/
api.tasks.prototype.get = ca({
params: {
waitForCompletion: {
type: 'boolean',
name: 'wait_for_completion'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_tasks/<%=taskId%>',
req: {
taskId: {
type: 'string'
}
}
}
});
/**
* Perform a [tasks.list](https://www.elastic.co/guide/en/elasticsearch/reference/master/tasks.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.nodes - A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you're connecting to, leave empty to get information from all nodes
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.actions - A comma-separated list of actions that should be returned. Leave empty to return all.
* @param {<<api-param-type-boolean,`Boolean`>>} params.detailed - Return detailed task information (default: false)
* @param {<<api-param-type-string,`String`>>} params.parentTaskId - Return tasks with specified parent task id (node_id:task_number). Set to -1 to return all.
* @param {<<api-param-type-boolean,`Boolean`>>} params.waitForCompletion - Wait for the matching tasks to complete (default: false)
* @param {<<api-param-type-string,`String`>>} [params.groupBy=nodes] - Group tasks by nodes or parent/child relationships
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
*/
api.tasks.prototype.list = ca({
params: {
nodes: {
type: 'list'
},
actions: {
type: 'list'
},
detailed: {
type: 'boolean'
},
parentTaskId: {
type: 'string',
name: 'parent_task_id'
},
waitForCompletion: {
type: 'boolean',
name: 'wait_for_completion'
},
groupBy: {
type: 'enum',
'default': 'nodes',
options: ['nodes', 'parents', 'none'],
name: 'group_by'
},
timeout: {
type: 'time'
}
},
url: {
fmt: '/_tasks'
}
});
/**
* Perform a [termvectors](https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-termvectors.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-boolean,`Boolean`>>} params.termStatistics - Specifies if total term frequency and document frequency should be returned.
* @param {<<api-param-type-boolean,`Boolean`>>} [params.fieldStatistics=true] - Specifies if document count, sum of document frequencies and sum of total term frequencies should be returned.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.fields - A comma-separated list of fields to return.
* @param {<<api-param-type-boolean,`Boolean`>>} [params.offsets=true] - Specifies if term offsets should be returned.
* @param {<<api-param-type-boolean,`Boolean`>>} [params.positions=true] - Specifies if term positions should be returned.
* @param {<<api-param-type-boolean,`Boolean`>>} [params.payloads=true] - Specifies if term payloads should be returned.
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random).
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value.
* @param {<<api-param-type-string,`String`>>} params.parent - Parent id of documents.
* @param {<<api-param-type-boolean,`Boolean`>>} params.realtime - Specifies if request is real-time as opposed to near-real-time (default: true).
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.index - The index in which the document resides.
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document.
* @param {<<api-param-type-string,`String`>>} params.id - The id of the document, when not specified a doc param should be supplied.
*/
api.termvectors = ca({
params: {
termStatistics: {
type: 'boolean',
'default': false,
required: false,
name: 'term_statistics'
},
fieldStatistics: {
type: 'boolean',
'default': true,
required: false,
name: 'field_statistics'
},
fields: {
type: 'list',
required: false
},
offsets: {
type: 'boolean',
'default': true,
required: false
},
positions: {
type: 'boolean',
'default': true,
required: false
},
payloads: {
type: 'boolean',
'default': true,
required: false
},
preference: {
type: 'string',
required: false
},
routing: {
type: 'string',
required: false
},
parent: {
type: 'string',
required: false
},
realtime: {
type: 'boolean',
required: false
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'external', 'external_gte', 'force'],
name: 'version_type'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/<%=id%>/_termvectors',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/<%=type%>/_termvectors',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
}
}
}],
method: 'POST'
});
/**
* Perform a [update](https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-update.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.includeTypeName - Whether to add the type name to the response
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the update operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-string,`String`>>} params.lang - The script language (default: painless)
* @param {<<api-param-type-string,`String`>>} params.parent - ID of the parent document. Is is only used for routing and when for the upsert request
* @param {<<api-param-type-string,`String`>>} params.refresh - If `true` then refresh the effected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes.
* @param {<<api-param-type-number,`Number`>>} params.retryOnConflict - Specify how many times should the operation be retried when a conflict occurs (default: 0)
* @param {<<api-param-type-string,`String`>>} params.routing - Specific routing value
* @param {<<api-param-type-duration-string,`DurationString`>>} params.timeout - Explicit operation timeout
* @param {<<api-param-type-number,`Number`>>} params.version - Explicit version number for concurrency control
* @param {<<api-param-type-string,`String`>>} params.versionType - Specific version type
* @param {<<api-param-type-string,`String`>>} params.id - Document ID
* @param {<<api-param-type-string,`String`>>} params.index - The name of the index
* @param {<<api-param-type-string,`String`>>} params.type - The type of the document
*/
api.update = ca({
params: {
includeTypeName: {
type: 'string',
name: 'include_type_name'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
_source: {
type: 'list'
},
_sourceExclude: {
type: 'list',
name: '_source_exclude'
},
_sourceInclude: {
type: 'list',
name: '_source_include'
},
lang: {
type: 'string'
},
parent: {
type: 'string'
},
refresh: {
type: 'enum',
options: ['true', 'false', 'wait_for', '']
},
retryOnConflict: {
type: 'number',
name: 'retry_on_conflict'
},
routing: {
type: 'string'
},
timeout: {
type: 'time'
},
version: {
type: 'number'
},
versionType: {
type: 'enum',
options: ['internal', 'force'],
name: 'version_type'
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/<%=id%>/_update',
req: {
index: {
type: 'string'
},
type: {
type: 'string'
},
id: {
type: 'string'
}
}
}, {
fmt: '/<%=index%>/_doc/<%=id%>/_update',
req: {
index: {
type: 'string'
},
id: {
type: 'string'
}
}
}],
needBody: true,
method: 'POST'
});
/**
* Perform a [updateByQuery](https://www.elastic.co/guide/en/elasticsearch/reference/master/docs-update-by-query.html) request
*
* @param {Object} params - An object with parameters used to carry out this action
* @param {<<api-param-type-string,`String`>>} params.analyzer - The analyzer to use for the query string
* @param {<<api-param-type-boolean,`Boolean`>>} params.analyzeWildcard - Specify whether wildcard and prefix queries should be analyzed (default: false)
* @param {<<api-param-type-string,`String`>>} [params.defaultOperator=OR] - The default operator for query string query (AND or OR)
* @param {<<api-param-type-string,`String`>>} params.df - The field to use as default where no field prefix is given in the query string
* @param {<<api-param-type-number,`Number`>>} params.from - Starting offset (default: 0)
* @param {<<api-param-type-boolean,`Boolean`>>} params.ignoreUnavailable - Whether specified concrete indices should be ignored when unavailable (missing or closed)
* @param {<<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>} [params.conflicts=abort] - What to do when the update by query hits version conflicts?
* @param {<<api-param-type-string,`String`>>} [params.expandWildcards=open] - Whether to expand wildcard expression to concrete indices that are open, closed or both.
* @param {<<api-param-type-boolean,`Boolean`>>} params.lenient - Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
* @param {<<api-param-type-string,`String`>>} params.pipeline - Ingest pipeline to set on index requests made by this action. (default: none)
* @param {<<api-param-type-string,`String`>>} params.preference - Specify the node or shard the operation should be performed on (default: random)
* @param {<<api-param-type-string,`String`>>} params.q - Query in the Lucene query string syntax
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.routing - A comma-separated list of specific routing values
* @param {<<api-param-type-duration-string,`DurationString`>>} params.scroll - Specify how long a consistent view of the index should be maintained for scrolled search
* @param {<<api-param-type-string,`String`>>} params.searchType - Search operation type
* @param {<<api-param-type-duration-string,`DurationString`>>} params.searchTimeout - Explicit timeout for each search request. Defaults to no timeout.
* @param {<<api-param-type-number,`Number`>>} params.size - Number of hits to return (default: 10)
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.sort - A comma-separated list of <field>:<direction> pairs
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._source - True or false to return the _source field or not, or a list of fields to return
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceExclude - A list of fields to exclude from the returned _source field
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params._sourceInclude - A list of fields to extract and return from the _source field
* @param {<<api-param-type-number,`Number`>>} params.terminateAfter - The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.stats - Specific 'tag' of the request for logging and statistical purposes
* @param {<<api-param-type-boolean,`Boolean`>>} params.version - Specify whether to return document version as part of a hit
* @param {<<api-param-type-boolean,`Boolean`>>} params.versionType - Should the document increment the version number (internal) on hit or not (reindex)
* @param {<<api-param-type-boolean,`Boolean`>>} params.requestCache - Specify if request cache should be used for this request or not, defaults to index level setting
* @param {<<api-param-type-boolean,`Boolean`>>} params.refresh - Should the effected indexes be refreshed?
* @param {<<api-param-type-duration-string,`DurationString`>>} [params.timeout=1m] - Time each individual bulk request should wait for shards that are unavailable.
* @param {<<api-param-type-string,`String`>>} params.waitForActiveShards - Sets the number of shard copies that must be active before proceeding with the update by query operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
* @param {<<api-param-type-number,`Number`>>} params.scrollSize - Size on the scroll request powering the update by query
* @param {<<api-param-type-boolean,`Boolean`>>} [params.waitForCompletion=true] - Should the request should block until the update by query operation is complete.
* @param {<<api-param-type-number,`Number`>>} params.requestsPerSecond - The throttle to set on this request in sub-requests per second. -1 means no throttle.
* @param {<<api-param-type-number,`Number`>>} [params.slices=1] - The number of slices this task should be divided into. Defaults to 1 meaning the task isn't sliced into subtasks.
* @param {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`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 {<<api-param-type-string,`String`>>, <<api-param-type-string-array,`String[]`>>, <<api-param-type-boolean,`Boolean`>>} params.type - A comma-separated list of document types to search; leave empty to perform the operation on all types
*/
api.updateByQuery = 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'
},
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'
},
pipeline: {
type: 'string'
},
preference: {
type: 'string'
},
q: {
type: 'string'
},
routing: {
type: 'list'
},
scroll: {
type: 'time'
},
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'
},
version: {
type: 'boolean'
},
versionType: {
type: 'boolean',
name: 'version_type'
},
requestCache: {
type: 'boolean',
name: 'request_cache'
},
refresh: {
type: 'boolean'
},
timeout: {
type: 'time',
'default': '1m'
},
waitForActiveShards: {
type: 'string',
name: 'wait_for_active_shards'
},
scrollSize: {
type: 'number',
name: 'scroll_size'
},
waitForCompletion: {
type: 'boolean',
'default': true,
name: 'wait_for_completion'
},
requestsPerSecond: {
type: 'number',
'default': 0,
name: 'requests_per_second'
},
slices: {
type: 'number',
'default': 1
}
},
urls: [{
fmt: '/<%=index%>/<%=type%>/_update_by_query',
req: {
index: {
type: 'list'
},
type: {
type: 'list'
}
}
}, {
fmt: '/<%=index%>/_update_by_query',
req: {
index: {
type: 'list'
}
}
}],
method: 'POST'
});
/***/ })
/******/ ]);
});
}());