interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.assignInWith
         */
        assignInWith<TSource extends {}, TResult extends {}>(
            source: TSource,
            customizer: AssignCustomizer
        ): LoDashExplicitObjectWrapper<TResult>;

        /**
         * @see assignInWith
         */
        assignInWith<TSource1 extends {}, TSource2 extends {}, TResult extends {}>(
            source1: TSource1,
            source2: TSource2,
            customizer: AssignCustomizer
        ): LoDashExplicitObjectWrapper<TResult>;

        /**
         * @see assignInWith
         */
        assignInWith<TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TResult extends {}>(
            source1: TSource1,
            source2: TSource2,
            source3: TSource3,
            customizer: AssignCustomizer
        ): LoDashExplicitObjectWrapper<TResult>;

        /**
         * @see assignInWith
         */
        assignInWith<TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TSource4 extends {}, TResult extends {}>(
            source1: TSource1,
            source2: TSource2,
            source3: TSource3,
            source4: TSource4,
            customizer: AssignCustomizer
        ): LoDashExplicitObjectWrapper<TResult>;

        /**
         * @see _.assignInWith
         */
        assignInWith(): LoDashExplicitObjectWrapper<T>;

        /**
         * @see _.assignInWith
         */
        assignInWith<TResult extends {}>(...otherArgs: any[]): LoDashExplicitObjectWrapper<TResult>;
    }


//_.create
interface LoDashStatic {
        /**
         * Creates an object that inherits from the given prototype object. If a properties object is provided its own
         * enumerable properties are assigned to the created object.
         *
         * @param prototype The object to inherit from.
         * @param properties The properties to assign to the object.
         * @return Returns the new object.
         */
        create<T extends Object, U extends Object>(
            prototype: T,
            properties?: U
        ): T & U;
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.create
         */
        create<U extends Object>(properties?: U): LoDashImplicitObjectWrapper<T & U>;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.create
         */
        create<U extends Object>(properties?: U): LoDashExplicitObjectWrapper<T & U>;
    }


//_.defaults
interface LoDashStatic {
        /**
         * Assigns own enumerable properties of source object(s) to the destination object for all destination
         * properties that resolve to undefined. Once a property is set, additional values of the same property are
         * ignored.
         *
         * Note: This method mutates object.
         *
         * @param object The destination object.
         * @param sources The source objects.
         * @return The destination object.
         */
        defaults<Obj extends {}, TResult extends {}>(
            object: Obj,
            ...sources: {}[]
        ): TResult;

        /**
         * @see _.defaults
         */
        defaults<Obj extends {}, S1 extends {}, TResult extends {}>(
            object: Obj,
            source1: S1,
            ...sources: {}[]
        ): TResult;

        /**
         * @see _.defaults
         */
        defaults<Obj extends {}, S1 extends {}, S2 extends {}, TResult extends {}>(
            object: Obj,
            source1: S1,
            source2: S2,
            ...sources: {}[]
        ): TResult;

        /**
         * @see _.defaults
         */
        defaults<Obj extends {}, S1 extends {}, S2 extends {}, S3 extends {}, TResult extends {}>(
            object: Obj,
            source1: S1,
            source2: S2,
            source3: S3,
            ...sources: {}[]
        ): TResult;

        /**
         * @see _.defaults
         */
        defaults<Obj extends {}, S1 extends {}, S2 extends {}, S3 extends {}, S4 extends {}, TResult extends {}>(
            object: Obj,
            source1: S1,
            source2: S2,
            source3: S3,
            source4: S4,
            ...sources: {}[]
        ): TResult;

        /**
         * @see _.defaults
         */
        defaults<TResult extends {}>(
            object: {},
            ...sources: {}[]
        ): TResult;
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.defaults
         */
        defaults<S1 extends {}, TResult extends {}>(
            source1: S1,
            ...sources: {}[]
        ): LoDashImplicitObjectWrapper<TResult>;

        /**
         * @see _.defaults
         */
        defaults<S1 extends {}, S2 extends {}, TResult extends {}>(
            source1: S1,
            source2: S2,
            ...sources: {}[]
        ): LoDashImplicitObjectWrapper<TResult>;

        /**
         * @see _.defaults
         */
        defaults<S1 extends {}, S2 extends {}, S3 extends {}, TResult extends {}>(
            source1: S1,
            source2: S2,
            source3: S3,
            ...sources: {}[]
        ): LoDashImplicitObjectWrapper<TResult>;

        /**
         * @see _.defaults
         */
        defaults<S1 extends {}, S2 extends {}, S3 extends {}, S4 extends {}, TResult extends {}>(
            source1: S1,
            source2: S2,
            source3: S3,
            source4: S4,
            ...sources: {}[]
        ): LoDashImplicitObjectWrapper<TResult>;

        /**
         * @see _.defaults
         */
        defaults(): LoDashImplicitObjectWrapper<T>;

        /**
         * @see _.defaults
         */
        defaults<TResult>(...sources: {}[]): LoDashImplicitObjectWrapper<TResult>;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.defaults
         */
        defaults<S1 extends {}, TResult extends {}>(
            source1: S1,
            ...sources: {}[]
        ): LoDashExplicitObjectWrapper<TResult>;

        /**
         * @see _.defaults
         */
        defaults<S1 extends {}, S2 extends {}, TResult extends {}>(
            source1: S1,
            source2: S2,
            ...sources: {}[]
        ): LoDashExplicitObjectWrapper<TResult>;

        /**
         * @see _.defaults
         */
        defaults<S1 extends {}, S2 extends {}, S3 extends {}, TResult extends {}>(
            source1: S1,
            source2: S2,
            source3: S3,
            ...sources: {}[]
        ): LoDashExplicitObjectWrapper<TResult>;

        /**
         * @see _.defaults
         */
        defaults<S1 extends {}, S2 extends {}, S3 extends {}, S4 extends {}, TResult extends {}>(
            source1: S1,
            source2: S2,
            source3: S3,
            source4: S4,
            ...sources: {}[]
        ): LoDashExplicitObjectWrapper<TResult>;

        /**
         * @see _.defaults
         */
        defaults(): LoDashExplicitObjectWrapper<T>;

        /**
         * @see _.defaults
         */
        defaults<TResult>(...sources: {}[]): LoDashExplicitObjectWrapper<TResult>;
    }


//_.defaultsDeep
interface LoDashStatic {
        /**
         * This method is like _.defaults except that it recursively assigns default properties.
         * @param object The destination object.
         * @param sources The source objects.
         * @return Returns object.
         **/
        defaultsDeep<T, TResult>(
            object: T,
            ...sources: any[]): TResult;
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.defaultsDeep
         **/
        defaultsDeep<TResult>(...sources: any[]): LoDashImplicitObjectWrapper<TResult>
    }


//_.extend
interface LoDashStatic {
        /**
         * @see assign
         */
        extend<TObject extends {}, TSource extends {}, TResult extends {}>(
            object: TObject,
            source: TSource,
            customizer?: AssignCustomizer,
            thisArg?: any
        ): TResult;

        /**
         * @see assign
         */
        extend<TObject extends {}, TSource1 extends {}, TSource2 extends {}, TResult extends {}>(
            object: TObject,
            source1: TSource1,
            source2: TSource2,
            customizer?: AssignCustomizer,
            thisArg?: any
        ): TResult;

        /**
         * @see assign
         */
        extend<TObject extends {}, TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TResult extends {}>(
            object: TObject,
            source1: TSource1,
            source2: TSource2,
            source3: TSource3,
            customizer?: AssignCustomizer,
            thisArg?: any
        ): TResult;

        /**
         * @see assign
         */
        extend<TObject extends {}, TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TSource4 extends {},
            TResult extends {}>
            (
                object: TObject,
                source1: TSource1,
                source2: TSource2,
                source3: TSource3,
                source4: TSource4,
                customizer?: AssignCustomizer,
                thisArg?: any
            ): TResult;

        /**
         * @see _.assign
         */
        extend<TObject extends {}>(object: TObject): TObject;

        /**
         * @see _.assign
         */
        extend<TObject extends {}, TResult extends {}>(
            object: TObject, ...otherArgs: any[]
        ): TResult;
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.assign
         */
        extend<TSource extends {}, TResult extends {}>(
            source: TSource,
            customizer?: AssignCustomizer,
            thisArg?: any
        ): LoDashImplicitObjectWrapper<TResult>;

        /**
         * @see assign
         */
        extend<TSource1 extends {}, TSource2 extends {}, TResult extends {}>(
            source1: TSource1,
            source2: TSource2,
            customizer?: AssignCustomizer,
            thisArg?: any
        ): LoDashImplicitObjectWrapper<TResult>;

        /**
         * @see assign
         */
        extend<TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TResult extends {}>(
            source1: TSource1,
            source2: TSource2,
            source3: TSource3,
            customizer?: AssignCustomizer,
            thisArg?: any
        ): LoDashImplicitObjectWrapper<TResult>;

        /**
         * @see assign
         */
        extend<TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TSource4 extends {}, TResult extends {}>(
            source1: TSource1,
            source2: TSource2,
            source3: TSource3,
            source4: TSource4,
            customizer?: AssignCustomizer,
            thisArg?: any
        ): LoDashImplicitObjectWrapper<TResult>;

        /**
         * @see _.assign
         */
        extend(): LoDashImplicitObjectWrapper<T>;

        /**
         * @see _.assign
         */
        extend<TResult extends {}>(...otherArgs: any[]): LoDashImplicitObjectWrapper<TResult>;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.assign
         */
        extend<TSource extends {}, TResult extends {}>(
            source: TSource,
            customizer?: AssignCustomizer,
            thisArg?: any
        ): LoDashExplicitObjectWrapper<TResult>;

        /**
         * @see assign
         */
        extend<TSource1 extends {}, TSource2 extends {}, TResult extends {}>(
            source1: TSource1,
            source2: TSource2,
            customizer?: AssignCustomizer,
            thisArg?: any
        ): LoDashExplicitObjectWrapper<TResult>;

        /**
         * @see assign
         */
        extend<TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TResult extends {}>(
            source1: TSource1,
            source2: TSource2,
            source3: TSource3,
            customizer?: AssignCustomizer,
            thisArg?: any
        ): LoDashExplicitObjectWrapper<TResult>;

        /**
         * @see assign
         */
        extend<TSource1 extends {}, TSource2 extends {}, TSource3 extends {}, TSource4 extends {}, TResult extends {}>(
            source1: TSource1,
            source2: TSource2,
            source3: TSource3,
            source4: TSource4,
            customizer?: AssignCustomizer,
            thisArg?: any
        ): LoDashExplicitObjectWrapper<TResult>;

        /**
         * @see _.assign
         */
        extend(): LoDashExplicitObjectWrapper<T>;

        /**
         * @see _.assign
         */
        extend<TResult extends {}>(...otherArgs: any[]): LoDashExplicitObjectWrapper<TResult>;
    }


//_.findKey
interface LoDashStatic {
        /**
         * This method is like _.find except that it returns the key of the first element predicate returns truthy for
         * instead of the element itself.
         *
         * If a property name is provided for predicate the created _.property style callback returns the property
         * value of the given element.
         *
         * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
         * elements that have a matching property value, else false.
         *
         * If an object is provided for predicate the created _.matches style callback returns true for elements that
         * have the properties of the given object, else false.
         *
         * @param object The object to search.
         * @param predicate The function invoked per iteration.
         * @param thisArg The this binding of predicate.
         * @return Returns the key of the matched element, else undefined.
         */
        findKey<TValues, TObject>(
            object: TObject,
            predicate?: DictionaryIterator<TValues, boolean>,
            thisArg?: any
        ): string;

        /**
         * @see _.findKey
         */
        findKey<TObject>(
            object: TObject,
            predicate?: ObjectIterator<any, boolean>,
            thisArg?: any
        ): string;

        /**
         * @see _.findKey
         */
        findKey<TObject>(
            object: TObject,
            predicate?: string,
            thisArg?: any
        ): string;

        /**
         * @see _.findKey
         */
        findKey<TWhere extends Dictionary<any>, TObject>(
            object: TObject,
            predicate?: TWhere
        ): string;
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.findKey
         */
        findKey<TValues>(
            predicate?: DictionaryIterator<TValues, boolean>,
            thisArg?: any
        ): string;

        /**
         * @see _.findKey
         */
        findKey(
            predicate?: ObjectIterator<any, boolean>,
            thisArg?: any
        ): string;

        /**
         * @see _.findKey
         */
        findKey(
            predicate?: string,
            thisArg?: any
        ): string;

        /**
         * @see _.findKey
         */
        findKey<TWhere extends Dictionary<any>>(
            predicate?: TWhere
        ): string;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.findKey
         */
        findKey<TValues>(
            predicate?: DictionaryIterator<TValues, boolean>,
            thisArg?: any
        ): LoDashExplicitWrapper<string>;

        /**
         * @see _.findKey
         */
        findKey(
            predicate?: ObjectIterator<any, boolean>,
            thisArg?: any
        ): LoDashExplicitWrapper<string>;

        /**
         * @see _.findKey
         */
        findKey(
            predicate?: string,
            thisArg?: any
        ): LoDashExplicitWrapper<string>;

        /**
         * @see _.findKey
         */
        findKey<TWhere extends Dictionary<any>>(
            predicate?: TWhere
        ): LoDashExplicitWrapper<string>;
    }


//_.findLastKey
interface LoDashStatic {
        /**
         * This method is like _.findKey except that it iterates over elements of a collection in the opposite order.
         *
         * If a property name is provided for predicate the created _.property style callback returns the property
         * value of the given element.
         *
         * If a value is also provided for thisArg the created _.matchesProperty style callback returns true for
         * elements that have a matching property value, else false.
         *
         * If an object is provided for predicate the created _.matches style callback returns true for elements that
         * have the properties of the given object, else false.
         *
         * @param object The object to search.
         * @param predicate The function invoked per iteration.
         * @param thisArg The this binding of predicate.
         * @return Returns the key of the matched element, else undefined.
         */
        findLastKey<TValues, TObject>(
            object: TObject,
            predicate?: DictionaryIterator<TValues, boolean>,
            thisArg?: any
        ): string;

        /**
         * @see _.findLastKey
         */
        findLastKey<TObject>(
            object: TObject,
            predicate?: ObjectIterator<any, boolean>,
            thisArg?: any
        ): string;

        /**
         * @see _.findLastKey
         */
        findLastKey<TObject>(
            object: TObject,
            predicate?: string,
            thisArg?: any
        ): string;

        /**
         * @see _.findLastKey
         */
        findLastKey<TWhere extends Dictionary<any>, TObject>(
            object: TObject,
            predicate?: TWhere
        ): string;
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.findLastKey
         */
        findLastKey<TValues>(
            predicate?: DictionaryIterator<TValues, boolean>,
            thisArg?: any
        ): string;

        /**
         * @see _.findLastKey
         */
        findLastKey(
            predicate?: ObjectIterator<any, boolean>,
            thisArg?: any
        ): string;

        /**
         * @see _.findLastKey
         */
        findLastKey(
            predicate?: string,
            thisArg?: any
        ): string;

        /**
         * @see _.findLastKey
         */
        findLastKey<TWhere extends Dictionary<any>>(
            predicate?: TWhere
        ): string;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.findLastKey
         */
        findLastKey<TValues>(
            predicate?: DictionaryIterator<TValues, boolean>,
            thisArg?: any
        ): LoDashExplicitWrapper<string>;

        /**
         * @see _.findLastKey
         */
        findLastKey(
            predicate?: ObjectIterator<any, boolean>,
            thisArg?: any
        ): LoDashExplicitWrapper<string>;

        /**
         * @see _.findLastKey
         */
        findLastKey(
            predicate?: string,
            thisArg?: any
        ): LoDashExplicitWrapper<string>;

        /**
         * @see _.findLastKey
         */
        findLastKey<TWhere extends Dictionary<any>>(
            predicate?: TWhere
        ): LoDashExplicitWrapper<string>;
    }


//_.forIn
interface LoDashStatic {
        /**
         * Iterates over own and inherited enumerable properties of an object invoking iteratee for each property. The
         * iteratee is bound to thisArg and invoked with three arguments: (value, key, object). Iteratee functions may
         * exit iteration early by explicitly returning false.
         *
         * @param object The object to iterate over.
         * @param iteratee The function invoked per iteration.
         * @param thisArg The this binding of iteratee.
         * @return Returns object.
         */
        forIn<T>(
            object: Dictionary<T>,
            iteratee?: DictionaryIterator<T, any>,
            thisArg?: any
        ): Dictionary<T>;

        /**
         * @see _.forIn
         */
        forIn<T extends {}>(
            object: T,
            iteratee?: ObjectIterator<any, any>,
            thisArg?: any
        ): T;
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.forIn
         */
        forIn<TValue>(
            iteratee?: DictionaryIterator<TValue, any>,
            thisArg?: any
        ): _.LoDashImplicitObjectWrapper<T>;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.forIn
         */
        forIn<TValue>(
            iteratee?: DictionaryIterator<TValue, any>,
            thisArg?: any
        ): _.LoDashExplicitObjectWrapper<T>;
    }


//_.forInRight
interface LoDashStatic {
        /**
         * This method is like _.forIn except that it iterates over properties of object in the opposite order.
         *
         * @param object The object to iterate over.
         * @param iteratee The function invoked per iteration.
         * @param thisArg The this binding of iteratee.
         * @return Returns object.
         */
        forInRight<T>(
            object: Dictionary<T>,
            iteratee?: DictionaryIterator<T, any>,
            thisArg?: any
        ): Dictionary<T>;

        /**
         * @see _.forInRight
         */
        forInRight<T extends {}>(
            object: T,
            iteratee?: ObjectIterator<any, any>,
            thisArg?: any
        ): T;
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.forInRight
         */
        forInRight<TValue>(
            iteratee?: DictionaryIterator<TValue, any>,
            thisArg?: any
        ): _.LoDashImplicitObjectWrapper<T>;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.forInRight
         */
        forInRight<TValue>(
            iteratee?: DictionaryIterator<TValue, any>,
            thisArg?: any
        ): _.LoDashExplicitObjectWrapper<T>;
    }


//_.forOwn
interface LoDashStatic {
        /**
         * Iterates over own enumerable properties of an object invoking iteratee for each property. The iteratee is
         * bound to thisArg and invoked with three arguments: (value, key, object). Iteratee functions may exit
         * iteration early by explicitly returning false.
         *
         * @param object The object to iterate over.
         * @param iteratee The function invoked per iteration.
         * @param thisArg The this binding of iteratee.
         * @return Returns object.
         */
        forOwn<T>(
            object: Dictionary<T>,
            iteratee?: DictionaryIterator<T, any>,
            thisArg?: any
        ): Dictionary<T>;

        /**
         * @see _.forOwn
         */
        forOwn<T extends {}>(
            object: T,
            iteratee?: ObjectIterator<any, any>,
            thisArg?: any
        ): T;
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.forOwn
         */
        forOwn<TValue>(
            iteratee?: DictionaryIterator<TValue, any>,
            thisArg?: any
        ): _.LoDashImplicitObjectWrapper<T>;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.forOwn
         */
        forOwn<TValue>(
            iteratee?: DictionaryIterator<TValue, any>,
            thisArg?: any
        ): _.LoDashExplicitObjectWrapper<T>;
    }


//_.forOwnRight
interface LoDashStatic {
        /**
         * This method is like _.forOwn except that it iterates over properties of object in the opposite order.
         *
         * @param object The object to iterate over.
         * @param iteratee The function invoked per iteration.
         * @param thisArg The this binding of iteratee.
         * @return Returns object.
         */
        forOwnRight<T>(
            object: Dictionary<T>,
            iteratee?: DictionaryIterator<T, any>,
            thisArg?: any
        ): Dictionary<T>;

        /**
         * @see _.forOwnRight
         */
        forOwnRight<T extends {}>(
            object: T,
            iteratee?: ObjectIterator<any, any>,
            thisArg?: any
        ): T;
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.forOwnRight
         */
        forOwnRight<TValue>(
            iteratee?: DictionaryIterator<TValue, any>,
            thisArg?: any
        ): _.LoDashImplicitObjectWrapper<T>;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.forOwnRight
         */
        forOwnRight<TValue>(
            iteratee?: DictionaryIterator<TValue, any>,
            thisArg?: any
        ): _.LoDashExplicitObjectWrapper<T>;
    }


//_.functions
interface LoDashStatic {
        /**
         * Creates an array of function property names from own enumerable properties
         * of `object`.
         *
         * @static
         * @memberOf _
         * @category Object
         * @param {Object} object The object to inspect.
         * @returns {Array} Returns the new array of property names.
         * @example
         *
         * function Foo() {
         *   this.a = _.constant('a');
         *   this.b = _.constant('b');
         * }
         *
         * Foo.prototype.c = _.constant('c');
         *
         * _.functions(new Foo);
         * // => ['a', 'b']
         */
        functions<T extends {}>(object: any): string[];
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.functions
         */
        functions(): _.LoDashImplicitArrayWrapper<string>;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.functions
         */
        functions(): _.LoDashExplicitArrayWrapper<string>;
    }


//_.functionsIn
interface LoDashStatic {
        /**
         * Creates an array of function property names from own and inherited
         * enumerable properties of `object`.
         *
         * @static
         * @memberOf _
         * @category Object
         * @param {Object} object The object to inspect.
         * @returns {Array} Returns the new array of property names.
         * @example
         *
         * function Foo() {
         *   this.a = _.constant('a');
         *   this.b = _.constant('b');
         * }
         *
         * Foo.prototype.c = _.constant('c');
         *
         * _.functionsIn(new Foo);
         * // => ['a', 'b', 'c']
         */
        functionsIn<T extends {}>(object: any): string[];
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.functionsIn
         */
        functionsIn(): _.LoDashImplicitArrayWrapper<string>;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.functionsIn
         */
        functionsIn(): _.LoDashExplicitArrayWrapper<string>;
    }


//_.get
interface LoDashStatic {
        /**
         * Gets the property value at path of object. If the resolved value is undefined the defaultValue is used
         * in its place.
         *
         * @param object The object to query.
         * @param path The path of the property to get.
         * @param defaultValue The value returned if the resolved value is undefined.
         * @return Returns the resolved value.
         */
        get<TObject, TResult>(
            object: TObject,
            path: StringRepresentable|StringRepresentable[],
            defaultValue?: TResult
        ): TResult;

        /**
         * @see _.get
         */
        get<TResult>(
            object: any,
            path: StringRepresentable|StringRepresentable[],
            defaultValue?: TResult
        ): TResult;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.get
         */
        get<TResult>(
            path: StringRepresentable|StringRepresentable[],
            defaultValue?: TResult
        ): TResult;
    }


interface LoDashImplicitArrayWrapper<T> {
        /**
         * @see _.get
         */
        get<TResult>(
            path: StringRepresentable|StringRepresentable[],
            defaultValue?: TResult
        ): TResult;
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.get
         */
        get<TResult>(
            path: StringRepresentable|StringRepresentable[],
            defaultValue?: TResult
        ): TResult;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.get
         */
        get<TResultWrapper>(
            path: StringRepresentable|StringRepresentable[],
            defaultValue?: any
        ): TResultWrapper;
    }


interface LoDashExplicitArrayWrapper<T> {
        /**
         * @see _.get
         */
        get<TResultWrapper>(
            path: StringRepresentable|StringRepresentable[],
            defaultValue?: any
        ): TResultWrapper;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.get
         */
        get<TResultWrapper>(
            path: StringRepresentable|StringRepresentable[],
            defaultValue?: any
        ): TResultWrapper;
    }


//_.has
interface LoDashStatic {
        /**
         * Checks if `path` is a direct property of `object`.
         *
         * @static
         * @memberOf _
         * @category Object
         * @param {Object} object The object to query.
         * @param {Array|string} path The path to check.
         * @returns {boolean} Returns `true` if `path` exists, else `false`.
         * @example
         *
         * var object = { 'a': { 'b': { 'c': 3 } } };
         * var other = _.create({ 'a': _.create({ 'b': _.create({ 'c': 3 }) }) });
         *
         * _.has(object, 'a');
         * // => true
         *
         * _.has(object, 'a.b.c');
         * // => true
         *
         * _.has(object, ['a', 'b', 'c']);
         * // => true
         *
         * _.has(other, 'a');
         * // => false
         */
        has<T extends {}>(
            object: T,
            path: StringRepresentable|StringRepresentable[]
        ): boolean;
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.has
         */
        has(path: StringRepresentable|StringRepresentable[]): boolean;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.has
         */
        has(path: StringRepresentable|StringRepresentable[]): LoDashExplicitWrapper<boolean>;
    }


//_.hasIn
interface LoDashStatic {
        /**
         * Checks if `path` is a direct or inherited property of `object`.
         *
         * @static
         * @memberOf _
         * @category Object
         * @param {Object} object The object to query.
         * @param {Array|string} path The path to check.
         * @returns {boolean} Returns `true` if `path` exists, else `false`.
         * @example
         *
         * var object = _.create({ 'a': _.create({ 'b': _.create({ 'c': 3 }) }) });
         *
         * _.hasIn(object, 'a');
         * // => true
         *
         * _.hasIn(object, 'a.b.c');
         * // => true
         *
         * _.hasIn(object, ['a', 'b', 'c']);
         * // => true
         *
         * _.hasIn(object, 'b');
         * // => false
         */
        hasIn<T extends {}>(
            object: T,
            path: StringRepresentable|StringRepresentable[]
        ): boolean;
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.hasIn
         */
        hasIn(path: StringRepresentable|StringRepresentable[]): boolean;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.hasIn
         */
        hasIn(path: StringRepresentable|StringRepresentable[]): LoDashExplicitWrapper<boolean>;
    }


//_.invert
interface LoDashStatic {
        /**
         * Creates an object composed of the inverted keys and values of object. If object contains duplicate values,
         * subsequent values overwrite property assignments of previous values unless multiValue is true.
         *
         * @param object The object to invert.
         * @param multiValue Allow multiple values per key.
         * @return Returns the new inverted object.
         */
        invert<T extends {}, TResult extends {}>(
            object: T,
            multiValue?: boolean
        ): TResult;

        /**
         * @see _.invert
         */
        invert<TResult extends {}>(
            object: Object,
            multiValue?: boolean
        ): TResult;
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.invert
         */
        invert<TResult extends {}>(multiValue?: boolean): LoDashImplicitObjectWrapper<TResult>;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.invert
         */
        invert<TResult extends {}>(multiValue?: boolean): LoDashExplicitObjectWrapper<TResult>;
    }


//_.inverBy
interface InvertByIterator<T> {
        (value: T): any;
    }


interface LoDashStatic {
        /**
         * This method is like _.invert except that the inverted object is generated from the results of running each
         * element of object through iteratee. The corresponding inverted value of each inverted key is an array of
         * keys responsible for generating the inverted value. The iteratee is invoked with one argument: (value).
         *
         * @param object The object to invert.
         * @param interatee The iteratee invoked per element.
         * @return Returns the new inverted object.
         */
        invertBy(
            object: Object,
            interatee?: InvertByIterator<any>|string
        ): Dictionary<string[]>;

        /**
         * @see _.invertBy
         */
        invertBy<T>(
            object: _.Dictionary<T>|_.NumericDictionary<T>,
            interatee?: InvertByIterator<T>|string
        ): Dictionary<string[]>;

        /**
         * @see _.invertBy
         */
        invertBy<W>(
            object: Object,
            interatee?: W
        ): Dictionary<string[]>;

        /**
         * @see _.invertBy
         */
        invertBy<T, W>(
            object: _.Dictionary<T>,
            interatee?: W
        ): Dictionary<string[]>;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.invertBy
         */
        invertBy(
            interatee?: InvertByIterator<any>
        ): LoDashImplicitObjectWrapper<Dictionary<string[]>>;
    }


interface LoDashImplicitArrayWrapper<T> {
        /**
         * @see _.invertBy
         */
        invertBy(
            interatee?: InvertByIterator<T>|string
        ): LoDashImplicitObjectWrapper<Dictionary<string[]>>;

        /**
         * @see _.invertBy
         */
        invertBy<W>(
            interatee?: W
        ): LoDashImplicitObjectWrapper<Dictionary<string[]>>;
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.invertBy
         */
        invertBy(
            interatee?: InvertByIterator<any>|string
        ): LoDashImplicitObjectWrapper<Dictionary<string[]>>;

        /**
         * @see _.invertBy
         */
        invertBy<W>(
            interatee?: W
        ): LoDashImplicitObjectWrapper<Dictionary<string[]>>;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.invertBy
         */
        invertBy(
            interatee?: InvertByIterator<any>
        ): LoDashExplicitObjectWrapper<Dictionary<string[]>>;
    }


interface LoDashExplicitArrayWrapper<T> {
        /**
         * @see _.invertBy
         */
        invertBy(
            interatee?: InvertByIterator<T>|string
        ): LoDashExplicitObjectWrapper<Dictionary<string[]>>;

        /**
         * @see _.invertBy
         */
        invertBy<W>(
            interatee?: W
        ): LoDashExplicitObjectWrapper<Dictionary<string[]>>;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.invertBy
         */
        invertBy(
            interatee?: InvertByIterator<any>|string
        ): LoDashExplicitObjectWrapper<Dictionary<string[]>>;

        /**
         * @see _.invertBy
         */
        invertBy<W>(
            interatee?: W
        ): LoDashExplicitObjectWrapper<Dictionary<string[]>>;
    }


//_.keys
interface LoDashStatic {
        /**
         * Creates an array of the own enumerable property names of object.
         *
         * Note: Non-object values are coerced to objects. See the ES spec for more details.
         *
         * @param object The object to query.
         * @return Returns the array of property names.
         */
        keys(object?: any): string[];
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.keys
         */
        keys(): LoDashImplicitArrayWrapper<string>;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.keys
         */
        keys(): LoDashExplicitArrayWrapper<string>;
    }


//_.keysIn
interface LoDashStatic {
        /**
         * Creates an array of the own and inherited enumerable property names of object.
         *
         * Note: Non-object values are coerced to objects.
         *
         * @param object The object to query.
         * @return An array of property names.
         */
        keysIn(object?: any): string[];
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.keysIn
         */
        keysIn(): LoDashImplicitArrayWrapper<string>;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.keysIn
         */
        keysIn(): LoDashExplicitArrayWrapper<string>;
    }


//_.mapKeys
interface LoDashStatic {
        /**
         * The opposite of _.mapValues; this method creates an object with the same values as object and keys generated
         * by running each own enumerable property of object through iteratee.
         *
         * @param object The object to iterate over.
         * @param iteratee The function invoked per iteration.
         * @param thisArg The this binding of iteratee.
         * @return Returns the new mapped object.
         */
        mapKeys<T, TKey>(
            object: List<T>,
            iteratee?: ListIterator<T, TKey>,
            thisArg?: any
        ): Dictionary<T>;

        /**
         * @see _.mapKeys
         */
        mapKeys<T, TKey>(
            object: Dictionary<T>,
            iteratee?: DictionaryIterator<T, TKey>,
            thisArg?: any
        ): Dictionary<T>;

        /**
         * @see _.mapKeys
         */
        mapKeys<T, TObject extends {}>(
            object: List<T>|Dictionary<T>,
            iteratee?: TObject
        ): Dictionary<T>;

        /**
         * @see _.mapKeys
         */
        mapKeys<T>(
            object: List<T>|Dictionary<T>,
            iteratee?: string,
            thisArg?: any
        ): Dictionary<T>;
    }


interface LoDashImplicitArrayWrapper<T> {
        /**
         * @see _.mapKeys
         */
        mapKeys<TKey>(
            iteratee?: ListIterator<T, TKey>,
            thisArg?: any
        ): LoDashImplicitObjectWrapper<Dictionary<T>>;

        /**
         * @see _.mapKeys
         */
        mapKeys<TObject extends {}>(
            iteratee?: TObject
        ): LoDashImplicitObjectWrapper<Dictionary<T>>;

        /**
         * @see _.mapKeys
         */
        mapKeys(
            iteratee?: string,
            thisArg?: any
        ): LoDashImplicitObjectWrapper<Dictionary<T>>;
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.mapKeys
         */
        mapKeys<TResult, TKey>(
            iteratee?: ListIterator<TResult, TKey>|DictionaryIterator<TResult, TKey>,
            thisArg?: any
        ): LoDashImplicitObjectWrapper<Dictionary<TResult>>;

        /**
         * @see _.mapKeys
         */
        mapKeys<TResult, TObject extends {}>(
            iteratee?: TObject
        ): LoDashImplicitObjectWrapper<Dictionary<TResult>>;

        /**
         * @see _.mapKeys
         */
        mapKeys<TResult>(
            iteratee?: string,
            thisArg?: any
        ): LoDashImplicitObjectWrapper<Dictionary<TResult>>;
    }


interface LoDashExplicitArrayWrapper<T> {
        /**
         * @see _.mapKeys
         */
        mapKeys<TKey>(
            iteratee?: ListIterator<T, TKey>,
            thisArg?: any
        ): LoDashExplicitObjectWrapper<Dictionary<T>>;

        /**
         * @see _.mapKeys
         */
        mapKeys<TObject extends {}>(
            iteratee?: TObject
        ): LoDashExplicitObjectWrapper<Dictionary<T>>;

        /**
         * @see _.mapKeys
         */
        mapKeys(
            iteratee?: string,
            thisArg?: any
        ): LoDashExplicitObjectWrapper<Dictionary<T>>;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.mapKeys
         */
        mapKeys<TResult, TKey>(
            iteratee?: ListIterator<TResult, TKey>|DictionaryIterator<TResult, TKey>,
            thisArg?: any
        ): LoDashExplicitObjectWrapper<Dictionary<TResult>>;

        /**
         * @see _.mapKeys
         */
        mapKeys<TResult, TObject extends {}>(
            iteratee?: TObject
        ): LoDashExplicitObjectWrapper<Dictionary<TResult>>;

        /**
         * @see _.mapKeys
         */
        mapKeys<TResult>(
            iteratee?: string,
            thisArg?: any
        ): LoDashExplicitObjectWrapper<Dictionary<TResult>>;
    }


//_.mapValues
interface LoDashStatic {
        /**
        * Creates an object with the same keys as object and values generated by running each own
        * enumerable property of object through iteratee. The iteratee function is bound to thisArg
        * and invoked with three arguments: (value, key, object).
        *
        * If a property name is provided iteratee the created "_.property" style callback returns
        * the property value of the given element.
        *
        * If a value is also provided for thisArg the creted "_.matchesProperty" style callback returns
        * true for elements that have a matching property value, else false;.
        *
        * If an object is provided for iteratee the created "_.matches" style callback returns true
        * for elements that have the properties of the given object, else false.
        *
        * @param {Object} object The object to iterate over.
        * @param {Function|Object|string} [iteratee=_.identity]  The function invoked per iteration.
        * @param {Object} [thisArg] The `this` binding of `iteratee`.
        * @return {Object} Returns the new mapped object.
        */
        mapValues<T, TResult>(obj: Dictionary<T>, callback: ObjectIterator<T, TResult>, thisArg?: any): Dictionary<TResult>;
        mapValues<T>(obj: Dictionary<T>, where: Dictionary<T>): Dictionary<boolean>;
        mapValues<T, TMapped>(obj: T, pluck: string): TMapped;
        mapValues<T>(obj: T, callback: ObjectIterator<any, any>, thisArg?: any): T;
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.mapValues
         * TValue is the type of the property values of T.
         * TResult is the type output by the ObjectIterator function
         */
        mapValues<TValue, TResult>(callback: ObjectIterator<TValue, TResult>, thisArg?: any): LoDashImplicitObjectWrapper<Dictionary<TResult>>;

        /**
         * @see _.mapValues
         * TResult is the type of the property specified by pluck.
         * T should be a Dictionary<Dictionary<TResult>>
         */
        mapValues<TResult>(pluck: string): LoDashImplicitObjectWrapper<Dictionary<TResult>>;

        /**
         * @see _.mapValues
         * TResult is the type of the properties on the object specified by pluck.
         * T should be a Dictionary<Dictionary<Dictionary<TResult>>>
         */
        mapValues<TResult>(pluck: string, where: Dictionary<TResult>): LoDashImplicitArrayWrapper<Dictionary<boolean>>;

        /**
         * @see _.mapValues
         * TResult is the type of the properties of each object in the values of T
         * T should be a Dictionary<Dictionary<TResult>>
         */
        mapValues<TResult>(where: Dictionary<TResult>): LoDashImplicitArrayWrapper<boolean>;
    }


//_.merge
interface LoDashStatic {
        /**
         * Recursively merges own and inherited enumerable properties of source
         * objects into the destination object, skipping source properties that resolve
         * to `undefined`. Array and plain object properties are merged recursively.
         * Other objects and value types are overridden by assignment. Source objects
         * are applied from left to right. Subsequent sources overwrite property
         * assignments of previous sources.
         *
         * **Note:** This method mutates `object`.
         *
         * @static
         * @memberOf _
         * @category Object
         * @param {Object} object The destination object.
         * @param {...Object} [sources] The source objects.
         * @returns {Object} Returns `object`.
         * @example
         *
         * var users = {
         *   'data': [{ 'user': 'barney' }, { 'user': 'fred' }]
         * };
         *
         * var ages = {
         *   'data': [{ 'age': 36 }, { 'age': 40 }]
         * };
         *
         * _.merge(users, ages);
         * // => { 'data': [{ 'user': 'barney', 'age': 36 }, { 'user': 'fred', 'age': 40 }] }
         */
        merge<TObject, TSource>(
            object: TObject,
            source: TSource
        ): TObject & TSource;

        /**
         * @see _.merge
         */
        merge<TObject, TSource1, TSource2>(
            object: TObject,
            source1: TSource1,
            source2: TSource2
        ): TObject & TSource1 & TSource2;

        /**
         * @see _.merge
         */
        merge<TObject, TSource1, TSource2, TSource3>(
            object: TObject,
            source1: TSource1,
            source2: TSource2,
            source3: TSource3
        ): TObject & TSource1 & TSource2 & TSource3;

        /**
         * @see _.merge
         */
        merge<TObject, TSource1, TSource2, TSource3, TSource4>(
            object: TObject,
            source1: TSource1,
            source2: TSource2,
            source3: TSource3,
            source4: TSource4
        ): TObject & TSource1 & TSource2 & TSource3 & TSource4;

        /**
         * @see _.merge
         */
        merge<TResult>(
            object: any,
            ...otherArgs: any[]
        ): TResult;
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.merge
         */
        merge<TSource>(
            source: TSource
        ): LoDashImplicitObjectWrapper<T & TSource>;

        /**
         * @see _.merge
         */
        merge<TSource1, TSource2>(
            source1: TSource1,
            source2: TSource2
        ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2>;

        /**
         * @see _.merge
         */
        merge<TSource1, TSource2, TSource3>(
            source1: TSource1,
            source2: TSource2,
            source3: TSource3
        ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>;

        /**
         * @see _.merge
         */
        merge<TSource1, TSource2, TSource3, TSource4>(
            source1: TSource1,
            source2: TSource2,
            source3: TSource3,
            source4: TSource4
        ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>;

        /**
         * @see _.merge
         */
        merge<TResult>(
            ...otherArgs: any[]
        ): LoDashImplicitObjectWrapper<TResult>;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.merge
         */
        merge<TSource>(
            source: TSource
        ): LoDashExplicitObjectWrapper<T & TSource>;

        /**
         * @see _.merge
         */
        merge<TSource1, TSource2>(
            source1: TSource1,
            source2: TSource2
        ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2>;

        /**
         * @see _.merge
         */
        merge<TSource1, TSource2, TSource3>(
            source1: TSource1,
            source2: TSource2,
            source3: TSource3
        ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>;

        /**
         * @see _.merge
         */
        merge<TSource1, TSource2, TSource3, TSource4>(
        ): LoDashExplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>;

        /**
         * @see _.merge
         */
        merge<TResult>(
            ...otherArgs: any[]
        ): LoDashExplicitObjectWrapper<TResult>;
    }


//_.mergeWith
interface MergeWithCustomizer {
        (value: any, srcValue: any, key?: string, object?: Object, source?: Object): any;
    }


interface LoDashStatic {
        /**
         * This method is like `_.merge` except that it accepts `customizer` which
         * is invoked to produce the merged values of the destination and source
         * properties. If `customizer` returns `undefined` merging is handled by the
         * method instead. The `customizer` is invoked with seven arguments:
         * (objValue, srcValue, key, object, source, stack).
         *
         * @static
         * @memberOf _
         * @category Object
         * @param {Object} object The destination object.
         * @param {...Object} sources The source objects.
         * @param {Function} customizer The function to customize assigned values.
         * @returns {Object} Returns `object`.
         * @example
         *
         * function customizer(objValue, srcValue) {
         *   if (_.isArray(objValue)) {
         *     return objValue.concat(srcValue);
         *   }
         * }
         *
         * var object = {
         *   'fruits': ['apple'],
         *   'vegetables': ['beet']
         * };
         *
         * var other = {
         *   'fruits': ['banana'],
         *   'vegetables': ['carrot']
         * };
         *
         * _.merge(object, other, customizer);
         * // => { 'fruits': ['apple', 'banana'], 'vegetables': ['beet', 'carrot'] }
         */
        mergeWith<TObject, TSource>(
            object: TObject,
            source: TSource,
            customizer: MergeWithCustomizer
        ): TObject & TSource;

        /**
         * @see _.mergeWith
         */
        mergeWith<TObject, TSource1, TSource2>(
            object: TObject,
            source1: TSource1,
            source2: TSource2,
            customizer: MergeWithCustomizer
        ): TObject & TSource1 & TSource2;

        /**
         * @see _.mergeWith
         */
        mergeWith<TObject, TSource1, TSource2, TSource3>(
            object: TObject,
            source1: TSource1,
            source2: TSource2,
            source3: TSource3,
            customizer: MergeWithCustomizer
        ): TObject & TSource1 & TSource2 & TSource3;

        /**
         * @see _.mergeWith
         */
        mergeWith<TObject, TSource1, TSource2, TSource3, TSource4>(
            object: TObject,
            source1: TSource1,
            source2: TSource2,
            source3: TSource3,
            source4: TSource4,
            customizer: MergeWithCustomizer
        ): TObject & TSource1 & TSource2 & TSource3 & TSource4;

        /**
         * @see _.mergeWith
         */
        mergeWith<TResult>(
            object: any,
            ...otherArgs: any[]
        ): TResult;
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.mergeWith
         */
        mergeWith<TSource>(
            source: TSource,
            customizer: MergeWithCustomizer
        ): LoDashImplicitObjectWrapper<T & TSource>;

        /**
         * @see _.mergeWith
         */
        mergeWith<TSource1, TSource2>(
            source1: TSource1,
            source2: TSource2,
            customizer: MergeWithCustomizer
        ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2>;

        /**
         * @see _.mergeWith
         */
        mergeWith<TSource1, TSource2, TSource3>(
            source1: TSource1,
            source2: TSource2,
            source3: TSource3,
            customizer: MergeWithCustomizer
        ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3>;

        /**
         * @see _.mergeWith
         */
        mergeWith<TSource1, TSource2, TSource3, TSource4>(
            source1: TSource1,
            source2: TSource2,
            source3: TSource3,
            source4: TSource4,
            customizer: MergeWithCustomizer
        ): LoDashImplicitObjectWrapper<T & TSource1 & TSource2 & TSource3 & TSource4>;

        /**
         * @see _.mergeWith
         */
        mergeWith<TResult>(
            ...otherArgs: any[]
        ): LoDashImplicitObjectWrapper<TResult>;
    }


//_.omit
interface LoDashStatic {
        /**
         * The opposite of `_.pick`; this method creates an object composed of the
         * own and inherited enumerable properties of `object` that are not omitted.
         *
         * @static
         * @memberOf _
         * @category Object
         * @param {Object} object The source object.
         * @param {...(string|string[])} [props] The property names to omit, specified
         *  individually or in arrays..
         * @returns {Object} Returns the new object.
         * @example
         *
         * var object = { 'a': 1, 'b': '2', 'c': 3 };
         *
         * _.omit(object, ['a', 'c']);
         * // => { 'b': '2' }
         */

        omit<TResult extends {}, T extends {}>(
            object: T,
            ...predicate: (StringRepresentable|StringRepresentable[])[]
        ): TResult;
    }


interface LoDashImplicitObjectWrapper<T> {

        /**
         * @see _.omit
         */
        omit<TResult extends {}>(
            ...predicate: (StringRepresentable|StringRepresentable[])[]
        ): LoDashImplicitObjectWrapper<TResult>;
    }


interface LoDashExplicitObjectWrapper<T> {

        /**
         * @see _.omit
         */
        omit<TResult extends {}>(
            ...predicate: (StringRepresentable|StringRepresentable[])[]
        ): LoDashExplicitObjectWrapper<TResult>;
    }


//_.omitBy
interface LoDashStatic {
        /**
         * The opposite of `_.pickBy`; this method creates an object composed of the
         * own and inherited enumerable properties of `object` that `predicate`
         * doesn't return truthy for.
         *
         * @static
         * @memberOf _
         * @category Object
         * @param {Object} object The source object.
         * @param {Function|Object|string} [predicate=_.identity] The function invoked per property.
         * @returns {Object} Returns the new object.
         * @example
         *
         * var object = { 'a': 1, 'b': '2', 'c': 3 };
         *
         * _.omitBy(object, _.isNumber);
         * // => { 'b': '2' }
         */
        omitBy<TResult extends {}, T extends {}>(
            object: T,
            predicate: ObjectIterator<any, boolean>
        ): TResult;
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.omitBy
         */
        omitBy<TResult extends {}>(
            predicate: ObjectIterator<any, boolean>
        ): LoDashImplicitObjectWrapper<TResult>;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.omitBy
         */
        omitBy<TResult extends {}>(
            predicate: ObjectIterator<any, boolean>
        ): LoDashExplicitObjectWrapper<TResult>;
    }


//_.pick
interface LoDashStatic {
        /**
         * Creates an object composed of the picked `object` properties.
         *
         * @static
         * @memberOf _
         * @category Object
         * @param {Object} object The source object.
         * @param {...(string|string[])} [props] The property names to pick, specified
         *  individually or in arrays.
         * @returns {Object} Returns the new object.
         * @example
         *
         * var object = { 'a': 1, 'b': '2', 'c': 3 };
         *
         * _.pick(object, ['a', 'c']);
         * // => { 'a': 1, 'c': 3 }
         */
        pick<TResult extends {}, T extends {}>(
            object: T,
            ...predicate: (StringRepresentable|StringRepresentable[])[]
        ): TResult;
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.pick
         */
        pick<TResult extends {}>(
            ...predicate: (StringRepresentable|StringRepresentable[])[]
        ): LoDashImplicitObjectWrapper<TResult>;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.pick
         */
        pick<TResult extends {}>(
            ...predicate: (StringRepresentable|StringRepresentable[])[]
        ): LoDashExplicitObjectWrapper<TResult>;
    }


//_.pickBy
interface LoDashStatic {
        /**
         * Creates an object composed of the `object` properties `predicate` returns
         * truthy for. The predicate is invoked with one argument: (value).
         *
         * @static
         * @memberOf _
         * @category Object
         * @param {Object} object The source object.
         * @param {Function|Object|string} [predicate=_.identity] The function invoked per property.
         * @returns {Object} Returns the new object.
         * @example
         *
         * var object = { 'a': 1, 'b': '2', 'c': 3 };
         *
         * _.pickBy(object, _.isNumber);
         * // => { 'a': 1, 'c': 3 }
         */
        pickBy<TResult extends {}, T extends {}>(
            object: T,
            predicate: ObjectIterator<any, boolean>
        ): TResult;
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.pickBy
         */
        pickBy<TResult extends {}>(
            predicate: ObjectIterator<any, boolean>
        ): LoDashImplicitObjectWrapper<TResult>;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.pickBy
         */
        pickBy<TResult extends {}>(
            predicate: ObjectIterator<any, boolean>
        ): LoDashExplicitObjectWrapper<TResult>;
    }


//_.result
interface LoDashStatic {
        /**
         * This method is like _.get except that if the resolved value is a function it’s invoked with the this binding
         * of its parent object and its result is returned.
         *
         * @param object The object to query.
         * @param path The path of the property to resolve.
         * @param defaultValue The value returned if the resolved value is undefined.
         * @return Returns the resolved value.
         */
        result<TObject, TResult>(
            object: TObject,
            path: StringRepresentable|StringRepresentable[],
            defaultValue?: TResult|((...args: any[]) => TResult)
        ): TResult;

        /**
         * @see _.result
         */
        result<TResult>(
            object: any,
            path: StringRepresentable|StringRepresentable[],
            defaultValue?: TResult|((...args: any[]) => TResult)
        ): TResult;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.result
         */
        result<TResult>(
            path: StringRepresentable|StringRepresentable[],
            defaultValue?: TResult|((...args: any[]) => TResult)
        ): TResult;
    }


interface LoDashImplicitArrayWrapper<T> {
        /**
         * @see _.result
         */
        result<TResult>(
            path: StringRepresentable|StringRepresentable[],
            defaultValue?: TResult|((...args: any[]) => TResult)
        ): TResult;
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.result
         */
        result<TResult>(
            path: StringRepresentable|StringRepresentable[],
            defaultValue?: TResult|((...args: any[]) => TResult)
        ): TResult;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.result
         */
        result<TResultWrapper>(
            path: StringRepresentable|StringRepresentable[],
            defaultValue?: any
        ): TResultWrapper;
    }


interface LoDashExplicitArrayWrapper<T> {
        /**
         * @see _.result
         */
        result<TResultWrapper>(
            path: StringRepresentable|StringRepresentable[],
            defaultValue?: any
        ): TResultWrapper;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.result
         */
        result<TResultWrapper>(
            path: StringRepresentable|StringRepresentable[],
            defaultValue?: any
        ): TResultWrapper;
    }


//_.set
interface LoDashStatic {
        /**
         * Sets the value at path of object. If a portion of path doesn’t exist it’s created. Arrays are created for
         * missing index properties while objects are created for all other missing properties. Use _.setWith to
         * customize path creation.
         *
         * @param object The object to modify.
         * @param path The path of the property to set.
         * @param value The value to set.
         * @return Returns object.
         */
        set<TResult>(
            object: Object,
            path: StringRepresentable|StringRepresentable[],
            value: any
        ): TResult;

        /**
         * @see _.set
         */
        set<V, TResult>(
            object: Object,
            path: StringRepresentable|StringRepresentable[],
            value: V
        ): TResult;

        /**
         * @see _.set
         */
        set<O, V, TResult>(
            object: O,
            path: StringRepresentable|StringRepresentable[],
            value: V
        ): TResult;
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.set
         */
        set<TResult>(
            path: StringRepresentable|StringRepresentable[],
            value: any
        ): LoDashImplicitObjectWrapper<TResult>;

        /**
         * @see _.set
         */
        set<V, TResult>(
            path: StringRepresentable|StringRepresentable[],
            value: V
        ): LoDashImplicitObjectWrapper<TResult>;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.set
         */
        set<TResult>(
            path: StringRepresentable|StringRepresentable[],
            value: any
        ): LoDashExplicitObjectWrapper<TResult>;

        /**
         * @see _.set
         */
        set<V, TResult>(
            path: StringRepresentable|StringRepresentable[],
            value: V
        ): LoDashExplicitObjectWrapper<TResult>;
    }


//_.setWith
interface SetWithCustomizer<T> {
        (nsValue: any, key: string, nsObject: T): any;
    }


interface LoDashStatic {
        /**
         * This method is like _.set except that it accepts customizer which is invoked to produce the objects of
         * path. If customizer returns undefined path creation is handled by the method instead. The customizer is
         * invoked with three arguments: (nsValue, key, nsObject).
         *
         * @param object The object to modify.
         * @param path The path of the property to set.
         * @param value The value to set.
         * @parem customizer The function to customize assigned values.
         * @return Returns object.
         */
        setWith<TResult>(
            object: Object,
            path: StringRepresentable|StringRepresentable[],
            value: any,
            customizer?: SetWithCustomizer<Object>
        ): TResult;

        /**
         * @see _.setWith
         */
        setWith<V, TResult>(
            object: Object,
            path: StringRepresentable|StringRepresentable[],
            value: V,
            customizer?: SetWithCustomizer<Object>
        ): TResult;

        /**
         * @see _.setWith
         */
        setWith<O, V, TResult>(
            object: O,
            path: StringRepresentable|StringRepresentable[],
            value: V,
            customizer?: SetWithCustomizer<O>
        ): TResult;
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.setWith
         */
        setWith<TResult>(
            path: StringRepresentable|StringRepresentable[],
            value: any,
            customizer?: SetWithCustomizer<T>
        ): LoDashImplicitObjectWrapper<TResult>;

        /**
         * @see _.setWith
         */
        setWith<V, TResult>(
            path: StringRepresentable|StringRepresentable[],
            value: V,
            customizer?: SetWithCustomizer<T>
        ): LoDashImplicitObjectWrapper<TResult>;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.setWith
         */
        setWith<TResult>(
            path: StringRepresentable|StringRepresentable[],
            value: any,
            customizer?: SetWithCustomizer<T>
        ): LoDashExplicitObjectWrapper<TResult>;

        /**
         * @see _.setWith
         */
        setWith<V, TResult>(
            path: StringRepresentable|StringRepresentable[],
            value: V,
            customizer?: SetWithCustomizer<T>
        ): LoDashExplicitObjectWrapper<TResult>;
    }


//_.toPairs
interface LoDashStatic {
        /**
         * Creates an array of own enumerable key-value pairs for object.
         *
         * @param object The object to query.
         * @return Returns the new array of key-value pairs.
         */
        toPairs<T extends {}>(object?: T): any[][];

        toPairs<T extends {}, TResult>(object?: T): TResult[][];
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.toPairs
         */
        toPairs<TResult>(): LoDashImplicitArrayWrapper<TResult[]>;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.toPairs
         */
        toPairs<TResult>(): LoDashExplicitArrayWrapper<TResult[]>;
    }


//_.toPairsIn
interface LoDashStatic {
        /**
         * Creates an array of own and inherited enumerable key-value pairs for object.
         *
         * @param object The object to query.
         * @return Returns the new array of key-value pairs.
         */
        toPairsIn<T extends {}>(object?: T): any[][];

        toPairsIn<T extends {}, TResult>(object?: T): TResult[][];
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.toPairsIn
         */
        toPairsIn<TResult>(): LoDashImplicitArrayWrapper<TResult[]>;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.toPairsIn
         */
        toPairsIn<TResult>(): LoDashExplicitArrayWrapper<TResult[]>;
    }


//_.transform
interface LoDashStatic {
        /**
         * An alternative to _.reduce; this method transforms object to a new accumulator object which is the result of
         * running each of its own enumerable properties through iteratee, with each invocation potentially mutating
         * the accumulator object. The iteratee is bound to thisArg and invoked with four arguments: (accumulator,
         * value, key, object). Iteratee functions may exit iteration early by explicitly returning false.
         *
         * @param object The object to iterate over.
         * @param iteratee The function invoked per iteration.
         * @param accumulator The custom accumulator value.
         * @param thisArg The this binding of iteratee.
         * @return Returns the accumulated value.
         */
        transform<T, TResult>(
            object: T[],
            iteratee?: MemoVoidArrayIterator<T, TResult[]>,
            accumulator?: TResult[],
            thisArg?: any
        ): TResult[];

        /**
         * @see _.transform
         */
        transform<T, TResult>(
            object: T[],
            iteratee?: MemoVoidArrayIterator<T, Dictionary<TResult>>,
            accumulator?: Dictionary<TResult>,
            thisArg?: any
        ): Dictionary<TResult>;

        /**
         * @see _.transform
         */
        transform<T, TResult>(
            object: Dictionary<T>,
            iteratee?: MemoVoidDictionaryIterator<T, Dictionary<TResult>>,
            accumulator?: Dictionary<TResult>,
            thisArg?: any
        ): Dictionary<TResult>;

        /**
         * @see _.transform
         */
        transform<T, TResult>(
            object: Dictionary<T>,
            iteratee?: MemoVoidDictionaryIterator<T, TResult[]>,
            accumulator?: TResult[],
            thisArg?: any
        ): TResult[];
    }


interface LoDashImplicitArrayWrapper<T> {
        /**
         * @see _.transform
         */
        transform<TResult>(
            iteratee?: MemoVoidArrayIterator<T, TResult[]>,
            accumulator?: TResult[],
            thisArg?: any
        ): LoDashImplicitArrayWrapper<TResult>;

        /**
         * @see _.transform
         */
        transform<TResult>(
            iteratee?: MemoVoidArrayIterator<T, Dictionary<TResult>>,
            accumulator?: Dictionary<TResult>,
            thisArg?: any
        ): LoDashImplicitObjectWrapper<Dictionary<TResult>>;
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.transform
         */
        transform<T, TResult>(
            iteratee?: MemoVoidDictionaryIterator<T, Dictionary<TResult>>,
            accumulator?: Dictionary<TResult>,
            thisArg?: any
        ): LoDashImplicitObjectWrapper<Dictionary<TResult>>;

        /**
         * @see _.transform
         */
        transform<T, TResult>(
            iteratee?: MemoVoidDictionaryIterator<T, TResult[]>,
            accumulator?: TResult[],
            thisArg?: any
        ): LoDashImplicitArrayWrapper<TResult>;
    }


//_.unset
interface LoDashStatic {
        /**
         * Removes the property at path of object.
         *
         * Note: This method mutates object.
         *
         * @param object The object to modify.
         * @param path The path of the property to unset.
         * @return Returns true if the property is deleted, else false.
         */
        unset<T>(
            object: T,
            path: StringRepresentable|StringRepresentable[]
        ): boolean;
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.unset
         */
        unset(path: StringRepresentable|StringRepresentable[]): LoDashImplicitWrapper<boolean>;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.unset
         */
        unset(path: StringRepresentable|StringRepresentable[]): LoDashExplicitWrapper<boolean>;
    }


//_.update
interface LoDashStatic {
        /**
         * This method is like _.set except that accepts updater to produce the value to set. Use _.updateWith to
         * customize path creation. The updater is invoked with one argument: (value).
         *
         * @param object The object to modify.
         * @param path The path of the property to set.
         * @param updater The function to produce the updated value.
         * @return Returns object.
         */
        update<TResult>(
            object: Object,
            path: StringRepresentable|StringRepresentable[],
            updater: Function
        ): TResult;

        /**
         * @see _.update
         */
        update<U extends Function, TResult>(
            object: Object,
            path: StringRepresentable|StringRepresentable[],
            updater: U
        ): TResult;

        /**
         * @see _.update
         */
        update<O extends {}, TResult>(
            object: O,
            path: StringRepresentable|StringRepresentable[],
            updater: Function
        ): TResult;

        /**
         * @see _.update
         */
        update<O, U extends Function, TResult>(
            object: O,
            path: StringRepresentable|StringRepresentable[],
            updater: U
        ): TResult;
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.update
         */
        update<TResult>(
            path: StringRepresentable|StringRepresentable[],
            updater: any
        ): LoDashImplicitObjectWrapper<TResult>;

        /**
         * @see _.update
         */
        update<U extends Function, TResult>(
            path: StringRepresentable|StringRepresentable[],
            updater: U
        ): LoDashImplicitObjectWrapper<TResult>;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.update
         */
        update<TResult>(
            path: StringRepresentable|StringRepresentable[],
            updater: any
        ): LoDashExplicitObjectWrapper<TResult>;

        /**
         * @see _.update
         */
        update<U extends Function, TResult>(
            path: StringRepresentable|StringRepresentable[],
            updater: U
        ): LoDashExplicitObjectWrapper<TResult>;
    }


//_.values
interface LoDashStatic {
        /**
         * Creates an array of the own enumerable property values of object.
         *
         * @param object The object to query.
         * @return Returns an array of property values.
         */
        values<T>(object?: any): T[];
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.values
         */
        values<T>(): LoDashImplicitArrayWrapper<T>;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.values
         */
        values<T>(): LoDashExplicitArrayWrapper<T>;
    }


//_.valuesIn
interface LoDashStatic {
        /**
         * Creates an array of the own and inherited enumerable property values of object.
         *
         * @param object The object to query.
         * @return Returns the array of property values.
         */
        valuesIn<T>(object?: any): T[];
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.valuesIn
         */
        valuesIn<T>(): LoDashImplicitArrayWrapper<T>;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.valuesIn
         */
        valuesIn<T>(): LoDashExplicitArrayWrapper<T>;
    }


/**********
     * String *
     **********/
//_.camelCase
interface LoDashStatic {
        /**
         * Converts string to camel case.
         *
         * @param string The string to convert.
         * @return Returns the camel cased string.
         */
        camelCase(string?: string): string;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.camelCase
         */
        camelCase(): string;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.camelCase
         */
        camelCase(): LoDashExplicitWrapper<string>;
    }


//_.capitalize
interface LoDashStatic {
        /**
         * Converts the first character of string to upper case and the remaining to lower case.
         *
         * @param string The string to capitalize.
         * @return Returns the capitalized string.
         */
        capitalize(string?: string): string;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.capitalize
         */
        capitalize(): string;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.capitalize
         */
        capitalize(): LoDashExplicitWrapper<string>;
    }


//_.deburr
interface LoDashStatic {
        /**
         * Deburrs string by converting latin-1 supplementary letters to basic latin letters and removing combining
         * diacritical marks.
         *
         * @param string The string to deburr.
         * @return Returns the deburred string.
         */
        deburr(string?: string): string;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.deburr
         */
        deburr(): string;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.deburr
         */
        deburr(): LoDashExplicitWrapper<string>;
    }


//_.endsWith
interface LoDashStatic {
        /**
         * Checks if string ends with the given target string.
         *
         * @param string The string to search.
         * @param target The string to search for.
         * @param position The position to search from.
         * @return Returns true if string ends with target, else false.
         */
        endsWith(
            string?: string,
            target?: string,
            position?: number
        ): boolean;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.endsWith
         */
        endsWith(
            target?: string,
            position?: number
        ): boolean;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.endsWith
         */
        endsWith(
            target?: string,
            position?: number
        ): LoDashExplicitWrapper<boolean>;
    }


// _.escape
interface LoDashStatic {
        /**
         * Converts the characters "&", "<", ">", '"', "'", and "`" in string to their corresponding HTML entities.
         *
         * Note: No other characters are escaped. To escape additional characters use a third-party library like he.
         *
         * hough the ">" character is escaped for symmetry, characters like ">" and "/" don’t need escaping in HTML
         * and have no special meaning unless they're part of a tag or unquoted attribute value. See Mathias Bynens’s
         * article (under "semi-related fun fact") for more details.
         *
         * Backticks are escaped because in IE < 9, they can break out of attribute values or HTML comments. See #59,
         * #102, #108, and #133 of the HTML5 Security Cheatsheet for more details.
         *
         * When working with HTML you should always quote attribute values to reduce XSS vectors.
         *
         * @param string The string to escape.
         * @return Returns the escaped string.
         */
        escape(string?: string): string;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.escape
         */
        escape(): string;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.escape
         */
        escape(): LoDashExplicitWrapper<string>;
    }


// _.escapeRegExp
interface LoDashStatic {
        /**
         * Escapes the RegExp special characters "^", "$", "\", ".", "*", "+", "?", "(", ")", "[", "]",
         * "{", "}", and "|" in string.
         *
         * @param string The string to escape.
         * @return Returns the escaped string.
         */
        escapeRegExp(string?: string): string;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.escapeRegExp
         */
        escapeRegExp(): string;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.escapeRegExp
         */
        escapeRegExp(): LoDashExplicitWrapper<string>;
    }


//_.kebabCase
interface LoDashStatic {
        /**
         * Converts string to kebab case.
         *
         * @param string The string to convert.
         * @return Returns the kebab cased string.
         */
        kebabCase(string?: string): string;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.kebabCase
         */
        kebabCase(): string;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.kebabCase
         */
        kebabCase(): LoDashExplicitWrapper<string>;
    }


//_.lowerCase
interface LoDashStatic {
        /**
         * Converts `string`, as space separated words, to lower case.
         *
         * @param string The string to convert.
         * @return Returns the lower cased string.
         */
        lowerCase(string?: string): string;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.lowerCase
         */
        lowerCase(): string;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.lowerCase
         */
        lowerCase(): LoDashExplicitWrapper<string>;
    }


//_.lowerFirst
interface LoDashStatic {
        /**
         * Converts the first character of `string` to lower case.
         *
         * @param string The string to convert.
         * @return Returns the converted string.
         */
        lowerFirst(string?: string): string;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.lowerFirst
         */
        lowerFirst(): string;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.lowerFirst
         */
        lowerFirst(): LoDashExplicitWrapper<string>;
    }


//_.pad
interface LoDashStatic {
        /**
         * Pads string on the left and right sides if it’s shorter than length. Padding characters are truncated if
         * they can’t be evenly divided by length.
         *
         * @param string The string to pad.
         * @param length The padding length.
         * @param chars The string used as padding.
         * @return Returns the padded string.
         */
        pad(
            string?: string,
            length?: number,
            chars?: string
        ): string;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.pad
         */
        pad(
            length?: number,
            chars?: string
        ): string;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.pad
         */
        pad(
            length?: number,
            chars?: string
        ): LoDashExplicitWrapper<string>;
    }


//_.padEnd
interface LoDashStatic {
        /**
         * Pads string on the right side if it’s shorter than length. Padding characters are truncated if they exceed
         * length.
         *
         * @param string The string to pad.
         * @param length The padding length.
         * @param chars The string used as padding.
         * @return Returns the padded string.
         */
        padEnd(
            string?: string,
            length?: number,
            chars?: string
        ): string;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.padEnd
         */
        padEnd(
            length?: number,
            chars?: string
        ): string;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.padEnd
         */
        padEnd(
            length?: number,
            chars?: string
        ): LoDashExplicitWrapper<string>;
    }


//_.padStart
interface LoDashStatic {
        /**
         * Pads string on the left side if it’s shorter than length. Padding characters are truncated if they exceed
         * length.
         *
         * @param string The string to pad.
         * @param length The padding length.
         * @param chars The string used as padding.
         * @return Returns the padded string.
         */
        padStart(
            string?: string,
            length?: number,
            chars?: string
        ): string;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.padStart
         */
        padStart(
            length?: number,
            chars?: string
        ): string;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.padStart
         */
        padStart(
            length?: number,
            chars?: string
        ): LoDashExplicitWrapper<string>;
    }


//_.parseInt
interface LoDashStatic {
        /**
         * Converts string to an integer of the specified radix. If radix is undefined or 0, a radix of 10 is used
         * unless value is a hexadecimal, in which case a radix of 16 is used.
         *
         * Note: This method aligns with the ES5 implementation of parseInt.
         *
         * @param string The string to convert.
         * @param radix The radix to interpret value by.
         * @return Returns the converted integer.
         */
        parseInt(
            string: string,
            radix?: number
        ): number;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.parseInt
         */
        parseInt(radix?: number): number;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.parseInt
         */
        parseInt(radix?: number): LoDashExplicitWrapper<number>;
    }


//_.repeat
interface LoDashStatic {
        /**
         * Repeats the given string n times.
         *
         * @param string The string to repeat.
         * @param n The number of times to repeat the string.
         * @return Returns the repeated string.
         */
        repeat(
            string?: string,
            n?: number
        ): string;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.repeat
         */
        repeat(n?: number): string;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.repeat
         */
        repeat(n?: number): LoDashExplicitWrapper<string>;
    }


//_.replace
interface LoDashStatic {
        /**
         * Replaces matches for pattern in string with replacement.
         *
         * Note: This method is based on String#replace.
         *
         * @param string
         * @param pattern
         * @param replacement
         * @return Returns the modified string.
         */
        replace(
            string: string,
            pattern: RegExp|string,
            replacement: Function|string
        ): string;

        /**
         * @see _.replace
         */
        replace(
            pattern?: RegExp|string,
            replacement?: Function|string
        ): string;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.replace
         */
        replace(
            pattern?: RegExp|string,
            replacement?: Function|string
        ): string;

        /**
         * @see _.replace
         */
        replace(
            replacement?: Function|string
        ): string;
    }


interface LoDashImplicitObjectWrapper<T> {
        /**
         * @see _.replace
         */
        replace(
            pattern?: RegExp|string,
            replacement?: Function|string
        ): string;

        /**
         * @see _.replace
         */
        replace(
            replacement?: Function|string
        ): string;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.replace
         */
        replace(
            pattern?: RegExp|string,
            replacement?: Function|string
        ): LoDashExplicitWrapper<string>;

        /**
         * @see _.replace
         */
        replace(
            replacement?: Function|string
        ): LoDashExplicitWrapper<string>;
    }


interface LoDashExplicitObjectWrapper<T> {
        /**
         * @see _.replace
         */
        replace(
            pattern?: RegExp|string,
            replacement?: Function|string
        ): LoDashExplicitWrapper<string>;

        /**
         * @see _.replace
         */
        replace(
            replacement?: Function|string
        ): LoDashExplicitWrapper<string>;
    }


//_.snakeCase
interface LoDashStatic {
        /**
         * Converts string to snake case.
         *
         * @param string The string to convert.
         * @return Returns the snake cased string.
         */
        snakeCase(string?: string): string;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.snakeCase
         */
        snakeCase(): string;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.snakeCase
         */
        snakeCase(): LoDashExplicitWrapper<string>;
    }


//_.split
interface LoDashStatic {
        /**
         * Splits string by separator.
         *
         * Note: This method is based on String#split.
         *
         * @param string
         * @param separator
         * @param limit
         * @return Returns the new array of string segments.
         */
        split(
            string: string,
            separator?: RegExp|string,
            limit?: number
        ): string[];
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.split
         */
        split(
            separator?: RegExp|string,
            limit?: number
        ): LoDashImplicitArrayWrapper<string>;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.split
         */
        split(
            separator?: RegExp|string,
            limit?: number
        ): LoDashExplicitArrayWrapper<string>;
    }


//_.startCase
interface LoDashStatic {
        /**
         * Converts string to start case.
         *
         * @param string The string to convert.
         * @return Returns the start cased string.
         */
        startCase(string?: string): string;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.startCase
         */
        startCase(): string;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.startCase
         */
        startCase(): LoDashExplicitWrapper<string>;
    }


//_.startsWith
interface LoDashStatic {
        /**
         * Checks if string starts with the given target string.
         *
         * @param string The string to search.
         * @param target The string to search for.
         * @param position The position to search from.
         * @return Returns true if string starts with target, else false.
         */
        startsWith(
            string?: string,
            target?: string,
            position?: number
        ): boolean;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.startsWith
         */
        startsWith(
            target?: string,
            position?: number
        ): boolean;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.startsWith
         */
        startsWith(
            target?: string,
            position?: number
        ): LoDashExplicitWrapper<boolean>;
    }


//_.template
interface TemplateOptions extends TemplateSettings {
        /**
         * The sourceURL of the template's compiled source.
         */
        sourceURL?: string;
    }


interface TemplateExecutor {
        (data?: Object): string;
        source: string;
    }


interface LoDashStatic {
        /**
         * Creates a compiled template function that can interpolate data properties in "interpolate" delimiters,
         * HTML-escape interpolated data properties in "escape" delimiters, and execute JavaScript in "evaluate"
         * delimiters. Data properties may be accessed as free variables in the template. If a setting object is
         * provided it takes precedence over _.templateSettings values.
         *
         * Note: In the development build _.template utilizes
         * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl) for easier
         * debugging.
         *
         * For more information on precompiling templates see
         * [lodash's custom builds documentation](https://lodash.com/custom-builds).
         *
         * For more information on Chrome extension sandboxes see
         * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval).
         *
         * @param string The template string.
         * @param options The options object.
         * @param options.escape The HTML "escape" delimiter.
         * @param options.evaluate The "evaluate" delimiter.
         * @param options.imports An object to import into the template as free variables.
         * @param options.interpolate The "interpolate" delimiter.
         * @param options.sourceURL The sourceURL of the template's compiled source.
         * @param options.variable The data object variable name.
         * @return Returns the compiled template function.
         */
        template(
            string: string,
            options?: TemplateOptions
        ): TemplateExecutor;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.template
         */
        template(options?: TemplateOptions): TemplateExecutor;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.template
         */
        template(options?: TemplateOptions): LoDashExplicitObjectWrapper<TemplateExecutor>;
    }


//_.toLower
interface LoDashStatic {
        /**
         * Converts `string`, as a whole, to lower case.
         *
         * @param string The string to convert.
         * @return Returns the lower cased string.
         */
        toLower(string?: string): string;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.toLower
         */
        toLower(): string;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.toLower
         */
        toLower(): LoDashExplicitWrapper<string>;
    }


//_.toUpper
interface LoDashStatic {
        /**
         * Converts `string`, as a whole, to upper case.
         *
         * @param string The string to convert.
         * @return Returns the upper cased string.
         */
        toUpper(string?: string): string;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.toUpper
         */
        toUpper(): string;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.toUpper
         */
        toUpper(): LoDashExplicitWrapper<string>;
    }


//_.trim
interface LoDashStatic {
        /**
         * Removes leading and trailing whitespace or specified characters from string.
         *
         * @param string The string to trim.
         * @param chars The characters to trim.
         * @return Returns the trimmed string.
         */
        trim(
            string?: string,
            chars?: string
        ): string;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.trim
         */
        trim(chars?: string): string;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.trim
         */
        trim(chars?: string): LoDashExplicitWrapper<string>;
    }


//_.trimEnd
interface LoDashStatic {
        /**
         * Removes trailing whitespace or specified characters from string.
         *
         * @param string The string to trim.
         * @param chars The characters to trim.
         * @return Returns the trimmed string.
         */
        trimEnd(
            string?: string,
            chars?: string
        ): string;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.trimEnd
         */
        trimEnd(chars?: string): string;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.trimEnd
         */
        trimEnd(chars?: string): LoDashExplicitWrapper<string>;
    }


//_.trimStart
interface LoDashStatic {
        /**
         * Removes leading whitespace or specified characters from string.
         *
         * @param string The string to trim.
         * @param chars The characters to trim.
         * @return Returns the trimmed string.
         */
        trimStart(
            string?: string,
            chars?: string
        ): string;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.trimStart
         */
        trimStart(chars?: string): string;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.trimStart
         */
        trimStart(chars?: string): LoDashExplicitWrapper<string>;
    }


//_.truncate
interface TruncateOptions {
        /** The maximum string length. */
        length?: number;
        /** The string to indicate text is omitted. */
        omission?: string;
        /** The separator pattern to truncate to. */
        separator?: string|RegExp;
    }


interface LoDashStatic {
        /**
         * Truncates string if it’s longer than the given maximum string length. The last characters of the truncated
         * string are replaced with the omission string which defaults to "…".
         *
         * @param string The string to truncate.
         * @param options The options object or maximum string length.
         * @return Returns the truncated string.
         */
        truncate(
            string?: string,
            options?: TruncateOptions
        ): string;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.truncate
         */
        truncate(options?: TruncateOptions): string;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.truncate
         */
        truncate(options?: TruncateOptions): LoDashExplicitWrapper<string>;
    }


//_.unescape
interface LoDashStatic {
        /**
         * The inverse of _.escape; this method converts the HTML entities &, <, >, ", ', and `
         * in string to their corresponding characters.
         *
         * Note: No other HTML entities are unescaped. To unescape additional HTML entities use a third-party library
         * like he.
         *
         * @param string The string to unescape.
         * @return Returns the unescaped string.
         */
        unescape(string?: string): string;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.unescape
         */
        unescape(): string;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.unescape
         */
        unescape(): LoDashExplicitWrapper<string>;
    }


//_.upperCase
interface LoDashStatic {
        /**
         * Converts `string`, as space separated words, to upper case.
         *
         * @param string The string to convert.
         * @return Returns the upper cased string.
         */
        upperCase(string?: string): string;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.upperCase
         */
        upperCase(): string;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.upperCase
         */
        upperCase(): LoDashExplicitWrapper<string>;
    }


//_.upperFirst
interface LoDashStatic {
        /**
         * Converts the first character of `string` to upper case.
         *
         * @param string The string to convert.
         * @return Returns the converted string.
         */
        upperFirst(string?: string): string;
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.upperFirst
         */
        upperFirst(): string;
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.upperFirst
         */
        upperFirst(): LoDashExplicitWrapper<string>;
    }


//_.words
interface LoDashStatic {
        /**
         * Splits `string` into an array of its words.
         *
         * @param string The string to inspect.
         * @param pattern The pattern to match words.
         * @return Returns the words of `string`.
         */
        words(
            string?: string,
            pattern?: string|RegExp
        ): string[];
    }


interface LoDashImplicitWrapper<T> {
        /**
         * @see _.words
         */
        words(pattern?: string|RegExp): string[];
    }


interface LoDashExplicitWrapper<T> {
        /**
         * @see _.words
         */
        words(pattern?: string|RegExp): LoDashExplicitArrayWrapper<string>;
    }


/***********
     * Utility *
     ***********/
//_.attempt
interface LoDashStatic {
        /**
         * Attempts to invoke func, returning either the result or the caught error object. Any additional arguments
         * are provided to func when it’s invoked.
         *
         * @param func The function to attempt.
         * @return Returns the func result or error object.
         */
        attempt<TResult>(func: (...args: any[]) => TResult, ...args: any[]): TResult|Error;
    }