@types/lodash 4.14.157 → 4.14.161

lodash/common/string.d.ts

@@ -1,7 +1,5 @@
 import _ = require("../index");
 declare module "../index" {
-    // camelCase
-
     interface LoDashStatic {
         /**
          * Converts string to camel case.
@@ -11,23 +9,19 @@ declare module "../index" {
          */
         camelCase(string?: string): string;
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.camelCase
          */
         camelCase(): string;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.camelCase
          */
-        camelCase(): LoDashExplicitWrapper<string>;
+        camelCase(): StringChain;
     }
 
-    // capitalize
-
     interface LoDashStatic {
         /**
          * Converts the first character of string to upper case and the remaining to lower case.
@@ -37,23 +31,19 @@ declare module "../index" {
          */
         capitalize(string?: string): string;
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.capitalize
          */
         capitalize(): string;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.capitalize
          */
-        capitalize(): LoDashExplicitWrapper<string>;
+        capitalize(): StringChain;
     }
 
-    // deburr
-
     interface LoDashStatic {
         /**
          * Deburrs string by converting latin-1 supplementary letters to basic latin letters and removing combining
@@ -64,23 +54,19 @@ declare module "../index" {
          */
         deburr(string?: string): string;
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.deburr
          */
         deburr(): string;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.deburr
          */
-        deburr(): LoDashExplicitWrapper<string>;
+        deburr(): StringChain;
     }
 
-    // endsWith
-
     interface LoDashStatic {
         /**
          * Checks if string ends with the given target string.
@@ -90,35 +76,21 @@ declare module "../index" {
          * @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;
+        endsWith(string?: string, target?: string, position?: number): boolean;
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.endsWith
          */
-        endsWith(
-            target?: string,
-            position?: number
-        ): boolean;
+        endsWith(target?: string, position?: number): boolean;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.endsWith
          */
-        endsWith(
-            target?: string,
-            position?: number
-        ): LoDashExplicitWrapper<boolean>;
+        endsWith(target?: string, position?: number): PrimitiveChain<boolean>;
     }
 
-    // escape
-
     interface LoDashStatic {
         /**
          * Converts the characters "&", "<", ">", '"', "'", and "`" in string to their corresponding HTML entities.
@@ -139,23 +111,19 @@ declare module "../index" {
          */
         escape(string?: string): string;
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.escape
          */
         escape(): string;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.escape
          */
-        escape(): LoDashExplicitWrapper<string>;
+        escape(): StringChain;
     }
 
-    // escapeRegExp
-
     interface LoDashStatic {
         /**
          * Escapes the RegExp special characters "^", "$", "\", ".", "*", "+", "?", "(", ")", "[", "]",
@@ -166,23 +134,19 @@ declare module "../index" {
          */
         escapeRegExp(string?: string): string;
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.escapeRegExp
          */
         escapeRegExp(): string;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.escapeRegExp
          */
-        escapeRegExp(): LoDashExplicitWrapper<string>;
+        escapeRegExp(): StringChain;
     }
 
-    // kebabCase
-
     interface LoDashStatic {
         /**
          * Converts string to kebab case.
@@ -192,23 +156,19 @@ declare module "../index" {
          */
         kebabCase(string?: string): string;
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.kebabCase
          */
         kebabCase(): string;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.kebabCase
          */
-        kebabCase(): LoDashExplicitWrapper<string>;
+        kebabCase(): StringChain;
     }
 
-    // lowerCase
-
     interface LoDashStatic {
         /**
          * Converts `string`, as space separated words, to lower case.
@@ -218,23 +178,19 @@ declare module "../index" {
          */
         lowerCase(string?: string): string;
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.lowerCase
          */
         lowerCase(): string;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.lowerCase
          */
-        lowerCase(): LoDashExplicitWrapper<string>;
+        lowerCase(): StringChain;
     }
 
-    // lowerFirst
-
     interface LoDashStatic {
         /**
          * Converts the first character of `string` to lower case.
@@ -244,23 +200,19 @@ declare module "../index" {
          */
         lowerFirst(string?: string): string;
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.lowerFirst
          */
         lowerFirst(): string;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.lowerFirst
          */
-        lowerFirst(): LoDashExplicitWrapper<string>;
+        lowerFirst(): StringChain;
     }
 
-    // pad
-
     interface LoDashStatic {
         /**
          * Pads string on the left and right sides if it’s shorter than length. Padding characters are truncated if
@@ -271,35 +223,21 @@ declare module "../index" {
          * @param chars The string used as padding.
          * @return Returns the padded string.
          */
-        pad(
-            string?: string,
-            length?: number,
-            chars?: string
-        ): string;
+        pad(string?: string, length?: number, chars?: string): string;
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.pad
          */
-        pad(
-            length?: number,
-            chars?: string
-        ): string;
+        pad(length?: number, chars?: string): string;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.pad
          */
-        pad(
-            length?: number,
-            chars?: string
-        ): LoDashExplicitWrapper<string>;
+        pad(length?: number, chars?: string): StringChain;
     }
 
-    // padEnd
-
     interface LoDashStatic {
         /**
          * Pads string on the right side if it’s shorter than length. Padding characters are truncated if they exceed
@@ -310,35 +248,21 @@ declare module "../index" {
          * @param chars The string used as padding.
          * @return Returns the padded string.
          */
-        padEnd(
-            string?: string,
-            length?: number,
-            chars?: string
-        ): string;
+        padEnd(string?: string, length?: number, chars?: string): string;
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.padEnd
          */
-        padEnd(
-            length?: number,
-            chars?: string
-        ): string;
+        padEnd(length?: number, chars?: string): string;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.padEnd
          */
-        padEnd(
-            length?: number,
-            chars?: string
-        ): LoDashExplicitWrapper<string>;
+        padEnd(length?: number, chars?: string): StringChain;
     }
 
-    // padStart
-
     interface LoDashStatic {
         /**
          * Pads string on the left side if it’s shorter than length. Padding characters are truncated if they exceed
@@ -349,35 +273,21 @@ declare module "../index" {
          * @param chars The string used as padding.
          * @return Returns the padded string.
          */
-        padStart(
-            string?: string,
-            length?: number,
-            chars?: string
-        ): string;
+        padStart(string?: string, length?: number, chars?: string): string;
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.padStart
          */
-        padStart(
-            length?: number,
-            chars?: string
-        ): string;
+        padStart(length?: number, chars?: string): string;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.padStart
          */
-        padStart(
-            length?: number,
-            chars?: string
-        ): LoDashExplicitWrapper<string>;
+        padStart(length?: number, chars?: string): StringChain;
     }
 
-    // parseInt
-
     interface LoDashStatic {
         /**
          * Converts string to an integer of the specified radix. If radix is undefined or 0, a radix of 10 is used
@@ -389,28 +299,21 @@ declare module "../index" {
          * @param radix The radix to interpret value by.
          * @return Returns the converted integer.
          */
-        parseInt(
-            string: string,
-            radix?: number
-        ): number;
+        parseInt(string: string, radix?: number): number;
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.parseInt
          */
         parseInt(radix?: number): number;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.parseInt
          */
-        parseInt(radix?: number): LoDashExplicitWrapper<number>;
+        parseInt(radix?: number): PrimitiveChain<number>;
     }
 
-    // repeat
-
     interface LoDashStatic {
         /**
          * Repeats the given string n times.
@@ -419,30 +322,22 @@ declare module "../index" {
          * @param n The number of times to repeat the string.
          * @return Returns the repeated string.
          */
-        repeat(
-            string?: string,
-            n?: number
-        ): string;
+        repeat(string?: string, n?: number): string;
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.repeat
          */
         repeat(n?: number): string;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.repeat
          */
-        repeat(n?: number): LoDashExplicitWrapper<string>;
+        repeat(n?: number): StringChain;
     }
-
     type ReplaceFunction = (match: string, ...args: any[]) => string;
 
-    // replace
-
     interface LoDashStatic {
         /**
          * Replaces matches for pattern in string with replacement.
@@ -451,57 +346,33 @@ declare module "../index" {
          *
          * @return Returns the modified string.
          */
-        replace(
-            string: string,
-            pattern: RegExp | string,
-            replacement: ReplaceFunction | string
-        ): string;
-
+        replace(string: string, pattern: RegExp | string, replacement: ReplaceFunction | string): string;
         /**
          * @see _.replace
          */
-        replace(
-            pattern: RegExp | string,
-            replacement: ReplaceFunction | string
-        ): string;
+        replace(pattern: RegExp | string, replacement: ReplaceFunction | string): string;
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.replace
          */
-        replace(
-            pattern: RegExp|string,
-            replacement: ReplaceFunction | string
-        ): string;
-
+        replace(pattern: RegExp | string, replacement: ReplaceFunction | string): string;
         /**
          * @see _.replace
          */
-        replace(
-            replacement: ReplaceFunction | string
-        ): string;
+        replace(replacement: ReplaceFunction | string): string;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.replace
          */
-        replace(
-            pattern: RegExp | string,
-            replacement: ReplaceFunction | string
-        ): LoDashExplicitWrapper<string>;
-
+        replace(pattern: RegExp | string, replacement: ReplaceFunction | string): StringChain;
         /**
          * @see _.replace
          */
-        replace(
-            replacement: ReplaceFunction | string
-        ): LoDashExplicitWrapper<string>;
+        replace(replacement: ReplaceFunction | string): StringChain;
     }
 
-    // snakeCase
-
     interface LoDashStatic {
         /**
          * Converts string to snake case.
@@ -511,79 +382,49 @@ declare module "../index" {
          */
         snakeCase(string?: string): string;
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.snakeCase
          */
         snakeCase(): string;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.snakeCase
          */
-        snakeCase(): LoDashExplicitWrapper<string>;
+        snakeCase(): StringChain;
     }
 
-    // split
-
     interface LoDashStatic {
         /**
          * Splits string by separator.
          *
          * Note: This method is based on String#split.
          *
-         * @param string The string to trim.
+         * @param string The string to split.
          * @param separator The separator pattern to split by.
          * @param limit The length to truncate results to.
          * @return Returns the new array of string segments.
          */
-        split(
-            string: string,
-            separator?: RegExp|string,
-            limit?: number
-        ): string[];
-
+        split(string: string | null | undefined, separator?: RegExp | string, limit?: number): string[];
         /**
-         * Splits string by separator.
-         *
-         * Note: This method is based on String#split.
-         *
-         * @param string The string to trim.
-         * @param index Not used in this overload.
-         * @param guard Enables use as an iteratee for methods like _.map. You should not pass this parameter directly in your code.
-         * @return Returns the new array of string segments.
+         * @see _.split
          */
-        split(
-            string: string,
-            index: string | number,
-            guard: object
-        ): string[];
+        split(string: string | null | undefined, index: string | number, guard: object): string[];
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.split
          */
-        split(
-            separator?: RegExp|string,
-            limit?: number
-        ): LoDashImplicitWrapper<string[]>;
+        split(separator?: RegExp | string, limit?: number): Collection<string>;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.split
          */
-        split(
-            separator?: RegExp|string,
-            limit?: number
-        ): LoDashExplicitWrapper<string[]>;
+        split(separator?: RegExp | string, limit?: number): CollectionChain<string>;
     }
 
-    // startCase
-
     interface LoDashStatic {
         /**
          * Converts string to start case.
@@ -593,23 +434,19 @@ declare module "../index" {
          */
         startCase(string?: string): string;
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.startCase
          */
         startCase(): string;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.startCase
          */
-        startCase(): LoDashExplicitWrapper<string>;
+        startCase(): StringChain;
     }
 
-    // startsWith
-
     interface LoDashStatic {
         /**
          * Checks if string starts with the given target string.
@@ -619,47 +456,34 @@ declare module "../index" {
          * @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;
+        startsWith(string?: string, target?: string, position?: number): boolean;
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.startsWith
          */
-        startsWith(
-            target?: string,
-            position?: number
-        ): boolean;
+        startsWith(target?: string, position?: number): boolean;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.startsWith
          */
-        startsWith(
-            target?: string,
-            position?: number
-        ): LoDashExplicitWrapper<boolean>;
+        startsWith(target?: string, position?: number): PrimitiveChain<boolean>;
     }
 
-    // template
-
     interface TemplateOptions extends TemplateSettings {
         /**
-         * The sourceURL of the template's compiled source.
+         * @see _.sourceURL
          */
         sourceURL?: string;
     }
-
     interface TemplateExecutor {
         (data?: object): string;
+        /**
+         * @see _.source
+         */
         source: string;
     }
-
     interface LoDashStatic {
         /**
          * Creates a compiled template function that can interpolate data properties in "interpolate" delimiters,
@@ -687,28 +511,21 @@ declare module "../index" {
          * @param options.variable The data object variable name.
          * @return Returns the compiled template function.
          */
-        template(
-            string?: string,
-            options?: TemplateOptions
-        ): TemplateExecutor;
+        template(string?: string, options?: TemplateOptions): TemplateExecutor;
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.template
          */
         template(options?: TemplateOptions): TemplateExecutor;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.template
          */
-        template(options?: TemplateOptions): LoDashExplicitWrapper<TemplateExecutor>;
+        template(options?: TemplateOptions): FunctionChain<TemplateExecutor>;
     }
 
-    // toLower
-
     interface LoDashStatic {
         /**
          * Converts `string`, as a whole, to lower case.
@@ -718,23 +535,19 @@ declare module "../index" {
          */
         toLower(string?: string): string;
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.toLower
          */
         toLower(): string;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.toLower
          */
-        toLower(): LoDashExplicitWrapper<string>;
+        toLower(): StringChain;
     }
 
-    // toUpper
-
     interface LoDashStatic {
         /**
          * Converts `string`, as a whole, to upper case.
@@ -744,23 +557,19 @@ declare module "../index" {
          */
         toUpper(string?: string): string;
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.toUpper
          */
         toUpper(): string;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.toUpper
          */
-        toUpper(): LoDashExplicitWrapper<string>;
+        toUpper(): StringChain;
     }
 
-    // trim
-
     interface LoDashStatic {
         /**
          * Removes leading and trailing whitespace or specified characters from string.
@@ -769,42 +578,25 @@ declare module "../index" {
          * @param chars The characters to trim.
          * @return Returns the trimmed string.
          */
-        trim(
-            string?: string,
-            chars?: string
-        ): string;
-
+        trim(string?: string, chars?: string): string;
         /**
-         * Removes leading and trailing whitespace or specified characters from string.
-         *
-         * @param string The string to trim.
-         * @param index Not used in this overload.
-         * @param guard Enables use as an iteratee for methods like _.map. You should not pass this parameter directly in your code.
-         * @return Returns the trimmed string.
+         * @see _.trim
          */
-        trim(
-            string: string,
-            index: string | number,
-            guard: object
-        ): string;
+        trim(string: string, index: string | number, guard: object): string;
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.trim
          */
         trim(chars?: string): string;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.trim
          */
-        trim(chars?: string): LoDashExplicitWrapper<string>;
+        trim(chars?: string): StringChain;
     }
 
-    // trimEnd
-
     interface LoDashStatic {
         /**
          * Removes trailing whitespace or specified characters from string.
@@ -813,42 +605,25 @@ declare module "../index" {
          * @param chars The characters to trim.
          * @return Returns the trimmed string.
          */
-        trimEnd(
-            string?: string,
-            chars?: string
-        ): string;
-
+        trimEnd(string?: string, chars?: string): string;
         /**
-         * Removes trailing whitespace or specified characters from string.
-         *
-         * @param string The string to trim.
-         * @param index Not used in this overload.
-         * @param guard Enables use as an iteratee for methods like _.map. You should not pass this parameter directly in your code.
-         * @return Returns the trimmed string.
+         * @see _.trimEnd
          */
-        trimEnd(
-            string: string,
-            index: string | number,
-            guard: object
-        ): string;
+        trimEnd(string: string, index: string | number, guard: object): string;
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.trimEnd
          */
         trimEnd(chars?: string): string;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.trimEnd
          */
-        trimEnd(chars?: string): LoDashExplicitWrapper<string>;
+        trimEnd(chars?: string): StringChain;
     }
 
-    // trimStart
-
     interface LoDashStatic {
         /**
          * Removes leading whitespace or specified characters from string.
@@ -857,51 +632,39 @@ declare module "../index" {
          * @param chars The characters to trim.
          * @return Returns the trimmed string.
          */
-        trimStart(
-            string?: string,
-            chars?: string
-        ): string;
-
+        trimStart(string?: string, chars?: string): string;
         /**
-         * Removes leading whitespace or specified characters from string.
-         *
-         * @param string The string to trim.
-         * @param index Not used in this overload.
-         * @param guard Enables use as an iteratee for methods like _.map. You should not pass this parameter directly in your code.
-         * @return Returns the trimmed string.
+         * @see _.trimStart
          */
-        trimStart(
-            string: string,
-            index: string | number,
-            guard: object
-        ): string;
+        trimStart(string: string, index: string | number, guard: object): string;
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.trimStart
          */
         trimStart(chars?: string): string;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.trimStart
          */
-        trimStart(chars?: string): LoDashExplicitWrapper<string>;
+        trimStart(chars?: string): StringChain;
     }
 
-    // truncate
-
     interface TruncateOptions {
-        /** The maximum string length. */
+        /**
+         * @see _.length
+         */
         length?: number;
-        /** The string to indicate text is omitted. */
+        /**
+         * @see _.omission
+         */
         omission?: string;
-        /** The separator pattern to truncate to. */
-        separator?: string|RegExp;
+        /**
+         * @see _.separator
+         */
+        separator?: string | RegExp;
     }
-
     interface LoDashStatic {
         /**
          * Truncates string if it’s longer than the given maximum string length. The last characters of the truncated
@@ -911,28 +674,21 @@ declare module "../index" {
          * @param options The options object or maximum string length.
          * @return Returns the truncated string.
          */
-        truncate(
-            string?: string,
-            options?: TruncateOptions
-        ): string;
+        truncate(string?: string, options?: TruncateOptions): string;
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.truncate
          */
         truncate(options?: TruncateOptions): string;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.truncate
          */
-        truncate(options?: TruncateOptions): LoDashExplicitWrapper<string>;
+        truncate(options?: TruncateOptions): StringChain;
     }
 
-    // unescape
-
     interface LoDashStatic {
         /**
          * The inverse of _.escape; this method converts the HTML entities &amp;, &lt;, &gt;, &quot;, &#39;, and &#96;
@@ -946,23 +702,19 @@ declare module "../index" {
          */
         unescape(string?: string): string;
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.unescape
          */
         unescape(): string;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.unescape
          */
-        unescape(): LoDashExplicitWrapper<string>;
+        unescape(): StringChain;
     }
 
-    // upperCase
-
     interface LoDashStatic {
         /**
          * Converts `string`, as space separated words, to upper case.
@@ -972,23 +724,19 @@ declare module "../index" {
          */
         upperCase(string?: string): string;
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.upperCase
          */
         upperCase(): string;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.upperCase
          */
-        upperCase(): LoDashExplicitWrapper<string>;
+        upperCase(): StringChain;
     }
 
-    // upperFirst
-
     interface LoDashStatic {
         /**
          * Converts the first character of `string` to upper case.
@@ -998,23 +746,19 @@ declare module "../index" {
          */
         upperFirst(string?: string): string;
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.upperFirst
          */
         upperFirst(): string;
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.upperFirst
          */
-        upperFirst(): LoDashExplicitWrapper<string>;
+        upperFirst(): StringChain;
     }
 
-    // words
-
     interface LoDashStatic {
         /**
          * Splits `string` into an array of its words.
@@ -1023,37 +767,22 @@ declare module "../index" {
          * @param pattern The pattern to match words.
          * @return Returns the words of `string`.
          */
-        words(
-            string?: string,
-            pattern?: string|RegExp
-        ): string[];
-
+        words(string?: string, pattern?: string | RegExp): string[];
         /**
-         * Splits `string` into an array of its words.
-         *
-         * @param string The string to inspect.
-         * @param index Not used in this overload.
-         * @param guard Enables use as an iteratee for methods like _.map. You should not pass this parameter directly in your code.
-         * @return Returns the words of `string`.
+         * @see _.words
          */
-        words(
-            string: string,
-            index: string | number,
-            guard: object
-        ): string[];
+        words(string: string, index: string | number, guard: object): string[];
     }
-
     interface LoDashImplicitWrapper<TValue> {
         /**
          * @see _.words
          */
-        words(pattern?: string|RegExp): string[];
+        words(pattern?: string | RegExp): string[];
     }
-
     interface LoDashExplicitWrapper<TValue> {
         /**
          * @see _.words
          */
-        words(pattern?: string|RegExp): LoDashExplicitWrapper<string[]>;
+        words(pattern?: string | RegExp): CollectionChain<string>;
     }
 }