function mean(numbers: number[]): number;

function isDate(value: unknown): boolean;

function slice(value: string | unknown[], start: number = 0, end: number = value.length): string | unknown[];

function kebabCase(string: string): string;

function isPlainObject(value: unknown): boolean;

function isFunction(value: unknown): boolean;

function isObject(value: unknown): boolean;

function camelCase (string: string): string;

function chunk(array: unknown[], size: number = 1): unknown[][];

function repeat(string: string, count: number): string;

function sumByProperty<Value>(values: Value[], property: PropertyT): number;

function endsWith(string: string, searchString: string, position?: number): boolean;

function meanByProperty(array: unknown[], property: string): number;

function lowerFirst(string: string): string;

function isRegExp(value: unknown): boolean;

function concat(array: unknown[], ...values: unknown[][]): unknown[];

function isFinite(value: unknown): boolean;

function toPath<Property extends PropertyT>(property: Property): PathT<Property>;

type PropertyT = PropertyKey;

type PathT<Property extends PropertyT> = Property extends ""
  ? []
  : Property extends number
    ? [Property]
    : Property extends symbol
      ? [Property]
      : Property extends `${ infer First }.${ infer Rest }`
        ? [...PathT<First>, ...PathT<Rest>]
        : Property extends `${ infer First }[${ infer Rest }`
          ? [...PathT<First>, ...PathT<Rest>]
          : Property extends `${ infer First }][${ infer Rest }`
            ? [...PathT<First>, ...PathT<Rest>]
            : Property extends `${ infer Last }]`
              ? [Last]
              : [Property];

function get(value: unknown, property: PropertyT, fallback: unknown): unknown;

function lowerCase(string: string): string;

function isInteger(value: unknown): boolean;

function isError(value: unknown): boolean;

function startsWith(string: string, searchString: string, position?: number): boolean;

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

function isNil(value: unknown): boolean;

function replace(string: string, pattern: RegExp | string, replacement: Function | string): string;

function upperFirst(string: string): string;

function isBuffer(value: unknown): boolean;

function join(array: unknown[], separator: string = ""): string;

function IsNaN(value: unknown): boolean;

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

function sumByFn<Value>(values: Value[], iteratee: (value: Value) => number): number;

function compact<Value>(array: Value[]): Array<CompactT<Value>>;

export type CompactT<Value> = Value extends ""
  ? never
  : Value extends 0
    ? never
    : Value extends false
      ? never
      : Value extends null
        ? never
        : Value extends undefined
          ? never
          : Value extends typeof NaN
            ? never
            : Value;

function isNull(value: unknown): boolean;

function meanByFn(array: unknown[], iteratee: (value: unknown) => number): number;

function isEven(number: number): boolean;

function split(string: string, separator: string | RegExp, limit?: number): string[];

function first<Value extends unknown[] | string>(value: Value): Value;

function isSymbol(value: unknown): value is symbol;

function snakeCase(string: string): string;

function isUndefined(value: unknown): boolean;

function tail<Value extends unknown[] | string>(value: Value): Value;

function sum(numbers: number[]): number;

const isArray = Array.isArray;

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

function isSafeInteger(value: unknown): boolean;

function capitalize(string: string): string;

function upperCase(string: string): string;

function head<Value extends unknown[] | string>(value: Value): Value;

function last<Value extends unknown[] | string>(value: Value): Value;