/**
 * NUMBER FUNCTIONS ============================================================
 * =============================================================================
 */
/**
 * Get the Divisor closest to the target for a Number
 * @example:
 *    closestDivisor(27, 5)
 *    >>> 3
 *    closestDivisor(16, 4)
 *    >>> 4
 *    closestDivisor(9, 4)
 *    >>> 3
 *
 * @param {number} number
 * @param {number} target
 * @returns {number} divisor - the smallest divisor closest to the target number
 */
export function closestDivisor(number: number, target: number): number;
/**
 * Check if value is between 0 and 1 (inclusive) and is classified as a Number primitive or object
 * (aka. [Unit interval](https://en.wikipedia.org/wiki/Unit_interval))
 * @param {any} v
 * @returns {boolean} true - if it is
 */
export function isUnitInterval(v: any): boolean;
/**
 * Returns true if the given variable is a number,
 * including if it's data type is not a number eg. '1'
 *
 * @example
 isNumeric('1')  // NOTE: isNumber('1') would return false
 >>> true
 isNumeric('a')
 >>> false
 *
 * @param {*} val
 * @returns {boolean}
 */
export function isNumeric(val: any): boolean;
/**
 * Check if given list of {from: Number, to: Number} is in continuous incrementing order
 * (useful for checking schedules of time durations in milliseconds)
 *
 * @param {Array<{from: Number, to: Number}>} arrayOfNumberRanges - to check for validity
 * @returns {Boolean} true - if it is a continuously incrementing ranges of numbers
 */
export function isContinuousNumberRanges(arrayOfNumberRanges: Array<{
    from: number;
    to: number;
}>): boolean;
/**
 * Check if value is an Unsigned Integer
 * @param {any} v
 * @returns {boolean} true - if it is
 */
export function isUnsignedInteger(v: any): boolean;
/**
 * Extract the Starting and Ending Number in given list of continuously incrementing number ranges
 *
 * @param {Array<{from: Number, to: Number}>} arrayOfNumberRanges - to check for values
 * @returns {{start: Number|Undefined, end: Number|Undefined}}
 */
export function startEndFromNumberRanges(arrayOfNumberRanges: Array<{
    from: number;
    to: number;
}>): {
    start: number | undefined;
    end: number | undefined;
};
/**
 * Increment Counter
 *
 * @example:
 *  - This is a Closure Function, declare at the start to instantiate the environment:
 *    const addCount = createIncrementCounter(7)
 *  - Then perform incrementing:
 *    addCount()
 *    >>> 8
 *  - Add 2 to current count:
 *    addCount(2)
 *    >>> 10
 *  - Reset Count:
 *    addCount(0)
 *    >>> 0
 *  - Subtract 2 from current count:
 *    addCount(-2)
 *    >>> -2
 *
 * @param {number} initValue - initial count
 * @return {Function} - closure that stores a local number count,
 *    and increments count by 1 when no argument passed
 * @return
 */
export function createIncrementCounter(initValue?: number): Function;
/**
 * Format Currency
 *
 * @param {Number|String} value - to format with currency symbol
 * @param {String} [symbol] - currency code to use, default is `$`
 */
export function formatCurrency(value: number | string, { symbol }?: string | undefined): string;
/**
 * Format Number to Delimited String, and optionally set the number of Decimals
 * @Note: use Number().toLocaleString() for faster performance if no fixed decimals needed.
 *
 * @param {number|string} value - number to format
 * @param {number} [decimals] - length of decimal
 * @param {number} [delimits] - length of digits to be delimited
 * @param {string} [sectionDelimiter] - section delimiter character
 * @param {string} [decimalDelimiter] - decimal delimiter character
 * @param {boolean} [ordinal] - whether to convert to ordinal number
 * @return {string} - delimited number with specified decimals
 */
export function formatNumber(value: number | string, { decimals, delimits, sectionDelimiter, decimalDelimiter, ordinal }?: number | undefined): string;
/**
 * Shorten Number to given Digits Length, with Suffix Added if Necessary
 * todo: Localise decimal numbers
 * @param {number|string} value - number to format
 * @param {Number} [digits] - maximum number of digits to keep (will add/remove decimals to match final length)
 * @param {Number} [divider] - value to divide by when determining exponent steps, example: 1024 for bytes
 * @param {String} [delimiter] - character to insert between computed value and suffix
 * @param {Object} [suffixes] - list of suffixes to use for each exponent
 * @return {String} number - shorten to digits length with suffix if needed
 */
export function shortNumber(value: number | string, digits?: number | undefined, divider?: number | undefined, delimiter?: string | undefined, suffixes?: Object | undefined): string;
/**
 * Format Number with SI Prefix
 * @link: https://github.com/ThomWright/format-si-prefix
 *
 * @param {Number} number - to format
 * @param {Number} [precision] - number of significant digits to keep, will round number if 0 given
 * @param {Number} [divider] - value to divide by when determining exponent steps, example: 1024 for bytes
 * @param {String} [delimiter] - character to insert between computed value and suffix
 * @param {Object} [suffixes] - list of suffixes to use for each exponent
 * @return {string} number - with unit suffix if needed
 */
export function formatSI(number: number, precision?: number | undefined, divider?: number | undefined, delimiter?: string | undefined, suffixes?: Object | undefined): string;
export namespace formatSI {
    const PREFIXES: {
        '24': string;
        '21': string;
        '18': string;
        '15': string;
        '12': string;
        '9': string;
        '6': string;
        '3': string;
        '0': string;
        '-3': string;
        '-6': string;
        '-9': string;
        '-12': string;
        '-15': string;
        '-18': string;
        '-21': string;
        '-24': string;
    };
}
/**
 * Calculate Logarithm for given exponent and base numbers
 *
 * @param {Number} exponent
 * @param {Number} base
 * @returns {number} log
 */
export function mathLog(exponent: number, base: number): number;
/**
 * Get Numeric Characters Pattern based on User's Locale Settings
 * @example:
 *    numericPattern().test('+1')
 *    >>> true
 *    numericPattern('en-US').test('+1,000')
 *    >>> false
 *    numericPattern('en-US').test('-1.000')
 *    >>> true
 *    numericPattern('fr-FR').test('.')
 *    >>> false
 *    numericPattern('fr-FR').test(',')
 *    >>> true
 *
 * @param {string|string[]} [locales] - string with a BCP 47 language tag, or an array of strings
 * @returns {RegExp} regex - that can be used to test for numeric input
 */
export function numericPattern(locales?: string | string[] | undefined): RegExp;
/**
 * Get the median number from a list of numbers
 * @param {number[]} array - list of numbers
 */
export function medianNumber(array: number[]): number;
/**
 * Parses value of input type="number" string into a Number type with Locale aware formatting
 * @see: https://stackoverflow.com/a/45309230
 * @example:
 *    parseNumber('1.123')
 *    >>> 1.123
 *    parseNumber('1.123', 'fr-FR')
 *    >>> 1123
 *    parseNumber('1,123', 'en-US')
 *    >>> 1123
 *    parseNumber('1,123', 'fr-FR')
 *    >>> 1.123
 *
 * Note:
 *  - input event.target.valueAsNumber does not work consistently in Safari and can return NaN
 *  - This function instead relies on Regex pattern to strip out non-valid number characters,
 *    based on current User's locale settings,
 *    then performs conversion to normalized number string that gets converted to Number.
 *
 * @param {string|number|null|void} value - from input event.target.value
 * @param {string|string[]} [locales] - string with a BCP 47 language tag, or an array of strings
 * @returns {number|null} number - converted from value string, or null if not a number
 */
export function parseNumberLocale(value: string | number | null | void, locales?: string | string[] | undefined): number | null;
/**
 * Format Number to Ordinal Numeric String
 *
 * @param {number|string} number - to format
 * @return {string} - ordered number (i.e. 1st, 2nd, 3rd, 4th...)
 */
export function toOrdinal(number: number | string): string;
export namespace toOrdinal {
    const list: string[];
}
/**
 * Compute Radian Value from given Degree
 *
 * @param {Number} degree - to ompute
 * @returns {Number} radian
 */
export function rad(degree: number): number;
/**
 * Round off a number to n* last digits
 * (e.g. converting timestamps into whole seconds)
 *
 * @example:
 *    roundTail(1234567, 3)
 *    >>> 1235000
 *    roundTail(1234567, 7)
 *    >>> 1000000
 *    roundTail(5234567, 7)
 *    >>> 10000000
 * @param {number} number - the value to convert
 * @param {number} lastDigits - the number of digits to round off to 0 at the end
 * @returns {number} - rounded number
 */
export function roundTail(number: number, lastDigits: number): number;
/**
 * Round Number to given Precision decimal point
 *
 * @example:
 *    roundNumber(123.4567, 3)
 *    >>> 123.457
 *
 * @param {number} number - value to round
 * @param {number} [precision] - decimal places to keep
 * @returns {number} - with rounded values
 */
export function round(number: number, precision?: number | undefined): number;
/**
 * Round Number up to given Precision decimal point
 *
 * @example:
 *    roundUp(123.4564, 3)
 *    >>> 123.457
 *
 * @param {number} number - value to round
 * @param {number} [precision] - decimal places to keep
 * @returns {number} - with rounded values
 */
export function roundUp(number: number, precision?: number | undefined): number;
/**
 * Round Number down to given Precision decimal point
 *
 * @example:
 *    roundDown(123.4567, 3)
 *    >>> 123.456
 *
 * @param {number} number - value to round
 * @param {number} [precision] - decimal places to keep
 * @returns {number} - with rounded values
 */
export function roundDown(number: number, precision?: number | undefined): number;
/**
 * Round Number to the closest Multiple of value
 * @Note: this function need precision rounding because of floating point issues, as the last operation is multiply
 *    => example: roundTo(1.2, 0.1)
 *    >>> 1.2000000000000002 -> this is the output without precision rounding
 *
 * @example:
 *    roundTo(123.4567, 10)
 *    >>> 120
 *
 * @param {number} number - value to round
 * @param {number} [multiple] - value, the multiple of which to round to
 * @returns {number} - rounded to given multiple of value
 */
export function roundTo(number: number, multiple?: number | undefined): number;
/**
 * Round Down Number to the closest Multiple of value
 * @Note: this function needs rounding twice, because
 *    => example: 1.2 / 0.1
 *    >>> 11.999999999999998 -> rounds down to 11
 *
 * @example:
 *    roundTo(123.4567, 10)
 *    >>> 120
 *
 * @param {number} number - value to round
 * @param {number} [multiple] - value, the multiple of which to round to
 * @returns {number} - rounded to given multiple of value
 */
export function roundDownTo(number: number, multiple?: number | undefined): number;
/**
 * Round Up Number to the closest Multiple of value
 * @Note: this function needs rounding twice, like roundDownTo
 *
 * @example:
 *    roundTo(123.4567, 10)
 *    >>> 130
 *
 * @param {number} number - value to round
 * @param {number} [multiple] - value, the multiple of which to round to
 * @returns {number} - rounded to given multiple of value
 */
export function roundUpTo(number: number, multiple?: number | undefined): number;
/**
 * Get decimal places of given Numeric value
 *
 * @param {number|string} value - number to get precision for
 * @return {number} precision - decimal places
 */
export function decimalPlaces(value: number | string): number;
/**
 * Calculates the Greatest Common Divisor between two numbers
 *
 * @param {number|string} a - first number
 * @param {number|string} b - second number
 * @returns {number} - the biggest divisible number between `a` and `b`
 */
export function greatestCommonDivisor(a: number | string, b: number | string): number;
/**
 * Returns a random integer/float between min (inclusive) and max (inclusive),
 * if given numbers are whole integers, then returned value will also be a whole number,
 * if given numbers are floats, then returned value can also be a float.
 *
 * Note: Using Math.round() will give you a non-uniform distribution!
 *
 * @param {number} min - minimum number
 * @param {number} max - maximum number
 * @returns {number} - random value between min and max, inclusive
 */
export function randomNumberInRange(min: number, max: number): number;
/**
 * Compute the Difference between two numbers in Percents
 *
 * @param {number} newNumber - new value to calculate percent change
 * @param {number} baseNumber - the number to calculate percentage from
 * @return {number|NaN} diff - percentage difference, or not a number
 */
export function toPercentage(newNumber: number, baseNumber: number): number | number;
/**
 * Convert Fraction number to Percentage string with '%', or render an empty string if not a number
 *
 * @param {Number|String} number - fraction from 0 to 1 to show as percent
 * @param {Number} [decimals] - number of digits to show after the dot
 * @returns {String} percentage - formatted string with set decimal places and '%', or empty string
 */
export function toPercent(number: number | string, decimals?: number | undefined): string;