import { IsNullable } from './is_empty.cjs';
import { DeepPartial, Collection, ObjectType, Many, AnyObject } from './types/custom_type.types.cjs';

declare const MAX_RECURSION_DEPTH_HIGH: number;
declare const MAX_RECURSION_DEPTH_MEDIUM: number;
declare const MAX_RECURSION_DEPTH_LOW: number;
declare const sleep: (ms?: number) => Promise<unknown>;
declare const findAndReplace: <T, R>(array: (T | R)[], filter: DeepPartial<T> | DeepPartial<R>, replace: (matched: T | R | undefined, index: number, array_: (T | R)[], filterFullfil: boolean) => R) => T | R | undefined;
declare const findManyAndReplace: <T, R>(array: (T | R)[], filter: DeepPartial<T> | DeepPartial<R>, replace: (matched: T | R | undefined, index: number, array_: (T | R)[], filterFullfil: boolean) => R) => Collection<T | R | undefined>;
declare const compareObjectDeep: (criteria: Record<any, any>, value: object, depth_?: number) => boolean;
declare const find: <T>(col: Collection<T> | undefined, filter?: DeepPartial<T> | undefined, customCondition?: ((element: T, index: number, _: T[], filterFullfil: boolean) => boolean) | undefined) => T | undefined;
declare const findMany: <T>(col: Collection<T> | undefined, filter?: DeepPartial<T> | undefined, customCondition?: ((element: T, index: number, _: T[], filterFullfil: boolean) => boolean) | undefined) => T[];
declare const chunk: <T>(input: Collection<T>, size: number) => T[][];
declare const batchOf: (index: number, total: number, batchSize: number) => string;
declare const transform: <R extends ObjectType<unknown, never>, T>(cols: ObjectType<T, keyof T> | Collection<T>, callback: (result: R, value: T, key: string | number) => void) => R | undefined;
declare const orderBy: <T extends Record<string, any>, Ts extends Collection<T> = never>(xs: Ts | Collection<T> | undefined, sortingRule: Partial<Record<keyof T, 1 | -1 | "asc" | "desc" | (1 | -1 | "asc" | "desc")[]>>) => Ts;
declare const orderByKeys: <T extends Record<string, any>, Ts extends Collection<T> = never, U extends keyof T = never>(xs: Ts | Collection<T> | undefined, keys?: Many<U>[], sortingRule?: (`asc` | `desc` | -1 | 1) | Array<`asc` | `desc` | -1 | 1>) => Ts;
declare const groupBy: <T extends Record<string, any>, C extends Collection<T>>(xs: C, key: string) => Record<string, C[]>;
declare const mergeArrayByKeys: <T extends Record<string, any>, Ts extends Collection<T>>(xs: Ts) => Record<string, T[]>;
declare const uniqueBy: <T>(array: T[], key: keyof T) => T[];
declare const arrayFilter: <T>(array: Collection<T>) => NonNullable<T>[];
declare const arrayFilterFunc: <T>(value: T) => value is Exclude<T, IsNullable>;
declare const arrayFilterEmptyFunc: <T>(value: T) => value is Exclude<T, "" | [] | null | undefined>;
declare const maxNumber: (array: number[]) => number;
declare const minNumber: (array: number[]) => number;
declare const sumNumbers: (array: number[]) => number;
declare const avgNumbers: (array: number[]) => number;
declare const pickRandomValue: <T, S extends boolean = true>(col: T[], strict?: S | undefined, max_call?: number) => S extends true ? T : T | undefined;
declare const pickRandomValues: <T, S extends boolean = true>(col: T[], howMuch?: number, strict?: S | undefined, max_call?: number) => S extends true ? T[] : (T | undefined)[];
declare const randomArrayValue: <T, S extends boolean = true>(col: T[], strict?: S | undefined, max_call?: number) => S extends true ? T : T | undefined;
declare const hasConsecutive: <T>(array: T[], limit?: number, slice?: number) => boolean;
declare const isPromise: <T>(objectTarget: T | Promise<T>) => objectTarget is Promise<T>;
declare const isTrulyValue: (unk: unknown) => unk is string | number | boolean | Date;
declare const isObject: <T = unknown>(object: unknown) => object is ObjectType<T, keyof T>;
declare const isObjectOnlyType: <T = unknown>(object: unknown) => object is ObjectType<T, keyof T>;
declare const isPlainObject: (object: unknown) => boolean;
declare const toPlainObject: <T>(object: T, max_stacks?: number) => T | undefined;
declare const isEqual: (x: unknown, y: unknown) => boolean;
declare const omitKeyProperty: <T extends object>(object: T, key: keyof T, maxStacks?: number) => T;
declare const omitKeysProperty: <T extends AnyObject>(object: T, keys: string[] | (keyof T)[], maxStacks?: number) => T;
declare const omitUndefinedProperty: <T extends Record<string, any>>(object: T, _?: any, __?: any, maxStacks?: number) => T;
declare const toString: <T>(unk: T) => string | undefined;
declare const toStringStrict: <T, R>(unk: T, throwHandler?: boolean | ((unk: T) => R)) => string | R;
declare const omitEmptyProperty: <T extends Record<string, unknown>>(object: T, _?: any, __?: any, maxStacks?: number) => T;
declare const isNull: (value: unknown) => value is null | undefined;
declare const nonNullValue: <E, S extends boolean = true>(variableValue: E, strict?: S | undefined, variableName?: string) => S extends true ? NonNullable<E> : NonNullable<E> | undefined;
declare const toNumberOrUndefined: (unk: unknown) => number | undefined;
declare const objectToArray: <T>(object: T) => T | (T extends Record<any, infer V> ? V : T);

export { MAX_RECURSION_DEPTH_HIGH, MAX_RECURSION_DEPTH_LOW, MAX_RECURSION_DEPTH_MEDIUM, arrayFilter, arrayFilterEmptyFunc, arrayFilterFunc, avgNumbers, batchOf, chunk, compareObjectDeep, find, findAndReplace, findMany, findManyAndReplace, groupBy, hasConsecutive, isEqual, isNull, isObject, isObjectOnlyType, isPlainObject, isPromise, isTrulyValue, maxNumber, mergeArrayByKeys, minNumber, nonNullValue, objectToArray, omitEmptyProperty, omitKeyProperty, omitKeysProperty, omitUndefinedProperty, orderBy, orderByKeys, pickRandomValue, pickRandomValues, randomArrayValue, sleep, sumNumbers, toNumberOrUndefined, toPlainObject, toString, toStringStrict, transform, uniqueBy };