/**
 * 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.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 2,696 bytes
 * - Micro-dash: 164 bytes
 */
declare function chunk<T>(array: readonly T[], size?: number): T[][];

type Nil = null | undefined;
type Primitive = boolean | number | string;
type Existent = Primitive | object;
type Falsy = '' | 0 | false | null | undefined;
type EmptyObject = Record<string, never>;
type ObjectWith<T> = Record<string, T>;
type ArrayIteratee<I, O> = (item: I, index: number) => O;
type ArrayNarrowingIteratee<O> = (item: any, index: number) => item is O;
type ObjectIteratee<T, O> = (item: T[keyof T], key: StringifiedKey<T>) => O;
type ValueNarrowingIteratee<I, O> = (item: any, key: StringifiedKey<I>) => item is O;
type KeyNarrowingIteratee<I, O> = (item: I[keyof I], key: any) => key is O;
type ValueIteratee<T, O> = (value: T) => O;
type Cast<I, O> = Exclude<I, O> extends never ? I : O;
type Narrow<I, O> = Extract<I, O> | Extract<O, I>;
type IfCouldBe<T1, T2, If, Else = never> = Narrow<T1, T2> extends never ? Else : If;
type IfIndexType<T, If, Else = never> = string extends T ? If : number extends T ? If : Else;
type IndexKeys<T> = {
    [K in keyof T]: IfIndexType<K, K>;
}[keyof T];
type NonIndexKeys<T> = {
    [K in keyof T]: IfIndexType<K, never, K>;
}[keyof T];
type PartialExceptIndexes<T> = {
    [K in NonIndexKeys<T>]?: T[K];
} & {
    [K in IndexKeys<T>]: T[K];
};
type StringifiedKey<T> = Cast<keyof T, string>;
type ValuesType<T> = T extends readonly [] ? T[number] : T extends ArrayLike<any> ? T[number] : T extends object ? T[keyof T] : never;
type DeepPartial<T> = T extends Array<infer E> ? Array<DeepPartial<E>> : T extends object ? {
    [K in keyof T]?: DeepPartial<T[K]>;
} : T | undefined;
type Evaluate<T> = T extends infer I ? {
    [K in keyof I]: T[K];
} : never;
type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
type Drop1Arg<T extends Function> = T extends (arg1: any, ...rest: infer A) => infer R ? (...rest: A) => R : never;
type Drop2Args<T extends Function> = T extends (arg1: any, arg2: any, ...rest: infer A) => infer R ? (...rest: A) => R : never;
type Drop3Args<T extends Function> = T extends (arg1: any, arg2: any, arg3: any, ...rest: infer A) => infer R ? (...rest: A) => R : never;
type Drop4Args<T extends Function> = T extends (arg1: any, arg2: any, arg3: any, arg4: any, ...rest: infer A) => infer R ? (...rest: A) => R : never;

/**
 * Creates an array with all falsey values removed. The values `false`, `null`, `0`, `""`, `undefined`, and `NaN` are falsey.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 113 bytes
 * - Micro-dash: 62 bytes
 */
declare function compact<T>(array: readonly T[]): Array<Exclude<T, Falsy>>;

/**
 * Creates a new array concatenating `array` with any additional arrays and/or values.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 1,563 bytes
 * - Micro-dash: 61 bytes
 */
declare function concat<T>(array: readonly T[], ...values: Array<T | readonly T[]>): T[];

/**
 * 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.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 7,481 bytes
 * - Micro-dash: 352 bytes
 */
declare function difference<T>(array: readonly T[], ...values: readonly T[][]): T[];

/**
 * Flattens `array` a single level deep.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 1,361 bytes
 * - Micro-dash: 113 bytes
 */
declare function flatten<T>(array: ReadonlyArray<T | readonly T[]>): T[];

/**
 * Gets all but the last element of `array`.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 249 bytes
 * - Micro-dash: 57 bytes
 */
declare function initial<T>(array: readonly T[]): T[];

/**
 * Creates an array of unique values that are included in all given arrays using SameValueZero for equality comparisons. The order and references of result values are determined by the first array.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 7,018 bytes
 * - Micro-dash: 125 bytes
 */
declare function intersection<T>(...arrays: Array<Nil | readonly T[]>): T[];

/**
 * Gets the last element of array.
 *
 * Differences from lodash:
 * - no special consideration is given to string-keyed values set on the array
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 92 bytes
 * - Micro-dash: 57 bytes
 */
declare function last<T>(array: readonly T[]): T;

/**
 * Gets the element at index `n` of `array`. If `n` is negative, the nth element from the end is returned.
 *
 * Differences from lodash:
 * - does not handle a fractional value for `index`
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 1,923 bytes
 * - Micro-dash: 94 bytes
 */
declare function nth<T>(array: readonly T[], index: number): T;
declare function nth<T>(array: Nil | readonly T[], index: number): T | undefined;

/**
 * Removes all given values from array using `SameValueZero` for equality comparisons.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 3,634 bytes
 * - Micro-dash: 217 bytes
 */
declare function pull<T>(array: T[], ...values: T[]): T[];

/**
 * This function is like `pull` except that it accepts an array of values to remove.
 *
 * **Note:** Unlike `difference`, this function mutates array.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 942 bytes
 * - Micro-dash: 199 bytes
 */
declare function pullAll<T>(array: T[], values: T[]): T[];

/**
 * Removes elements from array corresponding to indexes and returns an array of removed elements.
 *
 * *Note:* This function mutates `array`.
 *
 * Differences from lodash:
 * - behavior is undefined when attempting to pull attributes keyed with anything other than positive integers
 * - does not support deep paths
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 8,992 bytes
 * - Micro-dash: 280 bytes
 */
declare function pullAt(array: any[], ...indexes: Array<number[] | number>): any[];

/**
 * Removes all elements from array for which `predicate` returns truthy, and returns an array of the removed elements.
 *
 * Differences from lodash:
 * - iterates over `array` in reverse order
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 16,363 bytes
 * - Micro-dash: 118 bytes
 */
declare function remove<O>(array: any[], predicate: ArrayNarrowingIteratee<O>): O[];
declare function remove<T>(array: T[], predicate: ArrayIteratee<T, boolean>): T[];

/**
 * Uses a binary search to determine the lowest index at which `value` should be inserted into `array` in order to maintain its sort order.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 1,472 bytes
 * - Micro-dash: 274 bytes
 */
declare function sortedIndex<T>(array: Nil | readonly T[], value: T): number;

/**
 * Creates an array of unique values, in order, from all given `arrays`.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 7,561 bytes
 * - Micro-dash: 181 bytes
 */
declare function union<T>(...arrays: readonly T[][]): T[];

/**
 * Creates a duplicate-free version of an array, using `SameValueZero` for equality comparisons, 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.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 5,664 bytes
 * - Micro-dash: 64 bytes
 */
declare function uniq<T>(array: readonly T[]): T[];

/**
 * This function 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.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 16,671 bytes
 * - Micro-dash: 122 bytes
 */
declare function uniqBy<T>(array: readonly T[], iteratee: ValueIteratee<T, any>): T[];

/**
 * Creates an array excluding all given values.
 *
 * Differences from lodash:
 * - Uses triple equals rather than `SameValueZero`.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 6,819 bytes
 * - Micro-dash: 60 bytes
 */
declare function without<T>(array: readonly T[], ...values: readonly T[]): T[];

/**
 * 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.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 3,491 bytes
 * - Micro-dash: 197 bytes
 */
declare function zip<T1, T2>(array1: readonly T1[], array2: readonly T2[]): Array<[T1, T2]>;
declare function zip<T1, T2, T3>(array1: readonly T1[], array2: readonly T2[], array3: readonly T3[]): Array<[T1, T2, T3]>;
declare function zip<T1, T2, T3, T4>(array1: readonly T1[], array2: readonly T2[], array3: readonly T3[], array4: readonly T4[]): Array<[T1, T2, T3, T4]>;
declare function zip<T>(...arrays: readonly T[][]): T[][];
declare function zip<T>(...arrays: ReadonlyArray<Nil | readonly T[]>): Array<Array<Nil | T>>;

/**
 * This function is like `fromPairs` except that it accepts two arrays, one of property identifiers and one of corresponding values.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 2,252 bytes
 * - Micro-dash: 349 bytes
 */
declare function zipObject<K extends readonly [PropertyKey], V extends readonly [any, ...any[]]>(props: K, values: V): Record<K[0], V[0]>;
declare function zipObject<K extends readonly [PropertyKey, PropertyKey], V extends readonly [any, any, ...any[]]>(props: K, values: V): Record<K[0], V[0]> & Record<K[1], V[1]>;
declare function zipObject<K extends readonly [PropertyKey, PropertyKey, PropertyKey], V extends readonly [any, any, any, ...any[]]>(props: K, values: V): Record<K[0], V[0]> & Record<K[1], V[1]> & Record<K[2], V[2]>;
declare function zipObject<K extends readonly [PropertyKey, PropertyKey, PropertyKey, PropertyKey], V extends readonly [any, any, any, any, ...any[]]>(props: K, values: V): Record<K[3], V[3]> & Record<K[0], V[0]> & Record<K[1], V[1]> & Record<K[2], V[2]>;
declare function zipObject<K extends PropertyKey, V>(props: readonly K[], values: readonly V[]): Record<K, V | undefined>;

/**
 * Checks if `predicate` returns truty for **all** elements of `collection`. Iteration is stopped once predicate returns falsey.
 *
 * **Note:** This function returns `true` for [empty collections](https://en.wikipedia.org/wiki/Empty_set) because [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of elements of empty collections.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 16,503 bytes
 * - Micro-dash: 323 bytes
 */
declare function every<T>(array: readonly T[] | undefined, predicate: ArrayIteratee<T, any>): boolean;
declare function every<T>(object: T | undefined, predicate: ObjectIteratee<T, any>): boolean;

/**
 * Iterates over elements of `collection`, returning an array of all elements `predicate` returns truthy for.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 16,224 bytes
 * - Micro-dash: 319 bytes
 */
declare function filter<I, O>(array: Nil | readonly I[], predicate: ArrayNarrowingIteratee<O>): Array<Extract<I, O> | Extract<O, I>>;
declare function filter<T>(array: Nil | readonly T[], predicate: ArrayIteratee<T, boolean>): T[];
declare function filter<I, O>(object: I | Nil, predicate: ValueNarrowingIteratee<I, O>): Array<Extract<I[keyof I], O> | Extract<O, I[keyof I]>>;
declare function filter<I, O>(object: I | Nil, predicate: KeyNarrowingIteratee<I, O>): Array<{
    [K in keyof I]: IfCouldBe<Cast<K, string>, O, I[K]>;
}[keyof I]>;
declare function filter<T>(object: Nil | T, predicate: ObjectIteratee<T, boolean>): Array<T[keyof T]>;

type DefiniteValueMatches$1<T, O> = {
    [K in keyof T]: T[K] extends O ? T[K] : never;
}[keyof T];
type PossibleValueMatches$1<T, O> = {
    [K in keyof T]: IfCouldBe<T[K], O, Narrow<T[K], O>>;
}[keyof T];
type DefiniteKeyMatches<T, O> = {
    [K in keyof T]: Cast<K, string> extends O ? T[K] : never;
}[keyof T];
type PossibleKeyMatches<T, O> = {
    [K in keyof T]: IfCouldBe<Cast<K, string>, O, T[K]>;
}[keyof T];
/**
 * Iterates over elements of `collection`, returning the first element `predicate` returns truthy for.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 16,881 bytes
 * - Micro-dash: 241 bytes
 */
declare function find<I, O>(array: Nil | readonly I[], predicate: ArrayNarrowingIteratee<O>, fromIndex?: number): Extract<I, O> | Extract<O, I> | undefined;
declare function find<T>(array: Nil | readonly T[], predicate: ArrayIteratee<T, boolean>, fromIndex?: number): T | undefined;
declare function find<I, T extends NonNullable<I>, O, F extends number | undefined = undefined>(object: I, predicate: ValueNarrowingIteratee<T, O>, fromIndex?: F): IfCouldBe<F, number, undefined> | IfCouldBe<I, Nil, undefined> | PossibleValueMatches$1<T, O> | (DefiniteValueMatches$1<T, O> extends never ? undefined : never);
declare function find<I, T extends NonNullable<I>, O, F extends number | undefined = undefined>(object: I, predicate: KeyNarrowingIteratee<T, O>, fromIndex?: F): IfCouldBe<F, number, undefined> | IfCouldBe<I, Nil, undefined> | PossibleKeyMatches<T, O> | (DefiniteKeyMatches<T, O> extends never ? undefined : never);
declare function find<T>(object: Nil | T, predicate: ObjectIteratee<T, boolean>, fromIndex?: number): T[keyof T] | undefined;

/**
 * Creates a flattened array of values by running each element in `collection` thru `iteratee` and flattening the mapped results.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 16,579 bytes
 * - Micro-dash: 481 bytes
 */
declare function flatMap<I, O>(array: Nil | readonly I[], iteratee: ArrayIteratee<I, O | O[]>): O[];
declare function flatMap<T, O>(object: Nil | T, iteratee: ObjectIteratee<T, O | O[]>): O[];

/**
 * Iterates over elements of `collection` and invokes `iteratee` for each element. Iteratee functions may exit iteration early by explicitly returning `false`.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 4,526 bytes
 * - Micro-dash: 249 bytes
 */
declare function forEach<T extends Nil | readonly any[]>(array: T, iteratee: ArrayIteratee<NonNullable<T>[number], boolean | void>): T;
declare function forEach<T>(object: T, iteratee: ObjectIteratee<NonNullable<T>, boolean | void>): T;

/**
 * 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.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 16,678 bytes
 * - Micro-dash: 404 bytes
 */
declare function groupBy<T, K extends PropertyKey>(collection: Nil | ObjectWith<T> | readonly T[], iteratee: ValueIteratee<T, K>): Record<K, IfIndexType<K, T[], T[] | undefined>>;

/**
 * This function is like `forEach` except that it iterates over elements of `collection` from right to left.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 4,524 bytes
 * - Micro-dash: 245 bytes
 */
declare function forEachRight<T>(array: readonly T[] | undefined, iteratee: ArrayIteratee<T, boolean | void>): T[];
declare function forEachRight<T>(object: T | undefined, iteratee: ObjectIteratee<T, boolean | void>): T;

/**
 * Checks if `value` is in `collection`. If `collection` is a string, it's checked for a substring of `value`. If `fromIndex` is negative, it's used as the offset from the end of `collection`.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 5,533 bytes
 * - Micro-dash: 344 bytes
 */
declare function includes<T extends object | string | readonly any[]>(collection: T, value: T extends readonly any[] ? T[0] : T extends string ? string : T[keyof T], fromIndex?: number): boolean;

/**
 * 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 last element responsible for generating the key.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 16,606 bytes
 * - Micro-dash: 305 bytes
 */
declare function keyBy<T, K extends PropertyKey>(array: Nil | readonly T[], iteratee: ValueIteratee<T, K>): IfIndexType<K, Record<K, T>, Partial<Record<K, T>>>;
declare function keyBy<T, K extends PropertyKey>(object: Nil | T, iteratee: ValueIteratee<T[keyof T], K>): IfIndexType<K, Record<K, T[keyof T]>, Partial<Record<K, T[keyof T]>>>;

/**
 * Creates an array of values by running each element in `collection` thru `iteratee`.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 16,246 bytes
 * - Micro-dash: 316 bytes
 */
declare function map<I, O>(array: readonly I[] | undefined, iteratee: ArrayIteratee<I, O>): O[];
declare function map<T, O>(object: T | undefined, iteratee: ObjectIteratee<T, O>): O[];

/**
 * Creates an array of elements split into two groups, the first of which contains elements `predicate` returns truthy for, the second of which contains elements `predicate` returns falsey for.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 16,447 bytes
 * - Micro-dash: 333 bytes
 */
declare function partition<T, O>(array: Nil | T, predicate: ValueNarrowingIteratee<ValuesType<T>, O>): [
    IfCouldBe<ValuesType<T>, O, Array<Narrow<ValuesType<T>, O>>, []>,
    Exclude<ValuesType<T>, O> extends never ? [] : Array<Exclude<ValuesType<T>, O>>
];
declare function partition<T>(array: Nil | T, predicate: ValueIteratee<ValuesType<T>, any>): [Array<ValuesType<T>>, Array<ValuesType<T>>];

/**
 * Reduces `collection` to a value which is the accumulated result of running each element in collection thru `iteratee`, where each successive invocation is supplied the return value of the previous. If accumulator is not given, the first element of collection is used as the initial value.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 16,377 bytes
 * - Micro-dash: 386 bytes
 */
declare function reduce<T extends Nil | readonly any[]>(array: T, iteratee: (accumulator: NonNullable<T>[number], value: NonNullable<T>[number], index: number) => NonNullable<T>[number]): IfCouldBe<T, Nil, undefined> | NonNullable<T>[number];
declare function reduce<E, A>(array: Nil | readonly E[], iteratee: (accumulator: A, value: E, index: number) => A, accumulator: A): A;
declare function reduce<T>(object: T, iteratee: (accumulator: NonNullable<T>[keyof NonNullable<T>], value: NonNullable<T>[keyof NonNullable<T>], key: keyof NonNullable<T>) => NonNullable<T>[keyof NonNullable<T>]): IfCouldBe<T, Nil, undefined> | NonNullable<T>[keyof NonNullable<T>];
declare function reduce<T, A>(object: T, iteratee: (accumulator: A, value: NonNullable<T>[keyof NonNullable<T>], key: keyof NonNullable<T>) => A, accumulator: A): A;

/**
 * The opposite of `filter`; this function returns the elements of `collection` that `predicate` does **not** return truthy for.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 16,556 bytes
 * - Micro-dash: 375 bytes
 */
declare function reject<I, O>(array: Nil | readonly I[], predicate: ArrayNarrowingIteratee<O>): Array<Exclude<I, O>>;
declare function reject<T>(array: Nil | readonly T[], predicate: ArrayIteratee<T, boolean>): T[];
declare function reject<I, O>(object: I | Nil, predicate: ValueNarrowingIteratee<I, O>): Array<Exclude<I[keyof I], O>>;
declare function reject<I, O>(object: I | Nil, predicate: KeyNarrowingIteratee<I, O>): Array<{
    [K in keyof I]: Cast<K, string> extends O ? never : I[K];
}[keyof I]>;
declare function reject<T>(object: Nil | T, predicate: ObjectIteratee<T, boolean>): Array<T[keyof T]>;

/**
 * This function is like `_.reduce` except that it iterates over elements of `collection` from right to left.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 16,375 bytes
 * - Micro-dash: 382 bytes
 */
declare function reduceRight<T extends Nil | readonly any[]>(array: T, iteratee: (accumulator: NonNullable<T>[number], value: NonNullable<T>[number], index: number) => NonNullable<T>[number]): IfCouldBe<T, Nil, undefined> | NonNullable<T>[number];
declare function reduceRight<E, A>(array: Nil | readonly E[], iteratee: (accumulator: A, value: E, index: number) => A, accumulator: A): A;
declare function reduceRight<T>(object: T, iteratee: (accumulator: NonNullable<T>[keyof NonNullable<T>], value: NonNullable<T>[keyof NonNullable<T>], key: keyof NonNullable<T>) => NonNullable<T>[keyof NonNullable<T>]): IfCouldBe<T, Nil, undefined> | NonNullable<T>[keyof NonNullable<T>];
declare function reduceRight<T, A>(object: T, iteratee: (accumulator: A, value: NonNullable<T>[keyof NonNullable<T>], key: keyof NonNullable<T>) => A, accumulator: A): A;

/**
 * Gets a random element from `collection`.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 4,349 bytes
 * - Micro-dash: 563 bytes
 */
declare function sample<T>(collection: ObjectWith<T> | readonly T[]): T;

/**
 * Gets `n` random elements at unique keys from `collection` up to the size of `collection`.
 *
 * Differences from lodash:
 * - no special treatment given to fraction values of `n`
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 5,786 bytes
 * - Micro-dash: 826 bytes
 */
declare function sampleSize<T>(array: Nil | readonly T[], n?: number): T[];
declare function sampleSize<T>(object: Nil | T, n?: number): Array<T[keyof T]>;

/**
 * Creates an array of shuffled values, using a version of the [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle).
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 4,563 bytes
 * - Micro-dash: 965 bytes
 */
declare function shuffle<T>(array: Nil | readonly T[]): T[];
declare function shuffle<T>(object: Nil | T): Array<T[keyof T]>;

/**
 * Gets the size of collection by returning the number of its own enumerable string keyed properties.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 4,103 bytes
 * - Micro-dash: 214 bytes
 */
declare function size(collection: Nil | object | string | readonly any[]): number;

/**
 * Checks if `predicate` returns truthy for **any** element of `collection`. Iteration is stopped once `predicate` returns truthy.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 16,399 bytes
 * - Micro-dash: 323 bytes
 */
declare function some<T>(array: readonly T[] | undefined, predicate: ArrayIteratee<T, any>): boolean;
declare function some<T>(object: T | undefined, predicate: ObjectIteratee<T, any>): boolean;

/**
 * Creates an array of elements, sorted in ascending order by the results of running each element in a collection thru each iteratee. This function performs a stable sort, that is, it preserves the original sort order of equal elements.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 18,547 bytes
 * - Micro-dash: 682 bytes
 */
declare function sortBy<T>(collection: Nil | ObjectWith<T> | readonly T[], iteratees: Array<ValueIteratee<T, any>> | ValueIteratee<T, any>): T[];

/**
 * Creates a function that invokes the method at `object[key]` with `partials` prepended to the arguments it receives. Allows bound functions to reference methods that may be redefined or don't yet exist. See [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern) for more details.
 *
 * Differences from lodash:
 * - there is no "placeholder" functionality
 * - it will return plain functions; they will not inherit the prototype of `object[key]`
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 10,812 bytes
 * - Micro-dash: 70 bytes
 */
declare function bindKey<K extends PropertyKey, T extends Record<K, (...args: any[]) => any>>(object: T, key: K): (...args: Parameters<T[K]>) => ReturnType<T[K]>;
declare function bindKey<K extends PropertyKey, A1, T extends Record<K, (...args: [A1, ...any[]]) => any>>(object: T, key: K, arg1: A1): Drop1Arg<T[K]>;
declare function bindKey<K extends PropertyKey, A1, A2, T extends Record<K, (...args: [A1, A2, ...any[]]) => any>>(object: T, key: K, arg1: A1, arg2: A2): Drop2Args<T[K]>;
declare function bindKey<K extends PropertyKey, A1, A2, A3, T extends Record<K, (...args: [A1, A2, A3, ...any[]]) => any>>(object: T, key: K, arg1: A1, arg2: A2, arg3: A3): Drop3Args<T[K]>;
declare function bindKey<K extends PropertyKey, A1, A2, A3, A4, T extends Record<K, (...args: [A1, A2, A3, A4, ...any[]]) => any>>(object: T, key: K, arg1: A1, arg2: A2, arg3: A3, arg4: A4): Drop4Args<T[K]>;
declare function bindKey<K extends PropertyKey, A1, A2, A3, A4, T extends Record<K, (...args: [A1, A2, A3, A4, ...any[]]) => any>>(object: T, key: K, ...partials: [A1, A2, A3, A4, ...any[]]): (...args: any[]) => ReturnType<T[K]>;

interface CurriedFunction1<T1, R> {
    (): CurriedFunction1<T1, R>;
    (t1: T1): R;
}
interface CurriedFunction2<T1, T2, R> {
    (): CurriedFunction2<T1, T2, R>;
    (t1: T1): CurriedFunction1<T2, R>;
    (t1: T1, t2: T2): R;
}
interface CurriedFunction3<T1, T2, T3, R> {
    (): CurriedFunction3<T1, T2, T3, R>;
    (t1: T1): CurriedFunction2<T2, T3, R>;
    (t1: T1, t2: T2): CurriedFunction1<T3, R>;
    (t1: T1, t2: T2, t3: T3): R;
}
interface CurriedFunction4<T1, T2, T3, T4, R> {
    (): CurriedFunction4<T1, T2, T3, T4, R>;
    (t1: T1): CurriedFunction3<T2, T3, T4, R>;
    (t1: T1, t2: T2): CurriedFunction2<T3, T4, R>;
    (t1: T1, t2: T2, t3: T3): CurriedFunction1<T4, R>;
    (t1: T1, t2: T2, t3: T3, t4: T4): R;
}
/**
 * Creates a function that accepts arguments of `func` and either invokes func returning its result, if at least `arity` number of arguments have been provided, or returns a function that accepts the remaining `func` arguments, and so on. The `arity` of func may be specified if `func.length` is not sufficient.
 *
 * Differences from lodash:
 * - there is no "placeholder" functionality
 * - it will return plain functions; they will not inherit the prototype of `func`
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 10,527 bytes
 * - Micro-dash: 154 bytes
 */
declare function curry<T1, R>(func: (t1: T1) => R): CurriedFunction1<T1, R>;
declare function curry<T1, R>(func: (t1: T1, ...more: any[]) => R, arity: 1): CurriedFunction1<T1, R>;
declare function curry<T1, T2, R>(func: (t1: T1, t2: T2) => R): CurriedFunction2<T1, T2, R>;
declare function curry<T1, T2, R>(func: (t1: T1, t2: T2, ...more: any[]) => R, arity: 2): CurriedFunction2<T1, T2, R>;
declare function curry<T1, T2, T3, R>(func: (t1: T1, t2: T2, t3: T3) => R): CurriedFunction3<T1, T2, T3, R>;
declare function curry<T1, T2, T3, R>(func: (t1: T1, t2: T2, t3: T3, ...more: any[]) => R, arity: 3): CurriedFunction3<T1, T2, T3, R>;
declare function curry<T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4) => R): CurriedFunction4<T1, T2, T3, T4, R>;
declare function curry<T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4, ...more: any[]) => R, arity: 4): CurriedFunction4<T1, T2, T3, T4, R>;

/**
 * Creates a debounced function that delays invoking `func` until after `wait` milliseconds have elapsed since the last time the debounced function was invoked. The debounced function comes with a `cancel` method to cancel delayed `func` invocations. The `func` is invoked with the last arguments provided to the debounced function.
 *
 * If `wait` is 0, `func` invocation is deferred until to the next tick, similar to `setTimeout` with a timeout of `0`.
 *
 * Differences from lodash:
 * - the debounced function does not come with a `flush` method
 * - does not accept options
 * - does not return the results of the last invocation
 * - does not make any guarantees about the value of `this` in `func`
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 2,410 bytes
 * - Micro-dash: 149 bytes
 */
declare function debounce<T extends (...args: any[]) => any>(func: T, wait?: number): ((...args: Parameters<T>) => void) & {
    cancel: () => void;
};

/**
 * 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, the first argument provided to the memoized function is used as the map cache key. The `func` is invoked with the `this` binding of the memoized function.
 *
 * **Note:** The cache is exposed as the `cache` property on the memoized function.
 *
 * Differences from lodash:
 * - does not coerce keys to a string; any object can be used as in an ES6 `Map`
 * - does not let you customize cache creation
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 4,523 bytes
 * - Micro-dash: 231 bytes
 *
 * @param resolver The function to resolve the cache key.
 */
declare function memoize<T extends Function>(func: T, resolver?: Function): T & {
    cache: Map<any, any>;
};

/**
 * Creates a function that negates the result of the predicate `func`. The `func` predicate is invoked with the `this` binding and arguments of the created function.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 357 bytes
 * - Micro-dash: 107 bytes
 */
declare function negate<F extends (...args: any[]) => any>(predicate: F): (this: ThisParameterType<F>, ...args: Parameters<F>) => boolean;

/**
 * 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.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 1,809 bytes
 * - Micro-dash: 100 bytes
 */
declare function once<T extends (...args: any[]) => any>(func: T): (this: ThisParameterType<T>, ...args: Parameters<T>) => ReturnType<T>;

/**
 * Creates a function that invokes `func` with `partials` prepended to the arguments it receives. This function is like `bind` except it does not alter the `this` binding.
 *
 * Differences from lodash:
 * - there is no "placeholder" functionality
 * - sets the "length" property of partially applied functions
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 10,767 bytes
 * - Micro-dash: 48 bytes
 */
declare function partial<F extends (...args: any[]) => any>(func: F): F;
declare function partial<A1, F extends (arg1: A1, ...rest: any) => any>(func: F, arg1: A1): Drop1Arg<F>;
declare function partial<A1, A2, F extends (...args: [A1, A2, ...any[]]) => any>(func: F, arg1: A1, arg2: A2): Drop2Args<F>;
declare function partial<A1, A2, A3, F extends (...args: [A1, A2, A3, ...any[]]) => any>(func: F, arg1: A1, arg2: A2, arg3: A3): Drop3Args<F>;
declare function partial<A1, A2, A3, A4, F extends (...args: [A1, A2, A3, A4, ...any[]]) => any>(func: F, arg1: A1, arg2: A2, arg3: A3, arg4: A4): Drop4Args<F>;
declare function partial<A1, A2, A3, A4, F extends (...args: [A1, A2, A3, A4, ...any[]]) => any>(func: F, ...partials: [A1, A2, A3, A4, ...any[]]): (...args: any[]) => ReturnType<F>;

/**
 * Creates a throttled function that only invokes `func` at most once per every `wait` milliseconds. The throttled function comes with a `cancel` method to cancel delayed `func` invocations and a `flush` method to immediately invoke them. Provide `options` to indicate whether `func` should be invoked on the leading and/or trailing edge of the `wait` timeout. The `func` is invoked with the last arguments provided to the throttled function.
 *
 *  **Note**: If `leading` and `trailing` options are `true`, `func` is invoked on the trailing edge of the timeout only if the throttled function is invoked more than once during the `wait` timeout.
 *
 * If `wait` is 0 and `leading` is `false`, `func` invocation is deferred until to the next tick, similar to `setTimeout` with a timeout of 0.
 *
 * Differences from lodash:
 * - does not return the results of the last invocation
 * - does not make any guarantees about the value of `this` in `func`
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 2,661 bytes
 * - Micro-dash: 374 bytes
 */
declare function throttle<T extends (...args: any[]) => any>(func: T, wait?: number, { leading, trailing }?: {
    leading?: boolean | undefined;
    trailing?: boolean | undefined;
}): ((...args: Parameters<T>) => void) & {
    cancel: () => void;
    flush: () => void;
};

/**
 * Casts `value` as an array if it's not one.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 137 bytes
 * - Micro-dash: 69 bytes
 */
declare function castArray<T>(value: T): T extends readonly unknown[] ? T : T[];

/**
 * Creates a shallow clone of `value`.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 14,214 bytes
 * - Micro-dash: 97 bytes
 */
declare function clone<T>(value: T): T;

/**
 * This function is like `clone` except that it recursively clones `value`.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 14,222 bytes
 * - Micro-dash: 59 bytes
 */
declare function cloneDeep<T>(value: T): T;

/**
 * Checks if `value` is classified as a boolean primitive.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 794 bytes
 * - Micro-dash: 54 bytes
 */
declare function isBoolean(value: any): value is boolean;

/**
 * Checks if `value` is an empty object or collection.
 *
 * Objects are considered empty if they have no own enumerable string keyed properties.
 *
 * Arrays are considered empty if they have a `length` of `0`.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 4,945 bytes
 * - Micro-dash: 129 bytes
 */
declare function isEmpty(value: any): boolean;

/**
 * Performs a deep comparison between two values to determine if they are equivalent.
 *
 * Differences from lodash:
 * - cannot handle circular references
 * - does not give special treatment to arrays; their own properties are compared just like other objects. Note this means sparse arrays are not equal to their dense "equivalents".
 * - `isEqual(0, -0) === false`
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 12,400 bytes
 * - Micro-dash: 288 bytes
 */
declare function isEqual(value: any, other: any): boolean;

/**
 * Checks if `value` is classified as a `Function` object.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 924 bytes
 * - Micro-dash: 72 bytes
 */
declare function isFunction(value: any): value is (...args: any[]) => any;

/**
 * Performs a partial deep comparison between `object` and `source` to determine if `object` contains equivalent property values.
 *
 * *Note:* This function is equivalent to `matches` when source is partially applied.
 *
 * Partial comparisons will match empty array and empty object source values against any array or object value, respectively.
 *
 * Differences from lodash:
 * - does not match `0` to `-0`
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 12,917 bytes
 * - Micro-dash: 721 bytes
 */
declare function isMatch<T>(object: T, source: DeepPartial<T>): boolean;

/**
 * Checks if value is `null` or `undefined`.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 79 bytes
 * - Micro-dash: 71 bytes
 */
declare function isNil(value: any): value is Nil;

/**
 * Checks if `value` is classified as a `Number` primitive.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 796 bytes
 * - Micro-dash: 64 bytes
 */
declare function isNumber(value: any): value is number;

/**
 * Checks if `value` is the [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) of `Object`. _(e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)_
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 106 bytes
 * - Micro-dash: 65 bytes
 */
declare function isObject(value: any): value is object;

/**
 * Checks if `value` is classified as a `RegExp` object.
 *
 * Differences from lodash:
 * - returns `true` for subclasses of `RegExp`
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 1,152 bytes
 * - Micro-dash: 69 bytes
 */
declare function isRegExp(value: any): value is RegExp;

/**
 * Checks if `value` is classified as a String primitive.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 861 bytes
 * - Micro-dash: 98 bytes
 */
declare function isString(value: any): value is string;

/**
 * Checks if `value` is `undefined`.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 82 bytes
 * - Micro-dash: 74 bytes
 */
declare function isUndefined(value: any): value is undefined;

/**
 * Converts `value` to an array.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 7,022 bytes
 * - Micro-dash: 206 bytes
 */
declare function toArray(value: string): string[];
declare function toArray<T extends readonly any[]>(value: T): T;
declare function toArray<T extends object>(value: T): Array<T[keyof T]>;
declare function toArray(value: Nil | Primitive): [];
declare function toArray(value: any): any[];

/**
 * Converts `value` to a string. An empty string is returned for `null` and `undefined` values.
 *
 * Differences:
 * - `null` and `undefined` array references are blank
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 1,194 bytes
 * - Micro-dash: 82 bytes
 */
declare function toString(value: any): string;

/**
 * This function is like `max` except that it accepts `iteratee` which is invoked for each element in `array` to generate the criterion by which the value is ranked.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 15,906 bytes
 * - Micro-dash: 219 bytes
 */
declare function maxBy<T extends Existent>(array: readonly T[], iteratee: ValueIteratee<T, Primitive>): T;

/**
 * This function is like `min` except that it accepts `iteratee` which is invoked for each element in `array` to generate the criterion by which the value is ranked.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 15,906 bytes
 * - Micro-dash: 219 bytes
 */
declare function minBy<T extends Existent>(array: readonly T[], iteratee: ValueIteratee<T, Primitive>): T;

/**
 * Produces a random number between the inclusive `lower` and `upper` bounds. If only one argument is provided a number between `0` and the given number is returned. If `floating` is true, or either `lower` or `upper` are floats, a floating-point number is returned instead of an integer.
 *
 * Differences from lodash:
 * - does not coerce arguments into finite numbers. E.g. if you supply `NaN` or `Infinity`, results are not guaranteed.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 2,740 bytes
 * - Micro-dash: 380 bytes
 */
declare function random(floating?: boolean): number;
declare function random(upper: number, floating?: boolean): number;
declare function random(lower: number, upper: number, floating?: boolean): number;

/**
 * Computes `number` rounded to `precision`.
 *
 * ```ts
 * round(4.006); // 4
 * round(4.006, 2); // 4.01
 * round(4060, -2); // 4100
 * ```
 *
 * Differences from lodash:
 * - may return `NaN` with large `precision` values
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 2,270 bytes
 * - Micro-dash: 89 bytes
 */
declare function round(number: number, precision?: number): number;

/**
 * This function is like `sum` except that it accepts `iteratee` which is invoked for each element in `array` to generate the value to be summed. The iteratee is invoked with one argument: (value).
 *
 * Differences from lodash:
 * - does not skip `undefined` values
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 15,834 bytes
 * - Micro-dash: 77 bytes
 */
declare function sumBy<T>(array: readonly T[], iteratee: (element: T) => number): number;

/**
 * Clamps `number` within the inclusive lower and upper bounds.
 *
 * Differences from lodash:
 * - `lower` is required
 * - does not coerce bounds that are `NaN` to be `0`
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 1,652 bytes
 * - Micro-dash: 108 bytes
 */
declare function clamp(number: number, lower: number, upper: number): number;

/**
 * Checks if `n` is between `start` and up to, but not including, `end`. If start is greater than end the params are swapped to support negative ranges.
 *
 * Differences from lodash:
 * - `start` and `end` are both required
 * - does not coerce falsey bounds to `0`
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 1,736 bytes
 * - Micro-dash: 116 bytes
 */
declare function inRange(number: number, start: number, end: number): boolean;

type DefiniteValueMatches<T, O> = {
    [K in keyof T]: T[K] extends O ? K : never;
}[keyof T];
type PossibleValueMatches<T, O> = {
    [K in keyof T]: IfCouldBe<T[K], O, Cast<K, string>>;
}[keyof T];
type DefiniteKeyMatch<T, O> = {
    [K in keyof T]: Cast<K, string> extends O ? K : never;
}[keyof T];
type PossibleKeyMatch<T, O> = {
    [K in keyof T]: IfCouldBe<Cast<K, string>, O, Narrow<Cast<K, string>, O>>;
}[keyof T];
/**
 * This function is like `find` except that it returns the key of the first element `predicate` returns truthy for instead of the element itself.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 16,048 bytes
 * - Micro-dash: 377 bytes
 */
declare function findKey<T>(array: T[], predicate: ArrayIteratee<T, boolean>): string | undefined;
declare function findKey<I, T extends NonNullable<I>, O>(object: I, predicate: ValueNarrowingIteratee<T, O>): IfCouldBe<I, Nil, undefined> | PossibleValueMatches<T, O> | (DefiniteValueMatches<T, O> extends never ? undefined : never);
declare function findKey<I, T extends NonNullable<I>, O>(object: I, predicate: KeyNarrowingIteratee<T, O>): IfCouldBe<I, Nil, undefined> | PossibleKeyMatch<T, O> | (DefiniteKeyMatch<T, O> extends never ? undefined : never);
declare function findKey<T>(object: Nil | T, predicate: ObjectIteratee<T, boolean>): Cast<keyof T, string> | undefined;

/**
 * Iterates over own enumerable string keyed properties of an object and invokes `iteratee` for each property. Iteratee functions may exit iteration early by explicitly returning `false`.
 *
 * Differences from lodash:
 * - does not treat sparse arrays as dense
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 4,212 bytes
 * - Micro-dash: 265 bytes
 */
declare function forOwn<T>(object: T, iteratee: ObjectIteratee<T, boolean | void>): T;

/**
 * This function is like `forOwn` except that it iterates over properties of `object` in the opposite order.
 *
 * Differences from lodash:
 * - does not treat sparse arrays as dense
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 4,214 bytes
 * - Micro-dash: 261 bytes
 */
declare function forOwnRight<T>(object: T, iteratee: ObjectIteratee<T, boolean | void>): T;

/**
 * Creates an array of function property names from own enumerable properties of `object`.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 4,110 bytes
 * - Micro-dash: 198 bytes
 */
declare function functions<T extends object>(obj: T): Array<StringifiedKey<T>>;

type WithDefault<V, D> = (undefined extends D ? V : Exclude<V, undefined>) | (undefined extends V ? D : never);
/**
 * Gets the value at `path` of `object`. If the resolved value is `undefined`, the `defaultValue` is returned in its place.
 *
 * Differences from lodash:
 * - does not handle a dot-separated string for `path`
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 6,051 bytes
 * - Micro-dash: 237 bytes
 */
declare function get<T, K extends keyof NonNullable<T>, D = undefined>(object: T, key: K, defaultValue?: D): IfCouldBe<T, Nil, D> | WithDefault<NonNullable<T>[K], D>;
declare function get<D = undefined>(object: object, path: [], defaultValue?: D): D;
declare function get<T, K1 extends keyof NonNullable<T>, D = undefined>(object: T, path: readonly [K1], defaultValue?: D): IfCouldBe<T, Nil, D> | WithDefault<NonNullable<T>[K1], D>;
declare function get<T, K1 extends keyof NonNullable<T>, K2 extends keyof NonNullable<T>[K1], D = undefined>(object: T, path: readonly [K1, K2], defaultValue?: D): IfCouldBe<T, Nil, D> | WithDefault<NonNullable<T>[K1][K2], D>;
declare function get<T, K1 extends keyof NonNullable<T>, K2 extends keyof NonNullable<T>[K1], K3 extends keyof NonNullable<T>[K1][K2], D = undefined>(object: T, path: readonly [K1, K2, K3], defaultValue?: D): IfCouldBe<T, Nil, D> | WithDefault<NonNullable<T>[K1][K2][K3], D>;
declare function get<T, K1 extends keyof NonNullable<T>, K2 extends keyof NonNullable<T>[K1], K3 extends keyof NonNullable<T>[K1][K2], K4 extends keyof NonNullable<T>[K1][K2][K3], D = undefined>(object: T, path: readonly [K1, K2, K3, K4], defaultValue?: D): IfCouldBe<T, Nil, D> | WithDefault<NonNullable<T>[K1][K2][K3][K4], D>;
declare function get(object: Nil | object, path: readonly PropertyKey[], defaultValue?: any): any;

type Invoked<Func, Args> = NonNullable<Func> extends (...args: infer Params) => infer Ret ? IfCouldBe<Args, Params, Ret> | IfCouldBe<Func, Nil, undefined> : undefined;
type Invoke<T, Path extends readonly PropertyKey[], Args extends any[]> = Path extends readonly [] ? Invoked<T, Args> : Path extends readonly [
    infer K extends keyof NonNullable<T>,
    ...infer R extends PropertyKey[]
] ? Invoke<NonNullable<T>[K], R, Args> | IfCouldBe<T, Nil, undefined> : any;
/**
 * Invokes the method at `path` of `object`.
 *
 * Differences from lodash:
 * - only accepts an array for `path`, not a dot-separated string
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 7,407 bytes
 * - Micro-dash: 389 bytes
 */
declare function invoke<T extends object | Nil, const Path extends readonly PropertyKey[], Args extends any[]>(object: T, path: Path, ...args: Args): Invoke<T, Path, Args>;

/**
 * Creates an array of the own enumerable property names of object.
 *
 * Differences from lodash:
 * - does not give any special consideration for arguments objects, strings, or prototype objects (e.g. many will have `'length'` in the returned array)
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 3,866 bytes
 * - Micro-dash: 165 bytes
 */
declare function keys<T>(object: Nil | T): Array<StringifiedKey<T>>;

/**
 * The opposite of {@linkcode mapValues}; this function creates an object with the same values as `object` and keys generated by running each own enumerable string keyed property of object through `iteratee`.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 16,189 bytes
 * - Micro-dash: 123 bytes
 */
declare function mapKeys<A extends readonly any[], O extends PropertyKey>(array: A | Nil, iteratee: (item: A[number], index: number) => O): Record<O, A[number]>;
declare function mapKeys<T, O extends PropertyKey>(object: T, iteratee: ObjectIteratee<NonNullable<T>, O>): IfCouldBe<T, Nil, EmptyObject> | Record<O, NonNullable<T>[keyof NonNullable<T>]>;

/**
 * Creates an object with the same keys as `object` and values generated by running each own enumerable string keyed property of `object` thru `iteratee`.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 16,189 bytes
 * - Micro-dash: 120 bytes
 */
declare function mapValues<A extends readonly any[], O>(array: A | Nil, iteratee: (item: A[number], index: number) => O): Record<number, O>;
declare function mapValues<T, O>(object: T, iteratee: ObjectIteratee<NonNullable<T>, O>): IfCouldBe<T, Nil, {}> | Record<keyof NonNullable<T>, O>;

type Mergeable<O> = {
    [K in keyof O]?: O[K] extends object ? Mergeable<O[K]> : O[K];
} & object;
/**
 * Recursively merges own enumerable string keyed properties of source objects into the destination object. Object properties are merged recursively. Source objects are applied from left to right. Subsequent sources overwrite property assignments of previous sources.
 *
 * **Note:** This function mutates `object`.
 *
 * Differences from lodash:
 * - will overwrite a value with `undefined`
 * - only supports arguments that are objects
 * - cannot handle circular references
 * - when merging an array onto a non-array, the result is a non-array
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 11,996 bytes
 * - Micro-dash: 426 bytes
 */
declare function merge<O extends object, S extends Array<Mergeable<O>>>(object: O, ...sources: S): UnionToIntersection<O | S[number]>;

type RemainingKeys<T, Omits> = Exclude<keyof T, Omits> | Extract<PropertyKey, keyof T>;
/**
 * The opposite of `pick`; this function creates an object composed of the own enumerable string properties of object that are not omitted.
 *
 * Differences from lodash:
 * - `paths` must be direct keys of `object` (they cannot refer to deeper properties)
 * - does not work with arrays
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 18,060 bytes
 * - Micro-dash: 161 bytes
 */
declare function omit<T extends Nil | object, O extends ReadonlyArray<keyof Exclude<T, Nil>>>(object: T, ...paths: O): IfCouldBe<T, Nil, EmptyObject> | {
    [K in RemainingKeys<Exclude<T, Nil>, O[number]>]: Exclude<T, Nil>[K];
};

type IfDefinitelyIncluded$1<T, O, If, Else = never> = IfCouldBe<T, O, Else, If>;
type IfMaybeIncluded$1<T, O, If, Else = never> = IfDefinitelyIncluded$1<T, O, Else, Exclude<T, O> extends never ? Else : If>;
type KeysWithDefinitelyIncludedValues$1<T, O> = {
    [K in keyof T]: IfDefinitelyIncluded$1<T[K], O, K>;
}[keyof T];
type KeysWithMaybeIncludedValues$1<T, O> = {
    [K in keyof T]: IfMaybeIncluded$1<T[K], O, K>;
}[keyof T];
type DefinitelyIncludedKeys$1<T, O> = {
    [K in keyof T]: IfIndexType<K, Exclude<string, O> extends never ? never : K, IfDefinitelyIncluded$1<Cast<K, string>, O, K>>;
}[keyof T];
type MaybeIncludedKeys$1<T, O> = {
    [K in keyof T]: IfIndexType<K, never, IfMaybeIncluded$1<Cast<K, string>, O, K>>;
}[keyof T];
/**
 * The opposite of `pickBy`; this function creates an object composed of the own enumerable string keyed properties of `object` that `predicate` doesn't return truthy for.
 *
 * Differences from lodash:
 * - does not treat sparse arrays as dense
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 17,456 bytes
 * - Micro-dash: 389 bytes
 */
declare function omitBy<T, O>(object: Nil | readonly T[], predicate: ValueNarrowingIteratee<T[], O>): Record<number, Exclude<T, O>>;
declare function omitBy<T>(object: Nil | readonly T[], predicate: ObjectIteratee<T, boolean>): Record<number, T>;
declare function omitBy<I, T extends NonNullable<I>, O>(object: I, predicate: ValueNarrowingIteratee<T, O>): Evaluate<IfCouldBe<I, Nil, {}> | ({
    [K in KeysWithMaybeIncludedValues$1<T, O>]?: Exclude<T[K], O>;
} & {
    [K in KeysWithDefinitelyIncludedValues$1<T, O>]: Exclude<T[K], O>;
})>;
declare function omitBy<I, T extends NonNullable<I>, O>(object: I, predicate: KeyNarrowingIteratee<T, O>): Evaluate<IfCouldBe<I, Nil, {}> | ({
    [K in DefinitelyIncludedKeys$1<T, O>]: T[K];
} & {
    [K in MaybeIncludedKeys$1<T, O>]?: T[K];
})>;
declare function omitBy<T>(object: T, predicate: ObjectIteratee<T, boolean>): Evaluate<PartialExceptIndexes<NonNullable<T>>>;

/**
 * Creates an object composed of the picked `object` properties.
 *
 * Differences from lodash:
 * - `paths` must be direct properties of `object` (they cannot references deep properties)
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 9,083 bytes
 * - Micro-dash: 127 bytes
 */
declare function pick<T, P extends ReadonlyArray<keyof NonNullable<T>>>(object: T, ...paths: P): IfCouldBe<T, Nil, {}> | {
    [K in P[number]]: NonNullable<T>[K];
};

type IfDefinitelyIncluded<T, O, If, Else = never> = Exclude<T, O> extends never ? If : Else;
type IfMaybeIncluded<T, O, If, Else = never> = IfDefinitelyIncluded<T, O, Else, IfCouldBe<T, O, If, Else>>;
type KeysWithDefinitelyIncludedValues<T, O> = {
    [K in keyof T]: IfDefinitelyIncluded<T[K], O, K>;
}[keyof T];
type KeysWithMaybeIncludedValues<T, O> = {
    [K in keyof T]: IfMaybeIncluded<T[K], O, K>;
}[keyof T];
type DefinitelyIncludedKeys<T, O> = {
    [K in keyof T]: IfIndexType<K, IfCouldBe<O, string, IfCouldBe<K, string, Extract<O, K>, K>>, IfDefinitelyIncluded<Cast<K, string>, O, K>>;
}[keyof T];
type MaybeIncludedKeys<T, O> = {
    [K in keyof T]: IfIndexType<K, never, IfMaybeIncluded<Cast<K, string>, O, K>>;
}[keyof T];
/**
 * Creates an object composed of the `object` properties `predicate` returns truthy for.
 *
 * Differences from lodash:
 * - does not treat sparse arrays as dense
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 17,091 bytes
 * - Micro-dash: 346 bytes
 */
declare function pickBy<T, O>(object: Nil | readonly T[], predicate: ValueNarrowingIteratee<T[], O>): Record<number, Narrow<T, O>>;
declare function pickBy<T>(object: Nil | readonly T[], predicate: ObjectIteratee<T, boolean>): Record<number, T>;
declare function pickBy<I, T extends NonNullable<I>, O>(object: I, predicate: ValueNarrowingIteratee<T, O>): Evaluate<IfCouldBe<I, Nil, {}> | ({
    [K in KeysWithMaybeIncludedValues<T, O>]?: Narrow<T[K], O>;
} & {
    [K in KeysWithDefinitelyIncludedValues<T, O>]: Narrow<T[K], O>;
})>;
declare function pickBy<I, T extends NonNullable<I>, O>(object: I, predicate: KeyNarrowingIteratee<T, O>): Evaluate<IfCouldBe<I, Nil, {}> | ({
    [K in DefinitelyIncludedKeys<T, O>]: T[K];
} & {
    [K in MaybeIncludedKeys<T, O>]?: T[K];
})>;
declare function pickBy<T>(object: T, predicate: ObjectIteratee<T, boolean>): Evaluate<PartialExceptIndexes<NonNullable<T>>>;

/**
 * Sets the value at `path` of `object`. If a portion of `path` doesn't exist, it's created. Arrays are created for missing index properties while objects are created for all other missing properties.
 *
 * **Note:** This function mutates `object`.
 *
 * Differences from lodash:
 * - only accepts an array for `path`, not a dot-separated string
 * - does not handle `customizer` returning `undefined`
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 6,735 bytes
 * - Micro-dash: 259 bytes
 */
declare function set<T>(object: T, path: ReadonlyArray<number | string>, value: any): T;

/**
 * Creates an array of own enumerable string keyed-value pairs for `object` which can be consumed by `fromPairs`.
 *
 * Differences from lodash:
 * - does not give any special consideration for arguments objects, strings, or prototype objects (e.g. many will have `'length'` in the returned array)
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 5,791 bytes
 * - Micro-dash: 207 bytes
 */
declare function toPairs<T>(object: T): Array<[StringifiedKey<T>, T[keyof T]]>;

/**
 * An alternative to `reduce`; this function transforms `object` to a new `accumulator` object which is the result of running each of its own enumerable string keyed properties thru `iteratee`, with each invocation potentially mutating the `accumulator` object. If `accumulator` is not provided, a new plain object (`{}`) will be used. Iteratee functions may exit iteration early by explicitly returning `false`.
 *
 * Differences from lodash:
 * - the default accumulator will not have any special prototype, it will simply be `{}`
 * - does not treat sparse arrays as dense
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 16,402 bytes
 * - Micro-dash: 318 bytes
 */
declare function transform<E, A>(array: readonly E[] | undefined, iteratee: (accumulator: A, value: E, index: number) => boolean | void, accumulator?: A): A;
declare function transform<E, A>(object: ObjectWith<E> | undefined, iteratee: (accumulator: A, value: E, key: string) => boolean | void, accumulator?: A): A;

/**
 * This function is like `set()` except that it accepts `updater` to produce the value to set.
 *
 * **Note:** This function mutates `object`.
 *
 * Differences from lodash:
 * - only accepts an array for `path`, not a dot-separated string
 * - does not handle `customizer` returning `undefined`
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 7,006 bytes
 * - Micro-dash: 191 bytes
 */
declare function update<T>(object: T, path: ReadonlyArray<number | string>, updater: (val: any) => any): T;

/**
 * Creates an array of the own enumerable string keyed property values of `object`.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 4,073 bytes
 * - Micro-dash: 186 bytes
 */
declare function values<T>(object: T): Array<T[keyof T]>;

/**
 * Converts `string` to camel case.
 *
 * Differences from lodash:
 * - requires `string` to be a string
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 6,803 bytes
 * - Micro-dash: 388 bytes
 */
declare function camelCase(string: string): string;

/**
 * Converts the first character of `string` to upper case and the remaining to lower case.
 *
 * Differences from lodash:
 * - requires `string` to be a string
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 2,444 bytes
 * - Micro-dash: 117 bytes
 */
declare function capitalize(string: string): string;

/**
 * Converts `string` to [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles).
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 5,487 bytes
 * - Micro-dash: 295 bytes
 */
declare function kebabCase(string: string): string;

/**
 * Converts the first character of `string` to lower case.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 2,412 bytes
 * - Micro-dash: 100 bytes
 */
declare function lowerFirst(string: Nil | string): string;

/**
 * Pads `string` on the left and right sides if it's shorter than `length`. Padding characters are truncated if they can't be evenly divided by `length`.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 4,239 bytes
 * - Micro-dash: 97 bytes
 */
declare function pad(s: string, length: number, chars?: string): string;

/**
 * Pads `string` on the left side if it's shorter than `length`. Padding characters are truncated if they exceed `length`.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 4,169 bytes
 * - Micro-dash: 70 bytes
 */
declare function padStart(s: string, length: number, chars?: string): string;

/**
 * Pads `string` on the right side if it's shorter than `length`. Padding characters are truncated if they exceed `length`.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 4,169 bytes
 * - Micro-dash: 68 bytes
 */
declare function padEnd(s: string, length: number, chars?: string): string;

/**
 * Repeats the given string `n` times.
 *
 * Differences from lodash:
 * - does not work as an iteratee for functions like `map`
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 2,937 bytes
 * - Micro-dash: 94 bytes
 */
declare function repeat(string: string, n: number): string;

/**
 * Converts `string` to [snake case](https://en.wikipedia.org/wiki/Snake_case)
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 5,500 bytes
 * - Micro-dash: 308 bytes
 */
declare function snakeCase(string: string): string;

/**
 * Converts `string` to [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage).
 *
 * Differences from lodash:
 * - requires `string` to be a string
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 6,730 bytes
 * - Micro-dash: 321 bytes
 */
declare function startCase(string: string): string;

/**
 * Converts `string`, as a whole, to lower case just like `String#toLowerCase`.
 *
 * Differences from lodash:
 * - requires `string` to be a string
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 1,209 bytes
 * - Micro-dash: 51 bytes
 */
declare function toLower(string: string): string;

/**
 * Converts the first character of `string` to upper case.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 2,412 bytes
 * - Micro-dash: 100 bytes
 */
declare function upperFirst(string: Nil | string): string;

/**
 * Splits `string` into an array of its words.
 *
 * Differences from lodash:
 * - does not accept a `pattern` argument
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 2,760 bytes
 * - Micro-dash: 215 bytes
 */
declare function words(string: string): string[];

/**
 * Creates a function that returns `value`.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 80 bytes
 * - Micro-dash: 56 bytes
 */
declare function constant<T>(value: T): () => T;

/**
 * Creates a function that returns the result of invoking the given functions with the `this` binding of the created function, where each successive invocation is supplied the return value of the previous.
 *
 * Differences from lodash:
 * - does not accept an array of functions
 * - the first function called can take 0-1 arguments (in lodash it can be any number)
 * - might not construct a new function when it is unnecessary
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 5,695 bytes
 * - Micro-dash: 111 bytes
 */
declare function flow<R1, R2>(f1: () => R1, f2: (a: R1) => R2): () => R2;
declare function flow<R1, R2, R3>(f1: () => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): () => R3;
declare function flow<R1, R2, R3, R4>(f1: () => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): () => R4;
declare function flow<R1, R2, R3, R4, R5>(f1: () => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): () => R5;
declare function flow<R1, R2, R3, R4, R5, R6>(f1: () => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): () => R6;
declare function flow<R1, R2, R3, R4, R5, R6, R7>(f1: () => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): () => R7;
declare function flow<A1, R1, R2>(f1: (a1: A1) => R1, f2: (a: R1) => R2): (a1: A1) => R2;
declare function flow<A1, R1, R2, R3>(f1: (a1: A1) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (a1: A1) => R3;
declare function flow<A1, R1, R2, R3, R4>(f1: (a1: A1) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): (a1: A1) => R4;
declare function flow<A1, R1, R2, R3, R4, R5>(f1: (a1: A1) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): (a1: A1) => R5;
declare function flow<A1, R1, R2, R3, R4, R5, R6>(f1: (a1: A1) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): (a1: A1) => R6;
declare function flow<A1, R1, R2, R3, R4, R5, R6, R7>(f1: (a1: A1) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7): (a1: A1) => R7;
declare function flow(): <T>(a: T) => T;
declare function flow<T>(f1: () => T, ...funcs: Array<(val: T) => T>): () => T;
declare function flow<T>(...funcs: Array<(val: T) => T>): (val: T) => T;

/**
 * This function is like `flow` except that it creates a function that invokes the given functions from right to left.
 *
 * Differences from lodash:
 * - does not accept an array of functions
 * - the first function called can take 0-1 arguments (in lodash it can be any number)
 * - might not construct a new function when it is unnecessary
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 5,710 bytes
 * - Micro-dash: 111 bytes
 */
declare function flowRight<R1, R2>(f2: (a: R1) => R2, f1: () => R1): () => R2;
declare function flowRight<R1, R2, R3>(f3: (a: R2) => R3, f2: (a: R1) => R2, f1: () => R1): () => R3;
declare function flowRight<R1, R2, R3, R4>(f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: () => R1): () => R4;
declare function flowRight<R1, R2, R3, R4, R5>(f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: () => R1): () => R5;
declare function flowRight<R1, R2, R3, R4, R5, R6>(f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: () => R1): () => R6;
declare function flowRight<R1, R2, R3, R4, R5, R6, R7>(f7: (a: R6) => R7, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: () => R1): () => R7;
declare function flowRight<A1, R1, R2>(f2: (a: R1) => R2, f1: (a1: A1) => R1): (a1: A1) => R2;
declare function flowRight<A1, R1, R2, R3>(f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1) => R1): (a1: A1) => R3;
declare function flowRight<A1, R1, R2, R3, R4>(f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1) => R1): (a1: A1) => R4;
declare function flowRight<A1, R1, R2, R3, R4, R5>(f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1) => R1): (a1: A1) => R5;
declare function flowRight<A1, R1, R2, R3, R4, R5, R6>(f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1) => R1): (a1: A1) => R6;
declare function flowRight<A1, R1, R2, R3, R4, R5, R6, R7>(f7: (a: R6) => R7, f6: (a: R5) => R6, f5: (a: R4) => R5, f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: (a1: A1) => R1): (a1: A1) => R7;
declare function flowRight(): <T>(a: T) => T;
declare function flowRight<T>(...funcs: [...Array<(val: T) => T>, f1: () => T]): () => T;
declare function flowRight<T>(...funcs: Array<(val: T) => T>): (val: T) => T;

/**
 * This function returns the first argument it receives.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 51 bytes
 * - Micro-dash: 40 bytes
 */
declare function identity<T>(value: T): T;

/**
 * Creates a function that performs a partial deep comparison between a given `object` and `source`, returning `true` if the given object has equivalent property values, else `false`.
 *
 * Note: The created function is equivalent to `isMatch` with source partially applied.
 *
 * Partial comparisons will match empty array and empty object source values against any array or object value, respectively.
 *
 * Differences from lodash:
 * - does not match `0` to `-0`
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 18,319 bytes
 * - Micro-dash: 800 bytes
 */
declare function matches(source: any): (value: any) => boolean;

/**
 * This function returns `undefined`.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 48 bytes
 * - Micro-dash: 40 bytes
 */
declare function noop(): void;

type PropertyAtPath<T, Path extends readonly any[]> = Path extends [] ? T : Path extends readonly [infer First, ...infer Rest] ? First extends keyof NonNullable<T> ? IfCouldBe<T, Nil, undefined> | PropertyAtPath<NonNullable<T>[First], Rest> : undefined : unknown;
/**
 * Creates a function that returns the value at `path` of a given object.
 *
 * Differences from lodash:
 * - does not handle a dot-separated string for `path`
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 6,158 bytes
 * - Micro-dash: 207 bytes
 */
declare function property<K extends PropertyKey>(key: K): <T>(object: T) => PropertyAtPath<T, [K]>;
declare function property<P extends PropertyKey[]>(path: readonly [...P]): <T>(object: T) => PropertyAtPath<T, P>;

/**
 * Creates an array of numbers _(positive and/or negative)_ progressing from `start` up to, but not including, `end`. A `step` of `-1` is used if a negative `start` is specified without an `end` or `step`. If `end` is not specified, it's set to `start` with `start` then set to `0`.
 *
 * **Note:** JavaScript follows the IEEE-754 standard for resolving floating-point values which can produce unexpected results.
 *
 * Differences from lodash:
 * - does not work as an iteratee for functions like `map`
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 2,565 bytes
 * - Micro-dash: 209 bytes
 */
declare function range(end: number): number[];
declare function range(start: number, end: number, step?: number): number[];

/**
 * Invokes the iteratee `n` times, returning an array of the results of each invocation.
 *
 * Differences from lodash:
 * - has undefined behavior when given a non natural number for `n`
 * - does not provide a default for `iteratee`
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 1,920 bytes
 * - Micro-dash: 76 bytes
 */
declare function times<T>(n: number, iteratee: (index: number) => T): T[];

/**
 * Generates a unique ID. If `prefix` is given, the ID is appended to it.
 *
 * Contribution to minified bundle size, when it is the only function imported:
 * - Lodash: 1,238 bytes
 * - Micro-dash: 75 bytes
 */
declare function uniqueId(prefix?: string): string;

export { bindKey, camelCase, capitalize, castArray, chunk, clamp, clone, cloneDeep, compact, concat, constant, curry, debounce, difference, every, filter, find, findKey, flatMap, flatten, flow, flowRight, forEach, forEachRight, forOwn, forOwnRight, functions, get, groupBy, identity, inRange, includes, initial, intersection, invoke, isBoolean, isEmpty, isEqual, isFunction, isMatch, isNil, isNumber, isObject, isRegExp, isString, isUndefined, kebabCase, keyBy, keys, last, lowerFirst, map, mapKeys, mapValues, matches, maxBy, memoize, merge, minBy, negate, noop, nth, omit, omitBy, once, pad, padEnd, padStart, partial, partition, pick, pickBy, property, pull, pullAll, pullAt, random, range, reduce, reduceRight, reject, remove, repeat, round, sample, sampleSize, set, shuffle, size, snakeCase, some, sortBy, sortedIndex, startCase, sumBy, throttle, times, toArray, toLower, toPairs, toString, transform, union, uniq, uniqBy, uniqueId, update, upperFirst, values, without, words, zip, zipObject };