n2words 5.1.1 → 5.1.2

package/src/ar-SA.d.ts

@@ -1,42 +1,39 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
 /**
- * @typedef {object} CardinalOptions
- * @property {('masculine'|'feminine')} [gender] - Grammatical gender
- * @property {string} [negativeWord] - Custom word for negative numbers
- */
-/** @type {Required<CardinalOptions>} */
-export const cardinalDefaults: Required<CardinalOptions>;
-/** @type {{ gender: ReadonlyArray<Required<CardinalOptions>['gender']> }} */
-export const cardinalValues: {
-    gender: ReadonlyArray<Required<CardinalOptions>["gender"]>;
-};
-/**
- * @typedef {object} OrdinalOptions
- * @property {('masculine'|'feminine')} [gender] - Grammatical gender
+ * Arabic (Saudi Arabia) language converter
+ *
+ * CLDR: ar-SA | Modern Standard Arabic as used in Saudi Arabia
+ *
+ * Self-contained converter with gender agreement and complex pluralization.
+ *
+ * Key features:
+ * - Gender agreement (masculine/feminine forms)
+ * - Complex pluralization (singular/dual/plural)
+ * - Traditional Arabic number naming conventions
+ * - "و" (and) conjunction between segments
  */
-/** @type {Required<OrdinalOptions>} */
-export const ordinalDefaults: Required<OrdinalOptions>;
-/** @type {{ gender: ReadonlyArray<Required<OrdinalOptions>['gender']> }} */
-export const ordinalValues: {
-    gender: ReadonlyArray<Required<OrdinalOptions>["gender"]>;
-};
+export declare const cardinalMax: bigint;
+export declare const ordinalMax: bigint;
+export declare const currencyMax: bigint;
 export type CardinalOptions = {
     /**
      * - Grammatical gender
      */
-    gender?: "feminine" | "masculine" | undefined;
+    gender?: ('masculine' | 'feminine');
     /**
      * - Custom word for negative numbers
      */
-    negativeWord?: string | undefined;
+    negativeWord?: string;
 };
-export type OrdinalOptions = {
-    /**
-     * - Grammatical gender
-     */
-    gender?: "feminine" | "masculine" | undefined;
+/**
+ * @typedef {object} CardinalOptions
+ * @property {('masculine'|'feminine')} [gender] - Grammatical gender
+ * @property {string} [negativeWord] - Custom word for negative numbers
+ */
+/** @type {Required<CardinalOptions>} */
+export declare const cardinalDefaults: Required<CardinalOptions>;
+/** @type {{ gender: ReadonlyArray<Required<CardinalOptions>['gender']> }} */
+export declare const cardinalValues: {
+    gender: ReadonlyArray<Required<CardinalOptions>['gender']>;
 };
 /**
  * Converts a numeric value to Arabic words.
@@ -47,7 +44,23 @@ export type OrdinalOptions = {
  * toCardinal(1)                        // 'واحد'
  * toCardinal(1, {gender: 'feminine'})  // 'واحدة'
  */
-export function toCardinal(value: number | string | bigint, options?: CardinalOptions): string;
+declare function toCardinal(value: number | string | bigint, options?: CardinalOptions): string;
+export type OrdinalOptions = {
+    /**
+     * - Grammatical gender
+     */
+    gender?: ('masculine' | 'feminine');
+};
+/**
+ * @typedef {object} OrdinalOptions
+ * @property {('masculine'|'feminine')} [gender] - Grammatical gender
+ */
+/** @type {Required<OrdinalOptions>} */
+export declare const ordinalDefaults: Required<OrdinalOptions>;
+/** @type {{ gender: ReadonlyArray<Required<OrdinalOptions>['gender']> }} */
+export declare const ordinalValues: {
+    gender: ReadonlyArray<Required<OrdinalOptions>['gender']>;
+};
 /**
  * Converts a numeric value to Arabic ordinal words.
  * @param {number | string | bigint} value - The numeric value to convert (positive integer)
@@ -60,7 +73,7 @@ export function toCardinal(value: number | string | bigint, options?: CardinalOp
  * toOrdinal(1, {gender: 'feminine'})  // 'الأولى'
  * toOrdinal(3)                        // 'الثالث'
  */
-export function toOrdinal(value: number | string | bigint, options?: OrdinalOptions): string;
+declare function toOrdinal(value: number | string | bigint, options?: OrdinalOptions): string;
 /**
  * Converts a numeric value to Arabic currency words (Saudi Riyal).
  * @param {number | string | bigint} value - The currency amount to convert
@@ -72,4 +85,5 @@ export function toOrdinal(value: number | string | bigint, options?: OrdinalOpti
  * toCurrency(1)      // 'ريال واحد'
  * toCurrency(0.01)   // 'هللة واحدة'
  */
-export function toCurrency(value: number | string | bigint): string;
+declare function toCurrency(value: number | string | bigint): string;
+export { toCardinal, toOrdinal, toCurrency };

package/src/az-AZ.d.ts

@@ -1,12 +1,22 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
+/**
+ * Azerbaijani (Azerbaijan) language converter
+ *
+ * CLDR: az-AZ | Azerbaijani as used in Azerbaijan
+ *
+ * Key features:
+ * - Turkic language patterns
+ * - Implicit "bir" (one) omission before hundreds and thousands
+ * - Short scale naming
+ */
+export declare const cardinalMax: bigint;
+export declare const ordinalMax: bigint;
+export declare const currencyMax: bigint;
 /**
  * Converts a numeric value to Azerbaijani words.
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The number in Azerbaijani words
  */
-export function toCardinal(value: number | string | bigint): string;
+declare function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Azerbaijani ordinal words.
  * @param {number | string | bigint} value - The numeric value to convert (positive integer)
@@ -18,7 +28,7 @@ export function toCardinal(value: number | string | bigint): string;
  * toOrdinal(2)    // 'ikinci'
  * toOrdinal(21)   // 'iyirmibirinci'
  */
-export function toOrdinal(value: number | string | bigint): string;
+declare function toOrdinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Azerbaijani currency words (Manat).
  *
@@ -32,4 +42,5 @@ export function toOrdinal(value: number | string | bigint): string;
  * toCurrency(1.50)   // 'bir manat əlli qəpik'
  * toCurrency(-5)     // 'mənfi beş manat'
  */
-export function toCurrency(value: number | string | bigint): string;
+declare function toCurrency(value: number | string | bigint): string;
+export { toCardinal, toOrdinal, toCurrency };

package/src/bn-BD.d.ts

@@ -1,12 +1,23 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
+/**
+ * Bangla (Bangladesh) language converter
+ *
+ * CLDR: bn-BD | Bengali as used in Bangladesh
+ *
+ * Key features:
+ * - Indian numbering system (হাজার, লাখ, কোটি)
+ * - Bangla script (Bengali)
+ * - 3-2-2 grouping pattern (last 3 digits, then groups of 2)
+ * - Complete word forms for 0-99
+ */
+export declare const cardinalMax: bigint;
+export declare const ordinalMax: bigint;
+export declare const currencyMax: bigint;
 /**
  * Converts a numeric value to Bengali words.
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The number in Bengali words
  */
-export function toCardinal(value: number | string | bigint): string;
+declare function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Bengali ordinal words.
  * @param {number | string | bigint} value - The numeric value to convert (positive integer)
@@ -19,7 +30,7 @@ export function toCardinal(value: number | string | bigint): string;
  * toOrdinal(3)    // 'তৃতীয়'
  * toOrdinal(10)   // 'দশতম'
  */
-export function toOrdinal(value: number | string | bigint): string;
+declare function toOrdinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Bengali currency words (Bangladeshi Taka).
  * @param {number | string | bigint} value - The currency amount to convert
@@ -31,4 +42,5 @@ export function toOrdinal(value: number | string | bigint): string;
  * toCurrency(1)      // 'এক টাকা'
  * toCurrency(0.01)   // 'এক পয়সা'
  */
-export function toCurrency(value: number | string | bigint): string;
+declare function toCurrency(value: number | string | bigint): string;
+export { toCardinal, toOrdinal, toCurrency };

package/src/cs-CZ.d.ts

@@ -1,6 +1,18 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
+/**
+ * Czech (Czechia) language converter
+ *
+ * CLDR: cs-CZ | Czech as used in Czechia
+ *
+ * Czech-specific rules:
+ * - Three-form pluralization: 1 = singular, 2-4 = few, 5+ = many
+ * - Irregular hundreds: sto, dvě stě, tři sta, čtyři sta, pět set...
+ * - Gender: dva (masc) vs dvě (fem) for 2
+ * - Omit "one" before scale words: "tisíc" not "jedna tisíc"
+ * - Dynamic decimal separator: celá/celé/celých based on integer
+ */
+export declare const cardinalMax: bigint;
+export declare const ordinalMax: bigint;
+export declare const currencyMax: bigint;
 /**
  * Converts a numeric value to Czech words.
  *
@@ -16,7 +28,7 @@ export const currencyMax: bigint;
  * toCardinal(2000)         // 'dva tisíce'
  * toCardinal(5000)         // 'pět tisíc'
  */
-export function toCardinal(value: number | string | bigint): string;
+declare function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Czech ordinal words (masculine nominative).
  * @param {number | string | bigint} value - The numeric value to convert (must be a positive integer)
@@ -30,7 +42,7 @@ export function toCardinal(value: number | string | bigint): string;
  * toOrdinal(100)  // 'stý'
  * toOrdinal(1000) // 'tisící'
  */
-export function toOrdinal(value: number | string | bigint): string;
+declare function toOrdinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Czech currency words (Koruna).
  * @param {number | string | bigint} value - The currency amount to convert
@@ -43,4 +55,5 @@ export function toOrdinal(value: number | string | bigint): string;
  * toCurrency(1.50)   // 'jedna koruna padesát haléřů'
  * toCurrency(-5)     // 'mínus pět korun'
  */
-export function toCurrency(value: number | string | bigint): string;
+declare function toCurrency(value: number | string | bigint): string;
+export { toCardinal, toOrdinal, toCurrency };

package/src/da-DK.d.ts

@@ -1,6 +1,18 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
+/**
+ * Danish (Denmark) language converter
+ *
+ * CLDR: da-DK | Danish as used in Denmark
+ *
+ * Key features:
+ * - Vigesimal (base-20) tens naming: halvtreds (50), treds (60), etc.
+ * - Units-before-tens: "enogtyve" (21) = one-and-twenty
+ * - Compound thousands: "ettusind", "firetusinde"
+ * - "og" conjunction after hundreds and thousands
+ * - Long scale for millions+
+ */
+export declare const cardinalMax: bigint;
+export declare const ordinalMax: bigint;
+export declare const currencyMax: bigint;
 /**
  * Converts a numeric value to Danish words.
  * @param {number | string | bigint} value - The numeric value to convert
@@ -12,7 +24,7 @@ export const currencyMax: bigint;
  * toCardinal(1000)     // 'ettusind'
  * toCardinal(1000000)  // 'en millioner'
  */
-export function toCardinal(value: number | string | bigint): string;
+declare function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Danish ordinal words.
  * @param {number | string | bigint} value - The numeric value to convert (positive integer)
@@ -24,7 +36,7 @@ export function toCardinal(value: number | string | bigint): string;
  * toOrdinal(2)    // 'anden'
  * toOrdinal(21)   // 'enogtyvede'
  */
-export function toOrdinal(value: number | string | bigint): string;
+declare function toOrdinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Danish currency words (Danish Krone).
  *
@@ -38,4 +50,5 @@ export function toOrdinal(value: number | string | bigint): string;
  * toCurrency(42)     // 'toogfyrre kroner'
  * toCurrency(1.50)   // 'en krone og halvtreds øre'
  */
-export function toCurrency(value: number | string | bigint): string;
+declare function toCurrency(value: number | string | bigint): string;
+export { toCardinal, toOrdinal, toCurrency };

package/src/de-DE.d.ts

@@ -1,18 +1,19 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
 /**
- * @typedef {object} CurrencyOptions
- * @property {boolean} [and] - Use "und" between euros and cents
+ * German (Germany) language converter
+ *
+ * CLDR: de-DE | German as used in Germany
+ *
+ * Key features:
+ * - Inverted tens-ones order: "einundzwanzig" (one-and-twenty) for 21-99
+ * - Compound words without spaces below million level
+ * - Three forms of 1: "eins" (standalone), "ein" (before hundert/tausend), "eine" (before Million+)
+ * - Scale pluralization: Million → Millionen, Milliarde → Milliarden
+ * - Spaces only around million+ scale words
+ * - BigInt modulo for efficient segment extraction
  */
-/** @type {Required<CurrencyOptions>} */
-export const currencyDefaults: Required<CurrencyOptions>;
-export type CurrencyOptions = {
-    /**
-     * - Use "und" between euros 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 German words.
  *
@@ -27,7 +28,7 @@ export type CurrencyOptions = {
  * toCardinal(1000)         // 'eintausend'
  * toCardinal(1000000)      // 'eine Million'
  */
-export function toCardinal(value: number | string | bigint): string;
+declare function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to German ordinal words.
  *
@@ -45,7 +46,19 @@ export function toCardinal(value: number | string | bigint): string;
  * toOrdinal(100)  // 'einhundertste'
  * toOrdinal(1000) // 'eintausendste'
  */
-export function toOrdinal(value: number | string | bigint): string;
+declare function toOrdinal(value: number | string | bigint): string;
+export type CurrencyOptions = {
+    /**
+     * - Use "und" between euros and cents
+     */
+    and?: boolean;
+};
+/**
+ * @typedef {object} CurrencyOptions
+ * @property {boolean} [and] - Use "und" between euros and cents
+ */
+/** @type {Required<CurrencyOptions>} */
+export declare const currencyDefaults: Required<CurrencyOptions>;
 /**
  * Converts a numeric value to German currency words (Euro).
  * @param {number | string | bigint} value - The currency amount to convert
@@ -60,4 +73,5 @@ export function toOrdinal(value: number | string | bigint): string;
  * toCurrency(0.01)                  // 'ein Cent'
  * toCurrency(42.50, { and: false }) // 'zweiundvierzig Euro fünfzig Cent'
  */
-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/el-GR.d.ts

@@ -1,6 +1,17 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
+/**
+ * Greek (Greece) language converter
+ *
+ * CLDR: el-GR | Greek as used in Greece
+ *
+ * Key features:
+ * - Space-separated number composition
+ * - Implicit "one" (ένα) omission before scale words
+ * - Irregular hundreds (διακόσια, τριακόσια, etc.)
+ * - Per-digit decimal reading
+ */
+export declare const cardinalMax: bigint;
+export declare const ordinalMax: bigint;
+export declare const currencyMax: bigint;
 /**
  * Converts a numeric value to Greek words.
  * @param {number | string | bigint} value - The numeric value to convert
@@ -12,7 +23,7 @@ export const currencyMax: bigint;
  * toCardinal(1000)     // 'χίλια'
  * toCardinal('3.14')   // 'τρία κόμμα ένα τέσσερα'
  */
-export function toCardinal(value: number | string | bigint): string;
+declare function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Greek ordinal words.
  * @param {number | string | bigint} value - The numeric value to convert
@@ -23,7 +34,7 @@ export function toCardinal(value: number | string | bigint): string;
  * toOrdinal(1)   // 'πρώτος'
  * toOrdinal(21)  // 'εικοστός πρώτος'
  */
-export function toOrdinal(value: number | string | bigint): string;
+declare function toOrdinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Greek Euro currency words.
  * @param {number | string | bigint} value - The numeric value to convert
@@ -34,4 +45,5 @@ export function toOrdinal(value: number | string | bigint): string;
  * toCurrency(1)     // 'ένα ευρώ'
  * toCurrency(2.50)  // 'δύο ευρώ πενήντα λεπτά'
  */
-export function toCurrency(value: number | string | bigint): string;
+declare function toCurrency(value: number | string | bigint): string;
+export { toCardinal, toOrdinal, toCurrency };

package/src/en-AU.d.ts

@@ -1,18 +1,16 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
 /**
- * @typedef {object} CurrencyOptions
- * @property {boolean} [and] - Use "and" between dollars and cents
+ * English (Australia) language converter
+ *
+ * CLDR: en-AU | English as used in Australia
+ *
+ * Key features:
+ * - Western numbering system (short scale: billion = 10^9)
+ * - British-style "and" after hundreds
+ * - Australian Dollar currency (AUD)
  */
-/** @type {Required<CurrencyOptions>} */
-export const currencyDefaults: Required<CurrencyOptions>;
-export type CurrencyOptions = {
-    /**
-     * - Use "and" between dollars 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 Australian English words.
  * @param {number | string | bigint} value - The numeric value to convert
@@ -24,7 +22,7 @@ export type CurrencyOptions = {
  * toCardinal(101)          // 'one hundred and one'
  * 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 Australian English ordinal words.
  * @param {number | string | bigint} value - The numeric value to convert (must be a positive integer)
@@ -36,7 +34,19 @@ export function toCardinal(value: number | string | bigint): string;
  * toOrdinal(42)   // 'forty-second'
  * toOrdinal(100)  // 'one hundredth'
  */
-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
+     */
+    and?: boolean;
+};
+/**
+ * @typedef {object} CurrencyOptions
+ * @property {boolean} [and] - Use "and" between dollars and cents
+ */
+/** @type {Required<CurrencyOptions>} */
+export declare const currencyDefaults: Required<CurrencyOptions>;
 /**
  * Converts a numeric value to Australian English currency words.
  * @param {number | string | bigint} value - The currency amount to convert
@@ -50,4 +60,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-BD.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 taka and paise
+ * English (Bangladesh) language converter
+ *
+ * CLDR: en-BD | English as used in Bangladesh
+ *
+ * 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
+ * - Bangladeshi Taka currency (BDT)
  */
-/** @type {Required<CurrencyOptions>} */
-export const currencyDefaults: Required<CurrencyOptions>;
-export type CurrencyOptions = {
-    /**
-     * - Use "and" between taka 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 taka and paise
+     */
+    and?: boolean;
+};
+/**
+ * @typedef {object} CurrencyOptions
+ * @property {boolean} [and] - Use "and" between taka and paise
+ */
+/** @type {Required<CurrencyOptions>} */
+export declare const currencyDefaults: Required<CurrencyOptions>;
 /**
  * Converts a numeric value to Bangladeshi 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 taka 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-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 };