@ix-xs/node-comfort 1.2.0 → 2.0.0

package/types/src/Num.d.ts

@@ -1,242 +1,578 @@
 /**
- * Clamps a number between a minimum and maximum.
+ * Options for `formatBytes()`.
+ */
+export type FormatBytesOptions = {
+    /**
+     * Maximum decimals. Defaults to `1`.
+     */
+    decimals?: number | undefined;
+    /**
+     * 1 KB is 1024 bytes when `true`, 1000 when `false`. Defaults to `true`.
+     */
+    binary?: boolean | undefined;
+    /**
+     * Use `KiB`, `MiB`, `GiB` labels.
+     */
+    iec?: boolean | undefined;
+    /**
+     * Formats the number for a language, like `"fr"` for `"1,5 KB"`.
+     */
+    locale?: string | undefined;
+    /**
+     * Your own labels from bytes up, like `["o", "Ko", "Mo", "Go", "To"]`.
+     */
+    units?: string[] | undefined;
+};
+/**
+ * Options for `parseBytes()`.
+ */
+export type ParseBytesOptions = {
+    /**
+     * 1 KB is 1024 bytes when `true`, 1000 when `false`. `KiB` units are always 1024. Defaults to `true`.
+     */
+    binary?: boolean | undefined;
+};
+/**
+ * Options for `format()`.
+ */
+export type FormatNumberOptions = {
+    /**
+     * Language, like `"fr"` or `"en-US"`. Defaults to the one set with `setLocale()`, or `"en"`.
+     */
+    locale?: string | undefined;
+    /**
+     * Exact number of decimals.
+     */
+    decimals?: number | undefined;
+    /**
+     * Minimum decimals.
+     */
+    minDecimals?: number | undefined;
+    /**
+     * Maximum decimals. Defaults to `3`.
+     */
+    maxDecimals?: number | undefined;
+    /**
+     * Short notation like `1.2K` or `3.4M`.
+     */
+    compact?: boolean | undefined;
+    /**
+     * `"percent"` multiplies by 100 and adds `%`.
+     */
+    style?: "decimal" | "percent" | undefined;
+    /**
+     * Any `Intl` unit: `"kilometer"`, `"celsius"`, `"megabyte"`...
+     */
+    unit?: string | undefined;
+    /**
+     * How the unit is written. Defaults to `"short"`.
+     */
+    unitDisplay?: "long" | "short" | "narrow" | undefined;
+    /**
+     * When to show the sign. `"exceptZero"` gives `+5`.
+     */
+    signDisplay?: "always" | "auto" | "never" | "exceptZero" | undefined;
+    /**
+     * Thousands separators. Defaults to `true`.
+     */
+    grouping?: boolean | undefined;
+};
+/**
+ * Options for `currency()`.
+ */
+export type CurrencyOptions = {
+    /**
+     * Language. Defaults to the one set with `setLocale()`, or `"en"`.
+     */
+    locale?: string | undefined;
+    /**
+     * Defaults to the currency's usual decimals (2 for EUR, 0 for JPY).
+     */
+    decimals?: number | undefined;
+    /**
+     * `€`, `€`, `EUR` or `euros`. Defaults to `"symbol"`.
+     */
+    display?: "symbol" | "code" | "name" | "narrowSymbol" | undefined;
+    /**
+     * Show negative amounts in parentheses, like `($5.00)`.
+     */
+    accounting?: boolean | undefined;
+};
+/**
+ * Options for `ordinal()`.
+ */
+export type OrdinalOptions = {
+    /**
+     * Built in: `en`, `fr`, `es`, `it`, `pt`, `de`, `nl`. Defaults to the one set with `setLocale()`, or `"en"`.
+     */
+    locale?: string | undefined;
+    /**
+     * Your own suffixes, for other languages.
+     */
+    suffixes?: Partial<Record<Intl.LDMLPluralRule, string>> | undefined;
+};
+/**
+ * Options for `variance()` and `stdDev()`.
+ */
+export type VarianceOptions = {
+    /**
+     * Sample statistic (divides by n - 1) instead of population.
+     */
+    sample?: boolean | undefined;
+};
+/**
+ * Sets the default language of `format`, `currency`, `percent`,
+ * `abbreviate`, `ordinal` and `formatBytes`.
+ *
+ * @example
+ * num.setLocale("fr");
+ * num.currency(1234.5, "EUR"); // "1 234,50 €"
+ *
+ * @param {string} locale Like `"fr"`, `"en-GB"` or `"pt-BR"`.
+ * @returns {typeof import("./Num")} The module, so calls chain.
+ */
+export function setLocale(locale: string): typeof import("./Num");
+/**
+ * The current default language.
+ *
+ * @example
+ * num.getLocale(); // "en"
+ *
+ * @returns {string}
+ */
+export function getLocale(): string;
+/**
+ * Keeps a number between `min` and `max`.
  *
  * @example
- * nodeComfort.num.clamp(15, 0, 10); // 10
- * nodeComfort.num.clamp(-3, 0, 10); // 0
+ * num.clamp(150, 0, 100); // 100
+ * num.clamp(-5, 0, 100);  // 0
  *
- * @param {number} value - Value to clamp.
- * @param {number} min - Lower bound.
- * @param {number} max - Upper bound.
- * @returns {number} The clamped value.
+ * @param {number} value
+ * @param {number} min
+ * @param {number} max
+ * @returns {number}
  */
 export function clamp(value: number, min: number, max: number): number;
 /**
- * Checks whether a number is within an inclusive `[min, max]` range.
+ * Is the number between `min` and `max`, both included?
+ *
+ * @example
+ * num.inRange(10, 0, 10); // true
  *
- * @param {number} value - Value to test.
- * @param {number} min - Lower bound.
- * @param {number} max - Upper bound.
- * @returns {boolean} True if within range.
+ * @param {number} value
+ * @param {number} min
+ * @param {number} max
+ * @returns {boolean}
  */
 export function inRange(value: number, min: number, max: number): boolean;
 /**
- * Rounds a number to a given number of decimal places (avoids float artifacts).
+ * Wraps a number around a range, like an angle or a carousel index.
+ * `max` is excluded.
  *
  * @example
- * nodeComfort.num.round(1.005, 2); // 1.01
+ * num.wrap(370, 0, 360); // 10
+ * num.wrap(-1, 0, 5);    // 4
  *
- * @param {number} value - Value to round.
- * @param {number} [decimals=0] - Number of decimal places.
- * @returns {number} The rounded number.
+ * @param {number} value
+ * @param {number} min
+ * @param {number} max
+ * @returns {number}
+ */
+export function wrap(value: number, min: number, max: number): number;
+/**
+ * Rounds to `decimals` places without floating-point surprises:
+ * `Math.round(1.005 * 100) / 100` gives `1`, this gives `1.01`. Halves round
+ * away from zero, like in a spreadsheet.
+ *
+ * @example
+ * num.round(1.005, 2); // 1.01
+ * num.round(1234, -2); // 1200
+ * num.round(-2.5);     // -3
+ *
+ * @param {number} value
+ * @param {number} [decimals=0] Negative values round to tens, hundreds...
+ * @returns {number}
  */
 export function round(value: number, decimals?: number): number;
 /**
- * Rounds a number down to a given number of decimal places.
+ * Rounds down to `decimals` places.
+ *
+ * @example
+ * num.floor(1.789, 2); // 1.78
  *
- * @param {number} value - Value to round.
- * @param {number} [decimals=0] - Number of decimal places.
- * @returns {number} The floored number.
+ * @param {number} value
+ * @param {number} [decimals=0]
+ * @returns {number}
  */
 export function floor(value: number, decimals?: number): number;
 /**
- * Rounds a number up to a given number of decimal places.
+ * Rounds up to `decimals` places.
  *
- * @param {number} value - Value to round.
- * @param {number} [decimals=0] - Number of decimal places.
- * @returns {number} The ceiled number.
+ * @example
+ * num.ceil(1.231, 2); // 1.24
+ *
+ * @param {number} value
+ * @param {number} [decimals=0]
+ * @returns {number}
  */
 export function ceil(value: number, decimals?: number): number;
 /**
- * Linearly interpolates between `start` and `end` by ratio `t` (0..1).
+ * Rounds to the nearest multiple of `step`.
  *
  * @example
- * nodeComfort.num.lerp(0, 100, 0.5); // 50
+ * num.snap(17, 5);        // 15
+ * num.snap(0.37, 0.25);   // 0.25
  *
- * @param {number} start - Start value.
- * @param {number} end - End value.
- * @param {number} t - Interpolation factor (usually 0..1).
- * @returns {number} The interpolated value.
+ * @param {number} value
+ * @param {number} step
+ * @returns {number}
  */
-export function lerp(start: number, end: number, t: number): number;
+export function snap(value: number, step: number): number;
+/**
+ * Are two numbers equal within a small tolerance? The right way to compare
+ * float results, since `0.1 + 0.2 === 0.3` is `false`.
+ *
+ * @example
+ * num.approxEqual(0.1 + 0.2, 0.3); // true
+ *
+ * @param {number} a
+ * @param {number} b
+ * @param {number} [epsilon=Number.EPSILON * 16] Allowed difference, relative to the size of the numbers.
+ * @returns {boolean}
+ */
+export function approxEqual(a: number, b: number, epsilon?: number): boolean;
 /**
- * Re-maps a number from one range to another.
+ * The value at ratio `t` between `start` and `end`.
  *
  * @example
- * nodeComfort.num.mapRange(5, 0, 10, 0, 100); // 50
+ * num.lerp(0, 100, 0.25); // 25
  *
- * @param {number} value - Value to map.
- * @param {number} inMin - Input range minimum.
- * @param {number} inMax - Input range maximum.
- * @param {number} outMin - Output range minimum.
- * @param {number} outMax - Output range maximum.
- * @returns {number} The mapped value.
+ * @param {number} start
+ * @param {number} end
+ * @param {number} t Usually between 0 and 1.
+ * @returns {number}
+ */
+export function lerp(start: number, end: number, t: number): number;
+/**
+ * Moves a number from one range to another, keeping its relative position.
+ *
+ * @example
+ * num.mapRange(5, 0, 10, 0, 100); // 50
+ * num.mapRange(75, 0, 100, 1, 0); // 0.25
+ *
+ * @param {number} value
+ * @param {number} inMin
+ * @param {number} inMax
+ * @param {number} outMin
+ * @param {number} outMax
+ * @returns {number}
  */
 export function mapRange(value: number, inMin: number, inMax: number, outMin: number, outMax: number): number;
 /**
- * Returns a random number (float) in `[min, max)`.
+ * A random float from `min` (included) to `max` (excluded). Not for
+ * security: it uses `Math.random`.
  *
- * Not cryptographically secure. For secure randomness use `nodeComfort.id`.
+ * @example
+ * num.random(10, 20); // 13.84...
  *
- * @param {number} [min=0] - Lower bound (inclusive).
- * @param {number} [max=1] - Upper bound (exclusive).
- * @returns {number} A random float.
+ * @param {number} [min=0]
+ * @param {number} [max=1]
+ * @returns {number}
  */
 export function random(min?: number, max?: number): number;
 /**
- * Returns a random integer in `[min, max]` (both inclusive).
+ * A random integer from `min` to `max`, both included. Not for security.
  *
  * @example
- * nodeComfort.num.randomInt(1, 6); // dice roll
+ * num.randomInt(1, 6); // a dice roll
  *
- * @param {number} min - Lower bound (inclusive).
- * @param {number} max - Upper bound (inclusive).
- * @returns {number} A random integer.
+ * @param {number} min
+ * @param {number} max
+ * @returns {number}
  */
 export function randomInt(min: number, max: number): number;
 /**
- * Sums all numbers in an array.
+ * Adds up numbers.
  *
- * @param {number[]} values - Array of numbers.
- * @returns {number} The sum (0 for an empty array).
+ * @example
+ * num.sum([1, 2, 3]); // 6
+ *
+ * @param {Iterable<number>} values
+ * @returns {number}
  */
-export function sum(values: number[]): number;
+export function sum(values: Iterable<number>): number;
 /**
- * Returns the arithmetic mean (average) of an array of numbers.
+ * The mean, or `0` for an empty list.
+ *
+ * @example
+ * num.average([2, 4, 9]); // 5
  *
- * @param {number[]} values - Array of numbers.
- * @returns {number} The average (0 for an empty array).
+ * @param {Iterable<number>} values
+ * @returns {number}
  */
-export function average(values: number[]): number;
+export function average(values: Iterable<number>): number;
 /**
- * Returns the median value of an array of numbers.
+ * The middle value once sorted, or `0` for an empty list.
  *
- * @param {number[]} values - Array of numbers.
- * @returns {number} The median (0 for an empty array).
+ * @example
+ * num.median([3, 1, 2]);    // 2
+ * num.median([1, 2, 3, 4]); // 2.5
+ *
+ * @param {Iterable<number>} values
+ * @returns {number}
  */
-export function median(values: number[]): number;
+export function median(values: Iterable<number>): number;
 /**
- * Returns the smallest number in an array.
+ * The most frequent values.
+ *
+ * @example
+ * num.mode([1, 1, 2, 2, 3]); // [1, 2]
  *
- * @param {number[]} values - Array of numbers.
- * @returns {number|undefined} The minimum, or undefined if empty.
+ * @param {Iterable<number>} values
+ * @returns {number[]}
  */
-export function min(values: number[]): number | undefined;
+export function mode(values: Iterable<number>): number[];
 /**
- * Returns the largest number in an array.
+ * The variance: the average squared distance from the mean.
+ *
+ * @example
+ * num.variance([2, 4, 4, 4, 5, 5, 7, 9]); // 4
  *
- * @param {number[]} values - Array of numbers.
- * @returns {number|undefined} The maximum, or undefined if empty.
+ * @param {Iterable<number>} values
+ * @param {VarianceOptions} [options]
+ * @returns {number}
  */
-export function max(values: number[]): number | undefined;
+export function variance(values: Iterable<number>, options?: VarianceOptions): number;
 /**
- * Computes what percentage `value` is of `total`.
+ * The standard deviation.
  *
  * @example
- * nodeComfort.num.percent(25, 200); // 12.5
+ * num.stdDev([2, 4, 4, 4, 5, 5, 7, 9]); // 2
  *
- * @param {number} value - Partial value.
- * @param {number} total - Total value.
- * @param {number} [decimals=2] - Decimal places to keep.
- * @returns {number} The percentage.
+ * @param {Iterable<number>} values
+ * @param {VarianceOptions} [options]
+ * @returns {number}
  */
-export function percent(value: number, total: number, decimals?: number): number;
+export function stdDev(values: Iterable<number>, options?: VarianceOptions): number;
+/**
+ * The value under which `p` percent of the values fall, interpolated like
+ * Excel's `PERCENTILE.INC`.
+ *
+ * @example
+ * num.percentile([1, 2, 3, 4, 5], 90); // 4.6
+ * num.percentile(responseTimes, 95);   // p95 latency
+ *
+ * @param {Iterable<number>} values
+ * @param {number} p From 0 to 100.
+ * @returns {number} `NaN` for an empty list.
+ */
+export function percentile(values: Iterable<number>, p: number): number;
+/**
+ * The smallest number. Unlike `Math.min(...array)`, huge arrays are fine.
+ *
+ * @param {Iterable<number>} values
+ * @returns {number | undefined} `undefined` for an empty list.
+ */
+export function min(values: Iterable<number>): number | undefined;
 /**
- * Formats a byte count into a human-readable string (KB, MB, GB, ...).
+ * The largest number. Unlike `Math.max(...array)`, huge arrays are fine.
  *
- * By default uses binary sizing (base 1024) with familiar `KB`/`MB` labels.
- * Set `binary: false` for SI sizing (base 1000), or `iec: true` for
- * strict `KiB`/`MiB` labels.
+ * @param {Iterable<number>} values
+ * @returns {number | undefined} `undefined` for an empty list.
+ */
+export function max(values: Iterable<number>): number | undefined;
+/**
+ * What percentage `value` is of `total`. Returns `0` when `total` is `0`.
  *
  * @example
- * nodeComfort.num.formatBytes(1536);                 // "1.5 KB"
- * nodeComfort.num.formatBytes(1073741824);           // "1 GB"
- * nodeComfort.num.formatBytes(1000, { binary: false }); // "1 KB"
- * nodeComfort.num.formatBytes(1024, { iec: true });     // "1 KiB"
+ * num.percent(25, 200); // 12.5
+ * num.percent(1, 3, 1); // 33.3
  *
- * @param {number} bytes - Number of bytes.
- * @param {{ decimals?: number, binary?: boolean, iec?: boolean }} [options] - Formatting options.
- * @returns {string} The human-readable size.
+ * @param {number} value
+ * @param {number} total
+ * @param {number} [decimals=2]
+ * @returns {number}
  */
-export function formatBytes(bytes: number, options?: {
-    decimals?: number;
-    binary?: boolean;
-    iec?: boolean;
-}): string;
+export function percent(value: number, total: number, decimals?: number): number;
 /**
- * Formats a large number with a compact suffix (K, M, B, T).
+ * Greatest common divisor.
  *
  * @example
- * nodeComfort.num.abbreviate(1500);      // "1.5K"
- * nodeComfort.num.abbreviate(2_400_000); // "2.4M"
+ * num.gcd(12, 18, 27); // 3
  *
- * @param {number} value - Number to abbreviate.
- * @param {number} [decimals=1] - Decimal places.
- * @returns {string} The abbreviated number.
+ * @param {...number} values
+ * @returns {number}
  */
-export function abbreviate(value: number, decimals?: number): string;
+export function gcd(...values: number[]): number;
 /**
- * Inserts thousands separators into a number.
+ * Least common multiple.
  *
  * @example
- * nodeComfort.num.thousands(1234567);        // "1,234,567"
- * nodeComfort.num.thousands(1234.5, " ");    // "1 234.5"
+ * num.lcm(2, 3, 4); // 12
  *
- * @param {number} value - Number to format.
- * @param {string} [separator=","] - Thousands separator.
- * @returns {string} The formatted number.
+ * @param {...number} values
+ * @returns {number}
  */
-export function thousands(value: number, separator?: string): string;
+export function lcm(...values: number[]): number;
 /**
- * Returns the English ordinal suffix for a number ("st", "nd", "rd", "th").
+ * Is it a prime number?
  *
  * @example
- * nodeComfort.num.ordinal(1);  // "1st"
- * nodeComfort.num.ordinal(22); // "22nd"
+ * num.isPrime(7); // true
+ * num.isPrime(1); // false
  *
- * @param {number} value - The number.
- * @returns {string} The number with its ordinal suffix.
+ * @param {number} value
+ * @returns {boolean}
  */
-export function ordinal(value: number): string;
+export function isPrime(value: number): boolean;
 /**
- * Parses a value into a number, returning a fallback when it isn't numeric.
+ * `n!`. Pass `true` to get an exact bigint, since numbers lose precision
+ * past 18!.
  *
  * @example
- * nodeComfort.num.parse("42px");        // 42
- * nodeComfort.num.parse("nope", 0);     // 0
+ * num.factorial(5);        // 120
+ * num.factorial(25, true); // 15511210043330985984000000n
  *
- * @param {*} value - Value to parse.
- * @param {number} [fallback=NaN] - Value returned when parsing fails.
- * @returns {number} The parsed number or the fallback.
+ * @param {number} n
+ * @param {boolean} [asBigInt=false]
+ * @returns {number | bigint}
+ * @throws {RangeError} If `n` is negative or not an integer.
  */
-export function parse(value: any, fallback?: number): number;
+export function factorial(n: number, asBigInt?: boolean): number | bigint;
 /**
- * Checks whether a number is even.
- * @param {number} value - Number to check.
- * @returns {boolean} True if even.
+ * Is it even?
+ *
+ * @param {number} value
+ * @returns {boolean}
  */
 export function isEven(value: number): boolean;
 /**
- * Checks whether a number is odd.
- * @param {number} value - Number to check.
- * @returns {boolean} True if odd.
+ * Is it odd? Negative numbers work too.
+ *
+ * @param {number} value
+ * @returns {boolean}
  */
 export function isOdd(value: number): boolean;
 /**
- * Returns an array of numbers from `start` to `end`.
+ * Numbers from `start` up to `end` (excluded). With one argument, counts
+ * from 0. Goes down when `end` is smaller.
  *
- * `end` is exclusive. Supports a custom step and descending ranges.
+ * @example
+ * num.range(4);        // [0, 1, 2, 3]
+ * num.range(0, 10, 2); // [0, 2, 4, 6, 8]
+ * num.range(5, 0);     // [5, 4, 3, 2, 1]
+ *
+ * @param {number} start
+ * @param {number} [end]
+ * @param {number} [step] Defaults to `1`, or `-1` when counting down.
+ * @returns {number[]}
+ */
+export function range(start: number, end?: number, step?: number): number[];
+/**
+ * Reads a number from anything, ignoring trailing text like units.
  *
  * @example
- * nodeComfort.num.range(4);          // [0, 1, 2, 3]
- * nodeComfort.num.range(1, 5);       // [1, 2, 3, 4]
- * nodeComfort.num.range(0, 10, 2);   // [0, 2, 4, 6, 8]
- * nodeComfort.num.range(5, 0);       // [5, 4, 3, 2, 1]
+ * num.parse("42px");     // 42
+ * num.parse(" -3.5 kg"); // -3.5
+ * num.parse("nope", 0);  // 0
  *
- * @param {number} start - Start (or end if it's the only argument).
- * @param {number} [end] - End (exclusive).
- * @param {number} [step] - Step size (defaults to 1 or -1 based on direction).
- * @returns {number[]} The generated range.
+ * @param {unknown} value
+ * @param {number} [fallback=NaN] Returned when there's no number to read.
+ * @returns {number}
  */
-export function range(start: number, end?: number, step?: number): number[];
+export function parse(value: unknown, fallback?: number): number;
+/**
+ * Turns a size like `"10 MB"` into bytes. The opposite of `formatBytes()`.
+ *
+ * @example
+ * num.parseBytes("1.5 KB");                   // 1536
+ * num.parseBytes("2 GiB");                    // 2147483648
+ * num.parseBytes("1 KB", { binary: false });  // 1000
+ *
+ * @param {string | number} value A size like `"512kb"` or `"1.5G"`, or a number of bytes.
+ * @param {ParseBytesOptions} [options]
+ * @returns {number} Bytes, or `NaN` if it can't be read.
+ */
+export function parseBytes(value: string | number, options?: ParseBytesOptions): number;
+/**
+ * Formats a byte count as a readable size.
+ *
+ * @example
+ * num.formatBytes(1536);                     // "1.5 KB"
+ * num.formatBytes(1000, { binary: false });  // "1 KB"
+ * num.formatBytes(1536, { locale: "fr", units: ["o", "Ko", "Mo", "Go"] }); // "1,5 Ko"
+ *
+ * @param {number} bytes
+ * @param {FormatBytesOptions} [options]
+ * @returns {string}
+ */
+export function formatBytes(bytes: number, options?: FormatBytesOptions): string;
+/**
+ * Formats a number for display, with `Intl.NumberFormat` doing the work:
+ * separators, decimals, compact notation, percentages, units.
+ *
+ * @example
+ * num.format(1234567.891);                   // "1,234,567.891"
+ * num.format(1234567.891, { locale: "fr" }); // "1 234 567,891"
+ * num.format(0.256, { style: "percent" });   // "26%"
+ * num.format(1500, { compact: true });       // "1.5K"
+ * num.format(3.5, { unit: "kilometer" });    // "3.5 km"
+ *
+ * @param {number | bigint} value
+ * @param {FormatNumberOptions} [options]
+ * @returns {string}
+ */
+export function format(value: number | bigint, options?: FormatNumberOptions): string;
+/**
+ * Formats an amount of money.
+ *
+ * @example
+ * num.currency(1234.5, "USD");                   // "$1,234.50"
+ * num.currency(1234.5, "EUR", { locale: "fr" }); // "1 234,50 €"
+ * num.currency(-5, "USD", { accounting: true }); // "($5.00)"
+ *
+ * @param {number | bigint} value
+ * @param {string} code A currency code like `"EUR"`, `"USD"` or `"JPY"`.
+ * @param {CurrencyOptions} [options]
+ * @returns {string}
+ */
+export function currency(value: number | bigint, code: string, options?: CurrencyOptions): string;
+/**
+ * Shortens big numbers with `K`, `M`, `B` or `T`. For other languages, use
+ * `format(value, { compact: true, locale })`.
+ *
+ * @example
+ * num.abbreviate(1500);      // "1.5K"
+ * num.abbreviate(2_400_000); // "2.4M"
+ *
+ * @param {number} value
+ * @param {number} [decimals=1]
+ * @returns {string}
+ */
+export function abbreviate(value: number, decimals?: number): string;
+/**
+ * Adds thousands separators, leaving decimals alone.
+ *
+ * @example
+ * num.thousands(1234567.89, " "); // "1 234 567.89"
+ *
+ * @param {number | string} value
+ * @param {string} [separator=","]
+ * @returns {string}
+ */
+export function thousands(value: number | string, separator?: string): string;
+/**
+ * Adds the ordinal suffix: 1st, 2nd, 3rd... in several languages.
+ *
+ * @example
+ * num.ordinal(22);                   // "22nd"
+ * num.ordinal(1, { locale: "fr" });  // "1er"
+ * num.ordinal(3, { locale: "de" });  // "3."
+ *
+ * @param {number} value
+ * @param {OrdinalOptions} [options]
+ * @returns {string}
+ */
+export function ordinal(value: number, options?: OrdinalOptions): string;
 //# sourceMappingURL=Num.d.ts.map