import array from './array/index';
import async from './async/index';
import date from './date/index';
import debug from './debug/index';
import encoding from './encoding/index';
import file from './file/index';
import _function from './function/index';
import is from './is/index';
import math from './math/index';
import object from './object/index';
import query from './query/index';
import range from './range/index';
import regex from './regex/index';
import string from './string/index';
import vector2 from './vector2/index';
import web from './web/index';
export { array, async, date, debug, encoding, file, _function, is, math, object, query, range, regex, string, vector2, web };
declare const _default: {
    array: {
        any: <T>(xs?: T[]) => boolean;
        are: <T>(...xs: T[]) => boolean;
        chunk: (count: number) => <T>(xs: T[]) => T[] | T[][];
        difference: <T>(xs: T[], ys: T[]) => T[];
        differs: <T>(xs?: T[], ys?: T[]) => boolean;
        duplicates: <T>(xs: T[]) => T[];
        empty: unknown[];
        exact: (count: number) => <T>(xs: T[]) => T[];
        except: <T>(y: T) => (xs: T[]) => T[];
        filterInPlace: <T>(f: (value: T, index: number, context: T[]) => boolean) => (xs: T[]) => T[];
        find: <T>(predicate: (value: T, index: number, context: T[]) => boolean, fallback?: T) => (xs: T[]) => T;
        first: <T>([x]: T[]) => T | undefined;
        flatMap: <T, TResult>(f: (value: T, index: number, context: T[]) => TResult[]) => (xs: T[]) => TResult[];
        flatten: <T>(xs: T[]) => T[];
        insert: (index: number) => <T>(item: T) => ([...xs]: T[]) => T[];
        intersection: <T>(xs: T[], ys: T[]) => T[];
        is: (value?: unknown) => boolean;
        last: <T>(xs: T[]) => T | undefined;
        length: <T>(xs: T[]) => number;
        lengthDiffers: <T1, T2>(a: T1[], b: T2[]) => boolean;
        map: <T>(...fs: ((x: T) => T)[]) => (xs: T[]) => T[];
        midpoint: <T>(xs: T[]) => T | undefined;
        minMax: (xs: number[]) => number[];
        multiple: <T>(xs: T[]) => boolean;
        none: <T>(xs?: T[]) => boolean;
        partition: <T>(predicate: (x: T) => boolean) => (xs: T[]) => readonly [T[], T[]];
        pop: <T>(xs: T[]) => T[];
        range: (n: number) => number[];
        removeAt: (index: number) => <T>(xs: T[]) => T[];
        repeat: (count: number) => <T>(value: T) => T[];
        reverse: <T>(xs: T[]) => T[];
        reverseIf: (enabled: boolean) => <T>(xs: T[]) => T[];
        second: <T>(xs: T[]) => T | undefined;
        secondToLast: <T>(xs: T[]) => T | undefined;
        shift: (count: number) => <T>(xs: T[]) => T[];
        shuffle: <T>(xs: T[], random?: () => number) => T[];
        shuffleInPlace: <T>(xs: T[], random?: () => number) => T[];
        single: <T>(xs: T[]) => boolean;
        skip: (count: number) => <T>(xs: T[]) => T[];
        slidingWindow: (count: number) => <T>(xs: T[]) => T[][];
        sort: <T>(f?: (a: T, b: T) => number) => (xs: T[]) => T[];
        sum: (xs: number[]) => number;
        take: (count: number) => <T>(xs: T[]) => T[];
        unique: <T>(xs: T[]) => T[];
        uniqueBy: <T, TResult>(f: (x: T) => TResult) => (xs: T[]) => T[];
        zip: (xs: unknown[], ys: unknown[]) => [unknown, unknown][];
        zipN: <T>(...xs: T[][]) => T[][];
        zipWith: <T1, T2>(f?: (x: T1, y: T2) => [T1, T2]) => (xs: T1[], ys: T2[]) => [T1, T2][];
    };
    async: {
        debounce: (f: (...args: unknown[]) => unknown, wait: number) => (...args: unknown[]) => void;
        delay: (duration: number) => Promise<unknown>;
        sequence: <T>(tasks: (() => Promise<T>)[]) => Promise<Awaited<T>[]>;
    };
    date: {
        clamp: (min: Date, max: Date) => (date: Date) => Date;
        clone: (date: Date) => Date;
        dateDiff: (a: Date, b: Date) => number;
        dateInRange: (from: Date, to: Date) => (date: Date) => boolean;
        dayRange: (date: Date) => Date[];
        daysInMonths: (leapYear: boolean) => [number, number, number, number, number, number, number, number, number, number, number, number];
        daysInYear: (year: number) => 366 | 365;
        displayTime: (source: [number, number, number], showSeconds: boolean) => string;
        endOfDay: (date: Date) => Date;
        formatDate: (date: Date) => string;
        formatDateTime: (sourceDate: Date, showSeconds?: boolean) => string;
        formatDuration: (duration: number, showSeconds?: boolean) => string;
        formatTime: (date: Date, showSeconds?: boolean) => string;
        fromDays: (days: number) => number;
        fromHours: (hours: number) => number;
        fromMinutes: (minutes: number) => number;
        fromSeconds: (seconds: number) => number;
        joinDateTime: (date: string, time: string) => string;
        leapYear: (year: number) => boolean;
        parseHourMinutePair: (text?: string) => [number, number];
        splitDateTime: (dateTimeString: string) => [string, string];
        startOfDay: (date: Date) => Date;
        subtractDays: (sourceDate: Date, numberOfDays: number) => Date;
        toDate: (date: Date) => string;
        toDates: (xs: (string | number | Date)[]) => Date[];
        toDays: (milliseconds: number) => number;
        toHours: (milliseconds: number) => number;
        toISO: (x: Date) => string;
        toMinutes: (milliseconds: number) => number;
        toSeconds: (milliseconds: number) => number;
        valid: (date?: unknown) => boolean;
    };
    debug: {
        assert: (condition: boolean, callbackOrMessage?: (() => void) | string) => void;
        diff: (obj1?: unknown, obj2?: unknown) => {
            [index: string]: unknown;
        };
    };
    encoding: {
        base64url: {
            decode: (text: string, context?: import("./encoding/base64url/DecodeContext.interface").DecodeContext) => string;
            decodeBytes: (text: string, context?: import("./encoding/base64url/DecodeContext.interface").DecodeContext) => number[];
            encode: (text: string, context?: import("./encoding/base64url/EncodeContext.interface").EncodeContext) => string;
            encodeBytes: (bytes: number[], context?: import("./encoding/base64url/EncodeContext.interface").EncodeContext) => string;
            fromBase64: (base64: string) => string;
            toBase64: (base64Url: string) => string;
        };
        byteString: {
            from: (byteString: string) => number[];
            to: (bytes: number[]) => string;
        };
    };
    file: {
        validName: (name: string) => boolean;
    };
    _function: {
        compose: <T, TResult>(...fs: ((x: T) => T)[]) => (x: T) => T;
        constant: <T>(x: T) => () => T;
        identity: <T>(x: T) => T;
        memoize: <TResult>(f: (...xs: unknown[]) => TResult) => (...args: unknown[]) => TResult;
        memoizeShallow: <TResult>(f: (...xs: unknown[]) => TResult) => (...args: unknown[]) => TResult;
        memoizeWith: <T>(equals: (x: T[], y: T[]) => boolean) => <TResult>(f: (...xs: T[]) => TResult) => (...args: T[]) => TResult;
        noOp: () => void;
        not: (f: (...xs: unknown[]) => unknown) => (...args: unknown[]) => boolean;
        pipe: <T>(...fs: ((x: T) => T)[]) => (x: T) => T;
        when: (predicate: (...xs: unknown[]) => boolean) => (action: (...xs: unknown[]) => unknown) => (...args: unknown[]) => unknown;
        whenTrue: (action: (...xs: unknown[]) => unknown) => (...args: unknown[]) => unknown;
    };
    is: {
        array: (x?: unknown) => boolean;
        boolean: (x?: unknown) => x is boolean;
        byte: (x?: unknown) => boolean;
        date: (x?: unknown) => boolean;
        defined: (x?: unknown) => boolean;
        _function: (x?: unknown) => x is Function;
        integer: (x?: unknown) => boolean;
        nonNullable: <T>(val: T) => val is NonNullable<T>;
        normal: (x?: unknown) => boolean;
        number: (x?: unknown) => boolean;
        object: (x?: unknown) => boolean;
        string: (x?: unknown) => x is string;
    };
    math: {
        add: (a: number, b: number) => number;
        average: (xs?: number[]) => number;
        ceilToNearestPowerOfTwo: (x: number) => number;
        clamp: (min: number, max: number) => ((x: number) => number);
        clampNormal: (x: number) => number;
        clampPercentage: (x: number) => number;
        delta: (a: number, b: number) => number;
        inRectangleRange: (width: number, height: number) => ((x: number, y: number) => boolean);
        lerp: (t: number) => ((a: number, b: number) => number);
        maximumBy: (f: (x: number) => number) => ((xs: number[]) => number);
        median: (xs?: number[]) => number | undefined;
        minMax: ([a, b]: [number, number]) => [number, number];
        sameSign: (xs: number[]) => boolean;
        sign: (x: number) => number;
        standardDeviation: (xs: number[], origin?: number) => number;
        subtract: (a: number, b: number) => number;
    };
    object: {
        any: <T>(xs?: import("./object/types").GenericObject<T>) => boolean;
        apply: <T>(fs: {
            [index: string]: (...xs: T[]) => T;
        }) => (...xs: T[]) => import("./object/types").GenericObject<T>;
        empty: import("./object/types").GenericObject<unknown>;
        entries: <T>(xs: import("./object/types").GenericObject<T>) => [string, T][];
        enumerable: (...xs: string[]) => object;
        equals: (a: unknown, b: unknown) => boolean;
        every: <T>(f: (value: T, key: string, context: object) => boolean) => (xs: import("./object/types").GenericObject<T>) => boolean;
        filter: <T>(f: (value: T, key: string, context: object) => boolean) => (xs: import("./object/types").GenericObject<T>) => import("./object/types").GenericObject<T>;
        find: <T>(predicate: (value: T, key: string, context: object) => boolean) => (xs: import("./object/types").GenericObject<T>) => T | undefined;
        findEntry: <T>(predicate: (value: T, key: string, context: import("./object/types").GenericObject<T>) => boolean) => (xs: import("./object/types").GenericObject<T>) => [string, T] | undefined;
        findKey: <T>(predicate: (value: T, key: string, context: object) => boolean) => (xs: import("./object/types").GenericObject<T>) => string | undefined;
        first: <T>(xs: import("./object/types").GenericObject<T>) => T | undefined;
        flatMapValues: <T, TResult>(f: (value: T, key: string, context: import("./object/types").GenericObject<T>) => TResult[]) => (xs: import("./object/types").GenericObject<T>) => TResult[];
        fromEntries: <T>(entries: [string, T][]) => {
            [index: string]: T;
        };
        groupBy: (selector: (x: unknown) => string) => (xs: unknown[]) => {
            [index: string]: unknown[];
        };
        hasKey: (key: string) => (xs?: unknown) => boolean;
        last: <T>(xs: import("./object/types").GenericObject<T>) => T | undefined;
        length: <T>(xs: import("./object/types").GenericObject<T>) => number;
        map: <T, TResult>(f: (value: T, key: string, context: object) => TResult) => (xs: import("./object/types").GenericObject<T>) => import("./object/types").GenericObject<TResult>;
        mapEntries: <T, TResult>(f: (value: T, key: string, context: object) => TResult) => (xs: import("./object/types").GenericObject<T>) => [string, TResult][];
        mapKeys: <T>(f: (value: T, key: string, context: object) => string) => (xs: import("./object/types").GenericObject<T>) => import("./object/types").GenericObject<T>;
        mapValues: <T, TResult>(f: (value: T, key: string, context: object) => TResult) => (xs: import("./object/types").GenericObject<T>) => TResult[];
        merge: (a: {
            [index: string]: unknown;
        }, b: {
            [index: string]: unknown;
        }) => {
            [index: string]: unknown;
        };
        none: <T>(xs?: import("./object/types").GenericObject<T>) => boolean;
        some: <T>(f: (value: T, key: string, context: object) => boolean) => (xs: import("./object/types").GenericObject<T>) => boolean;
        sort: <T>(f: (a: T, b: T) => number) => (xs: import("./object/types").GenericObject<T>) => import("./object/types").GenericObject<T>;
    };
    query: {
        parse: (xs?: string) => {
            [index: string]: string | boolean;
        };
        read: (source: string) => {
            [index: string]: string;
        };
        serialize: <T>(xs?: import("./object/types").GenericObject<T>) => string;
    };
    range: {
        empty: ([min, max]: [number, number]) => boolean;
        equals: ([a, b]: [number, number], [c, d]: [number, number]) => boolean;
        length: ([min, max]: [number, number]) => number;
        split: (used: [number, number][], sourceRange?: number[]) => (range: [number, number]) => [number, number][];
    };
    regex: {
        escape: (string: string) => string;
    };
    string: {
        containsWhitespace: (x: string) => boolean;
        empty: string;
        firstToLower: (text: string) => string;
        firstToUpper: (text: string) => string;
        includes: (search: string) => (text: string) => boolean;
        nbsp: string;
        nonEmpty: (x?: string) => boolean;
        startsWith: (prefix: string) => (xs: string) => boolean;
    };
    vector2: {
        add: ([x1, y1]: [number, number], [x2, y2]: [number, number]) => [number, number];
        convertSpace: (space: {
            a: number;
            c: number;
            e: number;
            b: number;
            d: number;
            f: number;
        }) => ([x, y]: [number, number]) => number[];
        cross: ([a, b]: [number, number], [c, d]: [number, number]) => number;
        dot: ([a, b]: [number, number], [c, d]: [number, number]) => number;
        length: ([x, y]: [number, number]) => number;
        mul: ({ a, b, c, d, e, f }: {
            a: number;
            c: number;
            e: number;
            b: number;
            d: number;
            f: number;
        }, [x, y]: [number, number]) => number[];
        multiply: (m1: {
            a: number;
            c: number;
            e: number;
            b: number;
            d: number;
            f: number;
        }, m2: {
            a: number;
            b: number;
            c: number;
            d: number;
            e: number;
            f: number;
        }) => {
            a: number;
            c: number;
            e: number;
            b: number;
            d: number;
            f: number;
        };
        normalize: (vector: [number, number]) => [number, number];
        reflect: (a: [number, number], v: [number, number]) => [number, number];
        rotate: (angle?: number, cx?: number, cy?: number) => {
            a: number;
            c: number;
            e: number;
            b: number;
            d: number;
            f: number;
        };
        scale: (sx?: number, sy?: number) => {
            a: number;
            c: number;
            e: number;
            b: number;
            d: number;
            f: number;
        };
        sub: ([x1, y1]: [number, number], [x2, y2]: [number, number]) => [number, number];
        transform: (...matrices: {
            a: number;
            c: number;
            e: number;
            b: number;
            d: number;
            f: number;
        }[]) => {
            a: number;
            c: number;
            e: number;
            b: number;
            d: number;
            f: number;
        };
        translate: (tx?: number, ty?: number) => {
            a: number;
            c: number;
            e: number;
            b: number;
            d: number;
            f: number;
        };
    };
    web: {
        classNames: (...xs: unknown[]) => string;
        events: {
            cancel: (event: {
                preventDefault: () => void;
                stopPropagation: () => void;
            }) => boolean;
            openInNewTabIntent: ({ button, ctrlKey, metaKey, shiftKey }: {
                button?: number;
                ctrlKey?: boolean;
                metaKey?: boolean;
                shiftKey?: boolean;
            }) => boolean;
            prevent: (event: {
                preventDefault: () => void;
            }) => boolean;
            stop: (event: {
                stopPropagation: () => void;
            }) => boolean;
        };
    };
};
export default _default;