/**
 * Core type definitions for the Ultimate Lodash library
 */
export type Primitive = string | number | boolean | symbol | null | undefined;
export type DeepReadonly<T> = {
    readonly [P in keyof T]: T[P] extends Primitive ? T[P] : DeepReadonly<T[P]>;
};
export type DeepPartial<T> = {
    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};
export type DeepRequired<T> = {
    [P in keyof T]-?: T[P] extends object ? DeepRequired<T[P]> : T[P];
};
export type NonNullable<T> = T extends null | undefined ? never : T;
export type Predicate<T> = (value: T, index?: number, collection?: readonly T[]) => boolean;
export type ObjectPredicate<T> = (value: T[keyof T], key: keyof T, object: T) => boolean;
export type Iteratee<T, R> = (value: T, index?: number, collection?: readonly T[]) => R;
export type ObjectIteratee<T, R> = (value: T[keyof T], key: keyof T, object: T) => R;
export type PropertyPath = string | number | symbol | (string | number | symbol)[];
export type PropertyName = string | number | symbol;
export type Comparator<T> = (a: T, b: T) => number;
export type ValueIteratee<T, R> = ((value: T) => R) | PropertyPath | Partial<T>;
export type AnyFunction = (...args: any[]) => any;
export type VoidFunction = (...args: any[]) => void;
export type CurriedFunction1<T1, R> = {
    (): CurriedFunction1<T1, R>;
    (t1: T1): R;
};
export type CurriedFunction2<T1, T2, R> = {
    (): CurriedFunction2<T1, T2, R>;
    (t1: T1): CurriedFunction1<T2, R>;
    (t1: T1, t2: T2): R;
};
export type 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;
};
export type 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;
};
export interface LodashWrapper<T> {
    value(): T;
    valueOf(): T;
    toJSON(): T;
    toString(): string;
}
export interface CollectionChain<T> extends LodashWrapper<T[]> {
    chunk(size?: number): CollectionChain<T[]>;
    compact(): CollectionChain<NonNullable<T>>;
    filter(predicate?: Predicate<T>): CollectionChain<T>;
    map<U>(iteratee: Iteratee<T, U>): CollectionChain<U>;
    reduce<U>(iteratee: (accumulator: U, value: T, index: number, collection: T[]) => U, initialValue?: U): LodashWrapper<U>;
}
export interface MemoizeOptions {
    ttl?: number;
    maxSize?: number;
    resolver?: (...args: any[]) => string;
}
export interface DebounceOptions {
    leading?: boolean;
    trailing?: boolean;
    maxWait?: number;
}
export interface ThrottleOptions {
    leading?: boolean;
    trailing?: boolean;
}
export type PathValue<T, P extends PropertyPath> = P extends string | number | symbol ? T extends Record<P, any> ? T[P] : never : P extends readonly [infer Key, ...infer Rest] ? Key extends keyof T ? Rest extends PropertyPath ? PathValue<T[Key], Rest> : never : never : never;
export type SortOrder = "asc" | "desc";
export interface TemplateOptions {
    interpolate?: RegExp;
    evaluate?: RegExp;
    escape?: RegExp;
    variable?: string;
}
export interface SlugifyOptions {
    replacement?: string;
    lower?: boolean;
    strict?: boolean;
    locale?: string;
    trim?: boolean;
}
export interface PromiseSettledResult<T> {
    status: "fulfilled" | "rejected";
    value?: T;
    reason?: any;
}
export type TypeGuard<T, U extends T> = (value: T) => value is U;
export type GroupedResult<T> = Record<string, T[]>;
export interface StatisticalResult {
    mean: number;
    median: number;
    mode: number[];
    standardDeviation: number;
    variance: number;
    min: number;
    max: number;
    sum: number;
    count: number;
}