/**
 * Clamps a given number between a specified minimum and maximum value.
 *
 * @param n - The number to clamp.
 * @param min - The minimum allowed value (inclusive). If provided, the returned number will be at least this value.
 * @param max - The maximum allowed value (inclusive). If provided, the returned number will be at most this value.
 * @returns The clamped number if it is a valid number; otherwise, returns the original number (which may be NaN).
 */
export declare const clampNumber: (n: number, min?: number, max?: number) => number;
/**
 * Detects the grouping and decimal characters for a given locale.
 *
 * This function uses the Intl.NumberFormat API to format the number 1000.1 and extract its parts.
 * It then determines the grouping character (e.g., comma, period) and the decimal separator.
 * If a custom decimal separator (dSep) is provided, it takes precedence over the detected value.
 *
 * @param locale - A string indicating the locale to be used (e.g., "en-US", "it-IT").
 * @param dSep - An optional string to override the detected decimal separator.
 * @returns An object with two properties:
 *   - groupingChar: The detected grouping (thousands) separator.
 *   - decimalChar: The detected or overridden decimal separator.
 */
export declare const detectGrouping: (locale: string, dSep?: string) => {
    groupingChar: string;
    decimalChar: string;
};
/**
 * Formats a given input number according to the specified or default numeric format and locale.
 *
 * @param input - A string or number representing the value to be formatted.
 * @param format - An optional format string that determines the display format of the number.
 *                 If omitted, a default format is used based on whether the number is an integer
 *                 or has decimal places.
 * @param inputIsLocalized - An optional flag indicating if the input string is localized.
 * @param locale - An optional language that specifies the locale to use for formatting.
 * @returns A string containing the formatted number.
 *
 * @remarks
 * The function first converts the input to a number using a helper function (numberify). If no
 * format is provided, it determines a default format based on the numerical value: an integer
 * format ("0,0") if the number has no decimal part, or a fixed decimal format ("0,0.00") if it does.
 * It then parses the format into formatting options via the parseNumberFormat helper and uses
 * Intl.NumberFormat with the specified locale to generate the formatted string.
 */
export declare function formatNumber(input: string | number, format?: string, inputIsLocalized?: boolean, locale?: string): string;
/**
 * Returns the number of digits present in the fractional part of the provided numeric string.
 *
 * The function first attempts to find the decimal separator in the string. If found, it computes
 * the number of digits that follow it. If the decimal separator is not present, it checks for an
 * alternative (e.g., if the primary is "." it looks for "," and vice versa). When using the alternative,
 * it ensures that it is not merely a thousand grouping separator (by verifying that it is not followed by
 * exactly three digits).
 *
 * @param str - The numeric string to be evaluated.
 * @param grouping - The grouping separator used in the string.
 * @param decimal - The primary decimal separator.
 * @returns The count of digits in the fractional part of the number.
 */
export declare const getFractionLength: (str: string, grouping: string, decimal: string) => number;
/**
 * Returns the numeric value suffix corresponding to the provided type.
 *
 * The function converts the input type to uppercase and compares it against predefined values:
 * - "P": Returns the percentage suffix " %".
 * - "VE": Returns the Euro suffix " €".
 * - "VL": Returns the Pound suffix " £".
 * - "VV": Returns the Dollar suffix " $".
 *
 * @param type - A string representing the type from which to derive the numeric value suffix.
 * @returns A string containing the numeric value suffix associated with the provided type.
 */
export declare function getNumericValueSuffix(type: string): string;
/**
 * Normalizes a number represented as a formatted string by removing grouping characters,
 * converting the decimal separator if necessary, and parsing it into a floating-point number.
 *
 * @param raw - The raw string input representing the number.
 * @param groupingChar - The character used as the grouping (thousands separator) in the input.
 * @param decimalChar - The character used as the decimal separator in the input.
 * @returns The parsed number as a float, or NaN if the input is empty or cannot be parsed.
 */
export declare const normalizeNumber: (raw: string, groupingChar: string, decimalChar: string) => number;
/**
 * Converts an input value, either a string or a number, into a numeric value.
 *
 * For string inputs, the function handles localized formats by optionally removing group separators and
 * replacing the decimal separator with a dot. It also removes any type-specific numeric suffixes if a type is provided.
 *
 * @param input - The value to convert, which can be a string representing a number or an actual number.
 * @param inputIsLocalized - Indicates whether the input string is formatted using localized number formatting.
 * @param type - (Optional) A string specifying the numeric type, used for removing type-specific suffixes from the input.
 * @param decFmt - (Optional) The expected decimal format (separator) in the input string. Defaults to "." if not provided.
 * @param decimalSeparator - (Optional) The decimal separator used when the input is localized; used if decFmt is not explicitly provided.
 * @returns The numeric representation of the input value, or NaN if the conversion fails.
 */
export declare function numberify(input: string | number, inputIsLocalized?: boolean, type?: string, decFmt?: string, decimalSeparator?: string): number;
/**
 * Parses a number format string into an Intl.NumberFormatOptions object.
 *
 * The parser examines the provided format string to determine:
 * - Whether grouping is used, by checking for the presence of a comma (",") in the integer part.
 * - The number of decimal digits, by counting the zeros ("0") following a decimal point (".") if it exists.
 *
 * Example formats include: '0,0.00', '0,0', '0.000', etc.
 *
 * @param format - A string representing the desired number format.
 * @returns An Intl.NumberFormatOptions object configured based on the format.
 */
export declare function parseNumberFormat(format: string): Intl.NumberFormatOptions;
//# sourceMappingURL=number.d.ts.map