declare module "equal" {
    function equal(a: any, b: any): boolean;
    export { equal, equal as default };
}
declare module "array/dedupe" {
    type DedupeFilterFn<T> = (el: T) => boolean;
    type DedupeOptionsBase<T> = {
        filter_fn?: DedupeFilterFn<T>;
    };
    type DedupeOptionsWithKey<T extends Record<string, unknown>> = DedupeOptionsBase<T> & {
        key: keyof T;
    };
    type DedupeOptionsNoKey<T> = DedupeOptionsBase<T>;
    function dedupe<T extends Record<string, unknown>>(val: T[], opts: DedupeOptionsWithKey<T>): T[];
    function dedupe<T>(val: T[], opts?: DedupeOptionsNoKey<T>): T[];
    export { dedupe, dedupe as default };
}
declare module "number/round" {
    function round(val: number, precision?: number): number;
    export { round, round as default };
}
declare module "number/isIntegerAboveOrEqual" {
    function isIntegerAboveOrEqual(val: unknown, ref: number): val is number;
    export { isIntegerAboveOrEqual, isIntegerAboveOrEqual as default };
}
declare module "array/join" {
    interface joinOptions {
        delim?: string;
        dedupe?: boolean;
        trim?: boolean;
        innertrim?: boolean;
        valtrim?: boolean;
        valround?: number;
    }
    function join<T>(val: T[] | Set<T>, opts?: joinOptions): string;
    export { join, join as default };
}
declare module "object/merge" {
    type Merge<T, U> = {
        [K in keyof T | keyof U]: K extends keyof U ? U[K] : K extends keyof T ? T[K] : never;
    };
    type MergeNonUnion<T, U> = {
        [K in keyof T]: K extends keyof U ? U[K] : T[K];
    };
    type MergeArray<T, U extends Record<string, unknown>[], Union extends boolean> = U extends [infer Head, ...infer Tail] ? Head extends Record<string, unknown> ? Tail extends Record<string, unknown>[] ? MergeArray<Union extends true ? Merge<T, Head> : MergeNonUnion<T, Head>, Tail, Union> : Union extends true ? Merge<T, Head> : MergeNonUnion<T, Head> : T : T;
    type Merged<T extends Record<string, unknown>, U extends Record<string, unknown> | Record<string, unknown>[], Union extends boolean> = U extends any[] ? MergeArray<T, U, Union> : Union extends true ? Merge<T, U> : MergeNonUnion<T, U>;
    function merge<T extends Record<string, unknown>, U extends Record<string, unknown> | [Record<string, unknown>, ...Record<string, unknown>[]], Union extends boolean = false>(target: T, source: U, opts?: {
        union?: Union;
    }): Merged<T, U, Union>;
    export { merge, merge as default };
}
declare module "array/mapFn" {
    type MapOptions<T, U = T> = {
        merge?: boolean;
        transform_fn?: (el: T) => U;
    };
    type MapFn<T extends Record<string, any>> = (entry: T) => (string | number | boolean);
    function mapFn<T extends Record<string, any>, U extends Record<string, any> = T>(arr: T[], fn: MapFn<T>, opts?: MapOptions<T, U>): Record<string, U>;
    export { mapFn, mapFn as default };
}
declare module "array/mapFnAsMap" {
    type MapOptions<T, U = T> = {
        merge?: boolean;
        transform_fn?: (el: T) => U;
    };
    type MapFn<T extends Record<string, any>> = (entry: T) => string | number | null;
    function mapFnAsMap<T extends Record<string, any>, TFN extends MapFn<T>, U extends Record<string, any> = T>(arr: T[], fn: TFN, opts?: MapOptions<T, U>): Map<NonNullable<ReturnType<TFN>>, U>;
    export { mapFnAsMap, mapFnAsMap as default };
}
declare module "array/mapKey" {
    type MapOptions<T, U = T> = {
        merge?: boolean;
        filter_fn?: (el: T) => boolean;
        transform_fn?: (el: T) => U;
    };
    function mapKey<T extends Record<string, any>, U extends Record<string, any> = T, TKey extends keyof T = string>(arr: T[], key: TKey, opts?: MapOptions<T, U>): Record<string, U>;
    export { mapKey, mapKey as default };
}
declare module "array/mapKeyAsMap" {
    type MapOptions<T, U = T> = {
        merge?: boolean;
        filter_fn?: (el: T) => boolean;
        transform_fn?: (el: T) => U;
    };
    function mapKeyAsMap<T extends Record<string, any>, U extends Record<string, any> = T, TKey extends keyof T = string>(arr: T[], key: TKey, opts?: MapOptions<T, U>): Map<T[TKey], U>;
    export { mapKeyAsMap, mapKeyAsMap as default };
}
declare module "array/mapPrimitive" {
    type MapOptions = {
        valtrim?: boolean;
        valround?: boolean | number;
        keyround?: boolean;
        filter_fn?: (el: unknown) => boolean;
    };
    type mapReturn = Record<string, string | number>;
    function mapPrimitive(arr: unknown[], opts?: MapOptions): mapReturn;
    export { mapPrimitive, mapPrimitive as default };
}
declare module "object/isNotEmpty" {
    function isNotEmptyObject<T extends Record<string, unknown> = Record<string, unknown>>(val: T | unknown): val is T;
    export { isNotEmptyObject, isNotEmptyObject as default };
}
declare module "array/groupBy" {
    type Handler<T> = (val: T) => string | number | boolean | undefined;
    function groupBy<T extends Record<string, any>>(val: T[] | Set<T>, handler: Handler<T> | keyof T): Record<string, T[]>;
    export { groupBy, groupBy as default };
}
declare module "array/shuffle" {
    function shuffle(arr: unknown[]): void;
    export { shuffle, shuffle as default };
}
declare module "array/split" {
    type SplitOptions<T> = {
        filter_fn?: (el: T) => boolean;
    };
    function split<T>(arr: T[] | Set<T>, size: number, opts?: SplitOptions<T>): T[][];
    export { split, split as default };
}
declare module "object/is" {
    function isObject<T extends Record<string, unknown> = Record<string, unknown>>(val: T | unknown): val is T;
    export { isObject, isObject as default };
}
declare module "array/sort" {
    type sortOptions<T> = {
        filter_fn?: (el: T) => boolean;
        nokey_hide?: boolean;
        nokey_atend?: boolean;
    };
    type sortByFunction = (el: Record<string, any>) => string;
    function sort<T extends {
        [key: string]: any;
    }>(arr: T[], by: string | sortByFunction, dir?: 'asc' | 'desc', opts?: sortOptions<T>): T[];
    export { sort, sort as default };
}
declare module "array/is" {
    function isArray<T = unknown>(val: unknown): val is T[];
    export { isArray, isArray as default };
}
declare module "array/isNotEmpty" {
    function isNotEmptyArray<T = unknown>(val: unknown): val is T[];
    export { isNotEmptyArray, isNotEmptyArray as default };
}
declare module "array/index" {
    export { dedupe } from "array/dedupe";
    export { join } from "array/join";
    export { mapFn } from "array/mapFn";
    export { mapFnAsMap } from "array/mapFnAsMap";
    export { mapKey } from "array/mapKey";
    export { mapKeyAsMap } from "array/mapKeyAsMap";
    export { mapPrimitive } from "array/mapPrimitive";
    export { groupBy } from "array/groupBy";
    export { shuffle } from "array/shuffle";
    export { split } from "array/split";
    export { sort } from "array/sort";
    export { isArray } from "array/is";
    export { isNotEmptyArray } from "array/isNotEmpty";
    export { isNotEmptyArray as isNeArray } from "array/isNotEmpty";
}
declare module "boolean/is" {
    function isBoolean(val: unknown): val is boolean;
    export { isBoolean, isBoolean as default };
}
declare module "boolean/index" {
    export { isBoolean } from "boolean/is";
}
declare module "date/convertToDate" {
    function convertToDate(val: Date | string | number): Date | null;
    export { convertToDate, convertToDate as default };
}
declare module "date/addUTC" {
    export type AddUTCKey = 'years' | 'year' | 'months' | 'month' | 'days' | 'day' | 'hours' | 'hour' | 'minutes' | 'minute' | 'seconds' | 'second' | 'milliseconds' | 'millisecond';
    function addUTC(val: Date | string, amt?: number, key?: AddUTCKey): Date;
    export { addUTC, addUTC as default };
}
declare module "date/diff" {
    export type DiffKey = 'week' | 'weeks' | 'day' | 'days' | 'hour' | 'hours' | 'minute' | 'minutes' | 'second' | 'seconds' | 'millisecond' | 'milliseconds';
    function diff(val_a: Date | string, val_b: Date | string, key?: DiffKey): number;
    export { diff, diff as default };
}
declare module "date/endOfUTC" {
    export type EndOfUTCKey = 'year' | 'quarter' | 'month' | 'week' | 'week_sun' | 'week_mon' | 'week_tue' | 'week_wed' | 'week_thu' | 'week_fri' | 'week_sat' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond';
    function endOfUTC(val: Date | string, key?: EndOfUTCKey): Date;
    export { endOfUTC, endOfUTC as default };
}
declare module "number/isIntegerAbove" {
    function isIntegerAbove(val: unknown, ref: number): val is number;
    export { isIntegerAbove, isIntegerAbove as default };
}
declare module "caching/LRU" {
    export type LRUCacheOptions = {
        max_size?: number;
    };
    class LRUCache<V> {
        #private;
        constructor(opts?: LRUCacheOptions);
        get max_size(): number;
        set max_size(max_size: number);
        has(key: string): boolean;
        get(key: string): V | undefined;
        set(key: string, value: V): void;
        del(key: string): void;
        clear(): void;
        private addToFront;
        private removeNode;
        private moveToFront;
        private evictTail;
    }
    export { LRUCache, LRUCache as default };
}
declare module "date/format" {
    const WEEK_STARTS: {
        readonly mon: "mon";
        readonly sun: "sun";
        readonly sat: "sat";
    };
    export type WEEK_START = keyof typeof WEEK_STARTS;
    function format(val: Date | string, spec: string, locale?: string, zone?: string, sow?: WEEK_START): string;
    namespace format {
        var getLocale: () => string;
        var setLocale: (locale: string) => void;
        var getZone: () => string;
        var setZone: (zone: string) => void;
        var getStartOfWeek: () => "mon" | "sun" | "sat";
        var setStartOfWeek: (sow: WEEK_START) => void;
    }
    export { format, format as default };
}
declare module "date/isLeap" {
    function isLeap(val: Date | string): boolean;
    export { isLeap, isLeap as default };
}
declare module "date/nowUnix" {
    function nowUnix(): number;
    export { nowUnix, nowUnix as default };
}
declare module "date/nowUnixMs" {
    function nowUnixMs(): number;
    export { nowUnixMs, nowUnixMs as default };
}
declare module "number/isIntegerBetween" {
    function isIntegerBetween(val: unknown, min: number, max: number): val is number;
    export { isIntegerBetween, isIntegerBetween as default };
}
declare module "date/setTimeUTC" {
    export type TimeProps = {
        hour?: number;
        minute?: number;
        second?: number;
        millisecond?: number;
    };
    function setTimeUTC(val: Date | string, props: TimeProps): Date;
    export { setTimeUTC, setTimeUTC as default };
}
declare module "date/startOfUTC" {
    export type StartOfUTCKey = 'year' | 'quarter' | 'month' | 'week' | 'week_sun' | 'week_mon' | 'week_tue' | 'week_wed' | 'week_thu' | 'week_fri' | 'week_sat' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond';
    function startOfUTC(val: Date | string, key?: StartOfUTCKey): Date;
    export { startOfUTC, startOfUTC as default };
}
declare module "date/is" {
    function isDate(val: unknown): val is Date;
    export { isDate, isDate as default };
}
declare module "date/toUnix" {
    function toUnix(val: Date): number;
    export { toUnix, toUnix as default };
}
declare module "date/toUTC" {
    function toUTC(val: Date): Date;
    export { toUTC, toUTC as default };
}
declare module "date/isFormat" {
    export const MONTHS_LEAP: number[];
    export const MONTHS: number[];
    function isDateFormat(input: unknown, spec: string): input is string;
    export { isDateFormat, isDateFormat as default };
}
declare module "date/index" {
    export { addUTC } from "date/addUTC";
    export { convertToDate } from "date/convertToDate";
    export { diff } from "date/diff";
    export { endOfUTC } from "date/endOfUTC";
    export { format } from "date/format";
    export { isLeap } from "date/isLeap";
    export { nowUnix } from "date/nowUnix";
    export { nowUnixMs } from "date/nowUnixMs";
    export { setTimeUTC } from "date/setTimeUTC";
    export { startOfUTC } from "date/startOfUTC";
    export { toUnix } from "date/toUnix";
    export { toUTC } from "date/toUTC";
    export { isDateFormat as isFormat } from "date/isFormat";
    export { isDateFormat } from "date/isFormat";
    export { isDate } from "date/is";
}
declare module "string/forbiddenKeys" {
    export const FORBIDDEN_KEYS: Set<string>;
}
declare module "formdata/toObject" {
    type ToObjectConfig = {
        raw?: string[] | boolean;
        single?: string[];
        normalize_bool?: boolean;
        normalize_null?: boolean;
        normalize_date?: boolean;
        normalize_number?: boolean;
    };
    function toObject<T extends Record<string, unknown>>(form: FormData, config?: ToObjectConfig): T;
    export { toObject, toObject as default };
}
declare module "formdata/is" {
    function isFormData(val: unknown): val is FormData;
    export { isFormData, isFormData as default };
}
declare module "formdata/index" {
    export { toObject } from "formdata/toObject";
    export { isFormData } from "formdata/is";
}
declare module "function/is" {
    function isFunction(val: unknown): val is (...args: unknown[]) => unknown;
    export { isFunction, isFunction as default };
}
declare module "function/debounce" {
    function debounce<T extends (...args: any[]) => any>(fn: T, wait: number): T & {
        cancel: () => void;
        flush: () => void;
    };
    export { debounce, debounce as default };
}
declare module "function/noop" {
    function noop(): void;
    export { noop, noop as default };
}
declare module "function/noopresolve" {
    function noopresolve<T>(val?: T): Promise<T | undefined>;
    export { noopresolve, noopresolve as default };
}
declare module "function/noopreturn" {
    function noopreturn<T>(val?: T): T | undefined;
    export { noopreturn, noopreturn as default };
}
declare module "function/sleep" {
    function sleep(ms?: number): Promise<void>;
    export { sleep, sleep as default };
}
declare module "function/isAsync" {
    function isAsyncFunction(val: unknown): val is (...args: unknown[]) => Promise<unknown>;
    export { isAsyncFunction, isAsyncFunction as default };
}
declare module "function/index" {
    export { debounce } from "function/debounce";
    export { noop } from "function/noop";
    export { noopresolve } from "function/noopresolve";
    export { noopreturn } from "function/noopreturn";
    export { sleep } from "function/sleep";
    export { isFunction } from "function/is";
    export { isFunction as isFn } from "function/is";
    export { isAsyncFunction } from "function/isAsync";
    export { isAsyncFunction as isAsyncFn } from "function/isAsync";
}
declare module "regexp/is" {
    function isRegExp(val: unknown): val is RegExp;
    export { isRegExp, isRegExp as default };
}
declare module "regexp/sanitize" {
    function sanitizeRegExp(val: string): string | false;
    export { sanitizeRegExp, sanitizeRegExp as default };
}
declare module "regexp/index" {
    export { isRegExp } from "regexp/is";
    export { sanitizeRegExp } from "regexp/sanitize";
    export { sanitizeRegExp as sanitize } from "regexp/sanitize";
}
declare module "object/define" {
    function define(props: {
        [key: string]: any;
    }, obj?: {
        [key: string]: any;
    }): {
        [key: string]: any;
    };
    export { define, define as default };
}
declare module "deep/get" {
    type ObjectType = {
        [key: string]: any;
    };
    type ArrayType = any[];
    type DeepGetResult<T extends ObjectType | ArrayType, P extends string> = P extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? T[Key] extends ObjectType | ArrayType ? DeepGetResult<T[Key], Rest> : undefined : T extends ArrayType ? number extends keyof T ? DeepGetResult<T[number], Rest> : undefined : undefined : P extends `${infer Key}[${infer Index}]` ? Key extends keyof T ? T[Key] extends ArrayType ? Index extends `${number}` ? DeepGetResult<T[Key][number], ''> : undefined : undefined : T extends ArrayType ? number extends keyof T ? DeepGetResult<T[number], `[${Index}]`> : undefined : undefined : P extends keyof T ? T[P] : T extends ArrayType ? number extends keyof T ? T[number] : undefined : undefined;
    function deepGet<T extends ObjectType | ArrayType, P extends string>(obj: T, path: P, get_parent?: boolean): DeepGetResult<T, P> | undefined;
    export { deepGet, deepGet as default };
}
declare module "object/types" {
    export type DottedKeys<T> = (T extends Record<string, any> ? {
        [K in keyof T & string]: T[K] extends Record<string, any> ? K | `${K}.${DottedKeys<T[K]>}` : K;
    }[keyof T & string] : string) & string;
    export type DottedKeysWithArray<T> = (T extends Record<string, any> ? {
        [K in keyof T & string]: T[K] extends (infer U)[] ? U extends Record<string, any> ? K | `${K}.${DottedKeysWithArray<U>}` : K : T[K] extends Record<string, any> ? K | `${K}.${DottedKeysWithArray<T[K]>}` : K;
    }[keyof T & string] : string) & string;
    export type ExpandWildcard<T, P extends string> = P extends `*.${infer Key}` ? {
        [K in keyof T]: T[K] extends Record<string, any> ? `${K & string}.${Key}` : never;
    }[keyof T] : P;
    export type ExpandWildcardWithArray<T, P extends string> = P extends `*.${infer Key}` ? {
        [K in keyof T]: T[K] extends (infer U)[] ? U extends Record<string, any> ? `${K & string}.${Key}` : never : T[K] extends Record<string, any> ? `${K & string}.${Key}` : never;
    }[keyof T] : P;
}
declare module "object/pick" {
    import { type DottedKeys } from "object/types";
    type ObjectType = {
        [key: string]: any;
    };
    type PickFromObject<T, K extends string> = K extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? T[Key] extends ObjectType ? {
        [P in Key]: PickFromObject<T[Key], Rest>;
    } : object : object : K extends keyof T ? {
        [P in K]: T[K];
    } : object;
    type UnionToIntersection<U> = (U extends any ? (k: U) => void : object) extends (k: infer I) => void ? I : object;
    function pick<T extends Record<string, any>, K extends readonly DottedKeys<T>[]>(obj: T, keys: K): UnionToIntersection<PickFromObject<T, K[number]>>;
    export { pick, pick as default };
}
declare module "object/omit" {
    import { type DottedKeysWithArray, type ExpandWildcardWithArray } from "object/types";
    type OmitFromObject<T, K extends string> = T extends (infer U)[] ? OmitFromObject<U, K>[] : T extends Record<string, any> ? K extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? T[Key] extends Record<string, any> | any[] ? {
        [P in keyof T]: P extends Key ? OmitFromObject<T[Key], Rest> : T[P];
    } : T : T : Omit<T, K> : T;
    function omit<T extends Record<string, any>, K extends readonly (DottedKeysWithArray<T> | `*.${string}`)[]>(obj: T, keys: K): OmitFromObject<T, ExpandWildcardWithArray<T, K[number]>>;
    export { omit, omit as default };
}
declare module "object/scramble" {
    import { type DottedKeysWithArray } from "object/types";
    function scramble<T extends Record<string, any>, K extends readonly (DottedKeysWithArray<T> | `*.${string}`)[]>(obj: T, keys: K, options?: {
        replacement?: string;
    }): T;
    export { scramble, scramble as default };
}
declare module "object/index" {
    export { define } from "object/define";
    export { merge } from "object/merge";
    export { pick } from "object/pick";
    export { omit } from "object/omit";
    export { scramble } from "object/scramble";
    export { isObject } from "object/is";
    export { isNotEmptyObject } from "object/isNotEmpty";
    export { isNotEmptyObject as isNeObject } from "object/isNotEmpty";
}
declare module "number/is" {
    function isNumber(val: unknown): val is number;
    export { isNumber, isNumber as default };
}
declare module "number/isAbove" {
    function isNumberAbove(val: unknown, ref: number): val is number;
    export { isNumberAbove, isNumberAbove as default };
}
declare module "number/isAboveOrEqual" {
    function isNumberAboveOrEqual(val: unknown, ref: number): val is number;
    export { isNumberAboveOrEqual, isNumberAboveOrEqual as default };
}
declare module "number/isBelow" {
    function isNumberBelow(val: unknown, ref: number): val is number;
    export { isNumberBelow, isNumberBelow as default };
}
declare module "number/isBelowOrEqual" {
    function isNumberBelowOrEqual(val: unknown, ref: number): val is number;
    export { isNumberBelowOrEqual, isNumberBelowOrEqual as default };
}
declare module "number/isBetween" {
    function isNumberBetween(val: unknown, min: number, max: number): val is number;
    export { isNumberBetween, isNumberBetween as default };
}
declare module "number/isInteger" {
    function isInteger(val: unknown): val is number;
    export { isInteger, isInteger as default };
}
declare module "number/isIntegerBelow" {
    function isIntegerBelow(val: unknown, ref: number): val is number;
    export { isIntegerBelow, isIntegerBelow as default };
}
declare module "number/isIntegerBelowOrEqual" {
    function isIntegerBelowOrEqual(val: unknown, ref: number): val is number;
    export { isIntegerBelowOrEqual, isIntegerBelowOrEqual as default };
}
declare module "number/isNumericalNaN" {
    function isNumericalNaN(val: unknown): boolean;
    export { isNumericalNaN, isNumericalNaN as default };
}
declare module "number/randomBetween" {
    function randomBetween(min?: number, max?: number): number;
    export { randomBetween, randomBetween as default };
}
declare module "number/randomIntBetween" {
    function randomIntBetween(min?: number, max?: number): number;
    export { randomIntBetween, randomIntBetween as default };
}
declare module "number/toPercentage" {
    function toPercentage(val: number, precision?: number, min?: number, max?: number): number;
    export { toPercentage, toPercentage as default };
}
declare module "number/index" {
    export { isNumber } from "number/is";
    export { isNumber as isNum } from "number/is";
    export { isNumberAbove } from "number/isAbove";
    export { isNumberAbove as isNumGt } from "number/isAbove";
    export { isNumberAbove as isGt } from "number/isAbove";
    export { isNumberAboveOrEqual } from "number/isAboveOrEqual";
    export { isNumberAboveOrEqual as isNumGte } from "number/isAboveOrEqual";
    export { isNumberAboveOrEqual as isGte } from "number/isAboveOrEqual";
    export { isNumberBelow } from "number/isBelow";
    export { isNumberBelow as isNumLt } from "number/isBelow";
    export { isNumberBelow as isLt } from "number/isBelow";
    export { isNumberBelowOrEqual } from "number/isBelowOrEqual";
    export { isNumberBelowOrEqual as isNumLte } from "number/isBelowOrEqual";
    export { isNumberBelowOrEqual as isLte } from "number/isBelowOrEqual";
    export { isNumberBetween } from "number/isBetween";
    export { isNumberBetween as isNumBetween } from "number/isBetween";
    export { isNumberBetween as isBetween } from "number/isBetween";
    export { isInteger } from "number/isInteger";
    export { isInteger as isInt } from "number/isInteger";
    export { isIntegerAbove } from "number/isIntegerAbove";
    export { isIntegerAbove as isIntGt } from "number/isIntegerAbove";
    export { isIntegerAboveOrEqual } from "number/isIntegerAboveOrEqual";
    export { isIntegerAboveOrEqual as isIntGte } from "number/isIntegerAboveOrEqual";
    export { isIntegerBelow } from "number/isIntegerBelow";
    export { isIntegerBelow as isIntLt } from "number/isIntegerBelow";
    export { isIntegerBelowOrEqual } from "number/isIntegerBelowOrEqual";
    export { isIntegerBelowOrEqual as isIntLte } from "number/isIntegerBelowOrEqual";
    export { isIntegerBetween } from "number/isIntegerBetween";
    export { isIntegerBetween as isIntBetween } from "number/isIntegerBetween";
    export { isNumericalNaN } from "number/isNumericalNaN";
    export { randomBetween } from "number/randomBetween";
    export { randomBetween as randBetween } from "number/randomBetween";
    export { randomIntBetween } from "number/randomIntBetween";
    export { randomIntBetween as randIntBetween } from "number/randomIntBetween";
    export { round } from "number/round";
    export { toPercentage } from "number/toPercentage";
    export { toPercentage as toPct } from "number/toPercentage";
}
declare module "string/humanizeNumber" {
    interface humanizeNumberOptions {
        delim?: string;
        separator?: string;
        precision?: number;
        units?: string[] | boolean;
        divider?: number;
        real?: boolean;
    }
    function humanizeNumber(val: number | string, options?: humanizeNumberOptions): string;
    export { humanizeNumber, humanizeNumber as default };
}
declare module "string/humanizeBytes" {
    interface humanizeBytesOptions {
        delim?: string;
        separator?: string;
        precision?: number;
        units?: string[];
    }
    function humanizeBytes(val: number | string, options?: humanizeBytesOptions): string;
    export { humanizeBytes, humanizeBytes as default };
}
declare module "string/shorten" {
    function shorten(val: string, length: number, postfix?: string, truncate_words?: boolean): string;
    export { shorten, shorten as default };
}
declare module "string/is" {
    function isString(val: unknown): val is string;
    export { isString, isString as default };
}
declare module "string/isNotEmpty" {
    function isNotEmptyString(val: unknown, trimmed?: boolean): val is string;
    export { isNotEmptyString, isNotEmptyString as default };
}
declare module "string/isBetween" {
    function isStringBetween(val: unknown, min: number, max: number, trimmed?: boolean): val is string;
    export { isStringBetween, isStringBetween as default };
}
declare module "string/index" {
    export { humanizeBytes } from "string/humanizeBytes";
    export { humanizeNumber } from "string/humanizeNumber";
    export { shorten } from "string/shorten";
    export { isString } from "string/is";
    export { isNotEmptyString } from "string/isNotEmpty";
    export { isNotEmptyString as isNeString } from "string/isNotEmpty";
    export { isStringBetween } from "string/isBetween";
}
declare module "is" {
    import { equal } from "equal";
    import { isArray, isNeArray } from "array/index";
    import { isBoolean } from "boolean/index";
    import { isDate } from "date/index";
    import { isFormData } from "formdata/index";
    import { isFn, isAsyncFn } from "function/index";
    import { isRegExp } from "regexp/index";
    import { isObject, isNeObject } from "object/index";
    import { isNum, isNumBetween, isNumLt, isNumLte, isNumGt, isNumGte, isInt, isIntBetween, isIntLt, isIntLte, isIntGt, isIntGte } from "number/index";
    import { isString, isStringBetween, isNeString } from "string/index";
    const Is: Readonly<{
        Array: typeof isArray;
        NeArray: typeof isNeArray;
        NotEmptyArray: typeof isNeArray;
        Boolean: typeof isBoolean;
        Date: typeof isDate;
        Formdata: typeof isFormData;
        Function: typeof isFn;
        AsyncFunction: typeof isAsyncFn;
        Num: typeof isNum;
        NumBetween: typeof isNumBetween;
        NumAbove: typeof isNumGt;
        NumAboveOrEqual: typeof isNumGte;
        NumBelow: typeof isNumLt;
        NumBelowOrEqual: typeof isNumLte;
        NumGt: typeof isNumGt;
        NumGte: typeof isNumGte;
        NumLt: typeof isNumLt;
        NumLte: typeof isNumLte;
        Number: typeof isNum;
        NumberBetween: typeof isNumBetween;
        NumberAbove: typeof isNumGt;
        NumberAboveOrEqual: typeof isNumGte;
        NumberBelow: typeof isNumLt;
        NumberBelowOrEqual: typeof isNumLte;
        Int: typeof isInt;
        IntBetween: typeof isIntBetween;
        IntAbove: typeof isIntGt;
        IntAboveOrEqual: typeof isIntGte;
        IntBelow: typeof isIntLt;
        IntBelowOrEqual: typeof isIntLte;
        IntGt: typeof isIntGt;
        IntGte: typeof isIntGte;
        IntLt: typeof isIntLt;
        IntLte: typeof isIntLte;
        Integer: typeof isInt;
        IntegerBetween: typeof isIntBetween;
        IntegerBelow: typeof isIntLt;
        IntegerBelowOrEqual: typeof isIntLte;
        IntegerAbove: typeof isIntGt;
        IntegerAboveOrEqual: typeof isIntGte;
        RegExp: typeof isRegExp;
        Object: typeof isObject;
        NeObject: typeof isNeObject;
        NotEmptyObject: typeof isNeObject;
        String: typeof isString;
        StringBetween: typeof isStringBetween;
        NeString: typeof isNeString;
        NotEmptyString: typeof isNeString;
        Equal: typeof equal;
        Eq: typeof equal;
    }>;
    export { Is, Is as default };
}
declare module "hash/utils" {
    export function toString(raw: unknown): string;
}
declare module "hash/djb2" {
    function djb2(data: unknown): string;
    export { djb2, djb2 as default };
}
declare module "caching/memoize" {
    function memoize<T extends (...args: any[]) => unknown>(fn: T, resolver?: (...args: Parameters<T>) => any, cache_duration_ms?: number | false, cache_max_size?: number): T;
    export { memoize, memoize as default };
}
declare module "caching/index" {
    export { memoize } from "caching/memoize";
    export { LRUCache } from "caching/LRU";
    export { LRUCache as LRU } from "caching/LRU";
}
declare module "deep/freeze" {
    type deepInput = {
        [key: string]: any;
    } | {
        [key: string]: any;
    }[] | any[];
    type Frozen<T> = {
        readonly [K in keyof T]: Frozen<T[K]>;
    };
    function deepFreeze<T extends deepInput>(obj: T): Frozen<T>;
    export { deepFreeze, deepFreeze as default };
}
declare module "deep/seal" {
    type deepInput = {
        [key: string]: any;
    } | {
        [key: string]: any;
    }[] | any[];
    type Sealed<T> = {
        [K in keyof T]: Sealed<T[K]>;
    };
    function deepSeal<T extends deepInput>(obj: T): Sealed<T>;
    export { deepSeal, deepSeal as default };
}
declare module "deep/set" {
    function deepSet(obj: {
        [key: string]: any;
    } | {
        [key: string]: any;
    }[] | any[], path: string, value: any, define?: boolean): boolean;
    export { deepSet, deepSet as default };
}
declare module "deep/index" {
    export { deepFreeze as freeze } from "deep/freeze";
    export { deepFreeze } from "deep/freeze";
    export { deepGet as get } from "deep/get";
    export { deepGet } from "deep/get";
    export { deepSeal as seal } from "deep/seal";
    export { deepSeal } from "deep/seal";
    export { deepSet as set } from "deep/set";
    export { deepSet } from "deep/set";
}
declare module "hash/fnv1A" {
    export const FNV_32 = 2166136261;
    export const FNV_64 = 1099511628211n;
    function fnv1A(data: unknown, offset?: number): number;
    export { fnv1A, fnv1A as default };
}
declare module "hash/guid" {
    function guid(): string;
    export { guid, guid as default };
}
declare module "hash/hexId" {
    function hexId(size: number): string;
    export { hexId, hexId as default };
}
declare module "hash/uuidv7" {
    function uuidv7(): string;
    export { uuidv7, uuidv7 as default };
}
declare module "hash/index" {
    export { djb2 } from "hash/djb2";
    export { fnv1A } from "hash/fnv1A";
    export { guid } from "hash/guid";
    export { hexId } from "hash/hexId";
    export { uuidv7 } from "hash/uuidv7";
}
declare module "modules/PubSub" {
    type SyncFn = (data: unknown) => void;
    type AsyncFn = (data: unknown) => Promise<void>;
    type Fn = SyncFn | AsyncFn;
    export type RawEvents = {
        [key: string]: Fn | {
            run: Fn;
            once?: boolean;
        };
    };
    export type LogObject = {
        name: string;
        event: string;
        client_id: string;
        msg: string;
        on: Date;
        data: unknown;
        err: Error;
    };
    export type LogFn = (log: LogObject) => void;
    export type PubSubOptions = {
        logger?: LogFn;
        name?: string;
        store?: boolean;
    };
    class PubSub {
        #private;
        constructor(options?: PubSubOptions);
        get name(): string;
        publish(event: string, data?: unknown, store?: boolean): void;
        subscribe(events: RawEvents, client_id?: string, override?: boolean): string | null;
        unsubscribe(client_id: string, event?: string | string[]): void;
        clientIds(event?: string | string[]): Set<string>;
        clear(event?: string | string[]): void;
    }
    export { PubSub, PubSub as default };
}
declare module "modules/Scheduler" {
    export type LogObject = {
        name: string;
        msg: string;
        on: Date;
        data?: unknown;
        err: Error;
    };
    export type LogFn = (log: LogObject) => void;
    export type SchedulerOptions = {
        logger?: LogFn;
        name?: string;
        timeZone?: string | null;
        parallel?: boolean | number;
        auto?: boolean;
    };
    type SchedulerJobFn = ((data: any) => void | Promise<void>);
    type SchedulerJobFnDefault = (data: unknown) => void | Promise<void>;
    export type SchedulerJob<T extends SchedulerJobFn = SchedulerJobFnDefault> = {
        name: string;
        schedule: string;
        timeZone?: string | null;
        fn: T;
        data?: Parameters<T>[0];
    };
    class Scheduler {
        #private;
        constructor(options?: SchedulerOptions);
        get name(): string;
        get timeZone(): string | null;
        get parallel(): number | boolean;
        get isAutomatic(): boolean;
        get jobs(): {
            data?: {} | undefined;
            name: string;
            schedule: string;
            timeZone: string | null;
        }[];
        add<T extends SchedulerJobFn>(job: SchedulerJob<T>): boolean;
        remove(name: string | string[]): void;
        run(): Promise<void>;
        stopAutomaticRun(): void;
        startAutomaticRun(): void;
        private static convertToMap;
        private static getTimeParts;
        private static checkTimeAgainstMap;
        static isCronSchedule(raw: string): boolean;
        static cronShouldRun(schedule: string, timeZone?: string | null): boolean;
    }
    export { Scheduler, Scheduler as default };
}
declare module "modules/index" {
    export { PubSub } from "modules/PubSub";
    export { Scheduler } from "modules/Scheduler";
}