@valkyriestudios/utils 12.4.0 → 12.5.0

package/index.d.ts

@@ -6,185 +6,6 @@ declare module "equal" {
     function equal(a: any, b: any): boolean;
     export { equal, equal as default };
 }
-declare module "array/isNotEmpty" {
-    function isNotEmptyArray(val: unknown): val is unknown[];
-    export { isNotEmptyArray, isNotEmptyArray as default };
-}
-declare module "array/is" {
-    function isArray(val: unknown): val is unknown[];
-    export { isArray, isArray as default };
-}
-declare module "boolean/is" {
-    function isBoolean(val: unknown): val is boolean;
-    export { isBoolean, isBoolean as default };
-}
-declare module "date/is" {
-    function isDate(val: unknown): val is Date;
-    export { isDate, isDate as default };
-}
-declare module "function/is" {
-    function isFunction(val: unknown): val is (...args: unknown[]) => unknown;
-    export { isFunction, isFunction as default };
-}
-declare module "function/isAsync" {
-    function isAsyncFunction(val: unknown): val is (...args: unknown[]) => Promise<unknown>;
-    export { isAsyncFunction, isAsyncFunction as default };
-}
-declare module "number/is" {
-    function isNumber(val: unknown): val is number;
-    export { isNumber, isNumber 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/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/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/isInteger" {
-    function isInteger(val: unknown): val is number;
-    export { isInteger, isInteger as default };
-}
-declare module "number/isIntegerBetween" {
-    function isIntegerBetween(val: unknown, min: number, max: number): val is number;
-    export { isIntegerBetween, isIntegerBetween 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/isIntegerAbove" {
-    function isIntegerAbove(val: unknown, ref: number): val is number;
-    export { isIntegerAbove, isIntegerAbove as default };
-}
-declare module "number/isIntegerAboveOrEqual" {
-    function isIntegerAboveOrEqual(val: unknown, ref: number): val is number;
-    export { isIntegerAboveOrEqual, isIntegerAboveOrEqual as default };
-}
-declare module "regexp/is" {
-    function isRegExp(val: unknown): val is RegExp;
-    export { isRegExp, isRegExp as default };
-}
-declare module "object/is" {
-    function isObject(val: unknown): val is {
-        [key: string]: any;
-    };
-    export { isObject, isObject as default };
-}
-declare module "object/isNotEmpty" {
-    function isNotEmptyObject(val: unknown): val is {
-        [key: string]: any;
-    };
-    export { isNotEmptyObject, isNotEmptyObject as default };
-}
-declare module "string/is" {
-    function isString(val: unknown): val is string;
-    export { isString, isString 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/isNotEmpty" {
-    function isNotEmptyString(val: unknown, trimmed?: boolean): val is string;
-    export { isNotEmptyString, isNotEmptyString as default };
-}
-declare module "is" {
-    import { equal } from "equal";
-    import { isNotEmptyArray } from "array/isNotEmpty";
-    import { isArray } from "array/is";
-    import { isBoolean } from "boolean/is";
-    import { isDate } from "date/is";
-    import { isFunction } from "function/is";
-    import { isAsyncFunction } from "function/isAsync";
-    import { isNumber } from "number/is";
-    import { isNumberBetween } from "number/isBetween";
-    import { isNumberBelow } from "number/isBelow";
-    import { isNumberBelowOrEqual } from "number/isBelowOrEqual";
-    import { isNumberAbove } from "number/isAbove";
-    import { isNumberAboveOrEqual } from "number/isAboveOrEqual";
-    import { isInteger } from "number/isInteger";
-    import { isIntegerBetween } from "number/isIntegerBetween";
-    import { isIntegerBelow } from "number/isIntegerBelow";
-    import { isIntegerBelowOrEqual } from "number/isIntegerBelowOrEqual";
-    import { isIntegerAbove } from "number/isIntegerAbove";
-    import { isIntegerAboveOrEqual } from "number/isIntegerAboveOrEqual";
-    import { isRegExp } from "regexp/is";
-    import { isObject } from "object/is";
-    import { isNotEmptyObject } from "object/isNotEmpty";
-    import { isString } from "string/is";
-    import { isStringBetween } from "string/isBetween";
-    import { isNotEmptyString } from "string/isNotEmpty";
-    const Is: Readonly<{
-        Array: typeof isArray;
-        NeArray: typeof isNotEmptyArray;
-        NotEmptyArray: typeof isNotEmptyArray;
-        Boolean: typeof isBoolean;
-        Date: typeof isDate;
-        Function: typeof isFunction;
-        AsyncFunction: typeof isAsyncFunction;
-        Num: typeof isNumber;
-        NumBetween: typeof isNumberBetween;
-        NumAbove: typeof isNumberAbove;
-        NumAboveOrEqual: typeof isNumberAboveOrEqual;
-        NumBelow: typeof isNumberBelow;
-        NumBelowOrEqual: typeof isNumberBelowOrEqual;
-        NumGt: typeof isNumberAbove;
-        NumGte: typeof isNumberAboveOrEqual;
-        NumLt: typeof isNumberBelow;
-        NumLte: typeof isNumberBelowOrEqual;
-        Number: typeof isNumber;
-        NumberBetween: typeof isNumberBetween;
-        NumberAbove: typeof isNumberAbove;
-        NumberAboveOrEqual: typeof isNumberAboveOrEqual;
-        NumberBelow: typeof isNumberBelow;
-        NumberBelowOrEqual: typeof isNumberBelowOrEqual;
-        Int: typeof isInteger;
-        IntBetween: typeof isIntegerBetween;
-        IntAbove: typeof isIntegerAbove;
-        IntAboveOrEqual: typeof isIntegerAboveOrEqual;
-        IntBelow: typeof isIntegerBelow;
-        IntBelowOrEqual: typeof isIntegerBelowOrEqual;
-        IntGt: typeof isIntegerAbove;
-        IntGte: typeof isIntegerAboveOrEqual;
-        IntLt: typeof isIntegerBelow;
-        IntLte: typeof isIntegerBelowOrEqual;
-        Integer: typeof isInteger;
-        IntegerBetween: typeof isIntegerBetween;
-        IntegerBelow: typeof isIntegerBelow;
-        IntegerBelowOrEqual: typeof isIntegerBelowOrEqual;
-        IntegerAbove: typeof isIntegerAbove;
-        IntegerAboveOrEqual: typeof isIntegerAboveOrEqual;
-        RegExp: typeof isRegExp;
-        Object: typeof isObject;
-        NeObject: typeof isNotEmptyObject;
-        NotEmptyObject: typeof isNotEmptyObject;
-        String: typeof isString;
-        StringBetween: typeof isStringBetween;
-        NeString: typeof isNotEmptyString;
-        NotEmptyString: typeof isNotEmptyString;
-        Equal: typeof equal;
-        Eq: typeof equal;
-    }>;
-    export { Is, Is as default };
-}
 declare module "hash/fnv1A" {
     function fnv1A(data: unknown, offset?: number): number;
     export { fnv1A, fnv1A as default };
@@ -193,6 +14,14 @@ declare module "array/dedupe" {
     function dedupe<T>(val: T[]): T[];
     export { dedupe, dedupe as default };
 }
+declare module "array/is" {
+    function isArray(val: unknown): val is unknown[];
+    export { isArray, isArray as default };
+}
+declare module "array/isNotEmpty" {
+    function isNotEmptyArray(val: unknown): val is unknown[];
+    export { isNotEmptyArray, isNotEmptyArray as default };
+}
 declare module "number/round" {
     function round(val: number, precision?: number): number;
     export { round, round as default };
@@ -236,6 +65,12 @@ declare module "array/shuffle" {
     function shuffle(arr: unknown[]): void;
     export { shuffle, shuffle as default };
 }
+declare module "object/isNotEmpty" {
+    function isNotEmptyObject(val: unknown): val is {
+        [key: string]: any;
+    };
+    export { isNotEmptyObject, isNotEmptyObject as default };
+}
 declare module "array/sort" {
     interface sortOptions {
         filter_fn?: (el: any) => boolean;
@@ -249,9 +84,29 @@ declare module "array/sort" {
     function sort(arr: sortObject[], by: string | sortByFunction, dir?: 'asc' | 'desc', opts?: sortOptions): sortObject[];
     export { sort, sort as default };
 }
-declare module "caching/memoize" {
-    function memoize(fn: Function, resolver?: Function): Function;
-    export { memoize, memoize as default };
+declare module "array/index" {
+    import { dedupe } from "array/dedupe";
+    import { isArray } from "array/is";
+    import { isNotEmptyArray } from "array/isNotEmpty";
+    import { join } from "array/join";
+    import { mapFn } from "array/mapFn";
+    import { mapKey } from "array/mapKey";
+    import { mapPrimitive } from "array/mapPrimitive";
+    import { shuffle } from "array/shuffle";
+    import { sort } from "array/sort";
+    export { dedupe, isArray, isArray as is, isNotEmptyArray, isNotEmptyArray as isNotEmpty, isNotEmptyArray as isNeArray, isNotEmptyArray as isNe, join, mapFn, mapKey, mapPrimitive, shuffle, sort };
+}
+declare module "boolean/is" {
+    function isBoolean(val: unknown): val is boolean;
+    export { isBoolean, isBoolean as default };
+}
+declare module "boolean/index" {
+    import { isBoolean } from "boolean/is";
+    export { isBoolean, isBoolean as is };
+}
+declare module "date/is" {
+    function isDate(val: unknown): val is Date;
+    export { isDate, isDate as default };
 }
 declare module "date/addUTC" {
     function addUTC(val: Date, amt?: number, key?: 'years' | 'year' | 'months' | 'month' | 'days' | 'day' | 'hours' | 'hour' | 'minutes' | 'minute' | 'seconds' | 'second' | 'milliseconds' | 'millisecond'): Date;
@@ -281,53 +136,42 @@ declare module "date/startOfUTC" {
     function startOfUTC(val: Date, key?: 'year' | 'quarter' | 'month' | 'week' | 'week_sun' | 'week_mon' | 'week_tue' | 'week_wed' | 'week_thu' | 'week_fri' | 'week_sat' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond'): Date;
     export { startOfUTC, startOfUTC 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/toUnix" {
-    function toUnix(val: Date): number;
-    export { toUnix, toUnix as default };
+declare module "date/index" {
+    import { addUTC } from "date/addUTC";
+    import { diff } from "date/diff";
+    import { endOfUTC } from "date/endOfUTC";
+    import { format } from "date/format";
+    import { isDate } from "date/is";
+    import { nowUnix } from "date/nowUnix";
+    import { nowUnixMs } from "date/nowUnixMs";
+    import { startOfUTC } from "date/startOfUTC";
+    import { toUnix } from "date/toUnix";
+    import { toUTC } from "date/toUTC";
+    export { addUTC, diff, endOfUTC, format, isDate, isDate as is, nowUnix, nowUnixMs, startOfUTC, toUnix, toUTC };
 }
-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 "formdata/is" {
+    function isFormData(val: unknown): val is FormData;
+    export { isFormData, isFormData as default };
 }
-declare module "deep/get" {
-    function deepGet(obj: {
-        [key: string]: any;
-    } | {
-        [key: string]: any;
-    }[] | any[], path: string, get_parent?: boolean): any | undefined;
-    export { deepGet, deepGet as default };
+declare module "formdata/index" {
+    import { isFormData } from "formdata/is";
+    export { isFormData, isFormData as is };
 }
-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 "function/is" {
+    function isFunction(val: unknown): val is (...args: unknown[]) => unknown;
+    export { isFunction, isFunction 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 "function/isAsync" {
+    function isAsyncFunction(val: unknown): val is (...args: unknown[]) => Promise<unknown>;
+    export { isAsyncFunction, isAsyncFunction as default };
 }
 declare module "function/noop" {
     function noop(): void;
@@ -345,21 +189,27 @@ declare module "function/sleep" {
     function sleep(ms?: number): Promise<void>;
     export { sleep, sleep as default };
 }
-declare module "hash/guid" {
-    function guid(): string;
-    export { guid, guid as default };
+declare module "function/index" {
+    import { isFunction } from "function/is";
+    import { isAsyncFunction } from "function/isAsync";
+    import { noop } from "function/noop";
+    import { noopresolve } from "function/noopresolve";
+    import { noopreturn } from "function/noopreturn";
+    import { sleep } from "function/sleep";
+    export { isFunction, isFunction as is, isFunction as isFn, isAsyncFunction, isAsyncFunction as isAsync, isAsyncFunction as isAsyncFn, noop, noopresolve, noopreturn, sleep };
 }
-declare module "number/randomBetween" {
-    function randomBetween(min?: number, max?: number): number;
-    export { randomBetween, randomBetween as default };
+declare module "regexp/is" {
+    function isRegExp(val: unknown): val is RegExp;
+    export { isRegExp, isRegExp as default };
 }
-declare module "number/randomIntBetween" {
-    function randomIntBetween(min?: number, max?: number): number;
-    export { randomIntBetween, randomIntBetween as default };
+declare module "regexp/sanitize" {
+    function sanitizeRegExp(val: string): string | false;
+    export { sanitizeRegExp, sanitizeRegExp as default };
 }
-declare module "number/toPercentage" {
-    function toPercentage(val: number, precision?: number, min?: number, max?: number): number;
-    export { toPercentage, toPercentage as default };
+declare module "regexp/index" {
+    import { isRegExp } from "regexp/is";
+    import { sanitizeRegExp } from "regexp/sanitize";
+    export { isRegExp, isRegExp as is, sanitizeRegExp, sanitizeRegExp as sanitize };
 }
 declare module "object/define" {
     function define(props: {
@@ -371,6 +221,12 @@ declare module "object/define" {
     };
     export { define, define as default };
 }
+declare module "object/is" {
+    function isObject(val: unknown): val is {
+        [key: string]: any;
+    };
+    export { isObject, isObject as default };
+}
 declare module "object/merge" {
     function merge(target: {
         [key: string]: any;
@@ -381,6 +237,22 @@ declare module "object/merge" {
     };
     export { merge, merge as default };
 }
+declare module "deep/get" {
+    function deepGet(obj: {
+        [key: string]: any;
+    } | {
+        [key: string]: any;
+    }[] | any[], path: string, get_parent?: boolean): any | undefined;
+    export { deepGet, deepGet 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 "object/pick" {
     function pick(obj: {
         [key: string]: any;
@@ -389,9 +261,93 @@ declare module "object/pick" {
     };
     export { pick, pick as default };
 }
-declare module "regexp/sanitize" {
-    function sanitizeRegExp(val: string): string | false;
-    export { sanitizeRegExp, sanitizeRegExp as default };
+declare module "object/index" {
+    import { define } from "object/define";
+    import { isObject } from "object/is";
+    import { isNotEmptyObject } from "object/isNotEmpty";
+    import { merge } from "object/merge";
+    import { pick } from "object/pick";
+    export { define, isObject, isObject as is, isNotEmptyObject, isNotEmptyObject as isNotEmpty, isNotEmptyObject as isNeObject, isNotEmptyObject as isNe, merge, pick };
+}
+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/isIntegerAbove" {
+    function isIntegerAbove(val: unknown, ref: number): val is number;
+    export { isIntegerAbove, isIntegerAbove as default };
+}
+declare module "number/isIntegerAboveOrEqual" {
+    function isIntegerAboveOrEqual(val: unknown, ref: number): val is number;
+    export { isIntegerAboveOrEqual, isIntegerAboveOrEqual 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/isIntegerBetween" {
+    function isIntegerBetween(val: unknown, min: number, max: number): val is number;
+    export { isIntegerBetween, isIntegerBetween 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" {
+    import { isNumber } from "number/is";
+    import { isNumberAbove } from "number/isAbove";
+    import { isNumberAboveOrEqual } from "number/isAboveOrEqual";
+    import { isNumberBelow } from "number/isBelow";
+    import { isNumberBelowOrEqual } from "number/isBelowOrEqual";
+    import { isNumberBetween } from "number/isBetween";
+    import { isInteger } from "number/isInteger";
+    import { isIntegerAbove } from "number/isIntegerAbove";
+    import { isIntegerAboveOrEqual } from "number/isIntegerAboveOrEqual";
+    import { isIntegerBelow } from "number/isIntegerBelow";
+    import { isIntegerBelowOrEqual } from "number/isIntegerBelowOrEqual";
+    import { isIntegerBetween } from "number/isIntegerBetween";
+    import { isNumericalNaN } from "number/isNumericalNaN";
+    import { randomBetween } from "number/randomBetween";
+    import { randomIntBetween } from "number/randomIntBetween";
+    import { round } from "number/round";
+    import { toPercentage } from "number/toPercentage";
+    export { isNumber, isNumber as is, isNumber as isNum, isNumberAbove, isNumberAbove as isNumGt, isNumberAbove as isGt, isNumberAboveOrEqual, isNumberAboveOrEqual as isNumGte, isNumberAboveOrEqual as isGte, isNumberBelow, isNumberBelow as isNumLt, isNumberBelow as isLt, isNumberBelowOrEqual, isNumberBelowOrEqual as isNumLte, isNumberBelowOrEqual as isLte, isNumberBetween, isNumberBetween as isNumBetween, isInteger, isInteger as isInt, isIntegerAbove, isIntegerAbove as isIntGt, isIntegerAboveOrEqual, isIntegerAboveOrEqual as isIntGte, isIntegerBelow, isIntegerBelow as isIntLt, isIntegerBelowOrEqual, isIntegerBelowOrEqual as isIntLte, isIntegerBetween, isIntegerBetween as isIntBetween, isNumericalNaN, randomBetween, randomBetween as randBetween, randomIntBetween, randomIntBetween as randIntBetween, round, toPercentage, toPercentage as toPct };
 }
 declare module "string/humanizeNumber" {
     interface humanizeNumberOptions {
@@ -415,7 +371,141 @@ declare module "string/humanizeBytes" {
     function humanizeBytes(val: number | string, options?: humanizeBytesOptions): string;
     export { humanizeBytes, humanizeBytes 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/shorten" {
     function shorten(val: string, length: number, postfix?: string): string;
     export { shorten, shorten as default };
 }
+declare module "string/index" {
+    import { humanizeBytes } from "string/humanizeBytes";
+    import { humanizeNumber } from "string/humanizeNumber";
+    import { isString } from "string/is";
+    import { isNotEmptyString } from "string/isNotEmpty";
+    import { isStringBetween } from "string/isBetween";
+    import { shorten } from "string/shorten";
+    export { humanizeBytes, humanizeNumber, isString, isString as is, isNotEmptyString, isNotEmptyString as isNotEmpty, isNotEmptyString as isNeString, isNotEmptyString as isNe, isStringBetween, isStringBetween as isBetween, shorten };
+}
+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 "caching/memoize" {
+    function memoize(fn: Function, resolver?: Function): Function;
+    export { memoize, memoize as default };
+}
+declare module "caching/index" {
+    import { memoize } from "caching/memoize";
+    export { memoize };
+}
+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/index" {
+    import { deepFreeze } from "deep/freeze";
+    import { deepGet } from "deep/get";
+    import { deepSeal } from "deep/seal";
+    import { deepSet } from "deep/set";
+    export { deepFreeze as freeze, deepFreeze, deepGet as get, deepGet, deepSeal as seal, deepSeal, deepSet as set, deepSet };
+}
+declare module "hash/guid" {
+    function guid(): string;
+    export { guid, guid as default };
+}
+declare module "hash/index" {
+    import { fnv1A } from "hash/fnv1A";
+    import { guid } from "hash/guid";
+    export { fnv1A, guid };
+}