n2words 5.1.0 → 5.1.2

package/src/en-CA.d.ts

@@ -1,35 +1,43 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
 /**
- * @typedef {object} CardinalOptions
- * @property {boolean} [hundredPairing] - Use hundred-pairing for 1100-9999 (e.g., "fifteen hundred" instead of "one thousand five hundred")
- * @property {boolean} [and] - Use "and" after hundreds and before final small numbers (default: true, Canadian/British style)
- */
-/** @type {Required<CardinalOptions>} */
-export const cardinalDefaults: Required<CardinalOptions>;
-/**
- * @typedef {object} CurrencyOptions
- * @property {boolean} [and] - Use "and" between dollars and cents (e.g., "one dollar and fifty cents")
+ * Canadian English language converter
+ *
+ * CLDR: en-CA | English as used in Canada
+ *
+ * Exports:
+ * - toCardinal(value, options?)  - Cardinal numbers: 42 → "forty-two"
+ * - toOrdinal(value)             - Ordinal numbers: 42 → "forty-second"
+ * - toCurrency(value, options?)  - Currency: 42.50 → "forty-two dollars and fifty cents"
+ *
+ * Canadian English conventions:
+ * - Follows British English style for number words
+ * - "and" after hundreds: "one hundred and twenty-three" (default)
+ * - "and" before final segment: "one million and one" (default)
+ * - Hyphenated tens-ones: "twenty-one", "forty-two"
+ * - Western numbering system (short scale: billion = 10^9)
+ * - Optional hundred-pairing: 1500 → "fifteen hundred" (colloquial)
+ * - Optional "and" omission: 101 → "one hundred one" (American style)
+ * - Currency: Canadian Dollar (CAD) - dollar/dollars, cent/cents
  */
-/** @type {Required<CurrencyOptions>} */
-export const currencyDefaults: Required<CurrencyOptions>;
+export declare const cardinalMax: bigint;
+export declare const ordinalMax: bigint;
+export declare const currencyMax: bigint;
 export type CardinalOptions = {
     /**
      * - Use hundred-pairing for 1100-9999 (e.g., "fifteen hundred" instead of "one thousand five hundred")
      */
-    hundredPairing?: boolean | undefined;
+    hundredPairing?: boolean;
     /**
      * - Use "and" after hundreds and before final small numbers (default: true, Canadian/British style)
      */
-    and?: boolean | undefined;
-};
-export type CurrencyOptions = {
-    /**
-     * - Use "and" between dollars and cents (e.g., "one dollar and fifty cents")
-     */
-    and?: boolean | undefined;
+    and?: boolean;
 };
+/**
+ * @typedef {object} CardinalOptions
+ * @property {boolean} [hundredPairing] - Use hundred-pairing for 1100-9999 (e.g., "fifteen hundred" instead of "one thousand five hundred")
+ * @property {boolean} [and] - Use "and" after hundreds and before final small numbers (default: true, Canadian/British style)
+ */
+/** @type {Required<CardinalOptions>} */
+export declare const cardinalDefaults: Required<CardinalOptions>;
 /**
  * Converts a numeric value to Canadian English words.
  *
@@ -47,7 +55,7 @@ export type CurrencyOptions = {
  * toCardinal(1500)                          // 'one thousand five hundred'
  * toCardinal(1500, { hundredPairing: true }) // 'fifteen hundred'
  */
-export function toCardinal(value: number | string | bigint, options?: CardinalOptions): string;
+declare function toCardinal(value: number | string | bigint, options?: CardinalOptions): string;
 /**
  * Converts a numeric value to Canadian English ordinal words.
  * @param {number | string | bigint} value - The numeric value to convert (must be a positive integer)
@@ -64,7 +72,19 @@ export function toCardinal(value: number | string | bigint, options?: CardinalOp
  * toOrdinal(101)  // 'one hundred first'
  * toOrdinal(1000) // 'one thousandth'
  */
-export function toOrdinal(value: number | string | bigint): string;
+declare function toOrdinal(value: number | string | bigint): string;
+export type CurrencyOptions = {
+    /**
+     * - Use "and" between dollars and cents (e.g., "one dollar and fifty cents")
+     */
+    and?: boolean;
+};
+/**
+ * @typedef {object} CurrencyOptions
+ * @property {boolean} [and] - Use "and" between dollars and cents (e.g., "one dollar and fifty cents")
+ */
+/** @type {Required<CurrencyOptions>} */
+export declare const currencyDefaults: Required<CurrencyOptions>;
 /**
  * Converts a numeric value to Canadian English currency words.
  * @param {number | string | bigint} value - The currency amount to convert
@@ -78,4 +98,5 @@ export function toOrdinal(value: number | string | bigint): string;
  * toCurrency(0.99)                     // 'ninety-nine cents'
  * toCurrency(42.50, { and: false })    // 'forty-two dollars fifty cents'
  */
-export function toCurrency(value: number | string | bigint, options?: CurrencyOptions): string;
+declare function toCurrency(value: number | string | bigint, options?: CurrencyOptions): string;
+export { toCardinal, toOrdinal, toCurrency };

package/src/en-GB.d.ts

@@ -1,18 +1,17 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
 /**
- * @typedef {object} CurrencyOptions
- * @property {boolean} [and] - Use "and" between pounds and pence (e.g., "one pound and fifty pence")
+ * British English language converter
+ *
+ * CLDR: en-GB | English as used in the United Kingdom
+ *
+ * British English conventions:
+ * - "and" after hundreds: "one hundred and twenty-three"
+ * - "and" before final segment: "one million and one"
+ * - Hyphenated tens-ones: "twenty-one", "forty-two"
+ * - Western numbering system (short scale: billion = 10^9)
  */
-/** @type {Required<CurrencyOptions>} */
-export const currencyDefaults: Required<CurrencyOptions>;
-export type CurrencyOptions = {
-    /**
-     * - Use "and" between pounds and pence (e.g., "one pound and fifty pence")
-     */
-    and?: boolean | undefined;
-};
+export declare const cardinalMax: bigint;
+export declare const ordinalMax: bigint;
+export declare const currencyMax: bigint;
 /**
  * Converts a numeric value to English words.
  *
@@ -27,7 +26,7 @@ export type CurrencyOptions = {
  * toCardinal(-3.14)        // 'minus three point fourteen'
  * toCardinal('1000000')    // 'one million'
  */
-export function toCardinal(value: number | string | bigint): string;
+declare function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to British English ordinal words.
  * @param {number | string | bigint} value - The numeric value to convert (must be a positive integer)
@@ -44,7 +43,19 @@ export function toCardinal(value: number | string | bigint): string;
  * toOrdinal(101)  // 'one hundred first'
  * toOrdinal(1000) // 'one thousandth'
  */
-export function toOrdinal(value: number | string | bigint): string;
+declare function toOrdinal(value: number | string | bigint): string;
+export type CurrencyOptions = {
+    /**
+     * - Use "and" between pounds and pence (e.g., "one pound and fifty pence")
+     */
+    and?: boolean;
+};
+/**
+ * @typedef {object} CurrencyOptions
+ * @property {boolean} [and] - Use "and" between pounds and pence (e.g., "one pound and fifty pence")
+ */
+/** @type {Required<CurrencyOptions>} */
+export declare const currencyDefaults: Required<CurrencyOptions>;
 /**
  * Converts a numeric value to British English currency words.
  * @param {number | string | bigint} value - The currency amount to convert
@@ -59,4 +70,5 @@ export function toOrdinal(value: number | string | bigint): string;
  * toCurrency(0.01)                     // 'one penny'
  * toCurrency(42.50, { and: false })    // 'forty-two pounds fifty pence'
  */
-export function toCurrency(value: number | string | bigint, options?: CurrencyOptions): string;
+declare function toCurrency(value: number | string | bigint, options?: CurrencyOptions): string;
+export { toCardinal, toOrdinal, toCurrency };

package/src/en-GH.d.ts

@@ -1,18 +1,24 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
 /**
- * @typedef {object} CurrencyOptions
- * @property {boolean} [and] - Use "and" between cedis and pesewas
+ * Ghanaian English language converter
+ *
+ * CLDR: en-GH | English as used in Ghana
+ *
+ * Exports:
+ * - toCardinal(value)            - Cardinal numbers: 42 → "forty-two"
+ * - toOrdinal(value)             - Ordinal numbers: 42 → "forty-second"
+ * - toCurrency(value, options?)  - Currency: 42.50 → "forty-two cedis and fifty pesewas"
+ *
+ * Ghanaian English conventions:
+ * - Follows British English style
+ * - "and" after hundreds: "one hundred and twenty-three"
+ * - "and" before final segment: "one million and one"
+ * - Hyphenated tens-ones: "twenty-one", "forty-two"
+ * - Western numbering system (short scale: billion = 10^9)
+ * - Currency: Ghanaian Cedi (GHS) - cedi/cedis, pesewa/pesewas
  */
-/** @type {Required<CurrencyOptions>} */
-export const currencyDefaults: Required<CurrencyOptions>;
-export type CurrencyOptions = {
-    /**
-     * - Use "and" between cedis and pesewas
-     */
-    and?: boolean | undefined;
-};
+export declare const cardinalMax: bigint;
+export declare const ordinalMax: bigint;
+export declare const currencyMax: bigint;
 /**
  * Converts a numeric value to Ghanaian English words.
  * @param {number | string | bigint} value - The numeric value to convert
@@ -20,7 +26,7 @@ export type CurrencyOptions = {
  * @throws {TypeError} If value is not a valid numeric type
  * @throws {Error} If value is not a valid number format
  */
-export function toCardinal(value: number | string | bigint): string;
+declare function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Ghanaian English ordinal words.
  * @param {number | string | bigint} value - The numeric value to convert (must be a positive integer)
@@ -28,7 +34,19 @@ export function toCardinal(value: number | string | bigint): string;
  * @throws {TypeError} If value is not a valid numeric type
  * @throws {RangeError} If value is negative, zero, or has a decimal part
  */
-export function toOrdinal(value: number | string | bigint): string;
+declare function toOrdinal(value: number | string | bigint): string;
+export type CurrencyOptions = {
+    /**
+     * - Use "and" between cedis and pesewas
+     */
+    and?: boolean;
+};
+/**
+ * @typedef {object} CurrencyOptions
+ * @property {boolean} [and] - Use "and" between cedis and pesewas
+ */
+/** @type {Required<CurrencyOptions>} */
+export declare const currencyDefaults: Required<CurrencyOptions>;
 /**
  * Converts a numeric value to Ghanaian English currency words.
  * @param {number | string | bigint} value - The currency amount to convert
@@ -37,4 +55,5 @@ export function toOrdinal(value: number | string | bigint): string;
  * @throws {TypeError} If value is not a valid numeric type
  * @throws {Error} If value is not a valid number format
  */
-export function toCurrency(value: number | string | bigint, options?: CurrencyOptions): string;
+declare function toCurrency(value: number | string | bigint, options?: CurrencyOptions): string;
+export { toCardinal, toOrdinal, toCurrency };

package/src/en-IE.d.ts

@@ -1,18 +1,27 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
 /**
- * @typedef {object} CurrencyOptions
- * @property {boolean} [and] - Use "and" between euro and cent (e.g., "one euro and fifty cents")
+ * Irish English language converter
+ *
+ * CLDR: en-IE | English as used in Ireland
+ *
+ * Exports:
+ * - toCardinal(value)            - Cardinal numbers: 42 → "forty-two"
+ * - toOrdinal(value)             - Ordinal numbers: 42 → "forty-second"
+ * - toCurrency(value, options?)  - Currency: 42.50 → "forty-two euro and fifty cent"
+ *
+ * Irish English conventions:
+ * - Follows British English style
+ * - "and" after hundreds: "one hundred and twenty-three"
+ * - "and" before final segment: "one million and one"
+ * - Hyphenated tens-ones: "twenty-one", "forty-two"
+ * - Western numbering system (short scale: billion = 10^9)
+ * - Currency: Euro (EUR) - euro (singular/plural), cent/cents
+ *
+ * Note: In Irish English, "euro" is typically invariable (same for singular and plural),
+ * though "euros" is also accepted. This implementation uses "euro" for both.
  */
-/** @type {Required<CurrencyOptions>} */
-export const currencyDefaults: Required<CurrencyOptions>;
-export type CurrencyOptions = {
-    /**
-     * - Use "and" between euro and cent (e.g., "one euro and fifty cents")
-     */
-    and?: boolean | undefined;
-};
+export declare const cardinalMax: bigint;
+export declare const ordinalMax: bigint;
+export declare const currencyMax: bigint;
 /**
  * Converts a numeric value to Irish English words.
  *
@@ -27,7 +36,7 @@ export type CurrencyOptions = {
  * toCardinal(-3.14)        // 'minus three point fourteen'
  * toCardinal('1000000')    // 'one million'
  */
-export function toCardinal(value: number | string | bigint): string;
+declare function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Irish English ordinal words.
  * @param {number | string | bigint} value - The numeric value to convert (must be a positive integer)
@@ -44,7 +53,19 @@ export function toCardinal(value: number | string | bigint): string;
  * toOrdinal(101)  // 'one hundred first'
  * toOrdinal(1000) // 'one thousandth'
  */
-export function toOrdinal(value: number | string | bigint): string;
+declare function toOrdinal(value: number | string | bigint): string;
+export type CurrencyOptions = {
+    /**
+     * - Use "and" between euro and cent (e.g., "one euro and fifty cents")
+     */
+    and?: boolean;
+};
+/**
+ * @typedef {object} CurrencyOptions
+ * @property {boolean} [and] - Use "and" between euro and cent (e.g., "one euro and fifty cents")
+ */
+/** @type {Required<CurrencyOptions>} */
+export declare const currencyDefaults: Required<CurrencyOptions>;
 /**
  * Converts a numeric value to Irish English currency words.
  * @param {number | string | bigint} value - The currency amount to convert
@@ -59,4 +80,5 @@ export function toOrdinal(value: number | string | bigint): string;
  * toCurrency(0.01)                     // 'one cent'
  * toCurrency(42.50, { and: false })    // 'forty-two euro fifty cents'
  */
-export function toCurrency(value: number | string | bigint, options?: CurrencyOptions): string;
+declare function toCurrency(value: number | string | bigint, options?: CurrencyOptions): string;
+export { toCardinal, toOrdinal, toCurrency };

package/src/en-IN.d.ts

@@ -1,18 +1,17 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
 /**
- * @typedef {object} CurrencyOptions
- * @property {boolean} [and] - Use "and" between rupees and paise
+ * English (India) language converter
+ *
+ * CLDR: en-IN | English as used in India
+ *
+ * Key features:
+ * - Indian numbering system (thousand, lakh, crore, arab, kharab)
+ * - 3-2-2 grouping pattern (last 3 digits, then groups of 2)
+ * - British-style "and" after hundreds
+ * - Indian Rupee currency (INR)
  */
-/** @type {Required<CurrencyOptions>} */
-export const currencyDefaults: Required<CurrencyOptions>;
-export type CurrencyOptions = {
-    /**
-     * - Use "and" between rupees and paise
-     */
-    and?: boolean | undefined;
-};
+export declare const cardinalMax: bigint;
+export declare const ordinalMax: bigint;
+export declare const currencyMax: bigint;
 /**
  * Converts a numeric value to English words using Indian numbering.
  * @param {number | string | bigint} value - The numeric value to convert
@@ -25,7 +24,7 @@ export type CurrencyOptions = {
  * toCardinal(10000000)     // 'one crore'
  * toCardinal(1234567)      // 'twelve lakh thirty-four thousand five hundred and sixty-seven'
  */
-export function toCardinal(value: number | string | bigint): string;
+declare function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to English ordinal words using Indian numbering.
  * @param {number | string | bigint} value - The numeric value to convert (must be a positive integer)
@@ -37,7 +36,19 @@ export function toCardinal(value: number | string | bigint): string;
  * toOrdinal(100000)  // 'one lakhth'
  * toOrdinal(100001)  // 'one lakh first'
  */
-export function toOrdinal(value: number | string | bigint): string;
+declare function toOrdinal(value: number | string | bigint): string;
+export type CurrencyOptions = {
+    /**
+     * - Use "and" between rupees and paise
+     */
+    and?: boolean;
+};
+/**
+ * @typedef {object} CurrencyOptions
+ * @property {boolean} [and] - Use "and" between rupees and paise
+ */
+/** @type {Required<CurrencyOptions>} */
+export declare const currencyDefaults: Required<CurrencyOptions>;
 /**
  * Converts a numeric value to Indian English currency words.
  * @param {number | string | bigint} value - The currency amount to convert
@@ -52,4 +63,5 @@ export function toOrdinal(value: number | string | bigint): string;
  * toCurrency(0.50)                     // 'fifty paise'
  * toCurrency(42.50, { and: false })    // 'forty-two rupees fifty paise'
  */
-export function toCurrency(value: number | string | bigint, options?: CurrencyOptions): string;
+declare function toCurrency(value: number | string | bigint, options?: CurrencyOptions): string;
+export { toCardinal, toOrdinal, toCurrency };

package/src/en-KE.d.ts

@@ -1,18 +1,24 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
 /**
- * @typedef {object} CurrencyOptions
- * @property {boolean} [and] - Use "and" between shillings and cents
+ * Kenyan English language converter
+ *
+ * CLDR: en-KE | English as used in Kenya
+ *
+ * Exports:
+ * - toCardinal(value)            - Cardinal numbers: 42 → "forty-two"
+ * - toOrdinal(value)             - Ordinal numbers: 42 → "forty-second"
+ * - toCurrency(value, options?)  - Currency: 42.50 → "forty-two shillings and fifty cents"
+ *
+ * Kenyan English conventions:
+ * - Follows British English style
+ * - "and" after hundreds: "one hundred and twenty-three"
+ * - "and" before final segment: "one million and one"
+ * - Hyphenated tens-ones: "twenty-one", "forty-two"
+ * - Western numbering system (short scale: billion = 10^9)
+ * - Currency: Kenyan Shilling (KES) - shilling/shillings, cent/cents
  */
-/** @type {Required<CurrencyOptions>} */
-export const currencyDefaults: Required<CurrencyOptions>;
-export type CurrencyOptions = {
-    /**
-     * - Use "and" between shillings and cents
-     */
-    and?: boolean | undefined;
-};
+export declare const cardinalMax: bigint;
+export declare const ordinalMax: bigint;
+export declare const currencyMax: bigint;
 /**
  * Converts a numeric value to Kenyan English words.
  * @param {number | string | bigint} value - The numeric value to convert
@@ -20,17 +26,30 @@ export type CurrencyOptions = {
  * @throws {TypeError} If value is not a valid numeric type
  * @throws {Error} If value is not a valid number format
  */
-export function toCardinal(value: number | string | bigint): string;
+declare function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Kenyan English ordinal words.
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The ordinal in English words
  */
-export function toOrdinal(value: number | string | bigint): string;
+declare function toOrdinal(value: number | string | bigint): string;
+export type CurrencyOptions = {
+    /**
+     * - Use "and" between shillings and cents
+     */
+    and?: boolean;
+};
+/**
+ * @typedef {object} CurrencyOptions
+ * @property {boolean} [and] - Use "and" between shillings and cents
+ */
+/** @type {Required<CurrencyOptions>} */
+export declare const currencyDefaults: Required<CurrencyOptions>;
 /**
  * Converts a numeric value to Kenyan English currency words.
  * @param {number | string | bigint} value - The numeric value to convert
  * @param {CurrencyOptions} [options] - Optional configuration
  * @returns {string} The currency in English words
  */
-export function toCurrency(value: number | string | bigint, options?: CurrencyOptions): string;
+declare function toCurrency(value: number | string | bigint, options?: CurrencyOptions): string;
+export { toCardinal, toOrdinal, toCurrency };

package/src/en-MY.d.ts

@@ -1,18 +1,27 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
 /**
- * @typedef {object} CurrencyOptions
- * @property {boolean} [and] - Use "and" between ringgit and sen
+ * Malaysian English language converter
+ *
+ * CLDR: en-MY | English as used in Malaysia
+ *
+ * Exports:
+ * - toCardinal(value)            - Cardinal numbers: 42 → "forty-two"
+ * - toOrdinal(value)             - Ordinal numbers: 42 → "forty-second"
+ * - toCurrency(value, options?)  - Currency: 42.50 → "forty-two ringgit and fifty sen"
+ *
+ * Malaysian English conventions:
+ * - Follows British English style
+ * - "and" after hundreds: "one hundred and twenty-three"
+ * - "and" before final segment: "one million and one"
+ * - Hyphenated tens-ones: "twenty-one", "forty-two"
+ * - Western numbering system (short scale: billion = 10^9)
+ * - Currency: Malaysian Ringgit (MYR) - ringgit (invariable), sen (invariable)
+ *
+ * Note: Both "ringgit" and "sen" are typically invariable (same for singular and plural)
+ * in Malaysian English.
  */
-/** @type {Required<CurrencyOptions>} */
-export const currencyDefaults: Required<CurrencyOptions>;
-export type CurrencyOptions = {
-    /**
-     * - Use "and" between ringgit and sen
-     */
-    and?: boolean | undefined;
-};
+export declare const cardinalMax: bigint;
+export declare const ordinalMax: bigint;
+export declare const currencyMax: bigint;
 /**
  * Converts a numeric value to Malaysian English words.
  * @param {number | string | bigint} value - The numeric value to convert
@@ -20,15 +29,28 @@ export type CurrencyOptions = {
  * @throws {TypeError} If value is not a valid numeric type
  * @throws {Error} If value is not a valid number format
  */
-export function toCardinal(value: number | string | bigint): string;
+declare function toCardinal(value: number | string | bigint): string;
 /**
  * @param {number | string | bigint} value The numeric value to convert.
  * @returns {string} The number as an ordinal in English words.
  */
-export function toOrdinal(value: number | string | bigint): string;
+declare function toOrdinal(value: number | string | bigint): string;
+export type CurrencyOptions = {
+    /**
+     * - Use "and" between ringgit and sen
+     */
+    and?: boolean;
+};
+/**
+ * @typedef {object} CurrencyOptions
+ * @property {boolean} [and] - Use "and" between ringgit and sen
+ */
+/** @type {Required<CurrencyOptions>} */
+export declare const currencyDefaults: Required<CurrencyOptions>;
 /**
  * @param {number | string | bigint} value The numeric value to convert.
  * @param {CurrencyOptions} [options] - Optional configuration
  * @returns {string} The amount in Malaysian ringgit and sen in English words.
  */
-export function toCurrency(value: number | string | bigint, options?: CurrencyOptions): string;
+declare function toCurrency(value: number | string | bigint, options?: CurrencyOptions): string;
+export { toCardinal, toOrdinal, toCurrency };

package/src/en-NG.d.ts

@@ -1,18 +1,27 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
 /**
- * @typedef {object} CurrencyOptions
- * @property {boolean} [and] - Use "and" between naira and kobo (e.g., "one naira and fifty kobo")
+ * Nigerian English language converter
+ *
+ * CLDR: en-NG | English as used in Nigeria
+ *
+ * Exports:
+ * - toCardinal(value)            - Cardinal numbers: 42 → "forty-two"
+ * - toOrdinal(value)             - Ordinal numbers: 42 → "forty-second"
+ * - toCurrency(value, options?)  - Currency: 42.50 → "forty-two naira and fifty kobo"
+ *
+ * Nigerian English conventions:
+ * - Follows British English style
+ * - "and" after hundreds: "one hundred and twenty-three"
+ * - "and" before final segment: "one million and one"
+ * - Hyphenated tens-ones: "twenty-one", "forty-two"
+ * - Western numbering system (short scale: billion = 10^9)
+ * - Currency: Nigerian Naira (NGN) - naira (singular/plural), kobo (singular/plural)
+ *
+ * Note: In Nigerian English, both "naira" and "kobo" are typically invariable
+ * (same for singular and plural).
  */
-/** @type {Required<CurrencyOptions>} */
-export const currencyDefaults: Required<CurrencyOptions>;
-export type CurrencyOptions = {
-    /**
-     * - Use "and" between naira and kobo (e.g., "one naira and fifty kobo")
-     */
-    and?: boolean | undefined;
-};
+export declare const cardinalMax: bigint;
+export declare const ordinalMax: bigint;
+export declare const currencyMax: bigint;
 /**
  * Converts a numeric value to Nigerian English words.
  *
@@ -27,7 +36,7 @@ export type CurrencyOptions = {
  * toCardinal(-3.14)        // 'minus three point fourteen'
  * toCardinal('1000000')    // 'one million'
  */
-export function toCardinal(value: number | string | bigint): string;
+declare function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Nigerian English ordinal words.
  * @param {number | string | bigint} value - The numeric value to convert (must be a positive integer)
@@ -44,7 +53,19 @@ export function toCardinal(value: number | string | bigint): string;
  * toOrdinal(101)  // 'one hundred first'
  * toOrdinal(1000) // 'one thousandth'
  */
-export function toOrdinal(value: number | string | bigint): string;
+declare function toOrdinal(value: number | string | bigint): string;
+export type CurrencyOptions = {
+    /**
+     * - Use "and" between naira and kobo (e.g., "one naira and fifty kobo")
+     */
+    and?: boolean;
+};
+/**
+ * @typedef {object} CurrencyOptions
+ * @property {boolean} [and] - Use "and" between naira and kobo (e.g., "one naira and fifty kobo")
+ */
+/** @type {Required<CurrencyOptions>} */
+export declare const currencyDefaults: Required<CurrencyOptions>;
 /**
  * Converts a numeric value to Nigerian English currency words.
  * @param {number | string | bigint} value - The currency amount to convert
@@ -59,4 +80,5 @@ export function toOrdinal(value: number | string | bigint): string;
  * toCurrency(0.01)                     // 'one kobo'
  * toCurrency(42.50, { and: false })    // 'forty-two naira fifty kobo'
  */
-export function toCurrency(value: number | string | bigint, options?: CurrencyOptions): string;
+declare function toCurrency(value: number | string | bigint, options?: CurrencyOptions): string;
+export { toCardinal, toOrdinal, toCurrency };