export * from './Classes';
export * from './Error';
export * from './Functions';
export * from './Types';
import * as classes from './Classes';
import * as errorClasses from './Error';
import * as functions from './Functions';
import * as types from './Types';
export { classes, functions, types };
declare const _default: {
    addProperty: <T>(obj: types.MutableObject<T>, prop: string, value: T) => types.MutableObject<T>;
    asyncTimeout: (ms: number) => Promise<number | NodeJS.Timeout>;
    attributesToArray: <T>(obj: types.MutableObject<T>, removeNull?: boolean) => T[];
    b64ToString: (val: string) => string;
    bytesToSize: (bytes: number) => string;
    callbackify: <T, E extends Error>(func: (...args: never[]) => types.PromiseOr<T>, callback: (result: T | null, error: E | null) => types.PromiseOr<void>, ...params: never[]) => Promise<void>;
    callIfFunction: (func: unknown, ...params: unknown[]) => unknown;
    debounce: (fn: types.AnyFunction, wait?: number, immediate?: boolean) => types.AnyFunction;
    deepClone: <V>(obj: V) => V;
    deepCompare: (obj: types.MutableObject<unknown>, obj2: types.MutableObject<unknown>) => boolean;
    fibonacci: (index: number) => number;
    getProjectRoot: (dirPath: string) => string;
    getObjectKeys: <T extends object>(obj: T) => (keyof T)[];
    getTypeString: (arg: never) => string | undefined;
    hasProperty: (obj: object, prop: string) => boolean;
    hasValue: <T = unknown>(a: T) => boolean;
    mapObjectValues: <T extends object, R>(obj: T, mapper: (value: T[keyof T], key: keyof T, object: T) => R) => { [K in keyof T]: R; };
    measureTime: (label: string, func: (...args: unknown[]) => unknown, ...params: unknown[]) => void;
    merge: (a: object, b: object) => object;
    objectToString: (o: unknown) => string;
    parseArgs: (args: string[]) => (string | {
        flag: string;
        value?: string | undefined;
    })[];
    removeFirstDigit: (n: number) => number;
    removeLastDigit: (n: number) => number;
    removeProperty: (obj: types.MutableObject<unknown>, prop: string) => types.MutableObject<unknown>;
    removeXDigits: (n: number, pos: number) => number;
    strictJSONParse: (str: string) => object;
    stringToB64: (value: string) => string;
    syncTimeout: (milliseconds: number) => void;
    toOrdinal: (n: number) => string;
    AbstractClassInstanceCallError: typeof errorClasses.AbstractClassInstanceCallError;
    IndexOutOfBoundsError: typeof errorClasses.IndexOutOfBoundsError;
    AbstractClass: typeof classes.AbstractClass;
    ArrayUtils: {
        flat<T>(arr: Array<T | T[]>): T[];
        intersection<T>(a: T[], b: T[]): T[];
        union<T>(a: T[], b: T[]): T[];
        difference<T>(a: T[], b: T[]): T[];
        shuffle<X, T extends Array<X>>(array: T | X[]): void;
        countOccurrences<T>(array: T[], value: T): number;
        clear(array: unknown[]): void;
        clone<T>(array: T[]): Array<T>;
        deepClone<T>(array: T[]): Array<T>;
        removeDuplicates<T>(arr: T[]): T[];
        sortByKey<T extends object>(arr: T[], key: keyof T): T[];
        remove<T>(arr: T[], item: T): T[];
        zip<T, U>(arr1: T[], arr2: U[]): [T, U][];
        insert<T>(arr: T[], index: number, ...items: T[]): T[];
        uniqueSubArrays(arr: unknown[][]): unknown[][];
        quickSelect(arr: number[], k: number): number;
        quickSort<T>(arr: T[], compareFn: (a: T, b: T) => number): T[];
        chunks<T>(array: T[], chunkSize: number): T[][];
        findByPropertyValue<T>(array: T[], property: keyof T, value: unknown): classes.Optional<T>;
        findIndexByPropertyValue<T>(array: T[], property: keyof T, value: unknown): number;
        findAllIndices<T>(array: T[], condition: (element: T) => boolean): number[];
    };
    BetterMath: {
        round(value: number, digit: number): number;
        square(num: number): number;
        cube(num: number): number;
        distance(path: classes.Point[]): number;
        greatestCommonDivisor(a: number, b: number): number;
        gcd(a: number, b: number): number;
        lowestCommonDenominator(a: number, b: number): number;
        lcd(a: number, b: number): number;
        calculateAverage(numbers: number[]): number;
        avg(numbers: number[]): number;
        factorial(num: number): number;
        factorialIterative(num: number): number;
        median(values: number[]): number;
        nthRoot(number: number, n: number): number;
        logarithm(number: number, base: number): number;
        permutations(n: number, r: number): number;
        combinations(n: number, r: number): number;
        degreesToRadians(degrees: number): number;
        radiansToDegrees(radians: number): number;
        factorialWithMemoization(num: number, memo?: Map<number, number>): number;
        countDecimalDigits(number: number): number;
    };
    BuilderBuilder: typeof classes.BuilderBuilder;
    Collection: typeof classes.Collection;
    DataConverter: typeof classes.DataConverter;
    DateUtil: {
        getCurrentDate(): Date;
        today(): Date;
        tomorrow(): Date;
        yesterday(): Date;
        compareDates<T extends Date>(dt1: T | number | Date, dt2: T | number | Date): number;
        equals<T extends Date>(dt1: T | number | Date, dt2: T | number | Date): boolean;
        getMonthAbbr(number: number): string;
        getMonthFullName(number: number): string;
        getDayAbbr(number: number): string;
        getDayFullName(number: number): string;
        isLeapYear(year: number): boolean;
        weekFirstDay(): Date;
        weekLastDay(): Date;
        leapYearsInRange(startYear: number, endYear: number): number[];
        getMonthFirstDay(): Date;
        getMonthLastDay(): Date;
        toDate<T extends Date>(input: T | number): Date;
        isAfter<T extends Date>(date1: T | number | Date, date2: T | number | Date): boolean;
        isBefore<T extends Date>(date1: T | number | Date, date2: T | number | Date): boolean;
        yearsToMonths(years: number): number;
        isWeekend<T extends Date>(dt: T | number | Date): boolean;
        getDaysDiff<T extends Date>(dt1: T | number | Date, dt2: T | number | Date): number;
        addDays<T extends Date>(dt: T | number | Date, days: number): Date;
        formatDate<T extends Date>(dt: T | number | Date, format: string): string;
        getCurrentTimestamp(): number;
    };
    ImmutableClass: typeof classes.ImmutableClass;
    ImprovedArray: typeof classes.ImprovedArray;
    IsSomething: {
        isArray(arg: unknown): arg is Array<unknown>;
        isBoolean(arg: unknown): arg is boolean;
        isClass(arg: unknown): arg is types.Constructor<object>;
        isDate(arg: unknown): arg is Date;
        isDefined(arg: unknown): boolean;
        isEmpty(arg: unknown): boolean;
        isError(arg: unknown): arg is Error;
        isEven(num: number): boolean;
        isFunction(a: unknown): a is types.AnyFunction;
        isInfinite(arg: unknown): boolean;
        isNullorUndefined(arg: unknown): arg is null | undefined;
        isNumber(arg: unknown): arg is number;
        isObject(arg: unknown): arg is object;
        isPrime(num: number): boolean;
        isPrimitive(arg: unknown): arg is number | null | undefined | string | boolean | symbol;
        isRegExp(arg: unknown): arg is RegExp;
        isString(arg: unknown): arg is string;
        isSymbol(arg: unknown): arg is symbol;
        isType(arg: unknown, type: string): boolean;
        isInstanceOf(value: unknown, constructor: types.Constructor<object>): boolean | null;
        isDateValid(date: Date): boolean;
    };
    LRUCache: typeof classes.LRUCache;
    MatrixOperations: typeof classes.MatrixOperations;
    ObjectPool: typeof classes.ObjectPool;
    Optional: typeof classes.Optional;
    Point: typeof classes.Point;
    Point3d: typeof classes.Point3d;
    PrimeNumbers: typeof classes.PrimeNumbers;
    PromiseUtil: {
        readonly "__#private@#resFirst": <R, E extends Error>(resolve: import("./Classes/PromiseUtil").resolver, reject: import("./Classes/PromiseUtil").resolver, result: R, error: E | null) => unknown;
        readonly "__#private@#resReplace": <R, E extends Error>(resolve: import("./Classes/PromiseUtil").resolver, reject: import("./Classes/PromiseUtil").resolver, result: R | E) => unknown;
        readonly "__#private@#resLast": <R, E extends Error>(resolve: import("./Classes/PromiseUtil").resolver, reject: import("./Classes/PromiseUtil").resolver, error: E | null, result: R) => unknown;
        readonly "__#private@#MAPPINGS": import("./Classes/PromiseUtil").MappingTable;
        executeSequentially<T>(promises: types.PromiseOr<T>[]): Promise<[Array<T | null>, Error[]]>;
        handler<R, E extends Error>(promise: types.PromiseOr<R> | import("./Classes/PromiseUtil").AsyncFunction<R>): Promise<[R | null, E | null]>;
        retry<T>(func: () => types.PromiseOr<T>, maxRetries?: number): Promise<[T | null, Error[]]>;
        delay(milliseconds: number): Promise<void>;
        filter<T>(values: T[], asyncFilterFunc: (value: T) => types.PromiseOr<boolean>): Promise<T[]>;
        timeout<T>(promise: types.PromiseOr<T>, milliseconds: number): Promise<T>;
        batchPromises<T, R>(values: T[], batchSize: number, asyncFunc: (value: T) => types.PromiseOr<R>): Promise<R[]>;
        promisify<T extends unknown[], R>(func: types.AnyFunction, { callBackPosition, errorPosition }?: import("./Classes/PromiseUtil").PromisifyOptions): (...args: T) => Promise<R>;
        mapPromises<T, R>(values: T[], asyncMapFunc: (value: T) => types.PromiseOr<R>): Promise<R[]>;
        concurrentMap<T, R>(values: T[], asyncMapFunc: (value: T) => types.PromiseOr<R>, concurrency: number): Promise<R[]>;
        executeConcurrently<T>(promises: types.PromiseOr<T>[], concurrency: number): Promise<[Array<T | null>, Error[]]>;
    };
    Queue: typeof classes.Queue;
    Random: {
        readonly defaultCharset: string;
        randomInt(lower?: number, upper?: number): number;
        randomDouble(lower: number, upper: number): number;
        randomChar(charset?: string): string;
        randomString(length?: number, charset?: string): string;
        randomElement<T>(arr: T[]): T;
        randomElementInRange<T>(arr: T[], start: number, end: number): T;
        randomProperty<T extends object>(obj: T): T[keyof T];
        randomBoolean(): boolean;
        randomColor(): string;
        randomRgbColor(): number[];
        randomUUID(): string;
        randomDate(startDate: Date, endDate: Date): Date;
        randomEnumValue<T extends object>(enumObject: T): T[keyof T];
        randomDateInPast(yearsAgo: number): Date;
    };
    Set: typeof classes.Set;
    Stack: typeof classes.Stack;
    StopWatch: typeof classes.StopWatch;
    StringUtil: typeof classes.StringUtil;
    Tree: typeof classes.Tree;
    Tuple: typeof classes.Tuple;
    UnitConverter: typeof classes.UnitConverter;
    UrlUtil: {
        isUrl(url: string): boolean;
        parseUrl(url: string): URL;
        getDomainName(url: string): string;
        getPath(url: string): string;
        addQueryParams(url: string, params: types.MutableObject<string>): string;
        removeQueryParam(url: string, param: string): string;
        editQueryParams(url: string, params: types.MutableObject<string>): string;
        getQueryParams(url: string): types.MutableObject<string>;
        getQueryParamValue(url: string, param: string): string | null;
        updatePath(url: string, newPath: string): string;
        hasQueryParams(url: string): boolean;
        hasQueryParam(url: string, param: string): boolean;
        updateQueryParams(url: string, params: types.MutableObject<string>): string;
        replaceQueryParams(url: string, replacements: types.MutableObject<string>): string;
        removeQueryParams(url: string, paramsToRemove: string[]): string;
        mergeQueryParams(url1: string, url2: string): string;
        getProtocol(url: string): string;
        getPort(url: string): string;
        isAbsoluteUrl(url: string): boolean;
        encodeUrlComponent(component: string): string;
        decodeUrlComponent(encodedComponent: string): string;
    };
    Vector2d: typeof classes.Vector2d;
    Vector3d: typeof classes.Vector3d;
};
export default _default;