@types/lodash 4.14.100 → 4.14.104

lodash/function/partialRight.d.ts

@@ -1,150 +0,0 @@
-import * as _ from "../index";
-declare module "../index" {
-    interface LoDashStatic {
-        /**
-        * This method is like _.partial except that partial arguments are appended to those provided
-        * to the new function.
-        * @param func The function to partially apply arguments to.
-        * @param args Arguments to be partially applied.
-        * @return The new partially applied function.
-        **/
-        partialRight: PartialRight;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.partialRight
-         */
-        partialRight: ImplicitPartialRight;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.partialRight
-         */
-        partialRight: ExplicitPartialRight;
-    }
-
-    interface PartialRight {
-        // arity 0
-        <R>(func: Function0<R>): Function0<R>;
-        // arity 1
-        <T1, R>(func: Function1<T1, R>): Function1<T1, R>;
-        <T1, R>(func: Function1<T1, R>, arg1: T1): Function0<R>;
-        // arity 2
-        <T1, T2, R>(func: Function2<T1, T2, R>):                      Function2<T1, T2, R>;
-        <T1, T2, R>(func: Function2<T1, T2, R>, arg1: T1, plc2: PH):  Function1<    T2, R>;
-        <T1, T2, R>(func: Function2<T1, T2, R>,           arg2: T2):  Function1<T1,     R>;
-        <T1, T2, R>(func: Function2<T1, T2, R>, arg1: T1, arg2: T2):  Function0<        R>;
-        // arity 3
-        <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>):                                Function3<T1, T2, T3, R>;
-        <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1, plc2: PH, plc3: PH):  Function2<    T2, T3, R>;
-        <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>,           arg2: T2, plc3: PH):  Function2<T1,     T3, R>;
-        <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1, arg2: T2, plc3: PH):  Function1<        T3, R>;
-        <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>,                     arg3: T3):  Function2<T1, T2,     R>;
-        <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1, plc2: PH, arg3: T3):  Function1<    T2,     R>;
-        <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>,           arg2: T2, arg3: T3):  Function1<T1,         R>;
-        <T1, T2, T3, R>(func: Function3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3):  Function0<            R>;
-        // arity 4
-        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>):                                          Function4<T1, T2, T3, T4, R>;
-        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: PH, plc3: PH, plc4: PH):  Function3<    T2, T3, T4, R>;
-        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>,           arg2: T2, plc3: PH, plc4: PH):  Function3<T1,     T3, T4, R>;
-        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, plc3: PH, plc4: PH):  Function2<        T3, T4, R>;
-        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>,                     arg3: T3, plc4: PH):  Function3<T1, T2,     T4, R>;
-        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: PH, arg3: T3, plc4: PH):  Function2<    T2,     T4, R>;
-        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>,           arg2: T2, arg3: T3, plc4: PH):  Function2<T1,         T4, R>;
-        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, plc4: PH):  Function1<            T4, R>;
-        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>,                               arg4: T4):  Function3<T1, T2, T3,     R>;
-        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: PH, plc3: PH, arg4: T4):  Function2<    T2, T3,     R>;
-        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>,           arg2: T2, plc3: PH, arg4: T4):  Function2<T1,     T3,     R>;
-        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, plc3: PH, arg4: T4):  Function1<        T3,     R>;
-        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>,                     arg3: T3, arg4: T4):  Function2<T1, T2,         R>;
-        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, plc2: PH, arg3: T3, arg4: T4):  Function1<    T2,         R>;
-        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>,           arg2: T2, arg3: T3, arg4: T4):  Function1<T1,             R>;
-        <T1, T2, T3, T4, R>(func: Function4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4):  Function0<                R>;
-        // catch-all
-        (func: (...args: any[]) => any, ...args: any[]): (...args: any[]) => any;
-    }
-
-    interface ImplicitPartialRight {
-        // arity 0
-        <R>(this: LoDashImplicitWrapper<Function0<R>>): LoDashImplicitWrapper<Function0<R>>;
-        // arity 1
-        <T1, R>(this: LoDashImplicitWrapper<Function1<T1, R>>): LoDashImplicitWrapper<Function1<T1, R>>;
-        <T1, R>(this: LoDashImplicitWrapper<Function1<T1, R>>, arg1: T1): LoDashImplicitWrapper<Function0<R>>;
-        // arity 2
-        <T1, T2, R>(this: LoDashImplicitWrapper<Function2<T1, T2, R>>):                      LoDashImplicitWrapper<Function2<T1, T2, R>>;
-        <T1, T2, R>(this: LoDashImplicitWrapper<Function2<T1, T2, R>>, arg1: T1, plc2: PH):  LoDashImplicitWrapper<Function1<    T2, R>>;
-        <T1, T2, R>(this: LoDashImplicitWrapper<Function2<T1, T2, R>>,           arg2: T2):  LoDashImplicitWrapper<Function1<T1,     R>>;
-        <T1, T2, R>(this: LoDashImplicitWrapper<Function2<T1, T2, R>>, arg1: T1, arg2: T2):  LoDashImplicitWrapper<Function0<        R>>;
-        // arity 3
-        <T1, T2, T3, R>(this: LoDashImplicitWrapper<Function3<T1, T2, T3, R>>):                                LoDashImplicitWrapper<Function3<T1, T2, T3, R>>;
-        <T1, T2, T3, R>(this: LoDashImplicitWrapper<Function3<T1, T2, T3, R>>, arg1: T1, plc2: PH, plc3: PH):  LoDashImplicitWrapper<Function2<    T2, T3, R>>;
-        <T1, T2, T3, R>(this: LoDashImplicitWrapper<Function3<T1, T2, T3, R>>,           arg2: T2, plc3: PH):  LoDashImplicitWrapper<Function2<T1,     T3, R>>;
-        <T1, T2, T3, R>(this: LoDashImplicitWrapper<Function3<T1, T2, T3, R>>, arg1: T1, arg2: T2, plc3: PH):  LoDashImplicitWrapper<Function1<        T3, R>>;
-        <T1, T2, T3, R>(this: LoDashImplicitWrapper<Function3<T1, T2, T3, R>>,                     arg3: T3):  LoDashImplicitWrapper<Function2<T1, T2,     R>>;
-        <T1, T2, T3, R>(this: LoDashImplicitWrapper<Function3<T1, T2, T3, R>>, arg1: T1, plc2: PH, arg3: T3):  LoDashImplicitWrapper<Function1<    T2,     R>>;
-        <T1, T2, T3, R>(this: LoDashImplicitWrapper<Function3<T1, T2, T3, R>>,           arg2: T2, arg3: T3):  LoDashImplicitWrapper<Function1<T1,         R>>;
-        <T1, T2, T3, R>(this: LoDashImplicitWrapper<Function3<T1, T2, T3, R>>, arg1: T1, arg2: T2, arg3: T3):  LoDashImplicitWrapper<Function0<            R>>;
-        // arity 4
-        <T1, T2, T3, T4, R>(this: LoDashImplicitWrapper<Function4<T1, T2, T3, T4, R>>):                                          LoDashImplicitWrapper<Function4<T1, T2, T3, T4, R>>;
-        <T1, T2, T3, T4, R>(this: LoDashImplicitWrapper<Function4<T1, T2, T3, T4, R>>, arg1: T1, plc2: PH, plc3: PH, plc4: PH):  LoDashImplicitWrapper<Function3<    T2, T3, T4, R>>;
-        <T1, T2, T3, T4, R>(this: LoDashImplicitWrapper<Function4<T1, T2, T3, T4, R>>,           arg2: T2, plc3: PH, plc4: PH):  LoDashImplicitWrapper<Function3<T1,     T3, T4, R>>;
-        <T1, T2, T3, T4, R>(this: LoDashImplicitWrapper<Function4<T1, T2, T3, T4, R>>, arg1: T1, arg2: T2, plc3: PH, plc4: PH):  LoDashImplicitWrapper<Function2<        T3, T4, R>>;
-        <T1, T2, T3, T4, R>(this: LoDashImplicitWrapper<Function4<T1, T2, T3, T4, R>>,                     arg3: T3, plc4: PH):  LoDashImplicitWrapper<Function3<T1, T2,     T4, R>>;
-        <T1, T2, T3, T4, R>(this: LoDashImplicitWrapper<Function4<T1, T2, T3, T4, R>>, arg1: T1, plc2: PH, arg3: T3, plc4: PH):  LoDashImplicitWrapper<Function2<    T2,     T4, R>>;
-        <T1, T2, T3, T4, R>(this: LoDashImplicitWrapper<Function4<T1, T2, T3, T4, R>>,           arg2: T2, arg3: T3, plc4: PH):  LoDashImplicitWrapper<Function2<T1,         T4, R>>;
-        <T1, T2, T3, T4, R>(this: LoDashImplicitWrapper<Function4<T1, T2, T3, T4, R>>, arg1: T1, arg2: T2, arg3: T3, plc4: PH):  LoDashImplicitWrapper<Function1<            T4, R>>;
-        <T1, T2, T3, T4, R>(this: LoDashImplicitWrapper<Function4<T1, T2, T3, T4, R>>,                               arg4: T4):  LoDashImplicitWrapper<Function3<T1, T2, T3,     R>>;
-        <T1, T2, T3, T4, R>(this: LoDashImplicitWrapper<Function4<T1, T2, T3, T4, R>>, arg1: T1, plc2: PH, plc3: PH, arg4: T4):  LoDashImplicitWrapper<Function2<    T2, T3,     R>>;
-        <T1, T2, T3, T4, R>(this: LoDashImplicitWrapper<Function4<T1, T2, T3, T4, R>>,           arg2: T2, plc3: PH, arg4: T4):  LoDashImplicitWrapper<Function2<T1,     T3,     R>>;
-        <T1, T2, T3, T4, R>(this: LoDashImplicitWrapper<Function4<T1, T2, T3, T4, R>>, arg1: T1, arg2: T2, plc3: PH, arg4: T4):  LoDashImplicitWrapper<Function1<        T3,     R>>;
-        <T1, T2, T3, T4, R>(this: LoDashImplicitWrapper<Function4<T1, T2, T3, T4, R>>,                     arg3: T3, arg4: T4):  LoDashImplicitWrapper<Function2<T1, T2,         R>>;
-        <T1, T2, T3, T4, R>(this: LoDashImplicitWrapper<Function4<T1, T2, T3, T4, R>>, arg1: T1, plc2: PH, arg3: T3, arg4: T4):  LoDashImplicitWrapper<Function1<    T2,         R>>;
-        <T1, T2, T3, T4, R>(this: LoDashImplicitWrapper<Function4<T1, T2, T3, T4, R>>,           arg2: T2, arg3: T3, arg4: T4):  LoDashImplicitWrapper<Function1<T1,             R>>;
-        <T1, T2, T3, T4, R>(this: LoDashImplicitWrapper<Function4<T1, T2, T3, T4, R>>, arg1: T1, arg2: T2, arg3: T3, arg4: T4):  LoDashImplicitWrapper<Function0<                R>>;
-        // catch-all
-        (...args: any[]): LoDashImplicitWrapper<(...args: any[]) => any>;
-    }
-
-    interface ExplicitPartialRight {
-        // arity 0
-        <R>(this: LoDashExplicitWrapper<Function0<R>>): LoDashExplicitWrapper<Function0<R>>;
-        // arity 1
-        <T1, R>(this: LoDashExplicitWrapper<Function1<T1, R>>): LoDashExplicitWrapper<Function1<T1, R>>;
-        <T1, R>(this: LoDashExplicitWrapper<Function1<T1, R>>, arg1: T1): LoDashExplicitWrapper<Function0<R>>;
-        // arity 2
-        <T1, T2, R>(this: LoDashExplicitWrapper<Function2<T1, T2, R>>):                      LoDashExplicitWrapper<Function2<T1, T2, R>>;
-        <T1, T2, R>(this: LoDashExplicitWrapper<Function2<T1, T2, R>>, arg1: T1, plc2: PH):  LoDashExplicitWrapper<Function1<    T2, R>>;
-        <T1, T2, R>(this: LoDashExplicitWrapper<Function2<T1, T2, R>>,           arg2: T2):  LoDashExplicitWrapper<Function1<T1,     R>>;
-        <T1, T2, R>(this: LoDashExplicitWrapper<Function2<T1, T2, R>>, arg1: T1, arg2: T2):  LoDashExplicitWrapper<Function0<        R>>;
-        // arity 3
-        <T1, T2, T3, R>(this: LoDashExplicitWrapper<Function3<T1, T2, T3, R>>):                                LoDashExplicitWrapper<Function3<T1, T2, T3, R>>;
-        <T1, T2, T3, R>(this: LoDashExplicitWrapper<Function3<T1, T2, T3, R>>, arg1: T1, plc2: PH, plc3: PH):  LoDashExplicitWrapper<Function2<    T2, T3, R>>;
-        <T1, T2, T3, R>(this: LoDashExplicitWrapper<Function3<T1, T2, T3, R>>,           arg2: T2, plc3: PH):  LoDashExplicitWrapper<Function2<T1,     T3, R>>;
-        <T1, T2, T3, R>(this: LoDashExplicitWrapper<Function3<T1, T2, T3, R>>, arg1: T1, arg2: T2, plc3: PH):  LoDashExplicitWrapper<Function1<        T3, R>>;
-        <T1, T2, T3, R>(this: LoDashExplicitWrapper<Function3<T1, T2, T3, R>>,                     arg3: T3):  LoDashExplicitWrapper<Function2<T1, T2,     R>>;
-        <T1, T2, T3, R>(this: LoDashExplicitWrapper<Function3<T1, T2, T3, R>>, arg1: T1, plc2: PH, arg3: T3):  LoDashExplicitWrapper<Function1<    T2,     R>>;
-        <T1, T2, T3, R>(this: LoDashExplicitWrapper<Function3<T1, T2, T3, R>>,           arg2: T2, arg3: T3):  LoDashExplicitWrapper<Function1<T1,         R>>;
-        <T1, T2, T3, R>(this: LoDashExplicitWrapper<Function3<T1, T2, T3, R>>, arg1: T1, arg2: T2, arg3: T3):  LoDashExplicitWrapper<Function0<            R>>;
-        // arity 4
-        <T1, T2, T3, T4, R>(this: LoDashExplicitWrapper<Function4<T1, T2, T3, T4, R>>):                                          LoDashExplicitWrapper<Function4<T1, T2, T3, T4, R>>;
-        <T1, T2, T3, T4, R>(this: LoDashExplicitWrapper<Function4<T1, T2, T3, T4, R>>, arg1: T1, plc2: PH, plc3: PH, plc4: PH):  LoDashExplicitWrapper<Function3<    T2, T3, T4, R>>;
-        <T1, T2, T3, T4, R>(this: LoDashExplicitWrapper<Function4<T1, T2, T3, T4, R>>,           arg2: T2, plc3: PH, plc4: PH):  LoDashExplicitWrapper<Function3<T1,     T3, T4, R>>;
-        <T1, T2, T3, T4, R>(this: LoDashExplicitWrapper<Function4<T1, T2, T3, T4, R>>, arg1: T1, arg2: T2, plc3: PH, plc4: PH):  LoDashExplicitWrapper<Function2<        T3, T4, R>>;
-        <T1, T2, T3, T4, R>(this: LoDashExplicitWrapper<Function4<T1, T2, T3, T4, R>>,                     arg3: T3, plc4: PH):  LoDashExplicitWrapper<Function3<T1, T2,     T4, R>>;
-        <T1, T2, T3, T4, R>(this: LoDashExplicitWrapper<Function4<T1, T2, T3, T4, R>>, arg1: T1, plc2: PH, arg3: T3, plc4: PH):  LoDashExplicitWrapper<Function2<    T2,     T4, R>>;
-        <T1, T2, T3, T4, R>(this: LoDashExplicitWrapper<Function4<T1, T2, T3, T4, R>>,           arg2: T2, arg3: T3, plc4: PH):  LoDashExplicitWrapper<Function2<T1,         T4, R>>;
-        <T1, T2, T3, T4, R>(this: LoDashExplicitWrapper<Function4<T1, T2, T3, T4, R>>, arg1: T1, arg2: T2, arg3: T3, plc4: PH):  LoDashExplicitWrapper<Function1<            T4, R>>;
-        <T1, T2, T3, T4, R>(this: LoDashExplicitWrapper<Function4<T1, T2, T3, T4, R>>,                               arg4: T4):  LoDashExplicitWrapper<Function3<T1, T2, T3,     R>>;
-        <T1, T2, T3, T4, R>(this: LoDashExplicitWrapper<Function4<T1, T2, T3, T4, R>>, arg1: T1, plc2: PH, plc3: PH, arg4: T4):  LoDashExplicitWrapper<Function2<    T2, T3,     R>>;
-        <T1, T2, T3, T4, R>(this: LoDashExplicitWrapper<Function4<T1, T2, T3, T4, R>>,           arg2: T2, plc3: PH, arg4: T4):  LoDashExplicitWrapper<Function2<T1,     T3,     R>>;
-        <T1, T2, T3, T4, R>(this: LoDashExplicitWrapper<Function4<T1, T2, T3, T4, R>>, arg1: T1, arg2: T2, plc3: PH, arg4: T4):  LoDashExplicitWrapper<Function1<        T3,     R>>;
-        <T1, T2, T3, T4, R>(this: LoDashExplicitWrapper<Function4<T1, T2, T3, T4, R>>,                     arg3: T3, arg4: T4):  LoDashExplicitWrapper<Function2<T1, T2,         R>>;
-        <T1, T2, T3, T4, R>(this: LoDashExplicitWrapper<Function4<T1, T2, T3, T4, R>>, arg1: T1, plc2: PH, arg3: T3, arg4: T4):  LoDashExplicitWrapper<Function1<    T2,         R>>;
-        <T1, T2, T3, T4, R>(this: LoDashExplicitWrapper<Function4<T1, T2, T3, T4, R>>,           arg2: T2, arg3: T3, arg4: T4):  LoDashExplicitWrapper<Function1<T1,             R>>;
-        <T1, T2, T3, T4, R>(this: LoDashExplicitWrapper<Function4<T1, T2, T3, T4, R>>, arg1: T1, arg2: T2, arg3: T3, arg4: T4):  LoDashExplicitWrapper<Function0<                R>>;
-        // catch-all
-        (...args: any[]): LoDashExplicitWrapper<(...args: any[]) => any>;
-    }
-}

lodash/function/rearg.d.ts

@@ -1,28 +0,0 @@
-import * as _ from "../index";
-declare module "../index" {
-    interface LoDashStatic {
-        /**
-         * Creates a function that invokes func with arguments arranged according to the specified indexes where the
-         * argument value at the first index is provided as the first argument, the argument value at the second index
-         * is provided as the second argument, and so on.
-         * @param func The function to rearrange arguments for.
-         * @param indexes The arranged argument indexes, specified as individual indexes or arrays of indexes.
-         * @return Returns the new function.
-         */
-        rearg(func: (...args: any[]) => any, ...indexes: Array<Many<number>>): (...args: any[]) => any;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.rearg
-         */
-        rearg(...indexes: Array<Many<number>>): LoDashImplicitWrapper<(...args: any[]) => any>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.rearg
-         */
-        rearg(...indexes: Array<Many<number>>): LoDashExplicitWrapper<(...args: any[]) => any>;
-    }
-}

lodash/function/rest.d.ts

@@ -1,33 +0,0 @@
-import * as _ from "../index";
-declare module "../index" {
-    interface LoDashStatic {
-        /**
-         * Creates a function that invokes func with the this binding of the created function and arguments from start
-         * and beyond provided as an array.
-         *
-         * Note: This method is based on the rest parameter.
-         *
-         * @param func The function to apply a rest parameter to.
-         * @param start The start position of the rest parameter.
-         * @return Returns the new function.
-         */
-        rest(
-            func: (...args: any[]) => any,
-            start?: number
-        ): (...args: any[]) => any;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.rest
-         */
-        rest(start?: number): LoDashImplicitWrapper<(...args: any[]) => any>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.rest
-         */
-        rest(start?: number): LoDashExplicitWrapper<(...args: any[]) => any>;
-    }
-}

lodash/function/spread.d.ts

@@ -1,44 +0,0 @@
-import * as _ from "../index";
-declare module "../index" {
-    interface LoDashStatic {
-        /**
-         * Creates a function that invokes func with the this binding of the created function and an array of arguments
-         * much like Function#apply.
-         *
-         * Note: This method is based on the spread operator.
-         *
-         * @param func The function to spread arguments over.
-         * @return Returns the new function.
-         */
-        spread<TResult>(func: (...args: any[]) => TResult): (...args: any[]) => TResult;
-
-        /**
-         * @see _.spread
-         */
-        spread<TResult>(func: (...args: any[]) => TResult, start: number): (...args: any[]) => TResult;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.spread
-         */
-        spread<TResult>(this: LoDashImplicitWrapper<(...args: any[]) => TResult>): LoDashImplicitWrapper<(...args: any[]) => TResult>;
-
-        /**
-         * @see _.spread
-         */
-        spread<TResult>(this: LoDashImplicitWrapper<(...args: any[]) => TResult>, start: number): LoDashImplicitWrapper<(...args: any[]) => TResult>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.spread
-         */
-        spread<TResult>(this: LoDashExplicitWrapper<(...args: any[]) => TResult>): LoDashExplicitWrapper<(...args: any[]) => TResult>;
-
-        /**
-         * @see _.spread
-         */
-        spread<TResult>(this: LoDashExplicitWrapper<(...args: any[]) => TResult>, start: number): LoDashExplicitWrapper<(...args: any[]) => TResult>;
-    }
-}

lodash/function/throttle.d.ts

@@ -1,58 +0,0 @@
-import * as _ from "../index";
-declare module "../index" {
-    interface ThrottleSettings {
-        /**
-         * If you'd like to disable the leading-edge call, pass this as false.
-         */
-        leading?: boolean;
-
-        /**
-         * If you'd like to disable the execution on the trailing-edge, pass false.
-         */
-        trailing?: boolean;
-    }
-
-    interface LoDashStatic {
-        /**
-         * Creates a throttled function that only invokes func at most once per every wait milliseconds. The throttled
-         * function comes with a cancel method to cancel delayed invocations and a flush method to immediately invoke
-         * them. Provide an options object to indicate that func should be invoked on the leading and/or trailing edge
-         * of the wait timeout. Subsequent calls to the throttled function return the result of the last func call.
-         *
-         * Note: If leading and trailing options are true, func is invoked on the trailing edge of the timeout only if
-         * the the throttled function is invoked more than once during the wait timeout.
-         *
-         * @param func The function to throttle.
-         * @param wait The number of milliseconds to throttle invocations to.
-         * @param options The options object.
-         * @param options.leading Specify invoking on the leading edge of the timeout.
-         * @param options.trailing Specify invoking on the trailing edge of the timeout.
-         * @return Returns the new throttled function.
-         */
-        throttle<T extends (...args: any[]) => any>(
-            func: T,
-            wait?: number,
-            options?: ThrottleSettings
-        ): T & Cancelable;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.throttle
-         */
-        throttle(
-            wait?: number,
-            options?: ThrottleSettings
-        ): LoDashImplicitWrapper<TValue & Cancelable>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.throttle
-         */
-        throttle(
-            wait?: number,
-            options?: ThrottleSettings
-        ): LoDashExplicitWrapper<TValue & Cancelable>;
-    }
-}

lodash/function/unary.d.ts

@@ -1,32 +0,0 @@
-import * as _ from "../index";
-declare module "../index" {
-    interface LoDashStatic {
-        /**
-         * Creates a function that accepts up to one argument, ignoring any
-         * additional arguments.
-         *
-         * @category Function
-         * @param func The function to cap arguments for.
-         * @returns Returns the new function.
-         * @example
-         *
-         * _.map(['6', '8', '10'], _.unary(parseInt));
-         * // => [6, 8, 10]
-         */
-        unary<T, TResult>(func: (arg1: T, ...args: any[]) => TResult): (arg1: T) => TResult;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.unary
-         */
-        unary<T, TResult>(this: LoDashImplicitWrapper<(arg1: T, ...args: any[]) => TResult>): LoDashImplicitWrapper<(arg1: T) => TResult>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.unary
-         */
-        unary<T, TResult>(this: LoDashExplicitWrapper<(arg1: T, ...args: any[]) => TResult>): LoDashExplicitWrapper<(arg1: T) => TResult>;
-    }
-}

lodash/function/wrap.d.ts

@@ -1,61 +0,0 @@
-import * as _ from "../index";
-declare module "../index" {
-    interface LoDashStatic {
-        /**
-         * Creates a function that provides value to the wrapper function as its first argument. Any additional
-         * arguments provided to the function are appended to those provided to the wrapper function. The wrapper is
-         * invoked with the this binding of the created function.
-         *
-         * @param value The value to wrap.
-         * @param wrapper The wrapper function.
-         * @return Returns the new function.
-         */
-        wrap<T, TArgs, TResult>(
-            value: T,
-            wrapper: (value: T, ...args: TArgs[]) => TResult
-        ): (...args: TArgs[]) => TResult;
-
-        /**
-         * @see _.wrap
-         */
-        wrap<T, TResult>(
-            value: T,
-            wrapper: (value: T, ...args: any[]) => TResult
-        ): (...args: any[]) => TResult;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.wrap
-         */
-        wrap<TArgs, TResult>(
-            wrapper: (value: TValue, ...args: TArgs[]) => TResult
-        ): LoDashImplicitWrapper<(...args: TArgs[]) => TResult>;
-
-        /**
-         * @see _.wrap
-         */
-        wrap<TResult>(
-            wrapper: (value: TValue, ...args: any[]) => TResult
-        ): LoDashImplicitWrapper<(...args: any[]) => TResult>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.wrap
-         */
-        /**
-         * @see _.wrap
-         */
-        wrap<TArgs, TResult>(
-            wrapper: (value: TValue, ...args: TArgs[]) => TResult
-        ): LoDashExplicitWrapper<(...args: TArgs[]) => TResult>;
-
-        /**
-         * @see _.wrap
-         */
-        wrap<TResult>(
-            wrapper: (value: TValue, ...args: any[]) => TResult
-        ): LoDashExplicitWrapper<(...args: any[]) => TResult>;
-    }
-}

lodash/lang/castArray.d.ts

@@ -1,26 +0,0 @@
-import * as _ from "../index";
-declare module "../index" {
-    interface LoDashStatic {
-        /**
-         * Casts value as an array if it’s not one.
-         *
-         * @param value The value to inspect.
-         * @return Returns the cast array.
-         */
-        castArray<T>(value?: Many<T>): T[];
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.castArray
-         */
-        castArray<T>(this: LoDashImplicitWrapper<Many<T>>): LoDashImplicitWrapper<T[]>;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.castArray
-         */
-        castArray<T>(this: LoDashExplicitWrapper<Many<T>>): LoDashExplicitWrapper<T[]>;
-    }
-}

lodash/lang/clone.d.ts

@@ -1,31 +0,0 @@
-import * as _ from "../index";
-declare module "../index" {
-    interface LoDashStatic {
-        /**
-         * Creates a shallow clone of value.
-         *
-         * Note: This method is loosely based on the structured clone algorithm and supports cloning arrays,
-         * array buffers, booleans, date objects, maps, numbers, Object objects, regexes, sets, strings, symbols,
-         * and typed arrays. The own enumerable properties of arguments objects are cloned as plain objects. An empty
-         * object is returned for uncloneable values such as error objects, functions, DOM nodes, and WeakMaps.
-         *
-         * @param value The value to clone.
-         * @return Returns the cloned value.
-         */
-        clone<T>(value: T): T;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.clone
-         */
-        clone(): TValue;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.clone
-         */
-        clone(): this;
-    }
-}

lodash/lang/cloneDeep.d.ts

@@ -1,26 +0,0 @@
-import * as _ from "../index";
-declare module "../index" {
-    interface LoDashStatic {
-        /**
-         * This method is like _.clone except that it recursively clones value.
-         *
-         * @param value The value to recursively clone.
-         * @return Returns the deep cloned value.
-         */
-        cloneDeep<T>(value: T): T;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.cloneDeep
-         */
-        cloneDeep(): TValue;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.cloneDeep
-         */
-        cloneDeep(): this;
-    }
-}

lodash/lang/cloneDeepWith.d.ts

@@ -1,51 +0,0 @@
-import * as _ from "../index";
-declare module "../index" {
-    type CloneDeepWithCustomizer<TObject> = (value: any, key: number | string | undefined, object: TObject | undefined, stack: any) => any;
-
-    interface LoDashStatic {
-        /**
-         * This method is like _.cloneWith except that it recursively clones value.
-         *
-         * @param value The value to recursively clone.
-         * @param customizer The function to customize cloning.
-         * @return Returns the deep cloned value.
-         */
-        cloneDeepWith<T>(
-            value: T,
-            customizer: CloneDeepWithCustomizer<T>
-        ): any;
-
-        /**
-         * @see _.cloneDeepWith
-         */
-        cloneDeepWith<T>(value: T): T;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.cloneDeepWith
-         */
-        cloneDeepWith(
-            customizer: CloneDeepWithCustomizer<TValue>
-        ): any;
-
-        /**
-         * @see _.cloneDeepWith
-         */
-        cloneDeepWith(): TValue;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.cloneDeepWith
-         */
-        cloneDeepWith(
-            customizer: CloneDeepWithCustomizer<TValue>
-        ): LoDashExplicitWrapper<any>;
-
-        /**
-         * @see _.cloneDeepWith
-         */
-        cloneDeepWith(): this;
-    }
-}

lodash/lang/cloneWith.d.ts

@@ -1,74 +0,0 @@
-import * as _ from "../index";
-declare module "../index" {
-    type CloneWithCustomizer<TValue, TResult> = (value: TValue, key: number | string | undefined, object: any, stack: any) => TResult;
-
-    interface LoDashStatic {
-        /**
-         * This method is like _.clone except that it accepts customizer which is invoked to produce the cloned value.
-         * If customizer returns undefined cloning is handled by the method instead.
-         *
-         * @param value The value to clone.
-         * @param customizer The function to customize cloning.
-         * @return Returns the cloned value.
-         */
-        cloneWith<T, TResult extends object | string | number | boolean | null>(
-            value: T,
-            customizer: CloneWithCustomizer<T, TResult>
-        ): TResult;
-
-        /**
-         * @see _.cloneWith
-         */
-        cloneWith<T, TResult>(
-            value: T,
-            customizer: CloneWithCustomizer<T, TResult | undefined>
-        ): TResult | T;
-
-        /**
-         * @see _.cloneWith
-         */
-        cloneWith<T>(value: T): T;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.cloneWith
-         */
-        cloneWith<TResult extends object | string | number | boolean | null>(
-            customizer: CloneWithCustomizer<TValue, TResult>
-        ): TResult;
-
-        /**
-         * @see _.cloneWith
-         */
-        cloneWith<TResult>(
-            customizer: CloneWithCustomizer<TValue, TResult | undefined>
-        ): TResult | TValue;
-
-        /**
-         * @see _.cloneWith
-         */
-        cloneWith(): TValue;
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.cloneWith
-         */
-        cloneWith<TResult extends object | string | number | boolean | null>(
-            customizer: CloneWithCustomizer<TValue, TResult>
-        ): LoDashExplicitWrapper<TResult>;
-
-        /**
-         * @see _.cloneWith
-         */
-        cloneWith<TResult>(
-            customizer: CloneWithCustomizer<TValue, TResult | undefined>
-        ): LoDashExplicitWrapper<TResult | TValue>;
-
-        /**
-         * @see _.cloneWith
-         */
-        cloneWith(): this;
-    }
-}

lodash/lang/conformsTo.d.ts

@@ -1,31 +0,0 @@
-import * as _ from "../index";
-declare module "../index" {
-
-    interface LoDashStatic {
-        /**
-         * Checks if object conforms to source by invoking the predicate properties of source with the
-         * corresponding property values of object.
-         *
-         * Note: This method is equivalent to _.conforms when source is partially applied.
-         */
-        conformsTo<T>(object: T, source: ConformsPredicateObject<T>): boolean;
-    }
-
-    interface LoDashImplicitWrapper<TValue> {
-        /**
-         * @see _.conformsTo
-         */
-        conformsTo<T>(this: LoDashImplicitWrapper<T>, source: ConformsPredicateObject<T>): boolean;
-        // Note: we can't use TValue here,  because it generates a typescript error when strictFunctionTypes is enabled.
-    }
-
-    interface LoDashExplicitWrapper<TValue> {
-        /**
-         * @see _.conformsTo
-         */
-        conformsTo<T>(this: LoDashImplicitWrapper<T>, source: ConformsPredicateObject<T>): LoDashExplicitWrapper<boolean>;
-        // Note: we can't use TValue here,  because it generates a typescript error when strictFunctionTypes is enabled.
-    }
-
-    type CondPair<T, R> = [(val: T) => boolean, (val: T) => R]
-}