/**
 * Checks if the passed value is numeric one. For example these values (passed as string or number)
 * are considered as numeric values:
 *  - 0.001
 *  - .001
 *  - 10000
 *  - 1e+26
 *  - 22e-26
 *  - .45e+26
 *  - 0xabcdef (hex)
 *  - 0x1 (hex)
 *
 * these values are not considered as numeric:
 *  - - 1000
 *  - 100 000
 *
 * @param {*} value The value to check.
 * @param {string[]} additionalDelimiters An additional delimiters to be used while checking the numeric value.
 * @returns {boolean}
 */
export declare function isNumeric(value: unknown, additionalDelimiters?: string[]): boolean;
/**
 * Checks if the passed value is numeric-like value. The helper returns `true` for the same
 * values as for the `isNumeric` function plus `true` for numbers delimited by comma.
 *
 * @param {*} value The value to check.
 * @returns {boolean}
 */
export declare function isNumericLike(value: unknown): boolean;
/**
 * Whether the string is an integer with comma-separated thousands groups only.
 * This matches the grouping rule used by [[getParsedNumber]] when the cell uses a dot as the
 * decimal separator. It is not implied by [[isNumericLike]] because `isNumeric` allows at most
 * one comma-delimited segment.
 *
 * @param {string} value The raw string value.
 * @param {'.'|','|undefined} decimalSeparator Preferred decimal separator from cell meta.
 * @returns {boolean}
 */
export declare function isCommaThousandsGroupedInteger(value: string, decimalSeparator: '.' | ',' | undefined): boolean;
/**
 * Whether the string is an integer with dot-separated thousands groups only.
 * This matches the grouping rule used by European locales where the decimal separator
 * is a comma and the thousands separator is a dot (e.g. `7.000` → 7000).
 *
 * @param {string} value The raw string value.
 * @param {'.'|','|undefined} decimalSeparator Preferred decimal separator from cell meta.
 * @returns {boolean}
 */
export declare function isDotThousandsGroupedInteger(value: string, decimalSeparator: '.' | ',' | undefined): boolean;
/**
 * Whether the string is a float with dot-separated thousands groups and a comma decimal part.
 * This matches the grouping rule used by European locales where the decimal separator
 * is a comma and the thousands separator is a dot (e.g. `7.000,25` → 7000.25).
 *
 * @param {string} value The raw string value.
 * @param {'.'|','|undefined} decimalSeparator Preferred decimal separator from cell meta.
 * @returns {boolean}
 */
export declare function isDotThousandsGroupedFloat(value: string, decimalSeparator: '.' | ',' | undefined): boolean;
/**
 * A specialized version of `.forEach` defined by ranges.
 *
 * @param {number} rangeFrom The number from start iterate.
 * @param {number|Function} rangeTo The number where finish iterate or function as a iteratee.
 * @param {Function} [iteratee] The function invoked per iteration.
 */
export declare function rangeEach(rangeFrom: number, rangeTo: number | ((index: number) => unknown), iteratee?: (index: number) => unknown): void;
/**
 * A specialized version of `.forEach` defined by ranges iterable in reverse order.
 *
 * @param {number} rangeFrom The number from start iterate.
 * @param {number|Function} rangeTo The number where finish iterate or function as a iteratee.
 * @param {Function} [iteratee] The function invoked per iteration.
 */
export declare function rangeEachReverse(rangeFrom: number, rangeTo: number | ((index: number) => unknown), iteratee?: (index: number) => unknown): void;
/**
 * Calculate value from percent.
 *
 * @param {number} value Base value from percent will be calculated.
 * @param {string|number} percent Can be number or string (eq. `'33%'`).
 * @returns {number}
 */
export declare function valueAccordingPercent(value: number, percent: string | number): number;
/**
 * Clamps the value between min and max.
 *
 * @param {number} value The base number value.
 * @param {number} minValue The max number value.
 * @param {number} maxValue The min number value.
 * @returns {number}
 */
export declare function clamp(value: number, minValue: number, maxValue: number): number;
/**
 * Get parsed number from numeric string.
 *
 * @param {string} numericData Float (separated by a dot or a comma), integer, or a dot-thousands
 * grouped value used by European locales (e.g. `7.000` or `7.000,25` when `decimalSeparator` is `','`).
 * @param {object} [options={}] Parsing options.
 * @param {'.'|','} [options.decimalSeparator] Preferred decimal separator used by the cell.
 * @returns {number|null} Number if we get data in parsable format, not changed value otherwise.
 */
export declare function getParsedNumber(numericData: string, options?: {
    decimalSeparator?: '.' | ',';
}): number | null;
/**
 * Whether converting a plain numeric string to its parsed JS number loses information.
 * Two situations count as lossy: trailing fractional zeros (e.g. `9.0` → `9`) and precision
 * beyond `Number.MAX_SAFE_INTEGER` (e.g. `12345678901234567.8` → `12345678901234568`).
 *
 * Both the input and `String(parsedNumber)` are normalized to plain decimal notation before
 * comparing, so purely cosmetic differences (leading zeros, a leading `+`, `.5`/`5.`, and
 * scientific notation on either side — `1e2` vs `100`, `0.0000001` vs `1e-7`) are not treated
 * as loss. A plain `-0` is not loss either — the parsed number `-0` keeps the sign even though
 * `String(-0)` drops it. A mantissa trailing zero that a positive exponent shifts onto or left of the
 * decimal point (`1.0e2` → `100`, `1.10e2` → `110`) survives as an integer digit of the exact
 * value, so it is not loss either; only zeros that stay fractional after the shift
 * (`1.10e1` → `11.0`) are dropped by parsing and count as lossy.
 *
 * Intended only for the plain float path. Thousands-grouped inputs (e.g. `7.000`) are resolved
 * by the caller before this runs and must not be passed here.
 *
 * @param {string} rawInput The raw user input string.
 * @param {number} parsedNumber The number produced from `rawInput` by `getParsedNumber`.
 * @returns {boolean}
 */
export declare function isLossyNumericConversion(rawInput: string, parsedNumber: number): boolean;
/**
 * Check if the provided argument is an unsigned number.
 *
 * @param {*} value Value to check.
 * @returns {boolean}
 */
export declare function isUnsignedNumber(value: unknown): value is number;