diff --git a/lodash/lodash-tests.ts b/lodash/lodash-tests.ts
index f0f958b0c8..11f0a52a42 100644
--- a/lodash/lodash-tests.ts
+++ b/lodash/lodash-tests.ts
@@ -11905,3 +11905,578 @@ result = <_.TemplateSettings>_.templateSettings;
     res1___ = _.partialRight(func4,     "foo", true, 100);
     res____ = _.partialRight(func4, 42, "foo", true, 100);
 }
+
+/***************************
+ *  method_modules_tests   *
+ ***************************/
+
+import afterFunc = require("lodash.after");
+import aryFunc = require("lodash.ary");
+import assignFunc = require("lodash.assign");
+import assignInFunc = require("lodash.assignIn");
+import assignInWithFunc = require("lodash.assignInWith");
+import assignWithFunc = require("lodash.assignWith");
+import atFunc = require("lodash.at");
+import beforeFunc = require("lodash.before");
+import bindFunc = require("lodash.bind");
+import bindAllFunc = require("lodash.bindAll");
+import bindKeyFunc = require("lodash.bindKey");
+import castArrayFunc = require("lodash.castArray");
+import chainFunc = require("lodash.chain");
+import chunkFunc = require("lodash.chunk");
+import compactFunc = require("lodash.compact");
+import concatFunc = require("lodash.concat");
+import constantFunc = require("lodash.constant");
+import countByFunc = require("lodash.countBy");
+import createFunc = require("lodash.create");
+import curryFunc = require("lodash.curry");
+import curryRightFunc = require("lodash.curryRight");
+import debounceFunc = require("lodash.debounce");
+import defaultsFunc = require("lodash.defaults");
+import defaultsDeepFunc = require("lodash.defaultsDeep");
+import deferFunc = require("lodash.defer");
+import delayFunc = require("lodash.delay");
+import differenceFunc = require("lodash.difference");
+import differenceByFunc = require("lodash.differenceBy");
+import differenceWithFunc = require("lodash.differenceWith");
+import dropFunc = require("lodash.drop");
+import dropRightFunc = require("lodash.dropRight");
+import dropRightWhileFunc = require("lodash.dropRightWhile");
+import dropWhileFunc = require("lodash.dropWhile");
+import fillFunc = require("lodash.fill");
+import filterFunc = require("lodash.filter");
+import flatMapFunc = require("lodash.flatMap");
+import flattenFunc = require("lodash.flatten");
+import flattenDeepFunc = require("lodash.flattenDeep");
+import flattenDepthFunc = require("lodash.flattenDepth");
+import flipFunc = require("lodash.flip");
+import flowFunc = require("lodash.flow");
+import flowRightFunc = require("lodash.flowRight");
+import fromPairsFunc = require("lodash.fromPairs");
+import functionsFunc = require("lodash.functions");
+import functionsInFunc = require("lodash.functionsIn");
+import groupByFunc = require("lodash.groupBy");
+import initialFunc = require("lodash.initial");
+import intersectionFunc = require("lodash.intersection");
+import intersectionByFunc = require("lodash.intersectionBy");
+import intersectionWithFunc = require("lodash.intersectionWith");
+import invertFunc = require("lodash.invert");
+import invertByFunc = require("lodash.invertBy");
+import invokeMapFunc = require("lodash.invokeMap");
+import iterateeFunc = require("lodash.iteratee");
+import keyByFunc = require("lodash.keyBy");
+import keysFunc = require("lodash.keys");
+import keysInFunc = require("lodash.keysIn");
+import mapFunc = require("lodash.map");
+import mapKeysFunc = require("lodash.mapKeys");
+import mapValuesFunc = require("lodash.mapValues");
+import matchesFunc = require("lodash.matches");
+import matchesPropertyFunc = require("lodash.matchesProperty");
+import memoizeFunc = require("lodash.memoize");
+import mergeFunc = require("lodash.merge");
+import mergeWithFunc = require("lodash.mergeWith");
+import methodFunc = require("lodash.method");
+import methodOfFunc = require("lodash.methodOf");
+import mixinFunc = require("lodash.mixin");
+import negateFunc = require("lodash.negate");
+import nthArgFunc = require("lodash.nthArg");
+import omitFunc = require("lodash.omit");
+import omitByFunc = require("lodash.omitBy");
+import onceFunc = require("lodash.once");
+import orderByFunc = require("lodash.orderBy");
+import overFunc = require("lodash.over");
+import overArgsFunc = require("lodash.overArgs");
+import overEveryFunc = require("lodash.overEvery");
+import overSomeFunc = require("lodash.overSome");
+import partialFunc = require("lodash.partial");
+import partialRightFunc = require("lodash.partialRight");
+import partitionFunc = require("lodash.partition");
+import pickFunc = require("lodash.pick");
+import pickByFunc = require("lodash.pickBy");
+import propertyFunc = require("lodash.property");
+import propertyOfFunc = require("lodash.propertyOf");
+import pullFunc = require("lodash.pull");
+import pullAllFunc = require("lodash.pullAll");
+import pullAllByFunc = require("lodash.pullAllBy");
+import pullAtFunc = require("lodash.pullAt");
+import rangeFunc = require("lodash.range");
+import rangeRightFunc = require("lodash.rangeRight");
+import reargFunc = require("lodash.rearg");
+import rejectFunc = require("lodash.reject");
+import removeFunc = require("lodash.remove");
+import restFunc = require("lodash.rest");
+import reverseFunc = require("lodash.reverse");
+import sampleSizeFunc = require("lodash.sampleSize");
+import setFunc = require("lodash.set");
+import setWithFunc = require("lodash.setWith");
+import shuffleFunc = require("lodash.shuffle");
+import sliceFunc = require("lodash.slice");
+import sortByFunc = require("lodash.sortBy");
+import sortedUniqFunc = require("lodash.sortedUniq");
+import sortedUniqByFunc = require("lodash.sortedUniqBy");
+import splitFunc = require("lodash.split");
+import spreadFunc = require("lodash.spread");
+import tailFunc = require("lodash.tail");
+import takeFunc = require("lodash.take");
+import takeRightFunc = require("lodash.takeRight");
+import takeRightWhileFunc = require("lodash.takeRightWhile");
+import takeWhileFunc = require("lodash.takeWhile");
+import tapFunc = require("lodash.tap");
+import throttleFunc = require("lodash.throttle");
+import thruFunc = require("lodash.thru");
+import toArrayFunc = require("lodash.toArray");
+import toPairsFunc = require("lodash.toPairs");
+import toPairsInFunc = require("lodash.toPairsIn");
+import toPathFunc = require("lodash.toPath");
+import toPlainObjectFunc = require("lodash.toPlainObject");
+import transformFunc = require("lodash.transform");
+import unaryFunc = require("lodash.unary");
+import unionFunc = require("lodash.union");
+import unionByFunc = require("lodash.unionBy");
+import unionWithFunc = require("lodash.unionWith");
+import uniqFunc = require("lodash.uniq");
+import uniqByFunc = require("lodash.uniqBy");
+import uniqWithFunc = require("lodash.uniqWith");
+import unsetFunc = require("lodash.unset");
+import unzipFunc = require("lodash.unzip");
+import unzipWithFunc = require("lodash.unzipWith");
+import updateFunc = require("lodash.update");
+import valuesFunc = require("lodash.values");
+import valuesInFunc = require("lodash.valuesIn");
+import withoutFunc = require("lodash.without");
+import wordsFunc = require("lodash.words");
+import wrapFunc = require("lodash.wrap");
+import xorFunc = require("lodash.xor");
+import xorByFunc = require("lodash.xorBy");
+import xorWithFunc = require("lodash.xorWith");
+import zipFunc = require("lodash.zip");
+import zipObjectFunc = require("lodash.zipObject");
+import zipWithFunc = require("lodash.zipWith");
+import extendFunc = require("lodash.extend");
+import extendWithFunc = require("lodash.extendWith");
+import addFunc = require("lodash.add");
+import attemptFunc = require("lodash.attempt");
+import camelCaseFunc = require("lodash.camelCase");
+import capitalizeFunc = require("lodash.capitalize");
+import ceilFunc = require("lodash.ceil");
+import clampFunc = require("lodash.clamp");
+import cloneFunc = require("lodash.clone");
+import cloneDeepFunc = require("lodash.cloneDeep");
+import cloneDeepWithFunc = require("lodash.cloneDeepWith");
+import cloneWithFunc = require("lodash.cloneWith");
+import deburrFunc = require("lodash.deburr");
+import endsWithFunc = require("lodash.endsWith");
+import eqFunc = require("lodash.eq");
+import escapeFunc = require("lodash.escape");
+import escapeRegExpFunc = require("lodash.escapeRegExp");
+import everyFunc = require("lodash.every");
+import findFunc = require("lodash.find");
+import findIndexFunc = require("lodash.findIndex");
+import findKeyFunc = require("lodash.findKey");
+import findLastFunc = require("lodash.findLast");
+import findLastIndexFunc = require("lodash.findLastIndex");
+import findLastKeyFunc = require("lodash.findLastKey");
+import floorFunc = require("lodash.floor");
+import forEachFunc = require("lodash.forEach");
+import forEachRightFunc = require("lodash.forEachRight");
+import forInFunc = require("lodash.forIn");
+import forInRightFunc = require("lodash.forInRight");
+import forOwnFunc = require("lodash.forOwn");
+import forOwnRightFunc = require("lodash.forOwnRight");
+import getFunc = require("lodash.get");
+import gtFunc = require("lodash.gt");
+import gteFunc = require("lodash.gte");
+import hasFunc = require("lodash.has");
+import hasInFunc = require("lodash.hasIn");
+import headFunc = require("lodash.head");
+import identityFunc = require("lodash.identity");
+import includesFunc = require("lodash.includes");
+import indexOfFunc = require("lodash.indexOf");
+import inRangeFunc = require("lodash.inRange");
+import invokeFunc = require("lodash.invoke");
+import isArgumentsFunc = require("lodash.isArguments");
+import isArrayFunc = require("lodash.isArray");
+import isArrayBufferFunc = require("lodash.isArrayBuffer");
+import isArrayLikeFunc = require("lodash.isArrayLike");
+import isArrayLikeObjectFunc = require("lodash.isArrayLikeObject");
+import isBooleanFunc = require("lodash.isBoolean");
+import isBufferFunc = require("lodash.isBuffer");
+import isDateFunc = require("lodash.isDate");
+import isElementFunc = require("lodash.isElement");
+import isEmptyFunc = require("lodash.isEmpty");
+import isEqualFunc = require("lodash.isEqual");
+import isEqualWithFunc = require("lodash.isEqualWith");
+import isErrorFunc = require("lodash.isError");
+import isFiniteFunc = require("lodash.isFinite");
+import isFunctionFunc = require("lodash.isFunction");
+import isIntegerFunc = require("lodash.isInteger");
+import isLengthFunc = require("lodash.isLength");
+import isMapFunc = require("lodash.isMap");
+import isMatchFunc = require("lodash.isMatch");
+import isMatchWithFunc = require("lodash.isMatchWith");
+import isNaNFunc = require("lodash.isNaN");
+import isNativeFunc = require("lodash.isNative");
+import isNilFunc = require("lodash.isNil");
+import isNullFunc = require("lodash.isNull");
+import isNumberFunc = require("lodash.isNumber");
+import isObjectFunc = require("lodash.isObject");
+import isObjectLikeFunc = require("lodash.isObjectLike");
+import isPlainObjectFunc = require("lodash.isPlainObject");
+import isRegExpFunc = require("lodash.isRegExp");
+import isSafeIntegerFunc = require("lodash.isSafeInteger");
+import isSetFunc = require("lodash.isSet");
+import isStringFunc = require("lodash.isString");
+import isSymbolFunc = require("lodash.isSymbol");
+import isTypedArrayFunc = require("lodash.isTypedArray");
+import isUndefinedFunc = require("lodash.isUndefined");
+import isWeakMapFunc = require("lodash.isWeakMap");
+import isWeakSetFunc = require("lodash.isWeakSet");
+import joinFunc = require("lodash.join");
+import kebabCaseFunc = require("lodash.kebabCase");
+import lastFunc = require("lodash.last");
+import lastIndexOfFunc = require("lodash.lastIndexOf");
+import lowerCaseFunc = require("lodash.lowerCase");
+import lowerFirstFunc = require("lodash.lowerFirst");
+import ltFunc = require("lodash.lt");
+import lteFunc = require("lodash.lte");
+import maxFunc = require("lodash.max");
+import maxByFunc = require("lodash.maxBy");
+import meanFunc = require("lodash.mean");
+import minFunc = require("lodash.min");
+import minByFunc = require("lodash.minBy");
+import noConflictFunc = require("lodash.noConflict");
+import noopFunc = require("lodash.noop");
+import nowFunc = require("lodash.now");
+import padFunc = require("lodash.pad");
+import padEndFunc = require("lodash.padEnd");
+import padStartFunc = require("lodash.padStart");
+import parseIntFunc = require("lodash.parseInt");
+import randomFunc = require("lodash.random");
+import reduceFunc = require("lodash.reduce");
+import reduceRightFunc = require("lodash.reduceRight");
+import repeatFunc = require("lodash.repeat");
+import replaceFunc = require("lodash.replace");
+import resultFunc = require("lodash.result");
+import roundFunc = require("lodash.round");
+import runInContextFunc = require("lodash.runInContext");
+import sampleFunc = require("lodash.sample");
+import sizeFunc = require("lodash.size");
+import snakeCaseFunc = require("lodash.snakeCase");
+import someFunc = require("lodash.some");
+import sortedIndexFunc = require("lodash.sortedIndex");
+import sortedIndexByFunc = require("lodash.sortedIndexBy");
+import sortedIndexOfFunc = require("lodash.sortedIndexOf");
+import sortedLastIndexFunc = require("lodash.sortedLastIndex");
+import sortedLastIndexByFunc = require("lodash.sortedLastIndexBy");
+import sortedLastIndexOfFunc = require("lodash.sortedLastIndexOf");
+import startCaseFunc = require("lodash.startCase");
+import startsWithFunc = require("lodash.startsWith");
+import subtractFunc = require("lodash.subtract");
+import sumFunc = require("lodash.sum");
+import sumByFunc = require("lodash.sumBy");
+import templateFunc = require("lodash.template");
+import timesFunc = require("lodash.times");
+import toIntegerFunc = require("lodash.toInteger");
+import toLengthFunc = require("lodash.toLength");
+import toLowerFunc = require("lodash.toLower");
+import toNumberFunc = require("lodash.toNumber");
+import toSafeIntegerFunc = require("lodash.toSafeInteger");
+import toStringFunc = require("lodash.toString");
+import toUpperFunc = require("lodash.toUpper");
+import trimFunc = require("lodash.trim");
+import trimEndFunc = require("lodash.trimEnd");
+import trimStartFunc = require("lodash.trimStart");
+import truncateFunc = require("lodash.truncate");
+import unescapeFunc = require("lodash.unescape");
+import uniqueIdFunc = require("lodash.uniqueId");
+import upperCaseFunc = require("lodash.upperCase");
+import upperFirstFunc = require("lodash.upperFirst");
+import eachFunc = require("lodash.each");
+import eachRightFunc = require("lodash.eachRight");
+import firstFunc = require("lodash.first");
+namespace method_modules_tests {
+    _.after = afterFunc;
+    _.ary = aryFunc;
+    _.assign = assignFunc;
+    _.assignIn = assignInFunc;
+    _.assignInWith = assignInWithFunc;
+    _.assignWith = assignWithFunc;
+    _.at = atFunc;
+    _.before = beforeFunc;
+    _.bind = bindFunc;
+    _.bindAll = bindAllFunc;
+    _.bindKey = bindKeyFunc;
+    _.castArray = castArrayFunc;
+    _.chain = chainFunc;
+    _.chunk = chunkFunc;
+    _.compact = compactFunc;
+    _.concat = concatFunc;
+    _.constant = constantFunc;
+    _.countBy = countByFunc;
+    _.create = createFunc;
+    _.curry = curryFunc;
+    _.curryRight = curryRightFunc;
+    _.debounce = debounceFunc;
+    _.defaults = defaultsFunc;
+    _.defaultsDeep = defaultsDeepFunc;
+    _.defer = deferFunc;
+    _.delay = delayFunc;
+    _.difference = differenceFunc;
+    _.differenceBy = differenceByFunc;
+    _.differenceWith = differenceWithFunc;
+    _.drop = dropFunc;
+    _.dropRight = dropRightFunc;
+    _.dropRightWhile = dropRightWhileFunc;
+    _.dropWhile = dropWhileFunc;
+    _.fill = fillFunc;
+    _.filter = filterFunc;
+    _.flatMap = flatMapFunc;
+    _.flatten = flattenFunc;
+    _.flattenDeep = flattenDeepFunc;
+    _.flattenDepth = flattenDepthFunc;
+    _.flip = flipFunc;
+    _.flow = flowFunc;
+    _.flowRight = flowRightFunc;
+    _.fromPairs = fromPairsFunc;
+    _.functions = functionsFunc;
+    _.functionsIn = functionsInFunc;
+    _.groupBy = groupByFunc;
+    _.initial = initialFunc;
+    _.intersection = intersectionFunc;
+    _.intersectionBy = intersectionByFunc;
+    _.intersectionWith = intersectionWithFunc;
+    _.invert = invertFunc;
+    _.invertBy = invertByFunc;
+    _.invokeMap = invokeMapFunc;
+    _.iteratee = iterateeFunc;
+    _.keyBy = keyByFunc;
+    _.keys = keysFunc;
+    _.keysIn = keysInFunc;
+    _.map = mapFunc;
+    _.mapKeys = mapKeysFunc;
+    _.mapValues = mapValuesFunc;
+    _.matches = matchesFunc;
+    _.matchesProperty = matchesPropertyFunc;
+    _.memoize = memoizeFunc;
+    _.merge = mergeFunc;
+    _.mergeWith = mergeWithFunc;
+    _.method = methodFunc;
+    _.methodOf = methodOfFunc;
+    _.mixin = mixinFunc;
+    _.negate = negateFunc;
+    _.nthArg = nthArgFunc;
+    _.omit = omitFunc;
+    _.omitBy = omitByFunc;
+    _.once = onceFunc;
+    _.orderBy = orderByFunc;
+    _.over = overFunc;
+    _.overArgs = overArgsFunc;
+    _.overEvery = overEveryFunc;
+    _.overSome = overSomeFunc;
+    _.partial = partialFunc;
+    _.partialRight = partialRightFunc;
+    _.partition = partitionFunc;
+    _.pick = pickFunc;
+    _.pickBy = pickByFunc;
+    _.property = propertyFunc;
+    _.propertyOf = propertyOfFunc;
+    _.pull = pullFunc;
+    _.pullAll = pullAllFunc;
+    _.pullAllBy = pullAllByFunc;
+    _.pullAt = pullAtFunc;
+    _.range = rangeFunc;
+    _.rangeRight = rangeRightFunc;
+    _.rearg = reargFunc;
+    _.reject = rejectFunc;
+    _.remove = removeFunc;
+    _.rest = restFunc;
+    _.reverse = reverseFunc;
+    _.sampleSize = sampleSizeFunc;
+    _.set = setFunc;
+    _.setWith = setWithFunc;
+    _.shuffle = shuffleFunc;
+    _.slice = sliceFunc;
+    _.sortBy = sortByFunc;
+    _.sortedUniq = sortedUniqFunc;
+    _.sortedUniqBy = sortedUniqByFunc;
+    _.split = splitFunc;
+    _.spread = spreadFunc;
+    _.tail = tailFunc;
+    _.take = takeFunc;
+    _.takeRight = takeRightFunc;
+    _.takeRightWhile = takeRightWhileFunc;
+    _.takeWhile = takeWhileFunc;
+    _.tap = tapFunc;
+    _.throttle = throttleFunc;
+    _.thru = thruFunc;
+    _.toArray = toArrayFunc;
+    _.toPairs = toPairsFunc;
+    _.toPairsIn = toPairsInFunc;
+    _.toPath = toPathFunc;
+    _.toPlainObject = toPlainObjectFunc;
+    _.transform = transformFunc;
+    _.unary = unaryFunc;
+    _.union = unionFunc;
+    _.unionBy = unionByFunc;
+    _.unionWith = unionWithFunc;
+    _.uniq = uniqFunc;
+    _.uniqBy = uniqByFunc;
+    _.uniqWith = uniqWithFunc;
+    _.unset = unsetFunc;
+    _.unzip = unzipFunc;
+    _.unzipWith = unzipWithFunc;
+    _.update = updateFunc;
+    _.values = valuesFunc;
+    _.valuesIn = valuesInFunc;
+    _.without = withoutFunc;
+    _.words = wordsFunc;
+    _.wrap = wrapFunc;
+    _.xor = xorFunc;
+    _.xorBy = xorByFunc;
+    _.xorWith = xorWithFunc;
+    _.zip = zipFunc;
+    _.zipObject = zipObjectFunc;
+    _.zipWith = zipWithFunc;
+    _.extend = extendFunc;
+    _.extendWith = extendWithFunc;
+    _.add = addFunc;
+    _.attempt = attemptFunc;
+    _.camelCase = camelCaseFunc;
+    _.capitalize = capitalizeFunc;
+    _.ceil = ceilFunc;
+    _.clamp = clampFunc;
+    _.clone = cloneFunc;
+    _.cloneDeep = cloneDeepFunc;
+    _.cloneDeepWith = cloneDeepWithFunc;
+    _.cloneWith = cloneWithFunc;
+    _.deburr = deburrFunc;
+    _.endsWith = endsWithFunc;
+    _.eq = eqFunc;
+    _.escape = escapeFunc;
+    _.escapeRegExp = escapeRegExpFunc;
+    _.every = everyFunc;
+    _.find = findFunc;
+    _.findIndex = findIndexFunc;
+    _.findKey = findKeyFunc;
+    _.findLast = findLastFunc;
+    _.findLastIndex = findLastIndexFunc;
+    _.findLastKey = findLastKeyFunc;
+    _.floor = floorFunc;
+    _.forEach = forEachFunc;
+    _.forEachRight = forEachRightFunc;
+    _.forIn = forInFunc;
+    _.forInRight = forInRightFunc;
+    _.forOwn = forOwnFunc;
+    _.forOwnRight = forOwnRightFunc;
+    _.get = getFunc;
+    _.gt = gtFunc;
+    _.gte = gteFunc;
+    _.has = hasFunc;
+    _.hasIn = hasInFunc;
+    _.head = headFunc;
+    _.identity = identityFunc;
+    _.includes = includesFunc;
+    _.indexOf = indexOfFunc;
+    _.inRange = inRangeFunc;
+    _.invoke = invokeFunc;
+    _.isArguments = isArgumentsFunc;
+    _.isArray = isArrayFunc;
+    _.isArrayBuffer = isArrayBufferFunc;
+    _.isArrayLike = isArrayLikeFunc;
+    _.isArrayLikeObject = isArrayLikeObjectFunc;
+    _.isBoolean = isBooleanFunc;
+    _.isBuffer = isBufferFunc;
+    _.isDate = isDateFunc;
+    _.isElement = isElementFunc;
+    _.isEmpty = isEmptyFunc;
+    _.isEqual = isEqualFunc;
+    _.isEqualWith = isEqualWithFunc;
+    _.isError = isErrorFunc;
+    _.isFinite = isFiniteFunc;
+    _.isFunction = isFunctionFunc;
+    _.isInteger = isIntegerFunc;
+    _.isLength = isLengthFunc;
+    _.isMap = isMapFunc;
+    _.isMatch = isMatchFunc;
+    _.isMatchWith = isMatchWithFunc;
+    _.isNaN = isNaNFunc;
+    _.isNative = isNativeFunc;
+    _.isNil = isNilFunc;
+    _.isNull = isNullFunc;
+    _.isNumber = isNumberFunc;
+    _.isObject = isObjectFunc;
+    _.isObjectLike = isObjectLikeFunc;
+    _.isPlainObject = isPlainObjectFunc;
+    _.isRegExp = isRegExpFunc;
+    _.isSafeInteger = isSafeIntegerFunc;
+    _.isSet = isSetFunc;
+    _.isString = isStringFunc;
+    _.isSymbol = isSymbolFunc;
+    _.isTypedArray = isTypedArrayFunc;
+    _.isUndefined = isUndefinedFunc;
+    _.isWeakMap = isWeakMapFunc;
+    _.isWeakSet = isWeakSetFunc;
+    _.join = joinFunc;
+    _.kebabCase = kebabCaseFunc;
+    _.last = lastFunc;
+    _.lastIndexOf = lastIndexOfFunc;
+    _.lowerCase = lowerCaseFunc;
+    _.lowerFirst = lowerFirstFunc;
+    _.lt = ltFunc;
+    _.lte = lteFunc;
+    _.max = maxFunc;
+    _.maxBy = maxByFunc;
+    _.mean = meanFunc;
+    _.min = minFunc;
+    _.minBy = minByFunc;
+    _.noConflict = noConflictFunc;
+    _.noop = noopFunc;
+    _.now = nowFunc;
+    _.pad = padFunc;
+    _.padEnd = padEndFunc;
+    _.padStart = padStartFunc;
+    _.parseInt = parseIntFunc;
+    _.random = randomFunc;
+    _.reduce = reduceFunc;
+    _.reduceRight = reduceRightFunc;
+    _.repeat = repeatFunc;
+    _.replace = replaceFunc;
+    _.result = resultFunc;
+    _.round = roundFunc;
+    _.runInContext = runInContextFunc;
+    _.sample = sampleFunc;
+    _.size = sizeFunc;
+    _.snakeCase = snakeCaseFunc;
+    _.some = someFunc;
+    _.sortedIndex = sortedIndexFunc;
+    _.sortedIndexBy = sortedIndexByFunc;
+    _.sortedIndexOf = sortedIndexOfFunc;
+    _.sortedLastIndex = sortedLastIndexFunc;
+    _.sortedLastIndexBy = sortedLastIndexByFunc;
+    _.sortedLastIndexOf = sortedLastIndexOfFunc;
+    _.startCase = startCaseFunc;
+    _.startsWith = startsWithFunc;
+    _.subtract = subtractFunc;
+    _.sum = sumFunc;
+    _.sumBy = sumByFunc;
+    _.template = templateFunc;
+    _.times = timesFunc;
+    _.toInteger = toIntegerFunc;
+    _.toLength = toLengthFunc;
+    _.toLower = toLowerFunc;
+    _.toNumber = toNumberFunc;
+    _.toSafeInteger = toSafeIntegerFunc;
+    _.toString = toStringFunc;
+    _.toUpper = toUpperFunc;
+    _.trim = trimFunc;
+    _.trimEnd = trimEndFunc;
+    _.trimStart = trimStartFunc;
+    _.truncate = truncateFunc;
+    _.unescape = unescapeFunc;
+    _.uniqueId = uniqueIdFunc;
+    _.upperCase = upperCaseFunc;
+    _.upperFirst = upperFirstFunc;
+    _.each = eachFunc;
+    _.eachRight = eachRightFunc;
+    _.first = firstFunc;
+}
diff --git a/lodash/lodash.d.ts b/lodash/lodash.d.ts
index 3305528a5e..961520e6c4 100644
--- a/lodash/lodash.d.ts
+++ b/lodash/lodash.d.ts
@@ -21031,6 +21031,1835 @@ declare module "lodash" {
     export = _;
 }
 
+/*************************************************
+ *                                               * 
+ * The lodash method _.XXX exported as a module. *
+ *                                               *
+ *************************************************/
+
+
+declare module "lodash.after" {
+   const after: typeof _.after;
+   export = after;
+}
+
+
+declare module "lodash.ary" {
+   const ary: typeof _.ary;
+   export = ary;
+}
+
+
+declare module "lodash.assign" {
+   const assign: typeof _.assign;
+   export = assign;
+}
+
+
+declare module "lodash.assignIn" {
+   const assignIn: typeof _.assignIn;
+   export = assignIn;
+}
+
+
+declare module "lodash.assignInWith" {
+   const assignInWith: typeof _.assignInWith;
+   export = assignInWith;
+}
+
+
+declare module "lodash.assignWith" {
+   const assignWith: typeof _.assignWith;
+   export = assignWith;
+}
+
+
+declare module "lodash.at" {
+   const at: typeof _.at;
+   export = at;
+}
+
+
+declare module "lodash.before" {
+   const before: typeof _.before;
+   export = before;
+}
+
+
+declare module "lodash.bind" {
+   const bind: typeof _.bind;
+   export = bind;
+}
+
+
+declare module "lodash.bindAll" {
+   const bindAll: typeof _.bindAll;
+   export = bindAll;
+}
+
+
+declare module "lodash.bindKey" {
+   const bindKey: typeof _.bindKey;
+   export = bindKey;
+}
+
+
+declare module "lodash.castArray" {
+   const castArray: typeof _.castArray;
+   export = castArray;
+}
+
+
+declare module "lodash.chain" {
+   const chain: typeof _.chain;
+   export = chain;
+}
+
+
+declare module "lodash.chunk" {
+   const chunk: typeof _.chunk;
+   export = chunk;
+}
+
+
+declare module "lodash.compact" {
+   const compact: typeof _.compact;
+   export = compact;
+}
+
+
+declare module "lodash.concat" {
+   const concat: typeof _.concat;
+   export = concat;
+}
+
+/**
+* uncoment it if definition exists
+*/
+/*
+declare module "lodash.cond" {
+   const cond: typeof _.cond;
+   export = cond;
+}
+*/
+
+/**
+* uncoment it if definition exists
+*/
+/*
+declare module "lodash.conforms" {
+   const conforms: typeof _.conforms;
+   export = conforms;
+}
+*/
+
+declare module "lodash.constant" {
+   const constant: typeof _.constant;
+   export = constant;
+}
+
+
+declare module "lodash.countBy" {
+   const countBy: typeof _.countBy;
+   export = countBy;
+}
+
+
+declare module "lodash.create" {
+   const create: typeof _.create;
+   export = create;
+}
+
+
+declare module "lodash.curry" {
+   const curry: typeof _.curry;
+   export = curry;
+}
+
+
+declare module "lodash.curryRight" {
+   const curryRight: typeof _.curryRight;
+   export = curryRight;
+}
+
+
+declare module "lodash.debounce" {
+   const debounce: typeof _.debounce;
+   export = debounce;
+}
+
+
+declare module "lodash.defaults" {
+   const defaults: typeof _.defaults;
+   export = defaults;
+}
+
+
+declare module "lodash.defaultsDeep" {
+   const defaultsDeep: typeof _.defaultsDeep;
+   export = defaultsDeep;
+}
+
+
+declare module "lodash.defer" {
+   const defer: typeof _.defer;
+   export = defer;
+}
+
+
+declare module "lodash.delay" {
+   const delay: typeof _.delay;
+   export = delay;
+}
+
+
+declare module "lodash.difference" {
+   const difference: typeof _.difference;
+   export = difference;
+}
+
+
+declare module "lodash.differenceBy" {
+   const differenceBy: typeof _.differenceBy;
+   export = differenceBy;
+}
+
+
+declare module "lodash.differenceWith" {
+   const differenceWith: typeof _.differenceWith;
+   export = differenceWith;
+}
+
+
+declare module "lodash.drop" {
+   const drop: typeof _.drop;
+   export = drop;
+}
+
+
+declare module "lodash.dropRight" {
+   const dropRight: typeof _.dropRight;
+   export = dropRight;
+}
+
+
+declare module "lodash.dropRightWhile" {
+   const dropRightWhile: typeof _.dropRightWhile;
+   export = dropRightWhile;
+}
+
+
+declare module "lodash.dropWhile" {
+   const dropWhile: typeof _.dropWhile;
+   export = dropWhile;
+}
+
+
+declare module "lodash.fill" {
+   const fill: typeof _.fill;
+   export = fill;
+}
+
+
+declare module "lodash.filter" {
+   const filter: typeof _.filter;
+   export = filter;
+}
+
+
+declare module "lodash.flatMap" {
+   const flatMap: typeof _.flatMap;
+   export = flatMap;
+}
+
+/**
+* uncoment it if definition exists
+*/
+/*
+declare module "lodash.flatMapDeep" {
+   const flatMapDeep: typeof _.flatMapDeep;
+   export = flatMapDeep;
+}
+*/
+/**
+* uncoment it if definition exists
+*/
+/*
+declare module "lodash.flatMapDepth" {
+   const flatMapDepth: typeof _.flatMapDepth;
+   export = flatMapDepth;
+}
+*/
+
+declare module "lodash.flatten" {
+   const flatten: typeof _.flatten;
+   export = flatten;
+}
+
+
+declare module "lodash.flattenDeep" {
+   const flattenDeep: typeof _.flattenDeep;
+   export = flattenDeep;
+}
+
+declare module "lodash.flattenDepth" {
+   const flattenDepth: typeof _.flattenDepth;
+   export = flattenDepth;
+}
+
+declare module "lodash.flip" {
+   const flip: typeof _.flip;
+   export = flip;
+}
+
+
+declare module "lodash.flow" {
+   const flow: typeof _.flow;
+   export = flow;
+}
+
+
+declare module "lodash.flowRight" {
+   const flowRight: typeof _.flowRight;
+   export = flowRight;
+}
+
+
+declare module "lodash.fromPairs" {
+   const fromPairs: typeof _.fromPairs;
+   export = fromPairs;
+}
+
+
+declare module "lodash.functions" {
+   const functions: typeof _.functions;
+   export = functions;
+}
+
+
+declare module "lodash.functionsIn" {
+   const functionsIn: typeof _.functionsIn;
+   export = functionsIn;
+}
+
+
+declare module "lodash.groupBy" {
+   const groupBy: typeof _.groupBy;
+   export = groupBy;
+}
+
+
+declare module "lodash.initial" {
+   const initial: typeof _.initial;
+   export = initial;
+}
+
+
+declare module "lodash.intersection" {
+   const intersection: typeof _.intersection;
+   export = intersection;
+}
+
+
+declare module "lodash.intersectionBy" {
+   const intersectionBy: typeof _.intersectionBy;
+   export = intersectionBy;
+}
+
+
+declare module "lodash.intersectionWith" {
+   const intersectionWith: typeof _.intersectionWith;
+   export = intersectionWith;
+}
+
+
+declare module "lodash.invert" {
+   const invert: typeof _.invert;
+   export = invert;
+}
+
+
+declare module "lodash.invertBy" {
+   const invertBy: typeof _.invertBy;
+   export = invertBy;
+}
+
+
+declare module "lodash.invokeMap" {
+   const invokeMap: typeof _.invokeMap;
+   export = invokeMap;
+}
+
+
+declare module "lodash.iteratee" {
+   const iteratee: typeof _.iteratee;
+   export = iteratee;
+}
+
+
+declare module "lodash.keyBy" {
+   const keyBy: typeof _.keyBy;
+   export = keyBy;
+}
+
+
+declare module "lodash.keys" {
+   const keys: typeof _.keys;
+   export = keys;
+}
+
+
+declare module "lodash.keysIn" {
+   const keysIn: typeof _.keysIn;
+   export = keysIn;
+}
+
+
+declare module "lodash.map" {
+   const map: typeof _.map;
+   export = map;
+}
+
+
+declare module "lodash.mapKeys" {
+   const mapKeys: typeof _.mapKeys;
+   export = mapKeys;
+}
+
+
+declare module "lodash.mapValues" {
+   const mapValues: typeof _.mapValues;
+   export = mapValues;
+}
+
+
+declare module "lodash.matches" {
+   const matches: typeof _.matches;
+   export = matches;
+}
+
+
+declare module "lodash.matchesProperty" {
+   const matchesProperty: typeof _.matchesProperty;
+   export = matchesProperty;
+}
+
+
+declare module "lodash.memoize" {
+   const memoize: typeof _.memoize;
+   export = memoize;
+}
+
+
+declare module "lodash.merge" {
+   const merge: typeof _.merge;
+   export = merge;
+}
+
+
+declare module "lodash.mergeWith" {
+   const mergeWith: typeof _.mergeWith;
+   export = mergeWith;
+}
+
+
+declare module "lodash.method" {
+   const method: typeof _.method;
+   export = method;
+}
+
+
+declare module "lodash.methodOf" {
+   const methodOf: typeof _.methodOf;
+   export = methodOf;
+}
+
+
+declare module "lodash.mixin" {
+   const mixin: typeof _.mixin;
+   export = mixin;
+}
+
+
+declare module "lodash.negate" {
+   const negate: typeof _.negate;
+   export = negate;
+}
+
+
+declare module "lodash.nthArg" {
+   const nthArg: typeof _.nthArg;
+   export = nthArg;
+}
+
+
+declare module "lodash.omit" {
+   const omit: typeof _.omit;
+   export = omit;
+}
+
+
+declare module "lodash.omitBy" {
+   const omitBy: typeof _.omitBy;
+   export = omitBy;
+}
+
+
+declare module "lodash.once" {
+   const once: typeof _.once;
+   export = once;
+}
+
+
+declare module "lodash.orderBy" {
+   const orderBy: typeof _.orderBy;
+   export = orderBy;
+}
+
+
+declare module "lodash.over" {
+   const over: typeof _.over;
+   export = over;
+}
+
+
+declare module "lodash.overArgs" {
+   const overArgs: typeof _.overArgs;
+   export = overArgs;
+}
+
+
+declare module "lodash.overEvery" {
+   const overEvery: typeof _.overEvery;
+   export = overEvery;
+}
+
+
+declare module "lodash.overSome" {
+   const overSome: typeof _.overSome;
+   export = overSome;
+}
+
+
+declare module "lodash.partial" {
+   const partial: typeof _.partial;
+   export = partial;
+}
+
+
+declare module "lodash.partialRight" {
+   const partialRight: typeof _.partialRight;
+   export = partialRight;
+}
+
+
+declare module "lodash.partition" {
+   const partition: typeof _.partition;
+   export = partition;
+}
+
+
+declare module "lodash.pick" {
+   const pick: typeof _.pick;
+   export = pick;
+}
+
+
+declare module "lodash.pickBy" {
+   const pickBy: typeof _.pickBy;
+   export = pickBy;
+}
+
+
+declare module "lodash.property" {
+   const property: typeof _.property;
+   export = property;
+}
+
+
+declare module "lodash.propertyOf" {
+   const propertyOf: typeof _.propertyOf;
+   export = propertyOf;
+}
+
+
+declare module "lodash.pull" {
+   const pull: typeof _.pull;
+   export = pull;
+}
+
+
+declare module "lodash.pullAll" {
+   const pullAll: typeof _.pullAll;
+   export = pullAll;
+}
+
+
+declare module "lodash.pullAllBy" {
+   const pullAllBy: typeof _.pullAllBy;
+   export = pullAllBy;
+}
+
+/**
+* uncoment it if definition exists
+*/
+/*
+declare module "lodash.pullAllWith" {
+   const pullAllWith: typeof _.pullAllWith;
+   export = pullAllWith;
+}
+*/
+
+declare module "lodash.pullAt" {
+   const pullAt: typeof _.pullAt;
+   export = pullAt;
+}
+
+
+declare module "lodash.range" {
+   const range: typeof _.range;
+   export = range;
+}
+
+
+declare module "lodash.rangeRight" {
+   const rangeRight: typeof _.rangeRight;
+   export = rangeRight;
+}
+
+
+declare module "lodash.rearg" {
+   const rearg: typeof _.rearg;
+   export = rearg;
+}
+
+
+declare module "lodash.reject" {
+   const reject: typeof _.reject;
+   export = reject;
+}
+
+
+declare module "lodash.remove" {
+   const remove: typeof _.remove;
+   export = remove;
+}
+
+
+declare module "lodash.rest" {
+   const rest: typeof _.rest;
+   export = rest;
+}
+
+
+declare module "lodash.reverse" {
+   const reverse: typeof _.reverse;
+   export = reverse;
+}
+
+
+declare module "lodash.sampleSize" {
+   const sampleSize: typeof _.sampleSize;
+   export = sampleSize;
+}
+
+
+declare module "lodash.set" {
+   const set: typeof _.set;
+   export = set;
+}
+
+
+declare module "lodash.setWith" {
+   const setWith: typeof _.setWith;
+   export = setWith;
+}
+
+
+declare module "lodash.shuffle" {
+   const shuffle: typeof _.shuffle;
+   export = shuffle;
+}
+
+
+declare module "lodash.slice" {
+   const slice: typeof _.slice;
+   export = slice;
+}
+
+
+declare module "lodash.sortBy" {
+   const sortBy: typeof _.sortBy;
+   export = sortBy;
+}
+
+
+declare module "lodash.sortedUniq" {
+   const sortedUniq: typeof _.sortedUniq;
+   export = sortedUniq;
+}
+
+
+declare module "lodash.sortedUniqBy" {
+   const sortedUniqBy: typeof _.sortedUniqBy;
+   export = sortedUniqBy;
+}
+
+
+declare module "lodash.split" {
+   const split: typeof _.split;
+   export = split;
+}
+
+
+declare module "lodash.spread" {
+   const spread: typeof _.spread;
+   export = spread;
+}
+
+
+declare module "lodash.tail" {
+   const tail: typeof _.tail;
+   export = tail;
+}
+
+
+declare module "lodash.take" {
+   const take: typeof _.take;
+   export = take;
+}
+
+
+declare module "lodash.takeRight" {
+   const takeRight: typeof _.takeRight;
+   export = takeRight;
+}
+
+
+declare module "lodash.takeRightWhile" {
+   const takeRightWhile: typeof _.takeRightWhile;
+   export = takeRightWhile;
+}
+
+
+declare module "lodash.takeWhile" {
+   const takeWhile: typeof _.takeWhile;
+   export = takeWhile;
+}
+
+
+declare module "lodash.tap" {
+   const tap: typeof _.tap;
+   export = tap;
+}
+
+
+declare module "lodash.throttle" {
+   const throttle: typeof _.throttle;
+   export = throttle;
+}
+
+
+declare module "lodash.thru" {
+   const thru: typeof _.thru;
+   export = thru;
+}
+
+
+declare module "lodash.toArray" {
+   const toArray: typeof _.toArray;
+   export = toArray;
+}
+
+
+declare module "lodash.toPairs" {
+   const toPairs: typeof _.toPairs;
+   export = toPairs;
+}
+
+
+declare module "lodash.toPairsIn" {
+   const toPairsIn: typeof _.toPairsIn;
+   export = toPairsIn;
+}
+
+
+declare module "lodash.toPath" {
+   const toPath: typeof _.toPath;
+   export = toPath;
+}
+
+
+declare module "lodash.toPlainObject" {
+   const toPlainObject: typeof _.toPlainObject;
+   export = toPlainObject;
+}
+
+
+declare module "lodash.transform" {
+   const transform: typeof _.transform;
+   export = transform;
+}
+
+
+declare module "lodash.unary" {
+   const unary: typeof _.unary;
+   export = unary;
+}
+
+
+declare module "lodash.union" {
+   const union: typeof _.union;
+   export = union;
+}
+
+
+declare module "lodash.unionBy" {
+   const unionBy: typeof _.unionBy;
+   export = unionBy;
+}
+
+
+declare module "lodash.unionWith" {
+   const unionWith: typeof _.unionWith;
+   export = unionWith;
+}
+
+
+declare module "lodash.uniq" {
+   const uniq: typeof _.uniq;
+   export = uniq;
+}
+
+
+declare module "lodash.uniqBy" {
+   const uniqBy: typeof _.uniqBy;
+   export = uniqBy;
+}
+
+
+declare module "lodash.uniqWith" {
+   const uniqWith: typeof _.uniqWith;
+   export = uniqWith;
+}
+
+
+declare module "lodash.unset" {
+   const unset: typeof _.unset;
+   export = unset;
+}
+
+
+declare module "lodash.unzip" {
+   const unzip: typeof _.unzip;
+   export = unzip;
+}
+
+
+declare module "lodash.unzipWith" {
+   const unzipWith: typeof _.unzipWith;
+   export = unzipWith;
+}
+
+
+declare module "lodash.update" {
+   const update: typeof _.update;
+   export = update;
+}
+
+/**
+* uncoment it if definition exists
+*/
+/*
+declare module "lodash.updateWith" {
+   const updateWith: typeof _.updateWith;
+   export = updateWith;
+}
+*/
+
+declare module "lodash.values" {
+   const values: typeof _.values;
+   export = values;
+}
+
+
+declare module "lodash.valuesIn" {
+   const valuesIn: typeof _.valuesIn;
+   export = valuesIn;
+}
+
+
+declare module "lodash.without" {
+   const without: typeof _.without;
+   export = without;
+}
+
+
+declare module "lodash.words" {
+   const words: typeof _.words;
+   export = words;
+}
+
+
+declare module "lodash.wrap" {
+   const wrap: typeof _.wrap;
+   export = wrap;
+}
+
+
+declare module "lodash.xor" {
+   const xor: typeof _.xor;
+   export = xor;
+}
+
+
+declare module "lodash.xorBy" {
+   const xorBy: typeof _.xorBy;
+   export = xorBy;
+}
+
+
+declare module "lodash.xorWith" {
+   const xorWith: typeof _.xorWith;
+   export = xorWith;
+}
+
+
+declare module "lodash.zip" {
+   const zip: typeof _.zip;
+   export = zip;
+}
+
+
+declare module "lodash.zipObject" {
+   const zipObject: typeof _.zipObject;
+   export = zipObject;
+}
+
+/**
+* uncoment it if definition exists
+*/
+/*
+declare module "lodash.zipObjectDeep" {
+   const zipObjectDeep: typeof _.zipObjectDeep;
+   export = zipObjectDeep;
+}
+*/
+
+
+declare module "lodash.zipWith" {
+   const zipWith: typeof _.zipWith;
+   export = zipWith;
+}
+
+/**
+* uncoment it if definition exists
+*/
+/*
+declare module "lodash.entries" {
+   const entries: typeof _.entries;
+   export = entries;
+}
+*/
+/**
+* uncoment it if definition exists
+*/
+/*
+declare module "lodash.entriesIn" {
+   const entriesIn: typeof _.entriesIn;
+   export = entriesIn;
+}
+*/
+
+
+declare module "lodash.extend" {
+   const extend: typeof _.extend;
+   export = extend;
+}
+
+
+declare module "lodash.extendWith" {
+   const extendWith: typeof _.extendWith;
+   export = extendWith;
+}
+
+
+declare module "lodash.add" {
+   const add: typeof _.add;
+   export = add;
+}
+
+
+declare module "lodash.attempt" {
+   const attempt: typeof _.attempt;
+   export = attempt;
+}
+
+
+declare module "lodash.camelCase" {
+   const camelCase: typeof _.camelCase;
+   export = camelCase;
+}
+
+
+declare module "lodash.capitalize" {
+   const capitalize: typeof _.capitalize;
+   export = capitalize;
+}
+
+
+declare module "lodash.ceil" {
+   const ceil: typeof _.ceil;
+   export = ceil;
+}
+
+
+declare module "lodash.clamp" {
+   const clamp: typeof _.clamp;
+   export = clamp;
+}
+
+
+declare module "lodash.clone" {
+   const clone: typeof _.clone;
+   export = clone;
+}
+
+
+declare module "lodash.cloneDeep" {
+   const cloneDeep: typeof _.cloneDeep;
+   export = cloneDeep;
+}
+
+
+declare module "lodash.cloneDeepWith" {
+   const cloneDeepWith: typeof _.cloneDeepWith;
+   export = cloneDeepWith;
+}
+
+
+declare module "lodash.cloneWith" {
+   const cloneWith: typeof _.cloneWith;
+   export = cloneWith;
+}
+
+
+declare module "lodash.deburr" {
+   const deburr: typeof _.deburr;
+   export = deburr;
+}
+
+/**
+* uncoment it if definition exists
+*/
+/*
+declare module "lodash.divide" {
+   const divide: typeof _.divide;
+   export = divide;
+}
+*/
+
+declare module "lodash.endsWith" {
+   const endsWith: typeof _.endsWith;
+   export = endsWith;
+}
+
+
+declare module "lodash.eq" {
+   const eq: typeof _.eq;
+   export = eq;
+}
+
+
+declare module "lodash.escape" {
+   const escape: typeof _.escape;
+   export = escape;
+}
+
+
+declare module "lodash.escapeRegExp" {
+   const escapeRegExp: typeof _.escapeRegExp;
+   export = escapeRegExp;
+}
+
+
+declare module "lodash.every" {
+   const every: typeof _.every;
+   export = every;
+}
+
+
+declare module "lodash.find" {
+   const find: typeof _.find;
+   export = find;
+}
+
+
+declare module "lodash.findIndex" {
+   const findIndex: typeof _.findIndex;
+   export = findIndex;
+}
+
+
+declare module "lodash.findKey" {
+   const findKey: typeof _.findKey;
+   export = findKey;
+}
+
+
+declare module "lodash.findLast" {
+   const findLast: typeof _.findLast;
+   export = findLast;
+}
+
+
+declare module "lodash.findLastIndex" {
+   const findLastIndex: typeof _.findLastIndex;
+   export = findLastIndex;
+}
+
+
+declare module "lodash.findLastKey" {
+   const findLastKey: typeof _.findLastKey;
+   export = findLastKey;
+}
+
+
+declare module "lodash.floor" {
+   const floor: typeof _.floor;
+   export = floor;
+}
+
+
+declare module "lodash.forEach" {
+   const forEach: typeof _.forEach;
+   export = forEach;
+}
+
+
+declare module "lodash.forEachRight" {
+   const forEachRight: typeof _.forEachRight;
+   export = forEachRight;
+}
+
+
+declare module "lodash.forIn" {
+   const forIn: typeof _.forIn;
+   export = forIn;
+}
+
+
+declare module "lodash.forInRight" {
+   const forInRight: typeof _.forInRight;
+   export = forInRight;
+}
+
+
+declare module "lodash.forOwn" {
+   const forOwn: typeof _.forOwn;
+   export = forOwn;
+}
+
+
+declare module "lodash.forOwnRight" {
+   const forOwnRight: typeof _.forOwnRight;
+   export = forOwnRight;
+}
+
+
+declare module "lodash.get" {
+   const get: typeof _.get;
+   export = get;
+}
+
+
+declare module "lodash.gt" {
+   const gt: typeof _.gt;
+   export = gt;
+}
+
+
+declare module "lodash.gte" {
+   const gte: typeof _.gte;
+   export = gte;
+}
+
+
+declare module "lodash.has" {
+   const has: typeof _.has;
+   export = has;
+}
+
+
+declare module "lodash.hasIn" {
+   const hasIn: typeof _.hasIn;
+   export = hasIn;
+}
+
+
+declare module "lodash.head" {
+   const head: typeof _.head;
+   export = head;
+}
+
+
+declare module "lodash.identity" {
+   const identity: typeof _.identity;
+   export = identity;
+}
+
+
+declare module "lodash.includes" {
+   const includes: typeof _.includes;
+   export = includes;
+}
+
+
+declare module "lodash.indexOf" {
+   const indexOf: typeof _.indexOf;
+   export = indexOf;
+}
+
+
+declare module "lodash.inRange" {
+   const inRange: typeof _.inRange;
+   export = inRange;
+}
+
+
+declare module "lodash.invoke" {
+   const invoke: typeof _.invoke;
+   export = invoke;
+}
+
+
+declare module "lodash.isArguments" {
+   const isArguments: typeof _.isArguments;
+   export = isArguments;
+}
+
+
+declare module "lodash.isArray" {
+   const isArray: typeof _.isArray;
+   export = isArray;
+}
+
+
+declare module "lodash.isArrayBuffer" {
+   const isArrayBuffer: typeof _.isArrayBuffer;
+   export = isArrayBuffer;
+}
+
+
+declare module "lodash.isArrayLike" {
+   const isArrayLike: typeof _.isArrayLike;
+   export = isArrayLike;
+}
+
+
+declare module "lodash.isArrayLikeObject" {
+   const isArrayLikeObject: typeof _.isArrayLikeObject;
+   export = isArrayLikeObject;
+}
+
+
+declare module "lodash.isBoolean" {
+   const isBoolean: typeof _.isBoolean;
+   export = isBoolean;
+}
+
+
+declare module "lodash.isBuffer" {
+   const isBuffer: typeof _.isBuffer;
+   export = isBuffer;
+}
+
+
+declare module "lodash.isDate" {
+   const isDate: typeof _.isDate;
+   export = isDate;
+}
+
+
+declare module "lodash.isElement" {
+   const isElement: typeof _.isElement;
+   export = isElement;
+}
+
+
+declare module "lodash.isEmpty" {
+   const isEmpty: typeof _.isEmpty;
+   export = isEmpty;
+}
+
+
+declare module "lodash.isEqual" {
+   const isEqual: typeof _.isEqual;
+   export = isEqual;
+}
+
+
+declare module "lodash.isEqualWith" {
+   const isEqualWith: typeof _.isEqualWith;
+   export = isEqualWith;
+}
+
+
+declare module "lodash.isError" {
+   const isError: typeof _.isError;
+   export = isError;
+}
+
+
+declare module "lodash.isFinite" {
+   const isFinite: typeof _.isFinite;
+   export = isFinite;
+}
+
+
+declare module "lodash.isFunction" {
+   const isFunction: typeof _.isFunction;
+   export = isFunction;
+}
+
+
+declare module "lodash.isInteger" {
+   const isInteger: typeof _.isInteger;
+   export = isInteger;
+}
+
+
+declare module "lodash.isLength" {
+   const isLength: typeof _.isLength;
+   export = isLength;
+}
+
+
+declare module "lodash.isMap" {
+   const isMap: typeof _.isMap;
+   export = isMap;
+}
+
+
+declare module "lodash.isMatch" {
+   const isMatch: typeof _.isMatch;
+   export = isMatch;
+}
+
+
+declare module "lodash.isMatchWith" {
+   const isMatchWith: typeof _.isMatchWith;
+   export = isMatchWith;
+}
+
+
+declare module "lodash.isNaN" {
+   const isNaN: typeof _.isNaN;
+   export = isNaN;
+}
+
+
+declare module "lodash.isNative" {
+   const isNative: typeof _.isNative;
+   export = isNative;
+}
+
+
+declare module "lodash.isNil" {
+   const isNil: typeof _.isNil;
+   export = isNil;
+}
+
+
+declare module "lodash.isNull" {
+   const isNull: typeof _.isNull;
+   export = isNull;
+}
+
+
+declare module "lodash.isNumber" {
+   const isNumber: typeof _.isNumber;
+   export = isNumber;
+}
+
+
+declare module "lodash.isObject" {
+   const isObject: typeof _.isObject;
+   export = isObject;
+}
+
+
+declare module "lodash.isObjectLike" {
+   const isObjectLike: typeof _.isObjectLike;
+   export = isObjectLike;
+}
+
+
+declare module "lodash.isPlainObject" {
+   const isPlainObject: typeof _.isPlainObject;
+   export = isPlainObject;
+}
+
+
+declare module "lodash.isRegExp" {
+   const isRegExp: typeof _.isRegExp;
+   export = isRegExp;
+}
+
+
+declare module "lodash.isSafeInteger" {
+   const isSafeInteger: typeof _.isSafeInteger;
+   export = isSafeInteger;
+}
+
+
+declare module "lodash.isSet" {
+   const isSet: typeof _.isSet;
+   export = isSet;
+}
+
+
+declare module "lodash.isString" {
+   const isString: typeof _.isString;
+   export = isString;
+}
+
+
+declare module "lodash.isSymbol" {
+   const isSymbol: typeof _.isSymbol;
+   export = isSymbol;
+}
+
+
+declare module "lodash.isTypedArray" {
+   const isTypedArray: typeof _.isTypedArray;
+   export = isTypedArray;
+}
+
+
+declare module "lodash.isUndefined" {
+   const isUndefined: typeof _.isUndefined;
+   export = isUndefined;
+}
+
+
+declare module "lodash.isWeakMap" {
+   const isWeakMap: typeof _.isWeakMap;
+   export = isWeakMap;
+}
+
+
+declare module "lodash.isWeakSet" {
+   const isWeakSet: typeof _.isWeakSet;
+   export = isWeakSet;
+}
+
+
+declare module "lodash.join" {
+   const join: typeof _.join;
+   export = join;
+}
+
+
+declare module "lodash.kebabCase" {
+   const kebabCase: typeof _.kebabCase;
+   export = kebabCase;
+}
+
+
+declare module "lodash.last" {
+   const last: typeof _.last;
+   export = last;
+}
+
+
+declare module "lodash.lastIndexOf" {
+   const lastIndexOf: typeof _.lastIndexOf;
+   export = lastIndexOf;
+}
+
+
+declare module "lodash.lowerCase" {
+   const lowerCase: typeof _.lowerCase;
+   export = lowerCase;
+}
+
+
+declare module "lodash.lowerFirst" {
+   const lowerFirst: typeof _.lowerFirst;
+   export = lowerFirst;
+}
+
+
+declare module "lodash.lt" {
+   const lt: typeof _.lt;
+   export = lt;
+}
+
+
+declare module "lodash.lte" {
+   const lte: typeof _.lte;
+   export = lte;
+}
+
+
+declare module "lodash.max" {
+   const max: typeof _.max;
+   export = max;
+}
+
+
+declare module "lodash.maxBy" {
+   const maxBy: typeof _.maxBy;
+   export = maxBy;
+}
+
+
+declare module "lodash.mean" {
+   const mean: typeof _.mean;
+   export = mean;
+}
+
+/**
+* uncoment it if definition exists
+*/
+/*
+declare module "lodash.meanBy" {
+   const meanBy: typeof _.meanBy;
+   export = meanBy;
+}
+*/
+
+declare module "lodash.min" {
+   const min: typeof _.min;
+   export = min;
+}
+
+
+declare module "lodash.minBy" {
+   const minBy: typeof _.minBy;
+   export = minBy;
+}
+
+/**
+* uncoment it if definition exists
+*/
+/*
+declare module "lodash.multiply" {
+   const multiply: typeof _.multiply;
+   export = multiply;
+}
+*/
+
+/**
+* uncoment it if definition exists
+*/
+/*
+declare module "lodash.nth" {
+   const nth: typeof _.nth;
+   export = nth;
+}
+*/
+
+declare module "lodash.noConflict" {
+   const noConflict: typeof _.noConflict;
+   export = noConflict;
+}
+
+
+declare module "lodash.noop" {
+   const noop: typeof _.noop;
+   export = noop;
+}
+
+
+declare module "lodash.now" {
+   const now: typeof _.now;
+   export = now;
+}
+
+
+declare module "lodash.pad" {
+   const pad: typeof _.pad;
+   export = pad;
+}
+
+
+declare module "lodash.padEnd" {
+   const padEnd: typeof _.padEnd;
+   export = padEnd;
+}
+
+
+declare module "lodash.padStart" {
+   const padStart: typeof _.padStart;
+   export = padStart;
+}
+
+
+declare module "lodash.parseInt" {
+   const parseInt: typeof _.parseInt;
+   export = parseInt;
+}
+
+
+declare module "lodash.random" {
+   const random: typeof _.random;
+   export = random;
+}
+
+
+declare module "lodash.reduce" {
+   const reduce: typeof _.reduce;
+   export = reduce;
+}
+
+
+declare module "lodash.reduceRight" {
+   const reduceRight: typeof _.reduceRight;
+   export = reduceRight;
+}
+
+
+declare module "lodash.repeat" {
+   const repeat: typeof _.repeat;
+   export = repeat;
+}
+
+
+declare module "lodash.replace" {
+   const replace: typeof _.replace;
+   export = replace;
+}
+
+
+declare module "lodash.result" {
+   const result: typeof _.result;
+   export = result;
+}
+
+
+declare module "lodash.round" {
+   const round: typeof _.round;
+   export = round;
+}
+
+
+declare module "lodash.runInContext" {
+   const runInContext: typeof _.runInContext;
+   export = runInContext;
+}
+
+
+declare module "lodash.sample" {
+   const sample: typeof _.sample;
+   export = sample;
+}
+
+
+declare module "lodash.size" {
+   const size: typeof _.size;
+   export = size;
+}
+
+
+declare module "lodash.snakeCase" {
+   const snakeCase: typeof _.snakeCase;
+   export = snakeCase;
+}
+
+
+declare module "lodash.some" {
+   const some: typeof _.some;
+   export = some;
+}
+
+
+declare module "lodash.sortedIndex" {
+   const sortedIndex: typeof _.sortedIndex;
+   export = sortedIndex;
+}
+
+
+declare module "lodash.sortedIndexBy" {
+   const sortedIndexBy: typeof _.sortedIndexBy;
+   export = sortedIndexBy;
+}
+
+
+declare module "lodash.sortedIndexOf" {
+   const sortedIndexOf: typeof _.sortedIndexOf;
+   export = sortedIndexOf;
+}
+
+
+declare module "lodash.sortedLastIndex" {
+   const sortedLastIndex: typeof _.sortedLastIndex;
+   export = sortedLastIndex;
+}
+
+
+declare module "lodash.sortedLastIndexBy" {
+   const sortedLastIndexBy: typeof _.sortedLastIndexBy;
+   export = sortedLastIndexBy;
+}
+
+
+declare module "lodash.sortedLastIndexOf" {
+   const sortedLastIndexOf: typeof _.sortedLastIndexOf;
+   export = sortedLastIndexOf;
+}
+
+
+declare module "lodash.startCase" {
+   const startCase: typeof _.startCase;
+   export = startCase;
+}
+
+
+declare module "lodash.startsWith" {
+   const startsWith: typeof _.startsWith;
+   export = startsWith;
+}
+
+
+declare module "lodash.subtract" {
+   const subtract: typeof _.subtract;
+   export = subtract;
+}
+
+
+declare module "lodash.sum" {
+   const sum: typeof _.sum;
+   export = sum;
+}
+
+
+declare module "lodash.sumBy" {
+   const sumBy: typeof _.sumBy;
+   export = sumBy;
+}
+
+
+declare module "lodash.template" {
+   const template: typeof _.template;
+   export = template;
+}
+
+
+declare module "lodash.times" {
+   const times: typeof _.times;
+   export = times;
+}
+
+
+declare module "lodash.toInteger" {
+   const toInteger: typeof _.toInteger;
+   export = toInteger;
+}
+
+
+declare module "lodash.toLength" {
+   const toLength: typeof _.toLength;
+   export = toLength;
+}
+
+
+declare module "lodash.toLower" {
+   const toLower: typeof _.toLower;
+   export = toLower;
+}
+
+
+declare module "lodash.toNumber" {
+   const toNumber: typeof _.toNumber;
+   export = toNumber;
+}
+
+
+declare module "lodash.toSafeInteger" {
+   const toSafeInteger: typeof _.toSafeInteger;
+   export = toSafeInteger;
+}
+
+
+declare module "lodash.toString" {
+   const toString: typeof _.toString;
+   export = toString;
+}
+
+
+declare module "lodash.toUpper" {
+   const toUpper: typeof _.toUpper;
+   export = toUpper;
+}
+
+
+declare module "lodash.trim" {
+   const trim: typeof _.trim;
+   export = trim;
+}
+
+
+declare module "lodash.trimEnd" {
+   const trimEnd: typeof _.trimEnd;
+   export = trimEnd;
+}
+
+
+declare module "lodash.trimStart" {
+   const trimStart: typeof _.trimStart;
+   export = trimStart;
+}
+
+
+declare module "lodash.truncate" {
+   const truncate: typeof _.truncate;
+   export = truncate;
+}
+
+
+declare module "lodash.unescape" {
+   const unescape: typeof _.unescape;
+   export = unescape;
+}
+
+
+declare module "lodash.uniqueId" {
+   const uniqueId: typeof _.uniqueId;
+   export = uniqueId;
+}
+
+
+declare module "lodash.upperCase" {
+   const upperCase: typeof _.upperCase;
+   export = upperCase;
+}
+
+
+declare module "lodash.upperFirst" {
+   const upperFirst: typeof _.upperFirst;
+   export = upperFirst;
+}
+
+
+declare module "lodash.each" {
+   const each: typeof _.each;
+   export = each;
+}
+
+
+declare module "lodash.eachRight" {
+   const eachRight: typeof _.eachRight;
+   export = eachRight;
+}
+
+
+declare module "lodash.first" {
+   const first: typeof _.first;
+   export = first;
+}
+
 // Backward compatibility with --target es5
 interface Set<T> {}
 interface Map<K, V> {}