diff --git a/lodash/lodash-tests.ts b/lodash/lodash-tests.ts
index 1c385f976..f49180a80 100644
--- a/lodash/lodash-tests.ts
+++ b/lodash/lodash-tests.ts
@@ -1671,37 +1671,329 @@ module TestUnion {
     }
 }
 
-result = <number[]>_.uniq([1, 2, 1, 3, 1]);
-result = <number[]>_.uniq([1, 1, 2, 2, 3], true);
-result = <string[]>_.uniq(['A', 'b', 'C', 'a', 'B', 'c'], function (letter) {
-    return letter.toLowerCase();
-});
-result = <number[]>_.uniq([1, 2.5, 3, 1.5, 2, 3.5], function (num) { return this.floor(num); }, Math);
-result = <{ x: number; }[]>_.uniq([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
+// _.uniq
+module TestUniq {
+    type SampleObject = {a: number; b: string; c: boolean};
 
-result = <number[]>_.unique([1, 2, 1, 3, 1]);
-result = <number[]>_.unique([1, 1, 2, 2, 3], true);
-result = <string[]>_.unique(['A', 'b', 'C', 'a', 'B', 'c'], function (letter) {
-    return letter.toLowerCase();
-});
-result = <number[]>_.unique([1, 2.5, 3, 1.5, 2, 3.5], function (num) { return this.floor(num); }, Math);
-result = <{ x: number; }[]>_.unique([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
+    let array: SampleObject[];
+    let list: _.List<SampleObject>;
 
-result = <number[]>_([1, 2, 1, 3, 1]).uniq().value();
-result = <number[]>_([1, 1, 2, 2, 3]).uniq(true).value();
-result = <string[]>_(['A', 'b', 'C', 'a', 'B', 'c']).uniq(function (letter) {
-    return letter.toLowerCase();
-}).value();
-result = <number[]>_([1, 2.5, 3, 1.5, 2, 3.5]).uniq(function (num) { return this.floor(num); }, Math).value();
-result = <{ x: number; }[]>_([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }]).uniq('x').value();
+    let stringIterator: (value: string, index: number, collection: string) => string;
+    let listIterator: (value: SampleObject, index: number, collection: _.List<SampleObject>) => number;
 
-result = <number[]>_([1, 2, 1, 3, 1]).unique().value();
-result = <number[]>_([1, 1, 2, 2, 3]).unique(true).value();
-result = <string[]>_(['A', 'b', 'C', 'a', 'B', 'c']).unique(function (letter) {
-    return letter.toLowerCase();
-}).value();
-result = <number[]>_([1, 2.5, 3, 1.5, 2, 3.5]).unique(function (num) { return this.floor(num); }, Math).value();
-result = <{ x: number; }[]>_([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }]).unique('x').value();
+    {
+        let result: string[];
+
+        result = _.uniq<string>('abc');
+        result = _.uniq<string>('abc', true);
+        result = _.uniq<string>('abc', true, stringIterator);
+        result = _.uniq<string>('abc', true, stringIterator, any);
+        result = _.uniq<string, string>('abc', true, stringIterator);
+        result = _.uniq<string, string>('abc', true, stringIterator, any);
+        result = _.uniq<string>('abc', stringIterator);
+        result = _.uniq<string>('abc', stringIterator, any);
+        result = _.uniq<string, string>('abc', stringIterator);
+        result = _.uniq<string, string>('abc', stringIterator, any);
+    }
+
+    {
+        let result: SampleObject[];
+
+        result = _.uniq<SampleObject>(array);
+        result = _.uniq<SampleObject>(array, true);
+        result = _.uniq<SampleObject>(array, true, listIterator);
+        result = _.uniq<SampleObject>(array, true, listIterator, any);
+        result = _.uniq<SampleObject, number>(array, true, listIterator);
+        result = _.uniq<SampleObject, number>(array, true, listIterator, any);
+        result = _.uniq<SampleObject>(array, listIterator);
+        result = _.uniq<SampleObject>(array, listIterator, any);
+        result = _.uniq<SampleObject, number>(array, listIterator);
+        result = _.uniq<SampleObject, number>(array, listIterator, any);
+        result = _.uniq<SampleObject>(array, true, 'a');
+        result = _.uniq<SampleObject>(array, true, 'a', any);
+        result = _.uniq<SampleObject>(array, 'a');
+        result = _.uniq<SampleObject>(array, 'a', any);
+        result = _.uniq<SampleObject>(array, true, {a: 42});
+        result = _.uniq<{a: number}, SampleObject>(array, true, {a: 42});
+        result = _.uniq<SampleObject>(array, {a: 42});
+        result = _.uniq<{a: number}, SampleObject>(array, {a: 42});
+
+        result = _.uniq<SampleObject>(list);
+        result = _.uniq<SampleObject>(list, true);
+        result = _.uniq<SampleObject>(list, true, listIterator);
+        result = _.uniq<SampleObject>(list, true, listIterator, any);
+        result = _.uniq<SampleObject, number>(list, true, listIterator);
+        result = _.uniq<SampleObject, number>(list, true, listIterator, any);
+        result = _.uniq<SampleObject>(list, listIterator);
+        result = _.uniq<SampleObject>(list, listIterator, any);
+        result = _.uniq<SampleObject, number>(list, listIterator);
+        result = _.uniq<SampleObject, number>(list, listIterator, any);
+        result = _.uniq<SampleObject>(list, true, 'a');
+        result = _.uniq<SampleObject>(list, true, 'a', any);
+        result = _.uniq<SampleObject>(list, 'a');
+        result = _.uniq<SampleObject>(list, 'a', any);
+        result = _.uniq<SampleObject>(list, true, {a: 42});
+        result = _.uniq<{a: number}, SampleObject>(list, true, {a: 42});
+        result = _.uniq<SampleObject>(list, {a: 42});
+        result = _.uniq<{a: number}, SampleObject>(list, {a: 42});
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<string>;
+
+        result = _('abc').uniq();
+        result = _('abc').uniq(true);
+        result = _('abc').uniq<string>(true, stringIterator);
+        result = _('abc').uniq<string>(true, stringIterator, any);
+        result = _('abc').uniq<string>(stringIterator);
+        result = _('abc').uniq<string>(stringIterator, any);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<SampleObject>;
+
+        result = _(array).uniq();
+        result = _(array).uniq(true);
+        result = _(array).uniq<number>(true, listIterator);
+        result = _(array).uniq<number>(true, listIterator, any);
+        result = _(array).uniq<number>(listIterator);
+        result = _(array).uniq<number>(listIterator, any);
+        result = _(array).uniq(true, 'a');
+        result = _(array).uniq(true, 'a', any);
+        result = _(array).uniq('a');
+        result = _(array).uniq('a', any);
+        result = _(array).uniq<{a: number}>(true, {a: 42});
+        result = _(array).uniq<{a: number}>({a: 42});
+
+        result = _(list).uniq<SampleObject>();
+        result = _(list).uniq<SampleObject>(true);
+        result = _(list).uniq<SampleObject>(true, listIterator);
+        result = _(list).uniq<SampleObject>(true, listIterator, any);
+        result = _(list).uniq<SampleObject, number>(true, listIterator);
+        result = _(list).uniq<SampleObject, number>(true, listIterator, any);
+        result = _(list).uniq<SampleObject>(listIterator);
+        result = _(list).uniq<SampleObject>(listIterator, any);
+        result = _(list).uniq<SampleObject, number>(listIterator);
+        result = _(list).uniq<SampleObject, number>(listIterator, any);
+        result = _(list).uniq<SampleObject>(true, 'a');
+        result = _(list).uniq<SampleObject>(true, 'a', any);
+        result = _(list).uniq<SampleObject>('a');
+        result = _(list).uniq<SampleObject>('a', any);
+        result = _(list).uniq<SampleObject>(true, {a: 42});
+        result = _(list).uniq<{a: number}, SampleObject>(true, {a: 42});
+        result = _(list).uniq<SampleObject>({a: 42});
+        result = _(list).uniq<{a: number}, SampleObject>({a: 42});
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<string>;
+
+        result = _('abc').chain().uniq();
+        result = _('abc').chain().uniq(true);
+        result = _('abc').chain().uniq<string>(true, stringIterator);
+        result = _('abc').chain().uniq<string>(true, stringIterator, any);
+        result = _('abc').chain().uniq<string>(stringIterator);
+        result = _('abc').chain().uniq<string>(stringIterator, any);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<SampleObject>;
+
+        result = _(array).chain().uniq();
+        result = _(array).chain().uniq(true);
+        result = _(array).chain().uniq<number>(true, listIterator);
+        result = _(array).chain().uniq<number>(true, listIterator, any);
+        result = _(array).chain().uniq<number>(listIterator);
+        result = _(array).chain().uniq<number>(listIterator, any);
+        result = _(array).chain().uniq(true, 'a');
+        result = _(array).chain().uniq(true, 'a', any);
+        result = _(array).chain().uniq('a');
+        result = _(array).chain().uniq('a', any);
+        result = _(array).chain().uniq<{a: number}>(true, {a: 42});
+        result = _(array).chain().uniq<{a: number}>({a: 42});
+
+        result = _(list).chain().uniq<SampleObject>();
+        result = _(list).chain().uniq<SampleObject>(true);
+        result = _(list).chain().uniq<SampleObject>(true, listIterator);
+        result = _(list).chain().uniq<SampleObject>(true, listIterator, any);
+        result = _(list).chain().uniq<SampleObject, number>(true, listIterator);
+        result = _(list).chain().uniq<SampleObject, number>(true, listIterator, any);
+        result = _(list).chain().uniq<SampleObject>(listIterator);
+        result = _(list).chain().uniq<SampleObject>(listIterator, any);
+        result = _(list).chain().uniq<SampleObject, number>(listIterator);
+        result = _(list).chain().uniq<SampleObject, number>(listIterator, any);
+        result = _(list).chain().uniq<SampleObject>(true, 'a');
+        result = _(list).chain().uniq<SampleObject>(true, 'a', any);
+        result = _(list).chain().uniq<SampleObject>('a');
+        result = _(list).chain().uniq<SampleObject>('a', any);
+        result = _(list).chain().uniq<SampleObject>(true, {a: 42});
+        result = _(list).chain().uniq<{a: number}, SampleObject>(true, {a: 42});
+        result = _(list).chain().uniq<SampleObject>({a: 42});
+        result = _(list).chain().uniq<{a: number}, SampleObject>({a: 42});
+    }
+}
+
+// _.unique
+module TestUnique {
+    type SampleObject = {a: number; b: string; c: boolean};
+
+    let array: SampleObject[];
+    let list: _.List<SampleObject>;
+
+    let stringIterator: (value: string, index: number, collection: string) => string;
+    let listIterator: (value: SampleObject, index: number, collection: _.List<SampleObject>) => number;
+
+    {
+        let result: string[];
+
+        result = _.unique<string>('abc');
+        result = _.unique<string>('abc', true);
+        result = _.unique<string>('abc', true, stringIterator);
+        result = _.unique<string>('abc', true, stringIterator, any);
+        result = _.unique<string, string>('abc', true, stringIterator);
+        result = _.unique<string, string>('abc', true, stringIterator, any);
+        result = _.unique<string>('abc', stringIterator);
+        result = _.unique<string>('abc', stringIterator, any);
+        result = _.unique<string, string>('abc', stringIterator);
+        result = _.unique<string, string>('abc', stringIterator, any);
+    }
+
+    {
+        let result: SampleObject[];
+
+        result = _.unique<SampleObject>(array);
+        result = _.unique<SampleObject>(array, true);
+        result = _.unique<SampleObject>(array, true, listIterator);
+        result = _.unique<SampleObject>(array, true, listIterator, any);
+        result = _.unique<SampleObject, number>(array, true, listIterator);
+        result = _.unique<SampleObject, number>(array, true, listIterator, any);
+        result = _.unique<SampleObject>(array, listIterator);
+        result = _.unique<SampleObject>(array, listIterator, any);
+        result = _.unique<SampleObject, number>(array, listIterator);
+        result = _.unique<SampleObject, number>(array, listIterator, any);
+        result = _.unique<SampleObject>(array, true, 'a');
+        result = _.unique<SampleObject>(array, true, 'a', any);
+        result = _.unique<SampleObject>(array, 'a');
+        result = _.unique<SampleObject>(array, 'a', any);
+        result = _.unique<SampleObject>(array, true, {a: 42});
+        result = _.unique<{a: number}, SampleObject>(array, true, {a: 42});
+        result = _.unique<SampleObject>(array, {a: 42});
+        result = _.unique<{a: number}, SampleObject>(array, {a: 42});
+
+        result = _.unique<SampleObject>(list);
+        result = _.unique<SampleObject>(list, true);
+        result = _.unique<SampleObject>(list, true, listIterator);
+        result = _.unique<SampleObject>(list, true, listIterator, any);
+        result = _.unique<SampleObject, number>(list, true, listIterator);
+        result = _.unique<SampleObject, number>(list, true, listIterator, any);
+        result = _.unique<SampleObject>(list, listIterator);
+        result = _.unique<SampleObject>(list, listIterator, any);
+        result = _.unique<SampleObject, number>(list, listIterator);
+        result = _.unique<SampleObject, number>(list, listIterator, any);
+        result = _.unique<SampleObject>(list, true, 'a');
+        result = _.unique<SampleObject>(list, true, 'a', any);
+        result = _.unique<SampleObject>(list, 'a');
+        result = _.unique<SampleObject>(list, 'a', any);
+        result = _.unique<SampleObject>(list, true, {a: 42});
+        result = _.unique<{a: number}, SampleObject>(list, true, {a: 42});
+        result = _.unique<SampleObject>(list, {a: 42});
+        result = _.unique<{a: number}, SampleObject>(list, {a: 42});
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<string>;
+
+        result = _('abc').unique();
+        result = _('abc').unique(true);
+        result = _('abc').unique<string>(true, stringIterator);
+        result = _('abc').unique<string>(true, stringIterator, any);
+        result = _('abc').unique<string>(stringIterator);
+        result = _('abc').unique<string>(stringIterator, any);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<SampleObject>;
+
+        result = _(array).unique();
+        result = _(array).unique(true);
+        result = _(array).unique<number>(true, listIterator);
+        result = _(array).unique<number>(true, listIterator, any);
+        result = _(array).unique<number>(listIterator);
+        result = _(array).unique<number>(listIterator, any);
+        result = _(array).unique(true, 'a');
+        result = _(array).unique(true, 'a', any);
+        result = _(array).unique('a');
+        result = _(array).unique('a', any);
+        result = _(array).unique<{a: number}>(true, {a: 42});
+        result = _(array).unique<{a: number}>({a: 42});
+
+        result = _(list).unique<SampleObject>();
+        result = _(list).unique<SampleObject>(true);
+        result = _(list).unique<SampleObject>(true, listIterator);
+        result = _(list).unique<SampleObject>(true, listIterator, any);
+        result = _(list).unique<SampleObject, number>(true, listIterator);
+        result = _(list).unique<SampleObject, number>(true, listIterator, any);
+        result = _(list).unique<SampleObject>(listIterator);
+        result = _(list).unique<SampleObject>(listIterator, any);
+        result = _(list).unique<SampleObject, number>(listIterator);
+        result = _(list).unique<SampleObject, number>(listIterator, any);
+        result = _(list).unique<SampleObject>(true, 'a');
+        result = _(list).unique<SampleObject>(true, 'a', any);
+        result = _(list).unique<SampleObject>('a');
+        result = _(list).unique<SampleObject>('a', any);
+        result = _(list).unique<SampleObject>(true, {a: 42});
+        result = _(list).unique<{a: number}, SampleObject>(true, {a: 42});
+        result = _(list).unique<SampleObject>({a: 42});
+        result = _(list).unique<{a: number}, SampleObject>({a: 42});
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<string>;
+
+        result = _('abc').chain().unique();
+        result = _('abc').chain().unique(true);
+        result = _('abc').chain().unique<string>(true, stringIterator);
+        result = _('abc').chain().unique<string>(true, stringIterator, any);
+        result = _('abc').chain().unique<string>(stringIterator);
+        result = _('abc').chain().unique<string>(stringIterator, any);
+    }
+
+    {
+        let result: _.LoDashExplicitArrayWrapper<SampleObject>;
+
+        result = _(array).chain().unique();
+        result = _(array).chain().unique(true);
+        result = _(array).chain().unique<number>(true, listIterator);
+        result = _(array).chain().unique<number>(true, listIterator, any);
+        result = _(array).chain().unique<number>(listIterator);
+        result = _(array).chain().unique<number>(listIterator, any);
+        result = _(array).chain().unique(true, 'a');
+        result = _(array).chain().unique(true, 'a', any);
+        result = _(array).chain().unique('a');
+        result = _(array).chain().unique('a', any);
+        result = _(array).chain().unique<{a: number}>(true, {a: 42});
+        result = _(array).chain().unique<{a: number}>({a: 42});
+
+        result = _(list).chain().unique<SampleObject>();
+        result = _(list).chain().unique<SampleObject>(true);
+        result = _(list).chain().unique<SampleObject>(true, listIterator);
+        result = _(list).chain().unique<SampleObject>(true, listIterator, any);
+        result = _(list).chain().unique<SampleObject, number>(true, listIterator);
+        result = _(list).chain().unique<SampleObject, number>(true, listIterator, any);
+        result = _(list).chain().unique<SampleObject>(listIterator);
+        result = _(list).chain().unique<SampleObject>(listIterator, any);
+        result = _(list).chain().unique<SampleObject, number>(listIterator);
+        result = _(list).chain().unique<SampleObject, number>(listIterator, any);
+        result = _(list).chain().unique<SampleObject>(true, 'a');
+        result = _(list).chain().unique<SampleObject>(true, 'a', any);
+        result = _(list).chain().unique<SampleObject>('a');
+        result = _(list).chain().unique<SampleObject>('a', any);
+        result = _(list).chain().unique<SampleObject>(true, {a: 42});
+        result = _(list).chain().unique<{a: number}, SampleObject>(true, {a: 42});
+        result = _(list).chain().unique<SampleObject>({a: 42});
+        result = _(list).chain().unique<{a: number}, SampleObject>({a: 42});
+    }
+}
 
 // _.upzip
 module TestUnzip {
diff --git a/lodash/lodash.d.ts b/lodash/lodash.d.ts
index 3d22835b8..314223bfb 100644
--- a/lodash/lodash.d.ts
+++ b/lodash/lodash.d.ts
@@ -2837,343 +2837,810 @@ declare module _ {
     //_.uniq
     interface LoDashStatic {
         /**
-        * Creates a duplicate-value-free version of an array using strict equality for comparisons,
-        * i.e. ===. If the array is sorted, providing true for isSorted will use a faster algorithm.
-        * If a callback is provided each element of array is passed through the callback before
-        * uniqueness is computed. The callback is bound to thisArg and invoked with three arguments;
-        * (value, index, array).
-        *
-        * If a property name is provided for callback the created "_.pluck" style callback will
-        * return the property value of the given element.
-        *
-        * If an object is provided for callback the created "_.where" style callback will return
-        * true for elements that have the properties of the given object, else false.
-        * @param array Array to remove duplicates from.
-        * @param isSorted True if `array` is already sorted, optiona, default = false.
-        * @param iterator Transform the elements of `array` before comparisons for uniqueness.
-        * @param context 'this' object in `iterator`, optional.
-        * @return Copy of `array` where all elements are unique.
-        **/
-        uniq<T, TSort>(array: Array<T>, isSorted?: boolean): T[];
-
-        /**
-        * @see _.uniq
-        **/
-        uniq<T, TSort>(array: List<T>, isSorted?: boolean): T[];
-
-        /**
-        * @see _.uniq
-        **/
-        uniq<T, TSort>(
-            array: Array<T>,
-            isSorted: boolean,
-            callback: ListIterator<T, TSort>,
-            thisArg?: any): T[];
-
-        /**
-        * @see _.uniq
-        **/
-        uniq<T, TSort>(
-            array: List<T>,
-            isSorted: boolean,
-            callback: ListIterator<T, TSort>,
-            thisArg?: any): T[];
-
-        /**
-        * @see _.uniq
-        **/
-        uniq<T, TSort>(
-            array: Array<T>,
-            callback: ListIterator<T, TSort>,
-            thisArg?: any): T[];
-
-        /**
-        * @see _.uniq
-        **/
-        uniq<T, TSort>(
-            array: List<T>,
-            callback: ListIterator<T, TSort>,
-            thisArg?: any): T[];
-
-        /**
-        * @see _.uniq
-        * @param pluckValue _.pluck style callback
-        **/
-        uniq<T>(
-            array: Array<T>,
-            isSorted: boolean,
-            pluckValue: string): T[];
-
-        /**
-        * @see _.uniq
-        * @param pluckValue _.pluck style callback
-        **/
+         * Creates a duplicate-free version of an array, using SameValueZero for equality comparisons, in which only
+         * the first occurrence of each element is kept. Providing true for isSorted performs a faster search
+         * algorithm for sorted arrays. If an iteratee function is provided it’s invoked for each element in the
+         * array to generate the criterion by which uniqueness is computed. The iteratee is bound to thisArg and
+         * invoked with three arguments: (value, index, array).
+         *
+         * If a property name is provided for iteratee 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 iteratee the created _.matches style callback returns true for elements that
+         * have the properties of the given object, else false.
+         *
+         * @alias _.unique
+         *
+         * @param array The array to inspect.
+         * @param isSorted Specify the array is sorted.
+         * @param iteratee The function invoked per iteration.
+         * @param thisArg iteratee
+         * @return Returns the new duplicate-value-free array.
+         */
         uniq<T>(
             array: List<T>,
-            isSorted: boolean,
-            pluckValue: string): T[];
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): T[];
 
         /**
-        * @see _.uniq
-        * @param pluckValue _.pluck style callback
-        **/
-        uniq<T>(
-            array: Array<T>,
-            pluckValue: string): T[];
+         * @see _.uniq
+         */
+        uniq<T, TSort>(
+            array: List<T>,
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): T[];
 
         /**
-        * @see _.uniq
-        * @param pluckValue _.pluck style callback
-        **/
+         * @see _.uniq
+         */
         uniq<T>(
             array: List<T>,
-            pluckValue: string): T[];
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): T[];
 
         /**
-        * @see _.uniq
-        * @param whereValue _.where style callback
-        **/
-        uniq<W, T>(
-            array: Array<T>,
-            isSorted: boolean,
-            whereValue: W): T[];
-
-        /**
-        * @see _.uniq
-        * @param whereValue _.where style callback
-        **/
-        uniq<W, T>(
+         * @see _.uniq
+         */
+        uniq<T, TSort>(
             array: List<T>,
-            isSorted: boolean,
-            whereValue: W): T[];
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): T[];
 
         /**
-        * @see _.uniq
-        * @param whereValue _.where style callback
-        **/
-        uniq<W, T>(
-            array: Array<T>,
-            whereValue: W): T[];
-
-        /**
-        * @see _.uniq
-        * @param whereValue _.where style callback
-        **/
-        uniq<W, T>(
+         * @see _.uniq
+         */
+        uniq<T>(
             array: List<T>,
-            whereValue: W): T[];
+            isSorted?: boolean,
+            iteratee?: string,
+            thisArg?: any
+        ): T[];
 
         /**
-        * @see _.uniq
-        **/
-        unique<T>(array: Array<T>, isSorted?: boolean): T[];
-
-        /**
-        * @see _.uniq
-        **/
-        unique<T>(array: List<T>, isSorted?: boolean): T[];
-
-        /**
-        * @see _.uniq
-        **/
-        unique<T, TSort>(
-            array: Array<T>,
-            callback: ListIterator<T, TSort>,
-            thisArg?: any): T[];
-
-        /**
-        * @see _.uniq
-        **/
-        unique<T, TSort>(
+         * @see _.uniq
+         */
+        uniq<T>(
             array: List<T>,
-            callback: ListIterator<T, TSort>,
-            thisArg?: any): T[];
+            iteratee?: string,
+            thisArg?: any
+        ): T[];
 
         /**
-        * @see _.uniq
-        **/
-        unique<T, TSort>(
-            array: Array<T>,
-            isSorted: boolean,
-            callback: ListIterator<T, TSort>,
-            thisArg?: any): T[];
-
-        /**
-        * @see _.uniq
-        **/
-        unique<T, TSort>(
+         * @see _.uniq
+         */
+        uniq<T>(
             array: List<T>,
-            isSorted: boolean,
-            callback: ListIterator<T, TSort>,
-            thisArg?: any): T[];
+            isSorted?: boolean,
+            iteratee?: Object
+        ): T[];
 
         /**
-        * @see _.uniq
-        * @param pluckValue _.pluck style callback
-        **/
-        unique<T>(
-            array: Array<T>,
-            isSorted: boolean,
-            pluckValue: string): T[];
-
-        /**
-        * @see _.uniq
-        * @param pluckValue _.pluck style callback
-        **/
-        unique<T>(
+         * @see _.uniq
+         */
+        uniq<TWhere extends {}, T>(
             array: List<T>,
-            isSorted: boolean,
-            pluckValue: string): T[];
+            isSorted?: boolean,
+            iteratee?: TWhere
+        ): T[];
 
         /**
-        * @see _.uniq
-        * @param pluckValue _.pluck style callback
-        **/
-        unique<T>(
-            array: Array<T>,
-            pluckValue: string): T[];
-
-        /**
-        * @see _.uniq
-        * @param pluckValue _.pluck style callback
-        **/
-        unique<T>(
+         * @see _.uniq
+         */
+        uniq<T>(
             array: List<T>,
-            pluckValue: string): T[];
+            iteratee?: Object
+        ): T[];
 
         /**
-        * @see _.uniq
-        * @param whereValue _.where style callback
-        **/
-        unique<W, T>(
-            array: Array<T>,
-            whereValue?: W): T[];
-
-        /**
-        * @see _.uniq
-        * @param whereValue _.where style callback
-        **/
-        unique<W, T>(
+         * @see _.uniq
+         */
+        uniq<TWhere extends {}, T>(
             array: List<T>,
-            whereValue?: W): T[];
+            iteratee?: TWhere
+        ): T[];
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.uniq
+         */
+        uniq<TSort>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
 
         /**
-        * @see _.uniq
-        * @param whereValue _.where style callback
-        **/
-        unique<W, T>(
-            array: Array<T>,
-            isSorted: boolean,
-            whereValue?: W): T[];
-
-        /**
-        * @see _.uniq
-        * @param whereValue _.where style callback
-        **/
-        unique<W, T>(
-            array: List<T>,
-            isSorted: boolean,
-            whereValue?: W): T[];
+         * @see _.uniq
+         */
+        uniq<TSort>(
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
     }
 
     interface LoDashImplicitArrayWrapper<T> {
         /**
-        * @see _.uniq
-        **/
-        uniq<TSort>(isSorted?: boolean): LoDashImplicitArrayWrapper<T>;
-
-        /**
-        * @see _.uniq
-        **/
+         * @see _.uniq
+         */
         uniq<TSort>(
-            isSorted: boolean,
-            callback: ListIterator<T, TSort>,
-            thisArg?: any): LoDashImplicitArrayWrapper<T>;
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
 
         /**
-        * @see _.uniq
-        **/
+         * @see _.uniq
+         */
         uniq<TSort>(
-            callback: ListIterator<T, TSort>,
-            thisArg?: any): LoDashImplicitArrayWrapper<T>;
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
 
         /**
-        * @see _.uniq
-        * @param pluckValue _.pluck style callback
-        **/
+         * @see _.uniq
+         */
         uniq(
-            isSorted: boolean,
-            pluckValue: string): LoDashImplicitArrayWrapper<T>;
+            isSorted?: boolean,
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
 
         /**
-        * @see _.uniq
-        * @param pluckValue _.pluck style callback
-        **/
-        uniq(pluckValue: string): LoDashImplicitArrayWrapper<T>;
+         * @see _.uniq
+         */
+        uniq(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
 
         /**
-        * @see _.uniq
-        * @param whereValue _.where style callback
-        **/
-        uniq<W>(
-            isSorted: boolean,
-            whereValue: W): LoDashImplicitArrayWrapper<T>;
+         * @see _.uniq
+         */
+        uniq<TWhere extends {}>(
+            isSorted?: boolean,
+            iteratee?: TWhere
+        ): LoDashImplicitArrayWrapper<T>;
 
         /**
-        * @see _.uniq
-        * @param whereValue _.where style callback
-        **/
-        uniq<W>(
-            whereValue: W): LoDashImplicitArrayWrapper<T>;
+         * @see _.uniq
+         */
+        uniq<TWhere extends {}>(
+            iteratee?: TWhere
+        ): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        uniq<T>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
 
         /**
-        * @see _.uniq
-        **/
-        unique<TSort>(isSorted?: boolean): LoDashImplicitArrayWrapper<T>;
+         * @see _.uniq
+         */
+        uniq<T, TSort>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
 
         /**
-        * @see _.uniq
-        **/
+         * @see _.uniq
+         */
+        uniq<T>(
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T, TSort>(
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T>(
+            isSorted?: boolean,
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T>(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T>(
+            isSorted?: boolean,
+            iteratee?: Object
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<TWhere extends {}, T>(
+            isSorted?: boolean,
+            iteratee?: TWhere
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T>(
+            iteratee?: Object
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<TWhere extends {}, T>(
+            iteratee?: TWhere
+        ): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.uniq
+         */
+        uniq<TSort>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<TSort>(
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.uniq
+         */
+        uniq<TSort>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<TSort>(
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq(
+            isSorted?: boolean,
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<TWhere extends {}>(
+            isSorted?: boolean,
+            iteratee?: TWhere
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<TWhere extends {}>(
+            iteratee?: TWhere
+        ): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        uniq<T>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T, TSort>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T>(
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T, TSort>(
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T>(
+            isSorted?: boolean,
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T>(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T>(
+            isSorted?: boolean,
+            iteratee?: Object
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<TWhere extends {}, T>(
+            isSorted?: boolean,
+            iteratee?: TWhere
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<T>(
+            iteratee?: Object
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        uniq<TWhere extends {}, T>(
+            iteratee?: TWhere
+        ): LoDashExplicitArrayWrapper<T>;
+    }
+
+    //_.unique
+    interface LoDashStatic {
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            array: List<T>,
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.uniq
+         */
+        unique<T, TSort>(
+            array: List<T>,
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            array: List<T>,
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.uniq
+         */
+        unique<T, TSort>(
+            array: List<T>,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            array: List<T>,
+            isSorted?: boolean,
+            iteratee?: string,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            array: List<T>,
+            iteratee?: string,
+            thisArg?: any
+        ): T[];
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            array: List<T>,
+            isSorted?: boolean,
+            iteratee?: Object
+        ): T[];
+
+        /**
+         * @see _.uniq
+         */
+        unique<TWhere extends {}, T>(
+            array: List<T>,
+            isSorted?: boolean,
+            iteratee?: TWhere
+        ): T[];
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            array: List<T>,
+            iteratee?: Object
+        ): T[];
+
+        /**
+         * @see _.uniq
+         */
+        unique<TWhere extends {}, T>(
+            array: List<T>,
+            iteratee?: TWhere
+        ): T[];
+    }
+
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * @see _.uniq
+         */
         unique<TSort>(
-            isSorted: boolean,
-            callback: ListIterator<T, TSort>,
-            thisArg?: any): LoDashImplicitArrayWrapper<T>;
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
 
         /**
-        * @see _.uniq
-        **/
+         * @see _.uniq
+         */
         unique<TSort>(
-            callback: ListIterator<T, TSort>,
-            thisArg?: any): LoDashImplicitArrayWrapper<T>;
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitArrayWrapper<T> {
+        /**
+         * @see _.uniq
+         */
+        unique<TSort>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
 
         /**
-        * @see _.uniq
-        * @param pluckValue _.pluck style callback
-        **/
+         * @see _.uniq
+         */
+        unique<TSort>(
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
         unique(
-            isSorted: boolean,
-            pluckValue: string): LoDashImplicitArrayWrapper<T>;
+            isSorted?: boolean,
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
 
         /**
-        * @see _.uniq
-        * @param pluckValue _.pluck style callback
-        **/
-        unique(pluckValue: string): LoDashImplicitArrayWrapper<T>;
+         * @see _.uniq
+         */
+        unique(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
 
         /**
-        * @see _.uniq
-        * @param whereValue _.where style callback
-        **/
-        unique<W>(
-            isSorted: boolean,
-            whereValue: W): LoDashImplicitArrayWrapper<T>;
+         * @see _.uniq
+         */
+        unique<TWhere extends {}>(
+            isSorted?: boolean,
+            iteratee?: TWhere
+        ): LoDashImplicitArrayWrapper<T>;
 
         /**
-        * @see _.uniq
-        * @param whereValue _.where style callback
-        **/
-        unique<W>(
-            whereValue: W): LoDashImplicitArrayWrapper<T>;
+         * @see _.uniq
+         */
+        unique<TWhere extends {}>(
+            iteratee?: TWhere
+        ): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashImplicitObjectWrapper<T> {
+        unique<T>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<T, TSort>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<T, TSort>(
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            isSorted?: boolean,
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            isSorted?: boolean,
+            iteratee?: Object
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<TWhere extends {}, T>(
+            isSorted?: boolean,
+            iteratee?: TWhere
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            iteratee?: Object
+        ): LoDashImplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<TWhere extends {}, T>(
+            iteratee?: TWhere
+        ): LoDashImplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.uniq
+         */
+        unique<TSort>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<TSort>(
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitArrayWrapper<T> {
+        /**
+         * @see _.uniq
+         */
+        unique<TSort>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<TSort>(
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique(
+            isSorted?: boolean,
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<TWhere extends {}>(
+            isSorted?: boolean,
+            iteratee?: TWhere
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<TWhere extends {}>(
+            iteratee?: TWhere
+        ): LoDashExplicitArrayWrapper<T>;
+    }
+
+    interface LoDashExplicitObjectWrapper<T> {
+        unique<T>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<T, TSort>(
+            isSorted?: boolean,
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            iteratee?: ListIterator<T, any>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<T, TSort>(
+            iteratee?: ListIterator<T, TSort>,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            isSorted?: boolean,
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            iteratee?: string,
+            thisArg?: any
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            isSorted?: boolean,
+            iteratee?: Object
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<TWhere extends {}, T>(
+            isSorted?: boolean,
+            iteratee?: TWhere
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<T>(
+            iteratee?: Object
+        ): LoDashExplicitArrayWrapper<T>;
+
+        /**
+         * @see _.uniq
+         */
+        unique<TWhere extends {}, T>(
+            iteratee?: TWhere
+        ): LoDashExplicitArrayWrapper<T>;
     }
 
     //_.unzip