@valkyriestudios/utils 12.3.0 → 12.5.0

package/index.d.ts

@@ -1,173 +1,30 @@
 declare module "number/isNumericalNaN" {
-    export default function isNumericalNaN(val: unknown): boolean;
+    function isNumericalNaN(val: unknown): boolean;
+    export { isNumericalNaN, isNumericalNaN as default };
 }
 declare module "equal" {
     function equal(a: any, b: any): boolean;
-    export default equal;
-}
-declare module "array/isNotEmpty" {
-    export default function isNotEmptyArray(val: unknown): val is unknown[];
-}
-declare module "array/is" {
-    export default function isArray(val: unknown): val is unknown[];
-}
-declare module "boolean/is" {
-    export default function isBoolean(val: unknown): val is boolean;
-}
-declare module "date/is" {
-    export default function isDate(val: unknown): val is Date;
-}
-declare module "function/is" {
-    export default function isFunction(val: unknown): val is (...args: unknown[]) => unknown;
-}
-declare module "function/isAsync" {
-    export default function isAsyncFunction(val: unknown): val is (...args: unknown[]) => Promise<unknown>;
-}
-declare module "number/is" {
-    export default function isNumber(val: unknown): val is number;
-}
-declare module "number/isBetween" {
-    export default function isNumberBetween(val: unknown, min: number, max: number): val is number;
-}
-declare module "number/isBelow" {
-    export default function isNumberBelow(val: unknown, ref: number): val is number;
-}
-declare module "number/isBelowOrEqual" {
-    export default function isNumberBelowOrEqual(val: unknown, ref: number): val is number;
-}
-declare module "number/isAbove" {
-    export default function isNumberAbove(val: unknown, ref: number): val is number;
-}
-declare module "number/isAboveOrEqual" {
-    export default function isNumberAboveOrEqual(val: unknown, ref: number): val is number;
-}
-declare module "number/isInteger" {
-    export default function isInteger(val: unknown): val is number;
-}
-declare module "number/isIntegerBetween" {
-    export default function isIntegerBetween(val: unknown, min: number, max: number): val is number;
-}
-declare module "number/isIntegerBelow" {
-    export default function isIntegerBelow(val: unknown, ref: number): val is number;
-}
-declare module "number/isIntegerBelowOrEqual" {
-    export default function isIntegerBelowOrEqual(val: unknown, ref: number): val is number;
-}
-declare module "number/isIntegerAbove" {
-    export default function isIntegerAbove(val: unknown, ref: number): val is number;
-}
-declare module "number/isIntegerAboveOrEqual" {
-    export default function isIntegerAboveOrEqual(val: unknown, ref: number): val is number;
-}
-declare module "regexp/is" {
-    export default function isRegExp(val: unknown): val is RegExp;
-}
-declare module "object/is" {
-    export default function isObject(val: unknown): val is {
-        [key: string]: any;
-    };
-}
-declare module "object/isNotEmpty" {
-    export default function isNotEmptyObject(val: unknown): val is {
-        [key: string]: any;
-    };
-}
-declare module "string/is" {
-    export default function isString(val: unknown): val is string;
-}
-declare module "string/isBetween" {
-    export default function isStringBetween(val: unknown, min: number, max: number, trimmed?: boolean): val is string;
-}
-declare module "string/isNotEmpty" {
-    export default function isNotEmptyString(val: unknown, trimmed?: boolean): val is string;
-}
-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 default Is;
+    export { equal, equal as default };
 }
 declare module "hash/fnv1A" {
-    export default function fnv1A(data: unknown, offset?: number): number;
+    function fnv1A(data: unknown, offset?: number): number;
+    export { fnv1A, fnv1A as default };
 }
 declare module "array/dedupe" {
-    export default function dedupe<T>(val: T[]): T[];
+    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" {
-    export default function round(val: number, precision?: number): number;
+    function round(val: number, precision?: number): number;
+    export { round, round as default };
 }
 declare module "array/join" {
     interface joinOptions {
@@ -176,24 +33,23 @@ declare module "array/join" {
         valtrim?: boolean;
         valround?: number;
     }
-    export default function join(val: unknown[], opts?: joinOptions): string;
+    function join(val: unknown[], opts?: joinOptions): string;
+    export { join, join as default };
 }
 declare module "array/mapFn" {
     interface mapOptions {
         merge?: boolean;
     }
-    type mapFn = (entry: {
-        [key: string]: any;
-    }) => (string | number | boolean);
-    type mapReturn = Record<string, Record<string, any>>;
-    export default function mapFn(arr: Record<string, any>[], fn: mapFn, opts?: mapOptions): mapReturn;
+    type mapFn<T extends Record<string, any>> = (entry: T) => (string | number | boolean);
+    function mapFn<T extends Record<string, any>>(arr: T[], fn: mapFn<T>, opts?: mapOptions): Record<string, T>;
+    export { mapFn, mapFn as default };
 }
 declare module "array/mapKey" {
     interface mapOptions {
         merge?: boolean;
     }
-    type kvMap = Record<string, Record<string, any>>;
-    export default function mapKey(arr: Record<string, any>[], key: string, opts?: mapOptions): kvMap;
+    function mapKey<T extends Record<string, any>>(arr: T[], key: string, opts?: mapOptions): Record<string, T>;
+    export { mapKey, mapKey as default };
 }
 declare module "array/mapPrimitive" {
     interface mapOptions {
@@ -202,10 +58,18 @@ declare module "array/mapPrimitive" {
         keyround?: boolean;
     }
     type mapReturn = Record<string, string | number>;
-    export default function mapPrimitive(arr: unknown[], opts?: mapOptions): mapReturn;
+    function mapPrimitive(arr: unknown[], opts?: mapOptions): mapReturn;
+    export { mapPrimitive, mapPrimitive as default };
 }
 declare module "array/shuffle" {
-    export default function shuffle(arr: unknown[]): void;
+    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 {
@@ -217,106 +81,151 @@ declare module "array/sort" {
         [key: string]: any;
     }
     type sortByFunction = (el: sortObject) => string;
-    export default function sort(arr: sortObject[], by: string | sortByFunction, dir?: 'asc' | 'desc', opts?: sortOptions): sortObject[];
+    function sort(arr: sortObject[], by: string | sortByFunction, dir?: 'asc' | 'desc', opts?: sortOptions): sortObject[];
+    export { sort, sort 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 "caching/memoize" {
-    export default function memoize(fn: Function, resolver?: Function): Function;
+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" {
-    export default function addUTC(val: Date, amt?: number, key?: 'years' | 'year' | 'months' | 'month' | 'days' | 'day' | 'hours' | 'hour' | 'minutes' | 'minute' | 'seconds' | 'second' | 'milliseconds' | 'millisecond'): Date;
+    function addUTC(val: Date, amt?: number, key?: 'years' | 'year' | 'months' | 'month' | 'days' | 'day' | 'hours' | 'hour' | 'minutes' | 'minute' | 'seconds' | 'second' | 'milliseconds' | 'millisecond'): Date;
+    export { addUTC, addUTC as default };
 }
 declare module "date/diff" {
-    export default function diff(val_a: Date, val_b: Date, key?: 'week' | 'weeks' | 'day' | 'days' | 'hour' | 'hours' | 'minute' | 'minutes' | 'second' | 'seconds' | 'millisecond' | 'milliseconds'): number;
+    function diff(val_a: Date, val_b: Date, key?: 'week' | 'weeks' | 'day' | 'days' | 'hour' | 'hours' | 'minute' | 'minutes' | 'second' | 'seconds' | 'millisecond' | 'milliseconds'): number;
+    export { diff, diff as default };
 }
 declare module "date/endOfUTC" {
-    export default function endOfUTC(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;
+    function endOfUTC(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 { endOfUTC, endOfUTC as default };
 }
 declare module "date/format" {
-    export default function format(val: Date, spec: string, locale?: string, zone?: string): string;
+    function format(val: Date, spec: string, locale?: string, zone?: string): string;
+    export { format, format as default };
 }
 declare module "date/nowUnix" {
-    export default function nowUnix(): number;
+    function nowUnix(): number;
+    export { nowUnix, nowUnix as default };
 }
 declare module "date/nowUnixMs" {
-    export default function nowUnixMs(): number;
+    function nowUnixMs(): number;
+    export { nowUnixMs, nowUnixMs as default };
 }
 declare module "date/startOfUTC" {
-    export default 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;
-}
-declare module "date/toUTC" {
-    export default function toUTC(val: Date): Date;
+    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" {
-    export default function toUnix(val: Date): number;
+    function toUnix(val: Date): number;
+    export { toUnix, toUnix as default };
 }
-declare module "deep/freeze" {
-    type deepInput = {
-        [key: string]: any;
-    } | {
-        [key: string]: any;
-    }[] | any[];
-    type Frozen<T> = {
-        readonly [K in keyof T]: Frozen<T[K]>;
-    };
-    export default function deepFreeze<T extends deepInput>(obj: T): Frozen<T>;
-}
-declare module "deep/get" {
-    export default function deepGet(obj: {
-        [key: string]: any;
-    } | {
-        [key: string]: any;
-    }[] | any[], path: string, get_parent?: boolean): any | undefined;
+declare module "date/toUTC" {
+    function toUTC(val: Date): Date;
+    export { toUTC, toUTC 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 "formdata/is" {
+    function isFormData(val: unknown): val is FormData;
+    export { isFormData, isFormData 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]>;
-    };
-    export default function deepSeal<T extends deepInput>(obj: T): Sealed<T>;
+declare module "function/is" {
+    function isFunction(val: unknown): val is (...args: unknown[]) => unknown;
+    export { isFunction, isFunction as default };
 }
-declare module "deep/set" {
-    export default function deepSet(obj: {
-        [key: string]: any;
-    } | {
-        [key: string]: any;
-    }[] | any[], path: string, value: any, define?: boolean): boolean;
+declare module "function/isAsync" {
+    function isAsyncFunction(val: unknown): val is (...args: unknown[]) => Promise<unknown>;
+    export { isAsyncFunction, isAsyncFunction as default };
 }
 declare module "function/noop" {
-    export default function noop(): void;
+    function noop(): void;
+    export { noop, noop as default };
 }
 declare module "function/noopresolve" {
-    export default function noopresolve<T>(val?: T): Promise<T>;
+    function noopresolve<T>(val?: T): Promise<T>;
+    export { noopresolve, noopresolve as default };
 }
 declare module "function/noopreturn" {
-    export default function noopreturn<T>(val?: T): T;
+    function noopreturn<T>(val?: T): T;
+    export { noopreturn, noopreturn as default };
 }
 declare module "function/sleep" {
-    export default function sleep(ms?: number): Promise<void>;
-}
-declare module "hash/guid" {
-    export default function guid(): string;
+    function sleep(ms?: number): Promise<void>;
+    export { sleep, sleep 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" {
-    export default function randomBetween(min?: number, max?: number): number;
+declare module "regexp/is" {
+    function isRegExp(val: unknown): val is RegExp;
+    export { isRegExp, isRegExp as default };
 }
-declare module "number/randomIntBetween" {
-    export default function randomIntBetween(min?: number, max?: number): number;
+declare module "regexp/sanitize" {
+    function sanitizeRegExp(val: string): string | false;
+    export { sanitizeRegExp, sanitizeRegExp as default };
 }
-declare module "number/toPercentage" {
-    export default function toPercentage(val: number, precision?: number, min?: number, max?: number): number;
+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" {
-    export default function define(props: {
+    function define(props: {
         [key: string]: any;
     }, obj?: {
         [key: string]: any;
     }): {
         [key: string]: any;
     };
+    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: {
@@ -326,17 +235,119 @@ declare module "object/merge" {
     }): {
         [key: string]: any;
     };
-    export default 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" {
-    export default function pick(obj: {
+    function pick(obj: {
         [key: string]: any;
     }, keys: string[]): {
         [key: string]: any;
     };
+    export { pick, pick as default };
 }
-declare module "regexp/sanitize" {
-    export default function sanitizeRegExp(val: string): string | false;
+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 {
@@ -347,7 +358,8 @@ declare module "string/humanizeNumber" {
         divider?: number;
         real?: boolean;
     }
-    export default function humanizeNumber(val: number | string, options?: humanizeNumberOptions | false): string;
+    function humanizeNumber(val: number | string, options?: humanizeNumberOptions | false): string;
+    export { humanizeNumber, humanizeNumber as default };
 }
 declare module "string/humanizeBytes" {
     interface humanizeBytesOptions {
@@ -356,8 +368,144 @@ declare module "string/humanizeBytes" {
         precision?: number;
         units?: string[];
     }
-    export default function humanizeBytes(val: number | string, options?: humanizeBytesOptions): string;
+    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" {
-    export default function shorten(val: string, length: number, postfix?: string): string;
+    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 };
 }