cypress 4.2.0 → 4.5.0

package/types/lodash/common/array.d.ts

@@ -1,3713 +0,0 @@
-import _ = require("../index");
-declare module "../index" {
-    // chunk
-
-    interface LoDashStatic {
-        /**
-         * Creates an array of elements split into groups the length of size. If collection can’t be split evenly, the
-         * final chunk will be the remaining elements.
-         *
-         * @param array The array to process.
-         * @param size The length of each chunk.
-         * @return Returns the new array containing chunks.
-         */
-        chunk<T>(
-            array: List<T> | null | undefined,
-            size?: number
-        ): T[][];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.chunk
-         */
-        chunk<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            size?: number,
-        ): LoDashImplicitWrapper<T[][]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.chunk
-         */
-        chunk<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            size?: number,
-        ): LoDashExplicitWrapper<T[][]>;
-    }
-
-    // compact
-
-    interface LoDashStatic {
-        /**
-         * Creates an array with all falsey values removed. The values false, null, 0, "", undefined, and NaN are
-         * falsey.
-         *
-         * @param array The array to compact.
-         * @return Returns the new array of filtered values.
-         */
-        compact<T>(array: List<T | null | undefined | false | "" | 0> | null | undefined): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.compact
-         */
-        compact<T>(this: LoDashImplicitWrapper<List<T | null | undefined | false | "" | 0> | null | undefined>): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.compact
-         */
-        compact<T>(this: LoDashExplicitWrapper<List<T | null | undefined | false | "" | 0> | null | undefined>): LoDashExplicitWrapper<T[]>;
-    }
-
-    // concat
-
-    interface LoDashStatic {
-        /**
-         * Creates a new array concatenating `array` with any additional arrays
-         * and/or values.
-         *
-         * @category Array
-         * @param array The array to concatenate.
-         * @param [values] The values to concatenate.
-         * @returns 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]
-         */
-         concat<T>(array: Many<T>, ...values: Array<Many<T>>): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.compact
-         */
-        concat<T>(this: LoDashImplicitWrapper<Many<T>>, ...values: Array<Many<T>>): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.compact
-         */
-        concat<T>(this: LoDashExplicitWrapper<Many<T>>, ...values: Array<Many<T>>): LoDashExplicitWrapper<T[]>;
-    }
-
-    // difference
-
-    interface LoDashStatic {
-        /**
-         * Creates an array of unique array values not included in the other provided arrays using SameValueZero for
-         * equality comparisons.
-         *
-         * @param array The array to inspect.
-         * @param values The arrays of values to exclude.
-         * @return Returns the new array of filtered values.
-         */
-        difference<T>(
-            array: List<T> | null | undefined,
-            ...values: Array<List<T>>
-        ): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.difference
-         */
-        difference<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            ...values: Array<List<T>>
-        ): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.difference
-         */
-        difference<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            ...values: Array<List<T>>
-        ): LoDashExplicitWrapper<T[]>;
-    }
-
-    // differenceBy
-
-    interface LoDashStatic {
-        /**
-         * 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 uniqueness is computed. The iteratee is invoked with one
-         * argument: (value).
-         *
-         * @param array The array to inspect.
-         * @param values The values to exclude.
-         * @param iteratee The iteratee invoked per element.
-         * @returns Returns the new array of filtered values.
-         */
-        differenceBy<T1, T2>(
-            array: List<T1> | null | undefined,
-            values: List<T2>,
-            iteratee: ValueIteratee<T1 | T2>
-        ): T1[];
-
-        /**
-         * @see _.differenceBy
-         */
-        differenceBy<T1, T2, T3>(
-            array: List<T1> | null | undefined,
-            values1: List<T2>,
-            values2: List<T3>,
-            iteratee: ValueIteratee<T1 | T2 | T3>
-        ): T1[];
-
-        /**
-         * @see _.differenceBy
-         */
-        differenceBy<T1, T2, T3, T4>(
-            array: List<T1> | null | undefined,
-            values1: List<T2>,
-            values2: List<T3>,
-            values3: List<T4>,
-            iteratee: ValueIteratee<T1 | T2 | T3 | T4>
-        ): T1[];
-
-        /**
-         * @see _.differenceBy
-         */
-        differenceBy<T1, T2, T3, T4, T5>(
-            array: List<T1> | null | undefined,
-            values1: List<T2>,
-            values2: List<T3>,
-            values3: List<T4>,
-            values4: List<T5>,
-            iteratee: ValueIteratee<T1 | T2 | T3 | T4 | T5>
-        ): T1[];
-
-        /**
-         * @see _.differenceBy
-         */
-        differenceBy<T1, T2, T3, T4, T5, T6>(
-            array: List<T1> | null | undefined,
-            values1: List<T2>,
-            values2: List<T3>,
-            values3: List<T4>,
-            values4: List<T5>,
-            values5: List<T6>,
-            iteratee: ValueIteratee<T1 | T2 | T3 | T4 | T5 | T6>
-        ): T1[];
-
-        /**
-         * @see _.differenceBy
-         */
-        differenceBy<T1, T2, T3, T4, T5, T6, T7>(
-            array: List<T1> | null | undefined,
-            values1: List<T2>,
-            values2: List<T3>,
-            values3: List<T4>,
-            values4: List<T5>,
-            values5: List<T6>,
-            ...values: Array<List<T7> | ValueIteratee<T1 | T2 | T3 | T4 | T5 | T6 | T7>>
-        ): T1[];
-
-        /**
-         * @see _.differenceBy
-         */
-        differenceBy<T>(
-            array: List<T> | null | undefined,
-            ...values: Array<List<T>>
-        ): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.differenceBy
-         */
-        differenceBy<T1, T2>(
-            this: LoDashImplicitWrapper<List<T1> | null | undefined>,
-            values: List<T2>,
-            iteratee: ValueIteratee<T1 | T2>
-        ): LoDashImplicitWrapper<T1[]>;
-
-        /**
-         * @see _.differenceBy
-         */
-        differenceBy<T1, T2, T3>(
-            this: LoDashImplicitWrapper<List<T1> | null | undefined>,
-            values1: List<T2>,
-            values2: List<T3>,
-            iteratee: ValueIteratee<T1 | T2 | T3>
-        ): LoDashImplicitWrapper<T1[]>;
-
-        /**
-         * @see _.differenceBy
-         */
-        differenceBy<T1, T2, T3, T4>(
-            this: LoDashImplicitWrapper<List<T1> | null | undefined>,
-            values1: List<T2>,
-            values2: List<T3>,
-            values3: List<T4>,
-            iteratee: ValueIteratee<T1 | T2 | T3 | T4>
-        ): LoDashImplicitWrapper<T1[]>;
-
-        /**
-         * @see _.differenceBy
-         */
-        differenceBy<T1, T2, T3, T4, T5>(
-            this: LoDashImplicitWrapper<List<T1> | null | undefined>,
-            values1: List<T2>,
-            values2: List<T3>,
-            values3: List<T4>,
-            values4: List<T5>,
-            iteratee: ValueIteratee<T1 | T2 | T3 | T4 | T5>
-        ): LoDashImplicitWrapper<T1[]>;
-
-        /**
-         * @see _.differenceBy
-         */
-        differenceBy<T1, T2, T3, T4, T5, T6>(
-            this: LoDashImplicitWrapper<List<T1> | null | undefined>,
-            values1: List<T2>,
-            values2: List<T3>,
-            values3: List<T4>,
-            values4: List<T5>,
-            values5: List<T6>,
-            iteratee: ValueIteratee<T1 | T2 | T3 | T4 | T5 | T6>
-        ): LoDashImplicitWrapper<T1[]>;
-
-        /**
-         * @see _.differenceBy
-         */
-        differenceBy<T1, T2, T3, T4, T5, T6, T7>(
-            this: LoDashImplicitWrapper<List<T1> | null | undefined>,
-            values1: List<T2>,
-            values2: List<T3>,
-            values3: List<T4>,
-            values4: List<T5>,
-            values5: List<T6>,
-            ...values: Array<List<T7> | ValueIteratee<T1 | T2 | T3 | T4 | T5 | T6 | T7>>
-        ): LoDashImplicitWrapper<T1[]>;
-
-        /**
-         * @see _.differenceBy
-         */
-        differenceBy<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            ...values: Array<List<T>>
-        ): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.differenceBy
-         */
-        differenceBy<T1, T2>(
-            this: LoDashExplicitWrapper<List<T1> | null | undefined>,
-            values: List<T2>,
-            iteratee: ValueIteratee<T1 | T2>
-        ): LoDashExplicitWrapper<T1[]>;
-
-        /**
-         * @see _.differenceBy
-         */
-        differenceBy<T1, T2, T3>(
-            this: LoDashExplicitWrapper<List<T1> | null | undefined>,
-            values1: List<T2>,
-            values2: List<T3>,
-            iteratee: ValueIteratee<T1 | T2 | T3>
-        ): LoDashExplicitWrapper<T1[]>;
-
-        /**
-         * @see _.differenceBy
-         */
-        differenceBy<T1, T2, T3, T4>(
-            this: LoDashExplicitWrapper<List<T1> | null | undefined>,
-            values1: List<T2>,
-            values2: List<T3>,
-            values3: List<T4>,
-            iteratee: ValueIteratee<T1 | T2 | T3 | T4>
-        ): LoDashExplicitWrapper<T1[]>;
-
-        /**
-         * @see _.differenceBy
-         */
-        differenceBy<T1, T2, T3, T4, T5>(
-            this: LoDashExplicitWrapper<List<T1> | null | undefined>,
-            values1: List<T2>,
-            values2: List<T3>,
-            values3: List<T4>,
-            values4: List<T5>,
-            iteratee: ValueIteratee<T1 | T2 | T3 | T4 | T5>
-        ): LoDashExplicitWrapper<T1[]>;
-
-        /**
-         * @see _.differenceBy
-         */
-        differenceBy<T1, T2, T3, T4, T5, T6>(
-            this: LoDashExplicitWrapper<List<T1> | null | undefined>,
-            values1: List<T2>,
-            values2: List<T3>,
-            values3: List<T4>,
-            values4: List<T5>,
-            values5: List<T6>,
-            iteratee: ValueIteratee<T1 | T2 | T3 | T4 | T5 | T6>
-        ): LoDashExplicitWrapper<T1[]>;
-
-        /**
-         * @see _.differenceBy
-         */
-        differenceBy<T1, T2, T3, T4, T5, T6, T7>(
-            this: LoDashExplicitWrapper<List<T1> | null | undefined>,
-            values1: List<T2>,
-            values2: List<T3>,
-            values3: List<T4>,
-            values4: List<T5>,
-            values5: List<T6>,
-            ...values: Array<List<T7> | ValueIteratee<T1 | T2 | T3 | T4 | T5 | T6 | T7>>
-        ): LoDashExplicitWrapper<T1[]>;
-
-        /**
-         * @see _.differenceBy
-         */
-        differenceBy<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            ...values: Array<List<T>>
-        ): LoDashExplicitWrapper<T[]>;
-    }
-
-    // differenceWith
-
-    interface LoDashStatic {
-        /**
-         * Creates an array of unique `array` values not included in the other
-         * provided arrays using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)
-         * for equality comparisons.
-         *
-         * @category Array
-         * @param [values] The arrays to inspect.
-         * @param [comparator] The comparator invoked per element.
-         * @returns 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 }]
-         */
-        differenceWith<T1, T2>(
-            array: List<T1> | null | undefined,
-            values: List<T2>,
-            comparator: Comparator2<T1, T2>
-        ): T1[];
-
-        /**
-         * @see _.differenceWith
-         */
-        differenceWith<T1, T2, T3>(
-            array: List<T1> | null | undefined,
-            values1: List<T2>,
-            values2: List<T3>,
-            comparator: Comparator2<T1, T2 | T3>
-        ): T1[];
-
-        /**
-         * @see _.differenceWith
-         */
-        differenceWith<T1, T2, T3, T4>(
-            array: List<T1> | null | undefined,
-            values1: List<T2>,
-            values2: List<T3>,
-            ...values: Array<List<T4> | Comparator2<T1, T2 | T3 | T4>>
-        ): T1[];
-
-        /**
-         * @see _.differenceWith
-         */
-        differenceWith<T>(
-            array: List<T> | null | undefined,
-            ...values: Array<List<T>>
-        ): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.differenceWith
-         */
-        differenceWith<T1, T2>(
-            this: LoDashImplicitWrapper<List<T1> | null | undefined>,
-            values: List<T2>,
-            comparator: Comparator2<T1, T2>
-        ): LoDashImplicitWrapper<T1[]>;
-
-        /**
-         * @see _.differenceWith
-         */
-        differenceWith<T1, T2, T3>(
-            this: LoDashImplicitWrapper<List<T1> | null | undefined>,
-            values1: List<T2>,
-            values2: List<T3>,
-            comparator: Comparator2<T1, T2 | T3>
-        ): LoDashImplicitWrapper<T1[]>;
-
-        /**
-         * @see _.differenceWith
-         */
-        differenceWith<T1, T2, T3, T4>(
-            this: LoDashImplicitWrapper<List<T1> | null | undefined>,
-            values1: List<T2>,
-            values2: List<T3>,
-            ...values: Array<List<T4> | Comparator2<T1, T2 | T3 | T4>>
-        ): LoDashImplicitWrapper<T1[]>;
-
-        /**
-         * @see _.differenceWith
-         */
-        differenceWith<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            ...values: Array<List<T>>
-        ): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.differenceWith
-         */
-        differenceWith<T1, T2>(
-            this: LoDashExplicitWrapper<List<T1> | null | undefined>,
-            values: List<T2>,
-            comparator: Comparator2<T1, T2>
-        ): LoDashExplicitWrapper<T1[]>;
-
-        /**
-         * @see _.differenceWith
-         */
-        differenceWith<T1, T2, T3>(
-            this: LoDashExplicitWrapper<List<T1> | null | undefined>,
-            values1: List<T2>,
-            values2: List<T3>,
-            comparator: Comparator2<T1, T2 | T3>
-        ): LoDashExplicitWrapper<T1[]>;
-
-        /**
-         * @see _.differenceWith
-         */
-        differenceWith<T1, T2, T3, T4>(
-            this: LoDashExplicitWrapper<List<T1> | null | undefined>,
-            values1: List<T2>,
-            values2: List<T3>,
-            ...values: Array<List<T4> | Comparator2<T1, T2 | T3 | T4>>
-        ): LoDashExplicitWrapper<T1[]>;
-
-        /**
-         * @see _.differenceWith
-         */
-        differenceWith<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            ...values: Array<List<T>>
-        ): LoDashExplicitWrapper<T[]>;
-    }
-
-    // drop
-
-    interface LoDashStatic {
-        /**
-         * Creates a slice of array with n elements dropped from the beginning.
-         *
-         * @param array The array to query.
-         * @param n The number of elements to drop.
-         * @return Returns the slice of array.
-         */
-        drop<T>(array: List<T> | null | undefined, n?: number): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.drop
-         */
-        drop<T>(this: LoDashImplicitWrapper<List<T> | null | undefined>, n?: number): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.drop
-         */
-        drop<T>(this: LoDashExplicitWrapper<List<T> | null | undefined>, n?: number): LoDashExplicitWrapper<T[]>;
-    }
-
-    // dropRight
-
-    interface LoDashStatic {
-        /**
-         * Creates a slice of array with n elements dropped from the end.
-         *
-         * @param array The array to query.
-         * @param n The number of elements to drop.
-         * @return Returns the slice of array.
-         */
-        dropRight<T>(
-            array: List<T> | null | undefined,
-            n?: number
-        ): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.dropRight
-         */
-        dropRight<T>(this: LoDashImplicitWrapper<List<T> | null | undefined>, n?: number): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.dropRight
-         */
-        dropRight<T>(this: LoDashExplicitWrapper<List<T> | null | undefined>, n?: number): LoDashExplicitWrapper<T[]>;
-    }
-
-    // dropRightWhile
-
-    interface LoDashStatic {
-        /**
-         * 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).
-         *
-         * @param array The array to query.
-         * @param predicate The function invoked per iteration.
-         * @return Returns the slice of array.
-         */
-        dropRightWhile<T>(
-            array: List<T> | null | undefined,
-            predicate?: ListIteratee<T>
-        ): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.dropRightWhile
-         */
-        dropRightWhile<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            predicate?: ListIteratee<T>
-        ): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.dropRightWhile
-         */
-        dropRightWhile<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            predicate?: ListIteratee<T>
-        ): LoDashExplicitWrapper<T[]>;
-    }
-
-    // dropWhile
-
-    interface LoDashStatic {
-        /**
-         * 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).
-         *
-         * @param array The array to query.
-         * @param predicate The function invoked per iteration.
-         * @return Returns the slice of array.
-         */
-        dropWhile<T>(
-            array: List<T> | null | undefined,
-            predicate?: ListIteratee<T>
-        ): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.dropWhile
-         */
-        dropWhile<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            predicate?: ListIteratee<T>
-        ): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.dropWhile
-         */
-        dropWhile<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            predicate?: ListIteratee<T>
-        ): LoDashExplicitWrapper<T[]>;
-    }
-
-    // fill
-
-    interface LoDashStatic {
-        /**
-         * Fills elements of array with value from start up to, but not including, end.
-         *
-         * Note: This method mutates array.
-         *
-         * @param array The array to fill.
-         * @param value The value to fill array with.
-         * @param start The start position.
-         * @param end The end position.
-         * @return Returns array.
-         */
-        fill<T>(
-            array: any[] | null | undefined,
-            value: T
-        ): T[];
-
-        /**
-         * @see _.fill
-         */
-        fill<T>(
-            array: List<any> | null | undefined,
-            value: T
-        ): List<T>;
-
-        /**
-         * @see _.fill
-         */
-        fill<T, U>(
-            array: U[] | null | undefined,
-            value: T,
-            start?: number,
-            end?: number
-        ): Array<T | U>;
-
-        /**
-         * @see _.fill
-         */
-        fill<T, U>(
-            array: List<U> | null | undefined,
-            value: T,
-            start?: number,
-            end?: number
-        ): List<T | U>;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.fill
-         */
-        fill<T>(
-            this: LoDashImplicitWrapper<any[] | null | undefined>,
-            value: T
-        ): LoDashImplicitWrapper<T[]>;
-
-        /**
-         * @see _.fill
-         */
-        fill<T>(
-            this: LoDashImplicitWrapper<List<any> | null | undefined>,
-            value: T
-        ): LoDashImplicitWrapper<List<T>>;
-
-        /**
-         * @see _.fill
-         */
-        fill<T, U>(
-            this: LoDashImplicitWrapper<U[] | null | undefined>,
-            value: T,
-            start?: number,
-            end?: number
-        ): LoDashImplicitWrapper<Array<T | U>>;
-
-        /**
-         * @see _.fill
-         */
-        fill<T, U>(
-            this: LoDashImplicitWrapper<List<U> | null | undefined>,
-            value: T,
-            start?: number,
-            end?: number
-        ): LoDashImplicitWrapper<List<T | U>>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.fill
-         */
-        fill<T>(
-            this: LoDashExplicitWrapper<any[] | null | undefined>,
-            value: T
-        ): LoDashExplicitWrapper<T[]>;
-
-        /**
-         * @see _.fill
-         */
-        fill<T>(
-            this: LoDashExplicitWrapper<List<any> | null | undefined>,
-            value: T
-        ): LoDashExplicitWrapper<List<T>>;
-
-        /**
-         * @see _.fill
-         */
-        fill<T, U>(
-            this: LoDashExplicitWrapper<U[] | null | undefined>,
-            value: T,
-            start?: number,
-            end?: number
-        ): LoDashExplicitWrapper<Array<T | U>>;
-
-        /**
-         * @see _.fill
-         */
-        fill<T, U>(
-            this: LoDashExplicitWrapper<List<U> | null | undefined>,
-            value: T,
-            start?: number,
-            end?: number
-        ): LoDashExplicitWrapper<List<T | U>>;
-    }
-
-    // findIndex
-
-    interface LoDashStatic {
-        /**
-         * This method is like _.find except that it returns the index of the first element predicate returns truthy
-         * for instead of the element itself.
-         *
-         * @param array The array to search.
-         * @param predicate The function invoked per iteration.
-         * @param fromIndex The index to search from.
-         * @return Returns the index of the found element, else -1.
-         */
-        findIndex<T>(
-            array: List<T> | null | undefined,
-            predicate?: ListIterateeCustom<T, boolean>,
-            fromIndex?: number
-        ): number;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.findIndex
-         */
-        findIndex<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            predicate?: ListIterateeCustom<T, boolean>,
-            fromIndex?: number
-        ): number;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.findIndex
-         */
-        findIndex<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            predicate?: ListIterateeCustom<T, boolean>,
-            fromIndex?: number
-        ): LoDashExplicitWrapper<number>;
-    }
-
-    // findLastIndex
-
-    interface LoDashStatic {
-        /**
-         * This method is like _.findIndex except that it iterates over elements of collection from right to left.
-         *
-         * @param array The array to search.
-         * @param predicate The function invoked per iteration.
-         * @param fromIndex The index to search from.
-         * @return Returns the index of the found element, else -1.
-         */
-        findLastIndex<T>(
-            array: List<T> | null | undefined,
-            predicate?: ListIterateeCustom<T, boolean>,
-            fromIndex?: number
-        ): number;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.findLastIndex
-         */
-        findLastIndex<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            predicate?: ListIterateeCustom<T, boolean>,
-            fromIndex?: number
-        ): number;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.findLastIndex
-         */
-        findLastIndex<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            predicate?: ListIterateeCustom<T, boolean>,
-            fromIndex?: number
-        ): LoDashExplicitWrapper<number>;
-    }
-
-    // first
-
-    interface LoDashStatic {
-        first: typeof _.head; // tslint:disable-line:no-unnecessary-qualifier
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.head
-         */
-        first<T>(this: LoDashImplicitWrapper<List<T> | null | undefined>): T | undefined;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.head
-         */
-        first<T>(this: LoDashExplicitWrapper<List<T> | null | undefined>): LoDashExplicitWrapper<T | undefined>;
-    }
-
-    interface RecursiveArray<T> extends Array<T|RecursiveArray<T>> {}
-    interface ListOfRecursiveArraysOrValues<T> extends List<T|RecursiveArray<T>> {}
-
-    // flatten
-
-    interface LoDashStatic {
-        /**
-         * Flattens `array` a single level deep.
-         *
-         * @param array The array to flatten.
-         * @return Returns the new flattened array.
-         */
-        flatten<T>(array: List<Many<T>> | null | undefined): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.flatten
-         */
-        flatten<T>(this: LoDashImplicitWrapper<List<Many<T>> | null | undefined>): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.flatten
-         */
-        flatten<T>(this: LoDashExplicitWrapper<List<Many<T>> | null | undefined>): LoDashExplicitWrapper<T[]>;
-    }
-
-    // flattenDeep
-
-    interface LoDashStatic {
-        /**
-         * Recursively flattens a nested array.
-         *
-         * @param array The array to recursively flatten.
-         * @return Returns the new flattened array.
-         */
-        flattenDeep<T>(array: ListOfRecursiveArraysOrValues<T> | null | undefined): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.flattenDeep
-         */
-        flattenDeep<T>(this: LoDashImplicitWrapper<ListOfRecursiveArraysOrValues<T> | null | undefined>): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.flattenDeep
-         */
-        flattenDeep<T>(this: LoDashExplicitWrapper<ListOfRecursiveArraysOrValues<T> | null | undefined>): LoDashExplicitWrapper<T[]>;
-    }
-
-    // flattenDepth
-
-    interface LoDashStatic {
-        /**
-         * Recursively flatten array up to depth times.
-         *
-         * @param array The array to recursively flatten.
-         * @param number The maximum recursion depth.
-         * @return Returns the new flattened array.
-         */
-        flattenDepth<T>(array: ListOfRecursiveArraysOrValues<T> | null | undefined, depth?: number): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.flattenDeep
-         */
-        flattenDepth<T>(this: LoDashImplicitWrapper<ListOfRecursiveArraysOrValues<T> | null | undefined>, depth?: number): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.flattenDeep
-         */
-        flattenDepth<T>(this: LoDashExplicitWrapper<ListOfRecursiveArraysOrValues<T> | null | undefined>, depth?: number): LoDashExplicitWrapper<T[]>;
-    }
-
-    // fromPairs
-
-    interface LoDashStatic {
-        /**
-         * The inverse of `_.toPairs`; this method returns an object composed
-         * from key-value `pairs`.
-         *
-         * @category Array
-         * @param pairs The key-value pairs.
-         * @returns Returns the new object.
-         * @example
-         *
-         * _.fromPairs([['fred', 30], ['barney', 40]]);
-         * // => { 'fred': 30, 'barney': 40 }
-         */
-        fromPairs<T>(
-            pairs: List<[PropertyName, T]> | null | undefined
-        ): Dictionary<T>;
-
-        /**
-         @see _.fromPairs
-         */
-        fromPairs(
-            pairs: List<any[]> | null | undefined
-        ): Dictionary<any>;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.fromPairs
-         */
-        fromPairs<T>(
-          this: LoDashImplicitWrapper<List<[PropertyName, T]> | null | undefined>
-        ): LoDashImplicitWrapper<Dictionary<T>>;
-
-        /**
-         @see _.fromPairs
-         */
-        fromPairs(
-            this: LoDashImplicitWrapper<List<any[]> | null | undefined>
-        ): LoDashImplicitWrapper<Dictionary<any>>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.fromPairs
-         */
-        fromPairs<T>(
-          this: LoDashExplicitWrapper<List<[PropertyName, T]> | null | undefined>
-        ): LoDashExplicitWrapper<Dictionary<T>>;
-
-        /**
-         @see _.fromPairs
-         */
-        fromPairs(
-            this: LoDashExplicitWrapper<List<any[]> | null | undefined>
-        ): LoDashExplicitWrapper<Dictionary<any>>;
-    }
-
-    // head
-
-    interface LoDashStatic {
-        /**
-         * Gets the first element of array.
-         *
-         * @alias _.first
-         *
-         * @param array The array to query.
-         * @return Returns the first element of array.
-         */
-        head<T>(array: List<T> | null | undefined): T | undefined;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.head
-         */
-        head<T>(this: LoDashImplicitWrapper<List<T> | null | undefined>): T | undefined;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.head
-         */
-        head<T>(this: LoDashExplicitWrapper<List<T> | null | undefined>): LoDashExplicitWrapper<T | undefined>;
-    }
-
-    // indexOf
-
-    interface LoDashStatic {
-        /**
-         * Gets the index at which the first occurrence of `value` is found in `array`
-         * using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)
-         * for equality comparisons. If `fromIndex` is negative, it's used as the offset
-         * from the end of `array`.
-         *
-         * @category Array
-         * @param array The array to search.
-         * @param value The value to search for.
-         * @param [fromIndex=0] The index to search from.
-         * @returns Returns the index of the matched value, else `-1`.
-         * @example
-         *
-         * _.indexOf([1, 2, 1, 2], 2);
-         * // => 1
-         *
-         * // using `fromIndex`
-         * _.indexOf([1, 2, 1, 2], 2, 2);
-         * // => 3
-         */
-        indexOf<T>(
-            array: List<T> | null | undefined,
-            value: T,
-            fromIndex?: number
-        ): number;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.indexOf
-         */
-        indexOf<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            value: T,
-            fromIndex?: number
-        ): number;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.indexOf
-         */
-        indexOf<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            value: T,
-            fromIndex?: number
-        ): LoDashExplicitWrapper<number>;
-    }
-
-    // initial
-
-    interface LoDashStatic {
-        /**
-         * Gets all but the last element of array.
-         *
-         * @param array The array to query.
-         * @return Returns the slice of array.
-         */
-        initial<T>(array: List<T> | null | undefined): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.initial
-         */
-        initial<T>(this: LoDashImplicitWrapper<List<T> | null | undefined>): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.initial
-         */
-        initial<T>(this: LoDashExplicitWrapper<List<T> | null | undefined>): LoDashExplicitWrapper<T[]>;
-    }
-
-    // intersection
-
-    interface LoDashStatic {
-        /**
-         * Creates an array of unique values that are included in all of the provided arrays using SameValueZero for
-         * equality comparisons.
-         *
-         * @param arrays The arrays to inspect.
-         * @return Returns the new array of shared values.
-         */
-        intersection<T>(...arrays: Array<List<T>>): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.intersection
-         */
-        intersection<T>(
-            this: LoDashImplicitWrapper<List<T>>,
-            ...arrays: Array<List<T>>
-        ): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.intersection
-         */
-        intersection<T>(
-            this: LoDashExplicitWrapper<List<T>>,
-            ...arrays: Array<List<T>>
-        ): LoDashExplicitWrapper<T[]>;
-    }
-
-    // intersectionBy
-
-    interface LoDashStatic {
-        /**
-         * 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 uniqueness is computed. The iteratee is invoked with one argument: (value).
-         *
-         * @category Array
-         * @param [arrays] The arrays to inspect.
-         * @param [iteratee=_.identity] The iteratee invoked per element.
-         * @returns Returns the new array of shared values.
-         * @example
-         *
-         * _.intersectionBy([2.1, 1.2], [4.3, 2.4], Math.floor);
-         * // => [2.1]
-         *
-         * // using the `_.property` iteratee shorthand
-         * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
-         * // => [{ 'x': 1 }]
-         */
-        intersectionBy<T1, T2>(
-            array: List<T1> | null,
-            values: List<T2>,
-            iteratee: ValueIteratee<T1 | T2>
-        ): T1[];
-
-        /**
-         * @see _.intersectionBy
-         */
-        intersectionBy<T1, T2, T3>(
-            array: List<T1> | null,
-            values1: List<T2>,
-            values2: List<T3>,
-            iteratee: ValueIteratee<T1 | T2 | T3>
-        ): T1[];
-
-        /**
-         * @see _.intersectionBy
-         */
-        intersectionBy<T1, T2, T3, T4>(
-            array: List<T1> | null | undefined,
-            values1: List<T2>,
-            values2: List<T3>,
-            ...values: Array<List<T4> | ValueIteratee<T1 | T2 | T3 | T4>>
-        ): T1[];
-
-        /**
-         * @see _.intersectionBy
-         */
-        intersectionBy<T>(
-            array?: List<T> | null,
-            ...values: Array<List<T>>
-        ): T[];
-
-        /**
-         * @see _.intersectionBy
-         */
-        intersectionBy<T>(...values: Array<List<T> | ValueIteratee<T>>): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.intersectionBy
-         */
-        intersectionBy<T1, T2>(
-            this: LoDashImplicitWrapper<List<T1> | null | undefined>,
-            values: List<T2>,
-            iteratee: ValueIteratee<T1 | T2>
-        ): LoDashImplicitWrapper<T1[]>;
-
-        /**
-         * @see _.intersectionBy
-         */
-        intersectionBy<T1, T2, T3>(
-            this: LoDashImplicitWrapper<List<T1> | null | undefined>,
-            values1: List<T2>,
-            values2: List<T3>,
-            iteratee: ValueIteratee<T1 | T2 | T3>
-        ): LoDashImplicitWrapper<T1[]>;
-
-        /**
-         * @see _.intersectionBy
-         */
-        intersectionBy<T1, T2, T3, T4>(
-            this: LoDashImplicitWrapper<List<T1> | null | undefined>,
-            values1: List<T2>,
-            values2: List<T3>,
-            ...values: Array<List<T4> | ValueIteratee<T1 | T2 | T3 | T4>>
-        ): LoDashImplicitWrapper<T1[]>;
-
-        /**
-         * @see _.intersectionBy
-         */
-        intersectionBy<T1, T2>(
-            this: LoDashImplicitWrapper<List<T1> | null | undefined>,
-            ...values: Array<List<T2> | ValueIteratee<T1 | T2>>
-        ): LoDashImplicitWrapper<T1[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.intersectionBy
-         */
-        intersectionBy<T1, T2>(
-            this: LoDashExplicitWrapper<List<T1> | null | undefined>,
-            values: List<T2>,
-            iteratee: ValueIteratee<T1 | T2>
-        ): LoDashExplicitWrapper<T1[]>;
-
-        /**
-         * @see _.intersectionBy
-         */
-        intersectionBy<T1, T2, T3>(
-            this: LoDashExplicitWrapper<List<T1> | null | undefined>,
-            values1: List<T2>,
-            values2: List<T3>,
-            iteratee: ValueIteratee<T1 | T2 | T3>
-        ): LoDashExplicitWrapper<T1[]>;
-
-        /**
-         * @see _.intersectionBy
-         */
-        intersectionBy<T1, T2, T3, T4>(
-            this: LoDashExplicitWrapper<List<T1> | null | undefined>,
-            values1: List<T2>,
-            values2: List<T3>,
-            ...values: Array<List<T4> | ValueIteratee<T1 | T2 | T3 | T4>>
-        ): LoDashExplicitWrapper<T1[]>;
-
-        /**
-         * @see _.intersectionBy
-         */
-        intersectionBy<T1, T2>(
-            this: LoDashExplicitWrapper<List<T1> | null | undefined>,
-            ...values: Array<List<T2> | ValueIteratee<T1 | T2>>
-        ): LoDashExplicitWrapper<T1[]>;
-    }
-
-    // intersectionWith
-
-    interface LoDashStatic {
-        /**
-         * Creates an array of unique `array` values not included in the other
-         * provided arrays using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)
-         * for equality comparisons.
-         *
-         * @category Array
-         * @param [values] The arrays to inspect.
-         * @param [comparator] The comparator invoked per element.
-         * @returns 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 }];
-
-         * _.intersectionWith(objects, others, _.isEqual);
-         * // => [{ 'x': 1, 'y': 2 }]
-         */
-        intersectionWith<T1, T2>(
-            array: List<T1> | null | undefined,
-            values: List<T2>,
-            comparator: Comparator2<T1, T2>
-        ): T1[];
-
-        /**
-         * @see _.intersectionWith
-         */
-        intersectionWith<T1, T2, T3>(
-            array: List<T1> | null | undefined,
-            values1: List<T2>,
-            values2: List<T3>,
-            comparator: Comparator2<T1, T2 | T3>
-        ): T1[];
-
-        /**
-         * @see _.intersectionWith
-         */
-        intersectionWith<T1, T2, T3, T4>(
-            array: List<T1> | null | undefined,
-            values1: List<T2>,
-            values2: List<T3>,
-            ...values: Array<List<T4> | Comparator2<T1, T2 | T3 | T4>>
-        ): T1[];
-
-        /**
-         * @see _.intersectionWith
-         */
-        intersectionWith<T>(
-            array?: List<T> | null,
-            ...values: Array<List<T>>
-        ): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.intersectionWith
-         */
-        intersectionWith<T1, T2>(
-            this: LoDashImplicitWrapper<List<T1> | null | undefined>,
-            values: List<T2>,
-            comparator: Comparator2<T1, T2>
-        ): LoDashImplicitWrapper<T1[]>;
-
-        /**
-         * @see _.intersectionWith
-         */
-        intersectionWith<T1, T2, T3>(
-            this: LoDashImplicitWrapper<List<T1> | null | undefined>,
-            values1: List<T2>,
-            values2: List<T3>,
-            comparator: Comparator2<T1, T2 | T3>
-        ): LoDashImplicitWrapper<T1[]>;
-
-        /**
-         * @see _.intersectionWith
-         */
-        intersectionWith<T1, T2, T3, T4>(
-            this: LoDashImplicitWrapper<List<T1> | null | undefined>,
-            values1: List<T2>,
-            values2: List<T3>,
-            ...values: Array<List<T4> | Comparator2<T1, T2 | T3 | T4>>
-        ): LoDashImplicitWrapper<T1[]>;
-
-        /**
-         * @see _.intersectionWith
-         */
-        intersectionWith<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            ...values: Array<List<T>>
-        ): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.intersectionWith
-         */
-        intersectionWith<T1, T2>(
-            this: LoDashExplicitWrapper<List<T1> | null | undefined>,
-            values: List<T2>,
-            comparator: Comparator2<T1, T2>
-        ): LoDashExplicitWrapper<T1[]>;
-
-        /**
-         * @see _.intersectionWith
-         */
-        intersectionWith<T1, T2, T3>(
-            this: LoDashExplicitWrapper<List<T1> | null | undefined>,
-            values1: List<T2>,
-            values2: List<T3>,
-            comparator: Comparator2<T1, T2 | T3>
-        ): LoDashExplicitWrapper<T1[]>;
-
-        /**
-         * @see _.intersectionWith
-         */
-        intersectionWith<T1, T2, T3, T4>(
-            this: LoDashExplicitWrapper<List<T1> | null | undefined>,
-            values1: List<T2>,
-            values2: List<T3>,
-            ...values: Array<List<T4> | Comparator2<T1, T2 | T3 | T4>>
-        ): LoDashExplicitWrapper<T1[]>;
-
-        /**
-         * @see _.intersectionWith
-         */
-        intersectionWith<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            ...values: Array<List<T>>
-        ): LoDashExplicitWrapper<T[]>;
-    }
-
-    // join
-
-    interface LoDashStatic {
-        /**
-         * Converts all elements in `array` into a string separated by `separator`.
-         *
-         * @param array The array to convert.
-         * @param separator The element separator.
-         * @returns Returns the joined string.
-         */
-        join(
-            array: List<any> | null | undefined,
-            separator?: string
-        ): string;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.join
-         */
-        join(separator?: string): string;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.join
-         */
-        join(separator?: string): LoDashExplicitWrapper<string>;
-    }
-
-    // last
-
-    interface LoDashStatic {
-        /**
-         * Gets the last element of array.
-         *
-         * @param array The array to query.
-         * @return Returns the last element of array.
-         */
-        last<T>(array: List<T> | null | undefined): T | undefined;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.last
-         */
-        last<T>(this: LoDashImplicitWrapper<List<T> | null | undefined>): T | undefined;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.last
-         */
-        last<T>(this: LoDashExplicitWrapper<List<T> | null | undefined>): LoDashExplicitWrapper<T | undefined>;
-    }
-
-    // lastIndexOf
-
-    interface LoDashStatic {
-        /**
-         * This method is like _.indexOf except that it iterates over elements of array from right to left.
-         *
-         * @param array The array to search.
-         * @param value The value to search for.
-         * @param fromIndex The index to search from or true to perform a binary search on a sorted array.
-         * @return Returns the index of the matched value, else -1.
-         */
-        lastIndexOf<T>(
-            array: List<T> | null | undefined,
-            value: T,
-            fromIndex?: true|number
-        ): number;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.indexOf
-         */
-        lastIndexOf<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            value: T,
-            fromIndex?: true|number
-        ): number;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.indexOf
-         */
-        lastIndexOf<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            value: T,
-            fromIndex?: true|number
-        ): LoDashExplicitWrapper<number>;
-    }
-
-    // nth
-
-    interface LoDashStatic {
-        /**
-         * Gets the element at index `n` of `array`. If `n` is negative, the nth element from the end is returned.
-         *
-         * @param array array The array to query.
-         * @param value The index of the element to return.
-         * @return Returns the nth element of `array`.
-         */
-        nth<T>(
-            array: List<T> | null | undefined,
-            n?: number
-        ): T | undefined;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.nth
-         */
-        nth<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            n?: number
-        ): T | undefined;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.nth
-         */
-        nth<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            n?: number
-        ): LoDashExplicitWrapper<T | undefined>;
-    }
-
-    // pull
-
-    interface LoDashStatic {
-        /**
-         * Removes all provided values from array using SameValueZero for equality comparisons.
-         *
-         * Note: Unlike _.without, this method mutates array.
-         *
-         * @param array The array to modify.
-         * @param values The values to remove.
-         * @return Returns array.
-         */
-        pull<T>(
-            array: T[],
-            ...values: T[]
-        ): T[];
-
-        /**
-         * @see _.pull
-         */
-        pull<T>(
-            array: List<T>,
-            ...values: T[]
-        ): List<T>;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.pull
-         */
-        pull<T>(
-            this: LoDashImplicitWrapper<List<T>>,
-            ...values: T[]
-        ): this;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.pull
-         */
-        pull<T>(
-            this: LoDashExplicitWrapper<List<T>>,
-            ...values: T[]
-        ): this;
-    }
-
-    // pullAll
-
-    interface LoDashStatic {
-        /**
-         * This method is like `_.pull` except that it accepts an array of values to remove.
-         *
-         * **Note:** Unlike `_.difference`, this method mutates `array`.
-         *
-         * @category Array
-         * @param array The array to modify.
-         * @param values The values to remove.
-         * @returns Returns `array`.
-         * @example
-         *
-         * var array = [1, 2, 3, 1, 2, 3];
-         *
-         * _.pull(array, [2, 3]);
-         * console.log(array);
-         * // => [1, 1]
-         */
-        pullAll<T>(
-            array: T[],
-            values?: List<T>,
-        ): T[];
-
-        /**
-         * @see _.pullAll
-         */
-        pullAll<T>(
-            array: List<T>,
-            values?: List<T>,
-        ): List<T>;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.pullAll
-         */
-        pullAll<T>(
-            this: LoDashImplicitWrapper<List<T>>,
-            values?: List<T>
-        ): this;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.pullAll
-         */
-        pullAll<T>(
-            this: LoDashExplicitWrapper<List<T>>,
-            values?: List<T>
-        ): this;
-    }
-
-    // pullAllBy
-
-    interface LoDashStatic {
-        /**
-         * This method is like `_.pullAll` except that it accepts `iteratee` which is
-         * invoked for each element of `array` and `values` to to generate the criterion
-         * by which uniqueness is computed. The iteratee is invoked with one argument: (value).
-         *
-         * **Note:** Unlike `_.differenceBy`, this method mutates `array`.
-         *
-         * @category Array
-         * @param array The array to modify.
-         * @param values The values to remove.
-         * @param [iteratee=_.identity] The iteratee invoked per element.
-         * @returns 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 }]
-         */
-        pullAllBy<T>(
-            array: T[],
-            values?: List<T>,
-            iteratee?: ValueIteratee<T>
-        ): T[];
-
-        /**
-         * @see _.pullAllBy
-         */
-        pullAllBy<T>(
-            array: List<T>,
-            values?: List<T>,
-            iteratee?: ValueIteratee<T>
-        ): List<T>;
-
-        /**
-         * @see _.pullAllBy
-         */
-        pullAllBy<T1, T2>(
-            array: T1[],
-            values: List<T2>,
-            iteratee: ValueIteratee<T1 | T2>
-        ): T1[];
-
-        /**
-         * @see _.pullAllBy
-         */
-        pullAllBy<T1, T2>(
-            array: List<T1>,
-            values: List<T2>,
-            iteratee: ValueIteratee<T1 | T2>
-        ): List<T1>;
-    }
-
-    interface LoDashWrapper<TValue> {
-        /**
-         * @see _.pullAllBy
-         */
-        pullAllBy<T>(
-            this: LoDashWrapper<List<T>>,
-            values?: List<T>,
-            iteratee?: ValueIteratee<T>
-        ): this;
-
-        /**
-         * @see _.pullAllBy
-         */
-        pullAllBy<T1, T2>(
-            this: LoDashWrapper<List<T1>>,
-            values: List<T2>,
-            iteratee: ValueIteratee<T1 | T2>
-        ): this;
-    }
-
-    // pullAllWith
-
-    interface LoDashStatic {
-        /**
-         * 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`.
-         *
-         * @category Array
-         * @param array The array to modify.
-         * @param values The values to remove.
-         * @param [iteratee=_.identity] The iteratee invoked per element.
-         * @returns 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 }]
-         */
-        pullAllWith<T>(
-            array: T[],
-            values?: List<T>,
-            comparator?: Comparator<T>
-        ): T[];
-
-        /**
-         * @see _.pullAllWith
-         */
-        pullAllWith<T>(
-            array: List<T>,
-            values?: List<T>,
-            comparator?: Comparator<T>
-        ): List<T>;
-
-        /**
-         * @see _.pullAllWith
-         */
-        pullAllWith<T1, T2>(
-            array: T1[],
-            values: List<T2>,
-            comparator: Comparator2<T1, T2>
-        ): T1[];
-
-        /**
-         * @see _.pullAllWith
-         */
-        pullAllWith<T1, T2>(
-            array: List<T1>,
-            values: List<T2>,
-            comparator: Comparator2<T1, T2>
-        ): List<T1>;
-    }
-
-    interface LoDashWrapper<TValue> {
-        /**
-         * @see _.pullAllWith
-         */
-        pullAllWith<T>(
-            this: LoDashWrapper<List<T>>,
-            values?: List<T>,
-            comparator?: Comparator<T>
-        ): this;
-
-        /**
-         * @see _.pullAllWith
-         */
-        pullAllWith<T1, T2>(
-            this: LoDashWrapper<List<T1>>,
-            values: List<T2>,
-            comparator: Comparator2<T1, T2>
-        ): this;
-    }
-
-    // pullAt
-
-    interface LoDashStatic {
-        /**
-         * Removes elements from array corresponding to the given indexes and returns an array of the removed elements.
-         * Indexes may be specified as an array of indexes or as individual arguments.
-         *
-         * Note: Unlike _.at, this method mutates array.
-         *
-         * @param array The array to modify.
-         * @param indexes The indexes of elements to remove, specified as individual indexes or arrays of indexes.
-         * @return Returns the new array of removed elements.
-         */
-        pullAt<T>(
-            array: T[],
-            ...indexes: Array<Many<number>>
-        ): T[];
-
-        /**
-         * @see _.pullAt
-         */
-        pullAt<T>(
-            array: List<T>,
-            ...indexes: Array<Many<number>>
-        ): List<T>;
-    }
-
-    interface LoDashWrapper<TValue> {
-        /**
-         * @see _.pullAt
-         */
-        pullAt(...indexes: Array<Many<number>>): this;
-    }
-
-    // remove
-
-    interface LoDashStatic {
-        /**
-         * 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.
-         *
-         * @param array The array to modify.
-         * @param predicate The function invoked per iteration.
-         * @return Returns the new array of removed elements.
-         */
-        remove<T>(
-            array: List<T>,
-            predicate?: ListIteratee<T>
-        ): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.remove
-         */
-        remove<T>(
-            this: LoDashImplicitWrapper<List<T>>,
-            predicate?: ListIteratee<T>
-        ): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.remove
-         */
-        remove<T>(
-            this: LoDashExplicitWrapper<List<T>>,
-            predicate?: ListIteratee<T>
-        ): LoDashExplicitWrapper<T[]>;
-    }
-
-    // reverse
-
-    interface LoDashStatic {
-        /**
-         * 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).
-         *
-         * @category Array
-         * @returns Returns `array`.
-         * @example
-         *
-         * var array = [1, 2, 3];
-         *
-         * _.reverse(array);
-         * // => [3, 2, 1]
-         *
-         * console.log(array);
-         * // => [3, 2, 1]
-         */
-        reverse<TList extends List<any>>(
-            array: TList,
-        ): TList;
-    }
-
-    // slice
-
-    interface LoDashStatic {
-        /**
-         * Creates a slice of array from start up to, but not including, end.
-         *
-         * @param array The array to slice.
-         * @param start The start position.
-         * @param end The end position.
-         * @return Returns the slice of array.
-         */
-        slice<T>(
-            array: List<T> | null | undefined,
-            start?: number,
-            end?: number
-        ): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.slice
-         */
-        slice<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            start?: number,
-            end?: number
-        ): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.slice
-         */
-        slice<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            start?: number,
-            end?: number
-        ): LoDashExplicitWrapper<T[]>;
-    }
-
-    // sortedIndex
-
-    interface LoDashStatic {
-        /**
-         * Uses a binary search to determine the lowest index at which `value` should
-         * be inserted into `array` in order to maintain its sort order.
-         *
-         * @category Array
-         * @param array The sorted array to inspect.
-         * @param value The value to evaluate.
-         * @returns Returns the index at which `value` should be inserted into `array`.
-         * @example
-         *
-         * _.sortedIndex([30, 50], 40);
-         * // => 1
-         *
-         * _.sortedIndex([4, 5], 4);
-         * // => 0
-         */
-        sortedIndex<T>(
-            array: List<T> | null | undefined,
-            value: T
-        ): number;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.sortedIndex
-         */
-        sortedIndex<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            value: T
-        ): number;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.sortedIndex
-         */
-        sortedIndex<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            value: T
-        ): LoDashExplicitWrapper<number>;
-    }
-
-    // sortedIndexBy
-
-    interface LoDashStatic {
-        /**
-         * Uses a binary search to determine the lowest index at which `value` should
-         * be inserted into `array` in order to maintain its sort order.
-         *
-         * @category Array
-         * @param array The sorted array to inspect.
-         * @param value The value to evaluate.
-         * @returns Returns the index at which `value` should be inserted into `array`.
-         * @example
-         *
-         * _.sortedIndex([30, 50], 40);
-         * // => 1
-         *
-         * _.sortedIndex([4, 5], 4);
-         * // => 0
-         */
-        sortedIndex<T>(
-            array: List<T> | null | undefined,
-            value: T
-        ): number;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.sortedIndex
-         */
-        sortedIndex<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            value: T
-        ): number;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.sortedIndex
-         */
-        sortedIndex<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            value: T
-        ): LoDashExplicitWrapper<number>;
-    }
-
-    // _.sortedIndexBy
-    interface LoDashStatic {
-        /**
-         * 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).
-         *
-         * @category Array
-         * @param array The sorted array to inspect.
-         * @param value The value to evaluate.
-         * @param [iteratee=_.identity] The iteratee invoked per element.
-         * @returns Returns the index at which `value` should be inserted into `array`.
-         * @example
-         *
-         * var dict = { 'thirty': 30, 'forty': 40, 'fifty': 50 };
-         *
-         * _.sortedIndexBy(['thirty', 'fifty'], 'forty', _.propertyOf(dict));
-         * // => 1
-         *
-         * // using the `_.property` iteratee shorthand
-         * _.sortedIndexBy([{ 'x': 4 }, { 'x': 5 }], { 'x': 4 }, 'x');
-         * // => 0
-         */
-        sortedIndexBy<T>(
-            array: List<T> | null | undefined,
-            value: T,
-            iteratee?: ValueIteratee<T>
-        ): number;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.sortedIndexBy
-         */
-        sortedIndexBy<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            value: T,
-            iteratee?: ValueIteratee<T>
-        ): number;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.sortedIndexBy
-         */
-        sortedIndexBy<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            value: T,
-            iteratee?: ValueIteratee<T>
-        ): LoDashExplicitWrapper<number>;
-    }
-
-    // sortedIndexOf
-
-    interface LoDashStatic {
-        /**
-         * This method is like `_.indexOf` except that it performs a binary
-         * search on a sorted `array`.
-         *
-         * @category Array
-         * @param array The array to search.
-         * @param value The value to search for.
-         * @returns Returns the index of the matched value, else `-1`.
-         * @example
-         *
-         * _.sortedIndexOf([1, 1, 2, 2], 2);
-         * // => 2
-         */
-        sortedIndexOf<T>(
-            array: List<T> | null | undefined,
-            value: T
-        ): number;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.sortedIndexOf
-         */
-        sortedIndexOf<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            value: T
-        ): number;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.sortedIndexOf
-         */
-        sortedIndexOf<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            value: T
-        ): LoDashExplicitWrapper<number>;
-    }
-
-    // sortedLastIndex
-
-    interface LoDashStatic {
-        /**
-         * 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.
-         *
-         * @category Array
-         * @param array The sorted array to inspect.
-         * @param value The value to evaluate.
-         * @returns Returns the index at which `value` should be inserted into `array`.
-         * @example
-         *
-         * _.sortedLastIndex([4, 5], 4);
-         * // => 1
-         */
-        sortedLastIndex<T>(
-            array: List<T> | null | undefined,
-            value: T
-        ): number;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.sortedLastIndex
-         */
-        sortedLastIndex<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            value: T
-        ): number;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.sortedLastIndex
-         */
-        sortedLastIndex<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            value: T
-        ): LoDashExplicitWrapper<number>;
-    }
-
-    // sortedLastIndexBy
-
-    interface LoDashStatic {
-        /**
-         * 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).
-         *
-         * @category Array
-         * @param array The sorted array to inspect.
-         * @param value The value to evaluate.
-         * @param [iteratee=_.identity] The iteratee invoked per element.
-         * @returns Returns the index at which `value` should be inserted into `array`.
-         * @example
-         *
-         * // using the `_.property` iteratee shorthand
-         * _.sortedLastIndexBy([{ 'x': 4 }, { 'x': 5 }], { 'x': 4 }, 'x');
-         * // => 1
-         */
-        sortedLastIndexBy<T>(
-            array: List<T> | null | undefined,
-            value: T,
-            iteratee: ValueIteratee<T>
-        ): number;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.sortedLastIndexBy
-         */
-        sortedLastIndexBy<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            value: T,
-            iteratee: ValueIteratee<T>
-        ): number;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.sortedLastIndexBy
-         */
-        sortedLastIndexBy<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            value: T,
-            iteratee: ValueIteratee<T>
-        ): LoDashExplicitWrapper<number>;
-    }
-
-    // sortedLastIndexOf
-
-    interface LoDashStatic {
-        /**
-         * This method is like `_.lastIndexOf` except that it performs a binary
-         * search on a sorted `array`.
-         *
-         * @category Array
-         * @param array The array to search.
-         * @param value The value to search for.
-         * @returns Returns the index of the matched value, else `-1`.
-         * @example
-         *
-         * _.sortedLastIndexOf([1, 1, 2, 2], 2);
-         * // => 3
-         */
-        sortedLastIndexOf<T>(
-            array: List<T> | null | undefined,
-            value: T
-        ): number;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.sortedLastIndexOf
-         */
-        sortedLastIndexOf<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            value: T
-        ): number;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.sortedLastIndexOf
-         */
-        sortedLastIndexOf<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            value: T
-        ): LoDashExplicitWrapper<number>;
-    }
-
-    // sortedUniq
-
-    interface LoDashStatic {
-        /**
-         * This method is like `_.uniq` except that it's designed and optimized
-         * for sorted arrays.
-         *
-         * @category Array
-         * @param array The array to inspect.
-         * @returns Returns the new duplicate free array.
-         * @example
-         *
-         * _.sortedUniq([1, 1, 2]);
-         * // => [1, 2]
-         */
-        sortedUniq<T>(
-            array: List<T> | null | undefined
-        ): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.sortedUniq
-         */
-        sortedUniq<T>(this: LoDashImplicitWrapper<List<T> | null | undefined>): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.sortedUniq
-         */
-        sortedUniq<T>(this: LoDashExplicitWrapper<List<T> | null | undefined>): LoDashExplicitWrapper<T[]>;
-    }
-
-    // sortedUniqBy
-
-    interface LoDashStatic {
-        /**
-         * This method is like `_.uniqBy` except that it's designed and optimized
-         * for sorted arrays.
-         *
-         * @category Array
-         * @param array The array to inspect.
-         * @param [iteratee] The iteratee invoked per element.
-         * @returns Returns the new duplicate free array.
-         * @example
-         *
-         * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);
-         * // => [1.1, 2.2]
-         */
-        sortedUniqBy<T>(
-            array: List<T> | null | undefined,
-            iteratee: ValueIteratee<T>
-        ): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.sortedUniqBy
-         */
-        sortedUniqBy<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            iteratee: ValueIteratee<T>
-        ): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.sortedUniqBy
-         */
-        sortedUniqBy<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            iteratee: ValueIteratee<T>
-        ): LoDashExplicitWrapper<T[]>;
-    }
-
-    // tail
-
-    interface LoDashStatic {
-        /**
-         * Gets all but the first element of array.
-         *
-         * @param array The array to query.
-         * @return Returns the slice of array.
-         */
-        tail<T>(array: List<T> | null | undefined): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.tail
-         */
-        tail<T>(this: LoDashImplicitWrapper<List<T> | null | undefined>): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.tail
-         */
-        tail<T>(this: LoDashExplicitWrapper<List<T> | null | undefined>): LoDashExplicitWrapper<T[]>;
-    }
-
-    // take
-
-    interface LoDashStatic {
-        /**
-         * Creates a slice of array with n elements taken from the beginning.
-         *
-         * @param array The array to query.
-         * @param n The number of elements to take.
-         * @return Returns the slice of array.
-         */
-        take<T>(
-            array: List<T> | null | undefined,
-            n?: number
-        ): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.take
-         */
-        take<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            n?: number
-        ): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.take
-         */
-        take<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            n?: number
-        ): LoDashExplicitWrapper<T[]>;
-    }
-
-    // takeRight
-
-    interface LoDashStatic {
-        /**
-         * Creates a slice of array with n elements taken from the end.
-         *
-         * @param array The array to query.
-         * @param n The number of elements to take.
-         * @return Returns the slice of array.
-         */
-        takeRight<T>(
-            array: List<T> | null | undefined,
-            n?: number
-        ): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.takeRight
-         */
-        takeRight<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            n?: number
-        ): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.takeRight
-         */
-        takeRight<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            n?: number
-        ): LoDashExplicitWrapper<T[]>;
-    }
-
-    // takeRightWhile
-
-    interface LoDashStatic {
-        /**
-         * 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).
-         *
-         * @param array The array to query.
-         * @param predicate The function invoked per iteration.
-         * @return Returns the slice of array.
-         */
-        takeRightWhile<T>(
-            array: List<T> | null | undefined,
-            predicate?: ListIteratee<T>
-        ): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.takeRightWhile
-         */
-        takeRightWhile<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            predicate?: ListIteratee<T>
-        ): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.takeRightWhile
-         */
-        takeRightWhile<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            predicate?: ListIteratee<T>
-        ): LoDashExplicitWrapper<T[]>;
-    }
-
-    // takeWhile
-
-    interface LoDashStatic {
-        /**
-         * 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).
-         *
-         * @param array The array to query.
-         * @param predicate The function invoked per iteration.
-         * @return Returns the slice of array.
-         */
-        takeWhile<T>(
-            array: List<T> | null | undefined,
-            predicate?: ListIteratee<T>
-        ): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.takeWhile
-         */
-        takeWhile<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            predicate?: ListIteratee<T>
-        ): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.takeWhile
-         */
-        takeWhile<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            predicate?: ListIteratee<T>
-        ): LoDashExplicitWrapper<T[]>;
-    }
-
-    // union
-
-    interface LoDashStatic {
-        /**
-         * Creates an array of unique values, in order, from all of the provided arrays using SameValueZero for
-         * equality comparisons.
-         *
-         * @param arrays The arrays to inspect.
-         * @return Returns the new array of combined values.
-         */
-        union<T>(...arrays: Array<List<T> | null | undefined>): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.union
-         */
-        union<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            ...arrays: Array<List<T> | null | undefined>
-        ): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.union
-         */
-        union<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            ...arrays: Array<List<T> | null | undefined>
-        ): LoDashExplicitWrapper<T[]>;
-    }
-
-    // unionBy
-
-    interface LoDashStatic {
-        /**
-         * 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. The iteratee is invoked with one argument: (value).
-         *
-         * @param arrays The arrays to inspect.
-         * @param iteratee The iteratee invoked per element.
-         * @return Returns the new array of combined values.
-         */
-        unionBy<T>(
-            arrays: List<T> | null | undefined,
-            iteratee?: ValueIteratee<T>
-        ): T[];
-
-        /**
-         * @see _.unionBy
-         */
-        unionBy<T>(
-            arrays1: List<T> | null | undefined,
-            arrays2: List<T> | null | undefined,
-            iteratee?: ValueIteratee<T>
-        ): T[];
-
-        /**
-         * @see _.unionBy
-         */
-        unionBy<T>(
-            arrays1: List<T> | null | undefined,
-            arrays2: List<T> | null | undefined,
-            arrays3: List<T> | null | undefined,
-            iteratee?: ValueIteratee<T>
-        ): T[];
-
-        /**
-         * @see _.unionBy
-         */
-        unionBy<T>(
-            arrays1: List<T> | null | undefined,
-            arrays2: List<T> | null | undefined,
-            arrays3: List<T> | null | undefined,
-            arrays4: List<T> | null | undefined,
-            iteratee?: ValueIteratee<T>
-        ): T[];
-
-        /**
-         * @see _.unionBy
-         */
-        unionBy<T>(
-            arrays1: List<T> | null | undefined,
-            arrays2: List<T> | null | undefined,
-            arrays3: List<T> | null | undefined,
-            arrays4: List<T> | null | undefined,
-            arrays5: List<T> | null | undefined,
-            ...iteratee: Array<ValueIteratee<T> | List<T> | null | undefined>
-        ): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.unionBy
-         */
-        unionBy<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            iteratee?: ValueIteratee<T>
-        ): LoDashImplicitWrapper<T[]>;
-
-        /**
-         * @see _.unionBy
-         */
-        unionBy<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            arrays2: List<T> | null | undefined,
-            iteratee?: ValueIteratee<T>
-        ): LoDashImplicitWrapper<T[]>;
-
-        /**
-         * @see _.unionBy
-         */
-        unionBy<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            arrays2: List<T> | null | undefined,
-            arrays3: List<T> | null | undefined,
-            iteratee?: ValueIteratee<T>
-        ): LoDashImplicitWrapper<T[]>;
-
-        /**
-         * @see _.unionBy
-         */
-        unionBy<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            arrays2: List<T> | null | undefined,
-            arrays3: List<T> | null | undefined,
-            arrays4: List<T> | null | undefined,
-            iteratee?: ValueIteratee<T>
-        ): LoDashImplicitWrapper<T[]>;
-
-        /**
-         * @see _.unionBy
-         */
-        unionBy<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            arrays2: List<T> | null | undefined,
-            arrays3: List<T> | null | undefined,
-            arrays4: List<T> | null | undefined,
-            arrays5: List<T> | null | undefined,
-            ...iteratee: Array<ValueIteratee<T> | List<T> | null | undefined>
-        ): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.unionBy
-         */
-        unionBy<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            iteratee?: ValueIteratee<T>
-        ): LoDashExplicitWrapper<T[]>;
-
-        /**
-         * @see _.unionBy
-         */
-        unionBy<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            arrays2: List<T> | null | undefined,
-            iteratee?: ValueIteratee<T>
-        ): LoDashExplicitWrapper<T[]>;
-
-        /**
-         * @see _.unionBy
-         */
-        unionBy<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            arrays2: List<T> | null | undefined,
-            arrays3: List<T> | null | undefined,
-            iteratee?: ValueIteratee<T>
-        ): LoDashExplicitWrapper<T[]>;
-
-        /**
-         * @see _.unionBy
-         */
-        unionBy<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            arrays2: List<T> | null | undefined,
-            arrays3: List<T> | null | undefined,
-            arrays4: List<T> | null | undefined,
-            iteratee?: ValueIteratee<T>
-        ): LoDashExplicitWrapper<T[]>;
-
-        /**
-         * @see _.unionBy
-         */
-        unionBy<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            arrays2: List<T> | null | undefined,
-            arrays3: List<T> | null | undefined,
-            arrays4: List<T> | null | undefined,
-            arrays5: List<T> | null | undefined,
-            ...iteratee: Array<ValueIteratee<T> | List<T> | null | undefined>
-        ): LoDashExplicitWrapper<T[]>;
-    }
-
-    // unionWith
-
-    interface LoDashStatic {
-        /**
-         * This method is like `_.union` except that it accepts `comparator` which
-         * is invoked to compare elements of `arrays`. The comparator is invoked
-         * with two arguments: (arrVal, othVal).
-         *
-         * @category Array
-         * @param [arrays] The arrays to inspect.
-         * @param [comparator] The comparator invoked per element.
-         * @returns 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 }]
-         */
-        unionWith<T>(
-            arrays: List<T> | null | undefined,
-            comparator?: Comparator<T>
-        ): T[];
-
-        /**
-         * @see _.unionBy
-         */
-        unionWith<T>(
-            arrays: List<T> | null | undefined,
-            arrays2: List<T> | null | undefined,
-            comparator?: Comparator<T>
-        ): T[];
-
-        /**
-         * @see _.unionWith
-         */
-        unionWith<T>(
-            arrays: List<T> | null | undefined,
-            arrays2: List<T> | null | undefined,
-            arrays3: List<T> | null | undefined,
-            ...comparator: Array<Comparator<T> | List<T> | null | undefined>
-        ): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.unionWith
-         */
-        unionWith<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            comparator?: Comparator<T>
-        ): LoDashImplicitWrapper<T[]>;
-
-        /**
-         * @see _.unionWith
-         */
-        unionWith<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            arrays2: List<T> | null | undefined,
-            comparator?: Comparator<T>
-        ): LoDashImplicitWrapper<T[]>;
-
-        /**
-         * @see _.unionWith
-         */
-        unionWith<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            arrays2: List<T> | null | undefined,
-            arrays3: List<T> | null | undefined,
-            ...comparator: Array<Comparator<T> | List<T> | null | undefined>
-        ): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.unionWith
-         */
-        unionWith<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            comparator?: Comparator<T>
-        ): LoDashExplicitWrapper<T[]>;
-
-        /**
-         * @see _.unionWith
-         */
-        unionWith<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            arrays2: List<T> | null | undefined,
-            comparator?: Comparator<T>
-        ): LoDashExplicitWrapper<T[]>;
-
-        /**
-         * @see _.unionWith
-         */
-        unionWith<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            arrays2: List<T> | null | undefined,
-            arrays3: List<T> | null | undefined,
-            ...comparator: Array<Comparator<T> | List<T> | null | undefined>
-        ): LoDashExplicitWrapper<T[]>;
-    }
-
-    // uniq
-
-    interface LoDashStatic {
-        /**
-         * Creates a duplicate-free version of an array, using
-         * [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)
-         * for equality comparisons, in which only the first occurrence of each element
-         * is kept.
-         *
-         * @category Array
-         * @param array The array to inspect.
-         * @returns Returns the new duplicate free array.
-         * @example
-         *
-         * _.uniq([2, 1, 2]);
-         * // => [2, 1]
-         */
-        uniq<T>(
-            array: List<T> | null | undefined
-        ): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.uniq
-         */
-        uniq<T>(this: LoDashImplicitWrapper<List<T> | null | undefined>): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.uniq
-         */
-        uniq<T>(this: LoDashExplicitWrapper<List<T> | null | undefined>): LoDashExplicitWrapper<T[]>;
-    }
-
-    // uniqBy
-
-    interface LoDashStatic {
-        /**
-         * 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 iteratee is invoked with one argument: (value).
-         *
-         * @category Array
-         * @param array The array to inspect.
-         * @param [iteratee=_.identity] The iteratee invoked per element.
-         * @returns Returns the new duplicate free array.
-         * @example
-         *
-         * _.uniqBy([2.1, 1.2, 2.3], Math.floor);
-         * // => [2.1, 1.2]
-         *
-         * // using the `_.property` iteratee shorthand
-         * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
-         * // => [{ 'x': 1 }, { 'x': 2 }]
-         */
-        uniqBy<T>(
-            array: List<T> | null | undefined,
-            iteratee: ValueIteratee<T>
-        ): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.uniqBy
-         */
-        uniqBy<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            iteratee: ValueIteratee<T>
-        ): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.uniqBy
-         */
-        uniqBy<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            iteratee: ValueIteratee<T>
-        ): LoDashExplicitWrapper<T[]>;
-    }
-
-    // uniqWith
-
-    interface LoDashStatic {
-        /**
-         * This method is like `_.uniq` except that it accepts `comparator` which
-         * is invoked to compare elements of `array`. The comparator is invoked with
-         * two arguments: (arrVal, othVal).
-         *
-         * @category Array
-         * @param array The array to inspect.
-         * @param [comparator] The comparator invoked per element.
-         * @returns 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 }]
-         */
-        uniqWith<T>(
-            array: List<T> | null | undefined,
-            comparator?: Comparator<T>
-        ): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.uniqWith
-         */
-        uniqWith<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            comparator?: Comparator<T>
-        ): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.uniqWith
-         */
-        uniqWith<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            comparator?: Comparator<T>
-        ): LoDashExplicitWrapper<T[]>;
-    }
-
-    // unzip
-
-    interface LoDashStatic {
-        /**
-         * 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.
-         *
-         * @param array The array of grouped elements to process.
-         * @return Returns the new array of regrouped elements.
-         */
-        unzip<T>(array: T[][] | List<List<T>> | null | undefined): T[][];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.unzip
-         */
-        unzip<T>(this: LoDashImplicitWrapper<T[][] | List<List<T>> | null | undefined>): LoDashImplicitWrapper<T[][]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.unzip
-         */
-        unzip<T>(this: LoDashExplicitWrapper<T[][] | List<List<T>> | null | undefined>): LoDashExplicitWrapper<T[][]>;
-    }
-
-    // unzipWith
-
-    interface LoDashStatic {
-        /**
-         * This method is like _.unzip except that it accepts an iteratee to specify how regrouped values should be
-         * combined. The iteratee is invoked with four arguments: (accumulator, value, index, group).
-         *
-         * @param array The array of grouped elements to process.
-         * @param iteratee The function to combine regrouped values.
-         * @return Returns the new array of regrouped elements.
-         */
-        unzipWith<T, TResult>(
-            array: List<List<T>> | null | undefined,
-            iteratee: (...values: T[]) => TResult
-        ): TResult[];
-
-        /**
-         * @see _.unzipWith
-         */
-        unzipWith<T>(
-            array: List<List<T>> | null | undefined
-        ): T[][];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.unzipWith
-         */
-        unzipWith<T, TResult>(
-            this: LoDashImplicitWrapper<List<List<T>> | null | undefined>,
-            iteratee: (...values: T[]) => TResult
-        ): LoDashImplicitWrapper<TResult[]>;
-
-        /**
-         * @see _.unzipWith
-         */
-        unzipWith<T>(
-            this: LoDashImplicitWrapper<List<List<T>> | null | undefined>
-        ): LoDashImplicitWrapper<T[][]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.unzipWith
-         */
-        unzipWith<T, TResult>(
-            this: LoDashExplicitWrapper<List<List<T>> | null | undefined>,
-            iteratee: (...values: T[]) => TResult
-        ): LoDashExplicitWrapper<TResult[]>;
-
-        /**
-         * @see _.unzipWith
-         */
-        unzipWith<T>(
-            this: LoDashExplicitWrapper<List<List<T>> | null | undefined>
-        ): LoDashExplicitWrapper<T[][]>;
-    }
-
-    // without
-
-    interface LoDashStatic {
-        /**
-         * Creates an array excluding all provided values using SameValueZero for equality comparisons.
-         *
-         * @param array The array to filter.
-         * @param values The values to exclude.
-         * @return Returns the new array of filtered values.
-         */
-        without<T>(
-            array: List<T> | null | undefined,
-            ...values: T[]
-        ): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.without
-         */
-        without<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            ...values: T[]
-        ): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.without
-         */
-        without<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            ...values: T[]
-        ): LoDashExplicitWrapper<T[]>;
-    }
-
-    // xor
-
-    interface LoDashStatic {
-        /**
-         * Creates an array of unique values that is the symmetric difference of the provided arrays.
-         *
-         * @param arrays The arrays to inspect.
-         * @return Returns the new array of values.
-         */
-        xor<T>(...arrays: Array<List<T> | null | undefined>): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.xor
-         */
-        xor<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            ...arrays: Array<List<T> | null | undefined>
-        ): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.xor
-         */
-        xor<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            ...arrays: Array<List<T> | null | undefined>
-        ): LoDashExplicitWrapper<T[]>;
-    }
-
-    // xorBy
-
-    interface LoDashStatic {
-        /**
-         * 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
-         * uniqueness is computed. The iteratee is invoked with one argument: (value).
-         *
-         * @category Array
-         * @param [arrays] The arrays to inspect.
-         * @param [iteratee=_.identity] The iteratee invoked per element.
-         * @returns Returns the new array of values.
-         * @example
-         *
-         * _.xorBy([2.1, 1.2], [4.3, 2.4], Math.floor);
-         * // => [1.2, 4.3]
-         *
-         * // using the `_.property` iteratee shorthand
-         * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
-         * // => [{ 'x': 2 }]
-         */
-        xorBy<T>(
-            arrays: List<T> | null | undefined,
-            iteratee?: ValueIteratee<T>
-        ): T[];
-
-        /**
-         * @see _.xorBy
-         */
-        xorBy<T>(
-            arrays: List<T> | null | undefined,
-            arrays2: List<T> | null | undefined,
-            iteratee?: ValueIteratee<T>
-        ): T[];
-
-        /**
-         * @see _.xorBy
-         */
-        xorBy<T>(
-            arrays: List<T> | null | undefined,
-            arrays2: List<T> | null | undefined,
-            arrays3: List<T> | null | undefined,
-            ...iteratee: Array<ValueIteratee<T> | List<T> | null | undefined>
-        ): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.xor
-         */
-        xorBy<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            iteratee?: ValueIteratee<T>
-        ): LoDashImplicitWrapper<T[]>;
-
-        /**
-         * @see _.xorBy
-         */
-        xorBy<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            arrays2: List<T> | null | undefined,
-            iteratee?: ValueIteratee<T>
-        ): LoDashImplicitWrapper<T[]>;
-
-        /**
-         * @see _.xorBy
-         */
-        xorBy<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            arrays2: List<T> | null | undefined,
-            arrays3: List<T> | null | undefined,
-            ...iteratee: Array<ValueIteratee<T> | List<T> | null | undefined>
-        ): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.xorBy
-         */
-        xorBy<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            iteratee?: ValueIteratee<T>
-        ): LoDashExplicitWrapper<T[]>;
-
-        /**
-         * @see _.xorBy
-         */
-        xorBy<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            arrays2: List<T> | null | undefined,
-            iteratee?: ValueIteratee<T>
-        ): LoDashExplicitWrapper<T[]>;
-
-        /**
-         * @see _.xorBy
-         */
-        xorBy<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            arrays2: List<T> | null | undefined,
-            arrays3: List<T> | null | undefined,
-            ...iteratee: Array<ValueIteratee<T> | List<T> | null | undefined>
-        ): LoDashExplicitWrapper<T[]>;
-    }
-
-    // xorWith
-
-    interface LoDashStatic {
-        /**
-         * This method is like `_.xor` except that it accepts `comparator` which is
-         * invoked to compare elements of `arrays`. The comparator is invoked with
-         * two arguments: (arrVal, othVal).
-         *
-         * @category Array
-         * @param [arrays] The arrays to inspect.
-         * @param [comparator] The comparator invoked per element.
-         * @returns Returns the new array of 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 }]
-         */
-        xorWith<T>(
-            arrays: List<T> | null | undefined,
-            comparator?: Comparator<T>
-        ): T[];
-
-        /**
-         * @see _.xorWith
-         */
-        xorWith<T>(
-            arrays: List<T> | null | undefined,
-            arrays2: List<T> | null | undefined,
-            comparator?: Comparator<T>
-        ): T[];
-
-        /**
-         * @see _.xorWith
-         */
-        xorWith<T>(
-            arrays: List<T> | null | undefined,
-            arrays2: List<T> | null | undefined,
-            arrays3: List<T> | null | undefined,
-            ...comparator: Array<Comparator<T> | List<T> | null | undefined>
-        ): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.xorWith
-         */
-        xorWith<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            comparator?: Comparator<T>
-        ): LoDashImplicitWrapper<T[]>;
-
-        /**
-         * @see _.xorWith
-         */
-        xorWith<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            arrays2: List<T> | null | undefined,
-            comparator?: Comparator<T>
-        ): LoDashImplicitWrapper<T[]>;
-
-        /**
-         * @see _.xorWith
-         */
-        xorWith<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            arrays2: List<T> | null | undefined,
-            arrays3: List<T> | null | undefined,
-            ...comparator: Array<Comparator<T> | List<T> | null | undefined>
-        ): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.xorWith
-         */
-        xorWith<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            comparator?: Comparator<T>
-        ): LoDashExplicitWrapper<T[]>;
-
-        /**
-         * @see _.xorWith
-         */
-        xorWith<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            arrays2: List<T> | null | undefined,
-            comparator?: Comparator<T>
-        ): LoDashExplicitWrapper<T[]>;
-
-        /**
-         * @see _.xorWith
-         */
-        xorWith<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            arrays2: List<T> | null | undefined,
-            arrays3: List<T> | null | undefined,
-            ...comparator: Array<Comparator<T> | List<T> | null | undefined>
-        ): LoDashExplicitWrapper<T[]>;
-    }
-
-    // zip
-
-    interface LoDashStatic {
-        /**
-         * 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.
-         *
-         * @param arrays The arrays to process.
-         * @return Returns the new array of grouped elements.
-         */
-        zip<T1, T2>(arrays1: List<T1>, arrays2: List<T2>): Array<[T1 | undefined, T2 | undefined]>;
-
-        /**
-         * @see _.zip
-         */
-        zip<T1, T2, T3>(arrays1: List<T1>, arrays2: List<T2>, arrays3: List<T3>): Array<[T1 | undefined, T2 | undefined, T3 | undefined]>;
-
-        /**
-         * @see _.zip
-         */
-        zip<T1, T2, T3, T4>(arrays1: List<T1>, arrays2: List<T2>, arrays3: List<T3>, arrays4: List<T4>): Array<[T1 | undefined, T2 | undefined, T3 | undefined, T4 | undefined]>;
-
-        /**
-         * @see _.zip
-         */
-        zip<T1, T2, T3, T4, T5>(arrays1: List<T1>, arrays2: List<T2>, arrays3: List<T3>, arrays4: List<T4>, arrays5: List<T5>): Array<[T1 | undefined, T2 | undefined, T3 | undefined, T4 | undefined, T5 | undefined]>;
-
-        /**
-         * @see _.zip
-         */
-        zip<T>(...arrays: Array<List<T> | null | undefined>): Array<Array<T | undefined>>;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.zip
-         */
-        zip<T1, T2>(
-            this: LoDashImplicitWrapper<List<T1>>,
-            arrays2: List<T2>,
-        ): LoDashImplicitWrapper<Array<[T1 | undefined, T2 | undefined]>>;
-
-        /**
-         * @see _.zip
-         */
-        zip<T1, T2, T3>(
-            this: LoDashImplicitWrapper<List<T1>>,
-            arrays2: List<T2>,
-            arrays3: List<T3>,
-        ): LoDashImplicitWrapper<Array<[T1 | undefined, T2 | undefined, T3 | undefined]>>;
-
-        /**
-         * @see _.zip
-         */
-        zip<T1, T2, T3, T4>(
-            this: LoDashImplicitWrapper<List<T1>>,
-            arrays2: List<T2>,
-            arrays3: List<T3>,
-            arrays4: List<T4>,
-        ): LoDashImplicitWrapper<Array<[T1 | undefined, T2 | undefined, T3 | undefined, T4 | undefined]>>;
-
-        /**
-         * @see _.zip
-         */
-        zip<T1, T2, T3, T4, T5>(
-            this: LoDashImplicitWrapper<List<T1>>,
-            arrays2: List<T2>,
-            arrays3: List<T3>,
-            arrays4: List<T4>,
-            arrays5: List<T5>,
-        ): LoDashImplicitWrapper<Array<[T1 | undefined, T2 | undefined, T3 | undefined, T4 | undefined, T5 | undefined]>>;
-
-        /**
-         * @see _.zip
-         */
-        zip<T>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            ...arrays: Array<List<T> | null | undefined>
-        ): LoDashImplicitWrapper<Array<Array<T | undefined>>>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.zip
-         */
-        zip<T1, T2>(
-            this: LoDashExplicitWrapper<List<T1>>,
-            arrays2: List<T2>,
-        ): LoDashExplicitWrapper<Array<[T1 | undefined, T2 | undefined]>>;
-
-        /**
-         * @see _.zip
-         */
-        zip<T1, T2, T3>(
-            this: LoDashExplicitWrapper<List<T1>>,
-            arrays2: List<T2>,
-            arrays3: List<T3>,
-        ): LoDashExplicitWrapper<Array<[T1 | undefined, T2 | undefined, T3 | undefined]>>;
-
-        /**
-         * @see _.zip
-         */
-        zip<T1, T2, T3, T4>(
-            this: LoDashExplicitWrapper<List<T1>>,
-            arrays2: List<T2>,
-            arrays3: List<T3>,
-            arrays4: List<T4>,
-        ): LoDashExplicitWrapper<Array<[T1 | undefined, T2 | undefined, T3 | undefined, T4 | undefined]>>;
-
-        /**
-         * @see _.zip
-         */
-        zip<T1, T2, T3, T4, T5>(
-            this: LoDashExplicitWrapper<List<T1>>,
-            arrays2: List<T2>,
-            arrays3: List<T3>,
-            arrays4: List<T4>,
-            arrays5: List<T5>,
-        ): LoDashExplicitWrapper<Array<[T1 | undefined, T2 | undefined, T3 | undefined, T4 | undefined, T5 | undefined]>>;
-
-        /**
-         * @see _.zip
-         */
-        zip<T>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            ...arrays: Array<List<T> | null | undefined>
-        ): LoDashExplicitWrapper<Array<Array<T | undefined>>>;
-    }
-
-    // zipObject
-
-    interface LoDashStatic {
-        /**
-         * This method is like _.fromPairs except that it accepts two arrays, one of property
-         * identifiers and one of corresponding values.
-         *
-         * @param props The property names.
-         * @param values The property values.
-         * @return Returns the new object.
-         */
-        zipObject<T>(
-            props: List<PropertyName>,
-            values: List<T>
-        ): Dictionary<T>;
-
-        /**
-         * @see _.zipObject
-         */
-        zipObject(
-            props?: List<PropertyName>
-        ): Dictionary<undefined>;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.zipObject
-         */
-        zipObject<T>(
-            this: LoDashImplicitWrapper<List<PropertyName>>,
-            values: List<T>
-        ): LoDashImplicitWrapper<Dictionary<T>>;
-
-        /**
-         * @see _.zipObject
-         */
-        zipObject(
-            this: LoDashImplicitWrapper<List<PropertyName>>
-        ): LoDashImplicitWrapper<Dictionary<undefined>>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.zipObject
-         */
-        zipObject<T>(
-            this: LoDashExplicitWrapper<List<PropertyName>>,
-            values: List<T>
-        ): LoDashExplicitWrapper<Dictionary<T>>;
-
-        /**
-         * @see _.zipObject
-         */
-        zipObject(
-            this: LoDashExplicitWrapper<List<PropertyName>>
-        ): LoDashExplicitWrapper<Dictionary<undefined>>;
-    }
-
-    // zipObjectDeep
-
-    interface LoDashStatic {
-        /**
-         * This method is like _.zipObject except that it supports property paths.
-         *
-         * @param paths The property names.
-         * @param values The property values.
-         * @return Returns the new object.
-         */
-        zipObjectDeep(
-            paths?: List<PropertyPath>,
-            values?: List<any>
-        ): object;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.zipObjectDeep
-         */
-        zipObjectDeep(
-            this: LoDashImplicitWrapper<List<PropertyPath>>,
-            values?: List<any>
-        ): LoDashImplicitWrapper<object>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.zipObjectDeep
-         */
-        zipObjectDeep(
-            this: LoDashExplicitWrapper<List<PropertyPath>>,
-            values?: List<any>
-        ): LoDashExplicitWrapper<object>;
-    }
-
-    // zipWith
-
-    interface LoDashStatic {
-        /**
-         * This method is like _.zip except that it accepts an iteratee to specify how grouped values should be
-         * combined. The iteratee is invoked with four arguments: (accumulator, value, index,
-         * group).
-         * @param arrays The arrays to process.
-         * @param iteratee The function to combine grouped values.
-         * @return Returns the new array of grouped elements.
-         */
-        zipWith<T, TResult>(
-            arrays: List<T>,
-            iteratee: (value1: T) => TResult
-        ): TResult[];
-
-        /**
-         * @see _.zipWith
-         */
-        zipWith<T1, T2, TResult>(
-            arrays1: List<T1>,
-            arrays2: List<T2>,
-            iteratee: (value1: T1, value2: T2) => TResult
-        ): TResult[];
-
-        /**
-         * @see _.zipWith
-         */
-        zipWith<T1, T2, T3, TResult>(
-            arrays1: List<T1>,
-            arrays2: List<T2>,
-            arrays3: List<T3>,
-            iteratee: (value1: T1, value2: T2, value3: T3) => TResult
-        ): TResult[];
-
-        /**
-         * @see _.zipWith
-         */
-        zipWith<T1, T2, T3, T4, TResult>(
-            arrays1: List<T1>,
-            arrays2: List<T2>,
-            arrays3: List<T3>,
-            arrays4: List<T4>,
-            iteratee: (value1: T1, value2: T2, value3: T3, value4: T4) => TResult
-        ): TResult[];
-
-        /**
-         * @see _.zipWith
-         */
-        zipWith<T1, T2, T3, T4, T5, TResult>(
-            arrays1: List<T1>,
-            arrays2: List<T2>,
-            arrays3: List<T3>,
-            arrays4: List<T4>,
-            arrays5: List<T5>,
-            iteratee: (value1: T1, value2: T2, value3: T3, value4: T4, value5: T5) => TResult
-        ): TResult[];
-
-        /**
-         * @see _.zipWith
-         */
-        zipWith<T, TResult>(
-            ...iteratee: Array<((...group: T[]) => TResult) | List<T> | null | undefined>
-        ): TResult[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.zipWith
-         */
-        zipWith<T, TResult>(
-            this: LoDashImplicitWrapper<List<T>>,
-            iteratee: (value1: T) => TResult
-        ): LoDashImplicitWrapper<TResult[]>;
-
-        /**
-         * @see _.zipWith
-         */
-        zipWith<T1, T2, TResult>(
-            this: LoDashImplicitWrapper<List<T1>>,
-            arrays2: List<T2>,
-            iteratee: (value1: T1, value2: T2) => TResult
-        ): LoDashImplicitWrapper<TResult[]>;
-
-        /**
-         * @see _.zipWith
-         */
-        zipWith<T1, T2, T3, TResult>(
-            this: LoDashImplicitWrapper<List<T1>>,
-            arrays2: List<T2>,
-            arrays3: List<T3>,
-            iteratee: (value1: T1, value2: T2, value3: T3) => TResult
-        ): LoDashImplicitWrapper<TResult[]>;
-
-        /**
-         * @see _.zipWith
-         */
-        zipWith<T1, T2, T3, T4, TResult>(
-            this: LoDashImplicitWrapper<List<T1>>,
-            arrays2: List<T2>,
-            arrays3: List<T3>,
-            arrays4: List<T4>,
-            iteratee: (value1: T1, value2: T2, value3: T3, value4: T4) => TResult
-        ): LoDashImplicitWrapper<TResult[]>;
-
-        /**
-         * @see _.zipWith
-         */
-        zipWith<T1, T2, T3, T4, T5, TResult>(
-            this: LoDashImplicitWrapper<List<T1>>,
-            arrays2: List<T2>,
-            arrays3: List<T3>,
-            arrays4: List<T4>,
-            arrays5: List<T5>,
-            iteratee: (value1: T1, value2: T2, value3: T3, value4: T4, value5: T5) => TResult
-        ): LoDashImplicitWrapper<TResult[]>;
-
-        /**
-         * @see _.zipWith
-         */
-        zipWith<T, TResult>(
-            this: LoDashImplicitWrapper<List<T> | null | undefined>,
-            ...iteratee: Array<((...group: T[]) => TResult) | List<T> | null | undefined>
-        ): LoDashImplicitWrapper<TResult[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.zipWith
-         */
-        zipWith<T, TResult>(
-            this: LoDashExplicitWrapper<List<T>>,
-            iteratee: (value1: T) => TResult
-        ): LoDashExplicitWrapper<TResult[]>;
-
-        /**
-         * @see _.zipWith
-         */
-        zipWith<T1, T2, TResult>(
-            this: LoDashExplicitWrapper<List<T1>>,
-            arrays2: List<T2>,
-            iteratee: (value1: T1, value2: T2) => TResult
-        ): LoDashExplicitWrapper<TResult[]>;
-
-        /**
-         * @see _.zipWith
-         */
-        zipWith<T1, T2, T3, TResult>(
-            this: LoDashExplicitWrapper<List<T1>>,
-            arrays2: List<T2>,
-            arrays3: List<T3>,
-            iteratee: (value1: T1, value2: T2, value3: T3) => TResult
-        ): LoDashExplicitWrapper<TResult[]>;
-
-        /**
-         * @see _.zipWith
-         */
-        zipWith<T1, T2, T3, T4, TResult>(
-            this: LoDashExplicitWrapper<List<T1>>,
-            arrays2: List<T2>,
-            arrays3: List<T3>,
-            arrays4: List<T4>,
-            iteratee: (value1: T1, value2: T2, value3: T3, value4: T4) => TResult
-        ): LoDashExplicitWrapper<TResult[]>;
-
-        /**
-         * @see _.zipWith
-         */
-        zipWith<T1, T2, T3, T4, T5, TResult>(
-            this: LoDashExplicitWrapper<List<T1>>,
-            arrays2: List<T2>,
-            arrays3: List<T3>,
-            arrays4: List<T4>,
-            arrays5: List<T5>,
-            iteratee: (value1: T1, value2: T2, value3: T3, value4: T4, value5: T5) => TResult
-        ): LoDashExplicitWrapper<TResult[]>;
-
-        /**
-         * @see _.zipWith
-         */
-        zipWith<T, TResult>(
-            this: LoDashExplicitWrapper<List<T> | null | undefined>,
-            ...iteratee: Array<((...group: T[]) => TResult) | List<T> | null | undefined>
-        ): LoDashExplicitWrapper<TResult[]>;
-    }
-}