moderndash 0.0.14 → 0.0.16

package/dist/index.d.ts

@@ -0,0 +1,803 @@
+/**
+ * Creates an array of elements split into groups the length of size. If array can't be split evenly, the final chunk will be the remaining elements.
+ *
+ * @category Array
+ * @returns Returns the new array of chunks.
+ * @param chunkSize - The array to process.
+ * @param array - The length of each chunk
+ * @example
+ * chunk(2, ['a', 'b', 'c', 'd'])
+ * // => [['a', 'b'], ['c', 'd']]
+ *
+ * chunk(3, ['a', 'b', 'c', 'd'])
+ * // => [['a', 'b', 'c'], ['d']]
+ */
+declare function chunk<TInput>(chunkSize: number, array: TInput[]): TInput[][];
+
+type MinimumTwoArrays<TInput> = [TInput[], TInput[], ...TInput[][]];
+type IterateeFunction<T> = (value: T) => unknown;
+type PropertyShorthand<T> = keyof T;
+type RecordKey = string | number | symbol;
+type ArrayOrRecord<TInput> = TInput[] | Record<RecordKey, TInput>;
+type NoUnion<T, U = T> = T extends U ? [U] extends [T] ? T : never : never;
+/**
+ * @description Generic function type, should fit any function
+ * @typeParam TFunc - The input function type
+ */
+type GenericFunction<TFunc extends (...args: Parameters<TFunc>) => ReturnType<TFunc>> = (...args: Parameters<TFunc>) => ReturnType<TFunc>;
+
+/**
+ * Creates an array of `array` values not included in the other given arrays. The order and references of result values are determined by the first array.
+ *
+ * **Note:** Unlike `pullAll`, this method returns a new array.
+ *
+ * @category Array
+ * @param arrays - First array is inspected, others are excluded.
+ * @returns Returns the new array of filtered values.
+ * @example
+ * difference([2, 1], [2, 3])
+ * // => [1]
+ */
+declare function difference<TInput>(...arrays: MinimumTwoArrays<TInput>): TInput[];
+
+/**
+ * This method is like `difference` except that it accepts `iteratee` which
+ * is invoked for each element of `array` and `values` to generate the criterion
+ * by which they're compared. The order and references of result values are
+ * determined by the first array.
+ *
+ * **Note:** Unlike `pullAllBy`, this method returns a new array.
+ *
+ * @category Array
+ * @param iteratee - The iteratee invoked per element. Or property shorthand.
+ * @param arrays - First array to inspect. Others are excluded.
+
+ * @returns Returns the new array of filtered values.
+ * @example
+ * differenceBy(Math.floor, [2.1, 1.2], [2.3, 3.4])
+ * // => [1.2]
+ * differenceBy('x', [{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }])
+ * // => [{ 'x': 2 }]
+ */
+declare function differenceBy<T>(iteratee: IterateeFunction<T> | PropertyShorthand<T>, ...arrays: MinimumTwoArrays<T>): T[];
+
+/**
+ * This method is like `difference` except that it accepts `comparator`
+ * which is invoked to compare elements of `array` to `values`. The order and
+ * references of result values are determined by the first array. The comparator
+ * is invoked with two arguments: (arrVal, othVal).
+ *
+ * **Note:** Unlike `pullAllWith`, this method returns a new array.
+ *
+ * @category Array
+ * @param comparator - The comparator invoked per element.
+ * @param arrays - First array to inspect. Others are excluded.
+ * @returns Returns the new array of filtered values.
+ * @example
+ * differenceWith(isEqual, [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }], [{ 'x': 1, 'y': 2 }])
+ * // => [{ 'x': 2, 'y': 1 }]
+ */
+declare function differenceWith<T>(comparator: (a: T, b: T) => boolean, ...arrays: MinimumTwoArrays<T>): T[];
+
+/**
+ * Creates a slice of `array` excluding elements dropped from the end.
+ * Elements are dropped until `predicate` returns falsey. The predicate is
+ * invoked with three arguments: (value, index, array).
+ *
+ * @category Array
+ * @param predicate - The function invoked per iteration.
+ * @param array - The array to query.
+ * @returns Returns the slice of `array`.
+ * @example
+ * const users = [
+ *   { 'user': 'barney',  'active': false },
+ *   { 'user': 'fred',    'active': true },
+ *   { 'user': 'pebbles', 'active': true }
+ * ]
+ *
+ * dropRightWhile(({ active }) => active, users)
+ * // => objects for ['barney']
+ */
+declare function dropRightWhile<T>(predicate: (value: T) => boolean, array: T[]): T[];
+
+/**
+ * Creates a slice of `array` excluding elements dropped from the beginning.
+ * Elements are dropped until `predicate` returns falsey. The predicate is
+ * invoked with three arguments: (value, index, array).
+ *
+ * @category Array
+ * @param predicate - The function invoked per iteration.
+ * @param array - The array to query.
+ * @returns Returns the slice of `array`.
+ * @example
+ * const users = [
+ *   { 'user': 'barney',  'active': true },
+ *   { 'user': 'fred',    'active': true },
+ *   { 'user': 'pebbles', 'active': false }
+ * ]
+ *
+ * dropWhile(({ active }) => active, users)
+ * // => objects for ['pebbles']
+ */
+declare function dropWhile<T>(predicate: (value: T) => boolean, array: T[]): T[];
+
+/**
+ * Creates an array of unique values that are included in all given arrays.
+ * The order and references of result values are determined by the first array.
+ *
+ * @category Array
+ * @param arrays - The arrays to inspect.
+ * @returns Returns the new array of intersecting values.
+ * @example
+ * intersection([2, 1], [2, 3])
+ * // => [2]
+ */
+declare function intersection<TInput>(...arrays: MinimumTwoArrays<TInput>): TInput[];
+
+/**
+ * This method is like `intersection` except that it accepts `iteratee`
+ * which is invoked for each element of each `arrays` to generate the criterion
+ * by which they're compared. The order and references of result values are
+ * determined by the first array. The iteratee is invoked with one argument:
+ * (value).
+ *
+ * @example
+ * intersectionBy(Math.floor, [2.1, 1.2], [2.3, 3.4])
+ * // => [2.1]
+ * @category Array
+ * @param iteratee - The iteratee invoked per element. Or property shorthand.
+ * @param arrays - The arrays to inspect.
+ * @returns Returns the new array of intersecting values.
+ */
+declare function intersectionBy<TInput>(iteratee: IterateeFunction<TInput> | PropertyShorthand<TInput>, ...arrays: MinimumTwoArrays<TInput>): TInput[];
+
+/**
+ * This method is like `intersection` except that it accepts `comparator`
+ * which is invoked to compare elements of `arrays`. The order and references
+ * of result values are determined by the first array. The comparator is
+ * invoked with two arguments: (arrVal, othVal).
+ *
+ * @example
+ * const objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]
+ * const others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }]
+ *
+ * intersectionWith(isEqual, objects, others)
+ * // => [{ 'x': 1, 'y': 2 }]
+ * @category Array
+ * @param comparator - The comparator invoked per element.
+ * @param arrays - The arrays to inspect.
+ * @returns Returns the new array of intersecting values.
+ */
+declare function intersectionWith<T>(comparator: (a: T, b: T) => boolean, ...arrays: MinimumTwoArrays<T>): T[];
+
+/**
+ * Gets a random element from `array`.
+ *
+ * @category Array
+ * @param array - The array to sample.
+ * @returns Returns the random element.
+ * @example
+ * sample([1, 2, 3, 4])
+ * // => 2
+ */
+declare function sample<T>(array: T[]): T | undefined;
+
+/**
+ * Gets `n` random elements at unique keys from `array` up to the
+ * size of `array`.
+ *
+ * @category Array
+ * @param size The number of elements to sample.
+ * @param array The array to sample.
+ * @returns Returns the random elements.
+ * @example
+ * sampleSize([1, 2, 3], 2)
+ * // => [3, 1]
+ *
+ * sampleSize([1, 2, 3], 4)
+ * // => [2, 3, 1]
+ */
+declare function sampleSize<TInput>(size: number, array: TInput[]): TInput[];
+
+/**
+ * Creates an array of shuffled values, using a version of the
+ * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle).
+ *
+ * @since 0.1.0
+ * @category Array
+ * @param array - The array or object to shuffle.
+ * @returns Returns the new shuffled array.
+ * @example
+ * shuffle([1, 2, 3, 4])
+ * // => [4, 1, 3, 2]
+ */
+declare function shuffle<TInput>(array: TInput[]): TInput[];
+
+/**
+ * Creates a slice of `array` with elements taken from the end. Elements are
+ * taken until `predicate` returns falsey. The predicate is invoked with
+ * three arguments: (value, index, array).
+ *
+ * @category Array
+ * @param predicate - The function invoked per iteration.
+ * @param array - The array to query.
+ * @returns Returns the slice of `array`.
+ * @example
+ * const users = [
+ *   { 'user': 'barney',  'active': false },
+ *   { 'user': 'fred',    'active': true },
+ *   { 'user': 'pebbles', 'active': true }
+ * ]
+ *
+ * takeRightWhile(({ active }) => active, users)
+ * // => objects for ['fred', 'pebbles']
+ */
+declare function takeRightWhile<T>(predicate: (elem: T) => boolean, array: T[]): T[];
+
+/**
+ * Creates a slice of `array` with elements taken from the beginning. Elements
+ * are taken until `predicate` returns falsey. The predicate is invoked with
+ * three arguments: (value, index, array).
+ *
+ * @category Array
+ * @param predicate The function invoked per iteration.
+ * @param array The array to query.
+ * @returns Returns the slice of `array`.
+ * @example
+ * const users = [
+ *   { 'user': 'barney',  'active': true },
+ *   { 'user': 'fred',    'active': true },
+ *   { 'user': 'pebbles', 'active': false }
+ * ]
+ *
+ * takeWhile(({ active }) => active, users)
+ * // => objects for ['barney', 'fred']
+ */
+declare function takeWhile<T>(predicate: (elem: T) => boolean, array: T[]): T[];
+
+/**
+ * Creates a duplicate-free version of an array, in which only the first occurrence of each element is kept.
+ * The order of result values is determined by the order they occur in the array.
+ *
+ * @category Array
+ * @param array - The array to inspect.
+ * @returns Returns the new duplicate free array.
+ * @example
+ * uniq([2, 1, 2])
+ * // => [2, 1]
+ */
+declare function uniq<TInput>(array: TInput[]): TInput[];
+
+/**
+ * This method is like `uniq` except that it accepts `iteratee` which is
+ * invoked for each element in `array` to generate the criterion by which
+ * uniqueness is computed. The order of result values is determined by the
+ * order they occur in the array.
+ *
+ * @category Array
+ * @param array - The array to inspect.
+ * @param iteratee - The iteratee invoked per element. Or property shorthand.
+ * @returns Returns the new duplicate free array.
+ * @example
+ * uniqBy(Math.floor, [2.1, 1.2, 2.3])
+ * // => [2.1, 1.2]
+ */
+declare function uniqBy<T>(iteratee: IterateeFunction<T> | PropertyShorthand<T>, array: T[]): T[];
+
+/**
+ * This method is like `uniq` except that it accepts `comparator` which is invoked to compare elements of `array`.
+ * The order of result values is determined by the order they occur in the array.
+ *
+ * @category Array
+ * @param array - The array to inspect.
+ * @param comparator - The comparator invoked per element.
+ * @returns Returns the new duplicate free array.
+ * @example
+ * const objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }]
+ *
+ * uniqWith(isEqual, objects)
+ * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]
+ */
+declare function uniqWith<TInput>(comparator: (a: TInput, b: TInput) => boolean, array: TInput[]): TInput[];
+
+/**
+ * This method is like `zip` except that it accepts an array of grouped
+ * elements and creates an array regrouping the elements to their pre-zip configuration.
+ *
+ * @category Array
+ * @param array - The array of grouped elements to process.
+ * @returns Returns the new array of regrouped elements.
+ * @example
+ * const zipped = zip(['a', 'b'], [1, 2], [true, false])
+ * // => [['a', 1, true], ['b', 2, false]]
+ *
+ * unzip(zipped)
+ * // => [['a', 'b'], [1, 2], [true, false]]
+ */
+declare function unzip<TInput extends unknown[]>(array: TInput[]): TInput[];
+
+/**
+ * This method is like `unzip` except that it accepts `iteratee` to specify
+ * how regrouped values should be combined. The iteratee is invoked with the
+ * elements of each group: (...group).
+ *
+ * @category Array
+ * @param iteratee - The function to combine regrouped values.
+ * @param array - The array of grouped elements to process.
+ * @returns Returns the new array of regrouped elements.
+ * @example
+ * const zipped = zip([1, 2], [10, 20], [100, 200])
+ * // => [[1, 10, 100], [2, 20, 200]]
+ *
+ * unzipWith(add, zipped)
+ * // => [3, 30, 300]
+ */
+declare function unzipWith<TInput extends unknown[], TOutput>(iteratee: (...t: TInput) => TOutput, array: TInput[]): TOutput[];
+
+/**
+ * Creates an array of grouped elements, the first of which contains the first elements of the given arrays,
+ * the second of which contains the second elements of the given arrays, and so on.
+ *
+ * @category Array
+ * @param arrays - The arrays to process.
+ * @returns Returns the new array of grouped elements.
+ * @example
+ * zip(['a', 'b'], [1, 2], [true, false])
+ * // => [['a', 1, true], ['b', 2, false]]
+ */
+declare function zip<TInput>(...arrays: TInput[][]): TInput[][];
+
+type UnZip<A extends readonly unknown[]> = {
+    [K in keyof A]: readonly A[K][];
+};
+/**
+ * This method is like `zip` except that it accepts `iteratee` to specify
+ * how grouped values should be combined. The iteratee is invoked with the
+ * elements of each group: (...group).
+ *
+ * @category Array
+ * @param combineFunc - The function to combine grouped values.
+ * @param arrays - The arrays to process.
+ * @returns Returns the new array of grouped elements.
+ * @example
+ * zipWith([1, 2], [10, 20], [100, 200], (a, b, c) => a + b + c)
+ * // => [111, 222]
+ */
+declare function zipWith<Args extends unknown[], TOutput>(combineFunc: (...args: Args) => TOutput, ...arrays: UnZip<Args>): TOutput[];
+
+/**
+ * Creates an object composed of keys generated from the results of running
+ * each element of `collection` thru `iteratee`. The corresponding value of
+ * each key is the number of times the key was returned by `iteratee`.
+ *
+ * @example
+ * const users = [
+ *   { 'user': 'barney', 'active': true },
+ *   { 'user': 'betty', 'active': true },
+ *   { 'user': 'fred', 'active': false }
+ * ]
+ *
+ * countBy(users, value => value.active);
+ * // => { 'true': 2, 'false': 1 }
+ * @category Collection
+ * @param iteratee - The iteratee to transform keys.
+ * @param collection - The array or record to iterate over.
+ * @returns Returns the composed aggregate object.
+ */
+declare function countBy<TInput, TKey extends RecordKey>(collection: ArrayOrRecord<TInput>, iteratee: (value: TInput) => TKey): Record<TKey, number>;
+
+/**
+ * Creates an object composed of keys generated from the results of running
+ * each element of `collection` thru `iteratee`. The order of grouped values
+ * is determined by the order they occur in `collection`. The corresponding
+ * value of each key is an array of elements responsible for generating the
+ * key.
+ *
+ * @example
+ * groupBy([6.1, 4.2, 6.3], Math.floor)
+ * // => { '4': [4.2], '6': [6.1, 6.3] }
+ * @category Collection
+ * @param collection - The array or object to iterate over.
+ * @param iteratee - The iteratee to transform keys.
+ * @returns Returns the composed aggregate object.
+ */
+declare function groupBy<T, U extends RecordKey>(collection: ArrayOrRecord<T>, iteratee: (value: T) => U): Record<U, T[]>;
+
+declare function sortBy<T, U>(iteratee: (item: T) => NoUnion<number | bigint | Date | string, U>, array: T[]): T[];
+
+/**
+ * The opposite of `before`. This method creates a function that invokes `func` once it's called `n` or more times.
+ *
+ * @category Function
+ * @param n The number of calls before `func` is invoked.
+ * @param func The function to restrict.
+ * @returns Returns the new restricted function.
+ * @example
+ * const caution = () => console.log("Caution!");
+ *
+ * const afterFN = after(2, caution);
+ *
+ * afterFN()
+ * afterFN()
+ * afterFN()
+ * // => `caution` is invoked after called twice
+ */
+declare function after<TFunc extends GenericFunction<TFunc>>(n: number, func: TFunc): (...args: Parameters<TFunc>) => ReturnType<TFunc> | undefined;
+
+/**
+ * Creates a function that invokes `func`, while it's called less than `n` times. Subsequent
+ * calls to the created function return the result of the last `func` invocation.
+ *
+ * @category Function
+ * @param n - The number of calls at which `func` is no longer invoked.
+ * @param func - The function to restrict.
+ * @returns Returns the new restricted function.
+ * @example
+ * const caution = () => console.log("Caution!");
+ *
+ * // Only call caution two times
+ * const reducedCaution = before(2, caution)
+ *
+ * reducedCaution()
+ * reducedCaution()
+ * reducedCaution()
+ * // => `caution` is invoked twice
+ */
+declare function before<TFunc extends (...args: Parameters<TFunc>) => ReturnType<TFunc>>(n: number, func: TFunc): TFunc;
+
+declare function debounce<TFunc extends GenericFunction<TFunc>>(fn: TFunc, wait?: number, options?: {
+    leading?: boolean;
+    maxWait?: number;
+    trailing?: boolean;
+}): (this: ThisParameterType<TFunc>, ...args: Parameters<TFunc>) => ReturnType<TFunc>;
+
+/**
+ * Creates a function that memoizes the result of `func`. If `resolver` is
+ * provided, it determines the cache key for storing the result based on the
+ * arguments provided to the memoized function. By default, all arguments
+ * provided to the memoized function are used as the map cache key.
+ *
+ * **Note:** The cache is exposed as the `cache` property on the memoized
+ * function. Its creation may be customized by replacing the `memoize.Cache`
+ * constructor with one whose instances implement the
+ * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
+ * method interface of `clear`, `delete`, `get`, `has`, and `set`.
+ *
+ * @category Function
+ * @param func - The function to have its output memoized.
+ * @param resolver - The function to resolve the cache key.
+ * @typeParam TFunc - The input function type
+ * @typeParam Cache - The cache map type
+ * @returns  Returns the new memoized function.
+ * @example
+ * const object = \{ 'a': 1, 'b': 2 \}
+ *
+ * const values = memoize(values)
+ * values(object)
+ * // => [1, 2]
+ *
+ * values(object)
+ * // => [1, 2]
+ *
+ * object.a = 2
+ * values(object)
+ * // => [2, 2]
+ *
+ * // Modify the result cache.
+ * values.cache.set(object, ['a', 'b'])
+ * values(object)
+ * // => ['a', 'b']
+ *
+ * // Replace `memoize.Cache`.
+ * memoize.Cache = WeakMap
+ */
+declare function memoize<TFunc extends GenericFunction<TFunc>, Cache extends Map<string | symbol, ReturnType<TFunc>>>(func: TFunc, resolver?: ((...args: Parameters<TFunc>) => string | symbol)): TFunc & {
+    cache: Cache;
+};
+
+/**
+ * Creates a function that is restricted to invoking `func` once. Repeat calls
+ * to the function return the value of the first invocation. The `func` is
+ * invoked with the `this` binding and arguments of the created function.
+ *
+ * @category Function
+ * @param func - The function to restrict.
+ * @returns Returns the new restricted function.
+ * @example
+ * const initialize = once(() => console.log('initialize'))
+ * initialize()
+ * initialize()
+ * // => `createApplication` is invoked once
+ */
+declare function once<TFunc extends GenericFunction<TFunc>>(func: TFunc): TFunc;
+
+declare function throttle<TFunc extends GenericFunction<TFunc>>(func: TFunc, wait?: number, options?: {
+    leading?: boolean;
+    trailing?: boolean;
+}): (this: ThisParameterType<TFunc>, ...args: Parameters<TFunc>) => ReturnType<TFunc>;
+
+/**
+ * Invokes the iteratee `n` times, returning an array of the results of
+ * each invocation. The function is invoked with one argument: (index).
+ *
+ * @example
+ * times(3, index => console.log("Run", index)))
+ * // => "Run 0" | "Run 1" | "Run 2"
+ * times(3, Math.random)
+ * // => [0.123, 0.456, 0.789]
+ * times(4, () => 0)
+ * // => [0, 0, 0, 0]
+ * @category Function
+ * @param n - The number of times to invoke `func`.
+ * @param iteratee - The function invoked per iteration.
+ * @returns Returns the array of results.
+ */
+declare function times<T>(n: number, func: (index: number) => T): T[];
+
+/**
+ * Checks if `value` is an empty object, collection, map, or set.
+ *
+ * Objects are considered empty if they have no own enumerable string keyed
+ * properties.
+ *
+ * Array-like values such as `arguments` objects, arrays, buffers, strings, or
+ * Similarly, maps and sets are considered empty if they have a `size` of `0`.
+ *
+ * @category Lang
+ * @param value - The value to check.
+ * @returns Returns `true` if `value` is empty, else `false`.
+ * @example
+ * isEmpty(null)
+ * // => true
+ *
+ * isEmpty({})
+ * // => true
+ *
+ * isEmpty("")
+ * // => true
+ *
+ * isEmpty([1, 2, 3])
+ * // => false
+ *
+ * isEmpty('abc')
+ * // => false
+ *
+ * isEmpty({ 'a': 1 })
+ * // => false
+ */
+declare function isEmpty(value: string | object | null | undefined): boolean;
+
+/**
+ * Performs a deep comparison between two values to determine if they are
+ * equivalent.
+ *
+ * **Note:** This method supports comparing arrays, array buffers, booleans,
+ * date objects, error objects, maps, numbers, `Object` objects, regexes,
+ * sets, strings, symbols, and typed arrays. `Object` objects are compared
+ * by their own, not inherited, enumerable properties. Functions and DOM
+ * nodes are compared by strict equality, i.e. `===`.
+ *
+ * @category Lang
+ * @param value1 - The value to compare.
+ * @param value2 - The other value to compare.
+ * @returns Returns `true` if the values are equivalent, else `false`.
+ * @example
+ * var object = { 'a': 1 };
+ * var other = { 'a': 1 };
+ *
+ * _.isEqual(object, other);
+ * // => true
+ *
+ * object === other;
+ * // => false
+ */
+declare function isEqual(value1: unknown, value2: unknown): boolean;
+
+/**
+ * This method is like `_.isEqual` except that it accepts `customizer` which
+ * is invoked to compare values. If `customizer` returns `undefined`, comparisons
+ * are handled by the method instead. The `customizer` is invoked with up to
+ * six arguments: (objValue, othValue [, index|key, object, other, stack]).
+ *
+ * @category Lang
+ * @param value1 - The value to compare.
+ * @param value2 - The other value to compare.
+ * @param customizer - The function to customize comparisons.
+ * @returns Returns `true` if the values are equivalent, else `false`.
+ * @example
+ * function isGreeting(value) {
+ *   return /^h(?:i|ello)$/.test(value);
+ * }
+ *
+ * function customizer(objValue, othValue) {
+ *   if (isGreeting(objValue) && isGreeting(othValue)) {
+ *     return true;
+ *   }
+ * }
+ *
+ * var array = ['hello', 'goodbye'];
+ * var other = ['hi', 'goodbye'];
+ *
+ * isEqualWith(array, other, customizer);
+ * // => true
+*/
+declare function isEqualWith<T>(a: T, b: T, customizer: (value: T) => unknown): boolean;
+
+declare function isPlainObject(value: unknown): value is object;
+
+/**
+ * Creates an object composed of the picked `object` properties.
+ *
+ * @example
+ * const object = { 'a': 1, 'b': '2', 'c': 3 }
+ *
+ * pick(object, ['a', 'c'])
+ * // => { 'a': 1, 'c': 3 }
+ * @category Object
+ * @param object - The source object.
+ * @param keys - The property paths to pick.
+ * @returns Returns the new object.
+ */
+declare function pick<T, K extends keyof T>(object: T, keys: K[]): Pick<T, K>;
+
+/**
+ * Converts `string` to camelCase.
+ *
+ * @example
+ * camelCase('Foo Bar')
+ * // => 'fooBar'
+ * camelCase('--foo-bar--')
+ * // => 'fooBar'
+ * camelCase('__FOO_BAR__')
+ * // => 'fooBar'
+ * @category String
+ * @param str - The string to convert.
+ * @returns Returns the camel cased string.
+ */
+declare function camelCase(str: string): string;
+
+/**
+ * Converts the first character of a string to upper case and the remaining to lower case.
+ *
+ * @example
+ * capitalize('FRED')
+ * // => 'Fred'
+ * @category String
+ * @param str - The string to capitalize.
+ * @returns Returns the capitalized string.
+ */
+declare function capitalize(str: string): string;
+
+/**
+ * Deburrs a string by converting
+ * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)
+ * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)
+ * letters to basic Latin letters and removing
+ * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).
+ *
+ * @example
+ * deburr('déjà vu')
+ * // => 'deja vu'
+ * @category String
+ * @param str - The string to deburr.
+ * @returns Returns the deburred string.
+ */
+declare function deburr(str: string): string;
+
+/**
+ * Converts the characters `&`, `<`, `>`, `"` and `'` in a string to their corresponding HTML entities.
+ *
+ * @example
+ * escape('fred, barney, & pebbles')
+ * // => 'fred, barney, &amp; pebbles'
+ * @category String
+ * @param str - The string to escape.
+ * @returns Returns the escaped string.
+ */
+declare function escape(str: string): string;
+
+/**
+ * Escapes the `RegExp` special characters `^`, `$`, `\`, `.`, `*`, `+`,
+ * `?`, `(`, `)`, `[`, `]`, `{`, `}`, and `|` in a string.
+ *
+ * @example
+ * escapeRegExp('[moderndash](https://moderndash.io/)')
+ * // => '\[moderndash\]\(https://moderndash\.io/\)'
+ * @category String
+ * @param str - The string to escape.
+ * @returns Returns the escaped string.
+ */
+declare function escapeRegExp(str: string): string;
+
+/**
+ * Converts a string to kebab-case.
+ *
+ * @example
+ * kebabCase('Foo Bar')
+ * // => 'foo-bar'
+ * kebabCase('fooBar')
+ * // => 'foo-bar'
+ * kebabCase('__FOO_BAR__')
+ * // => 'foo-bar'
+ * @category String
+ * @param str - The string to convert.
+ * @returns Returns the kebab cased string.
+ */
+declare function kebabCase(str: string): string;
+
+/**
+ * Converts a string to PascalCase.
+ *
+ * @example
+ * kebabCase('Foo Bar')
+ * // => 'FooBar'
+ * kebabCase('fooBar')
+ * // => 'FooBar'
+ * kebabCase('__FOO_BAR__')
+ * // => 'FooBar'
+ * @category String
+ * @param str - The string to convert.
+ * @returns Returns the pascal cased string.
+ */
+declare function pascalCase(str: string): string;
+
+/**
+ * Converts a string to snake_case.
+ *
+ * @example
+ * snakeCase('Foo Bar')
+ * // => 'foo_bar'
+ * snakeCase('fooBar')
+ * // => 'foo_bar'
+ * snakeCase('--FOO-BAR--')
+ * // => 'foo_bar'
+ * snakeCase('foo2bar')
+ * // => 'foo_2_bar'
+ * @category String
+ * @param str - The string to convert.
+ * @returns Returns the snake cased string.
+ */
+declare function snakeCase(str: string): string;
+
+/**
+ * Converts a string to Start Case.
+ *
+ * @example
+ * startCase('--foo-bar--')
+ * // => 'Foo Bar'
+ * startCase('fooBar')
+ * // => 'Foo Bar'
+ * startCase('__FOO_BAR__')
+ * // => 'Foo Bar'
+ * @category String
+ * @param str - The string to convert.
+ * @returns Returns the start cased string.
+ */
+declare function startCase(str: string): string;
+
+/**
+ * Removes all special characters from a string.
+ *
+ * @example
+ * stripSpecialChars('Héllo! World #$%&*!')
+ * // => 'Hello World'
+ * @category String
+ * @param str - The string to remove special characters from.
+ * @returns Returns the string with special characters removed.
+*/
+declare function stripSpecialChars(str: string): string;
+
+/**
+ * Converts the HTML entities `&amp;`, `&lt;`, `&gt;`, `&quot;` and `&#39;`
+ * in a string to their corresponding characters.
+ *
+ * @example
+ * unescape('fred, barney, &amp; pebbles')
+ * // => 'fred, barney, & pebbles'
+ * @category String
+ * @param str - The string to unescape.
+ * @returns Returns the unescaped string.
+ */
+declare function unescape(str: string): string;
+
+export { ArrayOrRecord, GenericFunction, IterateeFunction, MinimumTwoArrays, NoUnion, PropertyShorthand, RecordKey, after, before, camelCase, capitalize, chunk, countBy, debounce, deburr, difference, differenceBy, differenceWith, dropRightWhile, dropWhile, escape, escapeRegExp, groupBy, intersection, intersectionBy, intersectionWith, isEmpty, isEqual, isEqualWith, isPlainObject, kebabCase, memoize, once, pascalCase, pick, sample, sampleSize, shuffle, snakeCase, sortBy, startCase, stripSpecialChars, takeRightWhile, takeWhile, throttle, times, unescape, uniq, uniqBy, uniqWith, unzip, unzipWith, zip, zipWith };