declare function addLeadingSlash(value: string): string;

declare function arrayToRecord(arr: string[]): Record<string, true>;

declare function assign<T extends object>(target: T, ...sources: unknown[]): T;

declare function castArray<T>(value: T | T[]): T[];

declare function cloneDeep<T>(value: T): T;

declare function compact<T>(array: T[] | null | undefined): T[];

declare function difference<T>(array: T[] | null | undefined, ...values: Array<T[] | null | undefined>): T[];

declare function eachRight<T>(collection: T[] | null | undefined, iteratee: (value: T, key: number, collection: T[]) => unknown): T[] | null | undefined;
declare function eachRight<T extends object>(collection: T | null | undefined, iteratee: (value: T[keyof T], key: string, collection: T) => unknown): T | null | undefined;

declare function filter<T>(collection: T[] | Record<string, T> | null | undefined, predicate: (value: T, key: number | string) => boolean): T[];

declare function find<T>(collection: T[] | Record<string, T> | null | undefined, predicate: (value: T, key: number | string) => boolean): T | undefined;

declare function flatten<T>(array: Array<T | T[]> | null | undefined): T[];

declare function flattenDeep<T>(array: unknown[]): T[];

declare function forEach<T>(collection: T[] | null | undefined, iteratee: (value: T, key: number, collection: T[]) => unknown): T[] | null | undefined;
declare function forEach<T extends object>(collection: T | null | undefined, iteratee: (value: T[keyof T], key: string, collection: T) => unknown): T | null | undefined;

type PropertyPath = string | number | Array<string | number>;

declare function get<T = unknown>(object: unknown, path: PropertyPath, defaultValue?: T): T;

declare function groupBy<T>(collection: T[] | Record<string, T> | null | undefined, iteratee: string | number | ((value: T, key: number | string, collection: T[] | Record<string, T>) => unknown)): Record<string, T[]>;

declare function hasOwn<TKey extends PropertyKey>(value: unknown, key: TKey): value is Record<TKey, unknown>;

declare function intersection<T>(...arrays: Array<T[] | null | undefined>): T[];

declare function intersectionBy<T>(...args: unknown[]): T[];

declare function isArray(value: unknown): value is unknown[];

declare function isBoolean(value: unknown): value is boolean;

declare function isEmpty(value: unknown): boolean;

declare function isEqual(left: unknown, right: unknown): boolean;

declare function isFunction(value: unknown): value is (...args: unknown[]) => unknown;

declare function isMatch(object: unknown, source: unknown): boolean;

declare function isNaNValue(value: unknown): boolean;

declare function isNil(value: unknown): value is null | undefined;

declare function isNumber(value: unknown): value is number;

declare function isObject(value: unknown): value is object;

declare function isPlainObject(value: unknown): value is Record<string, unknown>;

declare function isPromise<T = unknown>(value: unknown): value is PromiseLike<T>;

declare function isString(value: unknown): value is string;

declare function isUndefined(value: unknown): value is undefined;

declare function join(array: unknown[] | null | undefined, separator?: string): string;

declare function keys(value: unknown): string[];

declare function map<T, TResult>(collection: T[] | Record<string, T> | null | undefined, iteratee: string | number | ((value: T, key: number | string, collection: T[] | Record<string, T>) => TResult)): TResult[];

declare function mapKeys<TValue>(object: Record<string, TValue> | null | undefined, iteratee: (value: TValue, key: string, object: Record<string, TValue>) => string): Record<string, TValue>;

declare function mapValues<TValue, TResult>(object: Record<string, TValue> | null | undefined, iteratee: (value: TValue, key: string, object: Record<string, TValue>) => TResult): Record<string, TResult>;

declare function mapValuesAsync<TObject extends Record<string, unknown>, TResult>(object: TObject, asyncFn: (value: TObject[keyof TObject], key: string, object: TObject) => Promise<TResult> | TResult): Promise<Record<string, TResult>>;

declare function noop(): void;

declare function omit<T extends object>(object: T, paths: PropertyPath | PropertyPath[]): Partial<T>;

declare function omitBy<TValue>(object: Record<string, TValue> | null | undefined, predicate: (value: TValue, key: string, object: Record<string, TValue>) => boolean): Record<string, TValue>;

declare function parseBooleanString(str: string | undefined, defaultValue?: boolean): boolean | undefined;

declare function orderBy<T>(collection: T[] | null | undefined, iteratees?: Array<string | number | ((value: T) => unknown)>, orders?: string[]): T[];

declare function padEnd(value: unknown, length?: number, chars?: string): string;

declare function pick<T extends object>(object: T, paths: PropertyPath | PropertyPath[]): Partial<T>;

declare function pickBy<TValue>(object: Record<string, TValue> | null | undefined, predicate: (value: TValue, key: string, object: Record<string, TValue>) => boolean): Record<string, TValue>;

declare function normalizeUrlPath(url: string): string;

declare function reduce<T, TResult>(collection: T[] | null | undefined, iteratee: (accumulator: TResult, value: T, key: number, collection: T[]) => TResult, accumulator?: TResult): TResult;
declare function reduce<T, TResult>(collection: Record<string, T> | null | undefined, iteratee: (accumulator: TResult, value: T, key: string, collection: Record<string, T>) => TResult, accumulator?: TResult): TResult;

declare function removeConsecutiveSlashesFromUrl(url: string): string;

declare function set<T>(object: T, path: PropertyPath, value: unknown): T;

declare function startCase(value: unknown): string;

declare function sum(values: number[] | null | undefined): number;

declare function sumBy<T>(collection: T[] | null | undefined, iteratee: string | number | ((value: T, key: number, collection: T[]) => number | undefined)): number;

declare function toAsyncFn<TArgs extends unknown[], TResult>(fn?: ((this: unknown, ...args: TArgs) => TResult | PromiseLike<TResult>) | null, defaultValue?: TResult): (this: unknown, ...args: TArgs) => PromiseLike<unknown> | Promise<any>;

declare function toStringRecord(value: unknown): Record<string, string> | undefined;

declare function uniq<T>(array: T[] | null | undefined): T[];

declare function uniqBy<T>(array: T[] | null | undefined, iteratee?: string | number | ((value: T, key: number, collection: T[]) => unknown)): T[];

declare function upperCase(value: unknown): string;

export { addLeadingSlash, arrayToRecord, assign, castArray, cloneDeep, compact, difference, eachRight, filter, find, flatten, flattenDeep, forEach, get, groupBy, hasOwn, intersection, intersectionBy, isArray, isBoolean, isEmpty, isEqual, isFunction, isMatch, isNaNValue as isNaN, isNil, isNumber, isObject, isPlainObject, isPromise, isString, isUndefined, join, keys, map, mapKeys, mapValues, mapValuesAsync, noop, normalizeUrlPath, omit, omitBy, orderBy, padEnd, parseBooleanString, pick, pickBy, reduce, removeConsecutiveSlashesFromUrl, set, startCase, sum, sumBy, toAsyncFn, toStringRecord, uniq, uniqBy, upperCase };