n2words 1.24.0 → 2.0.0

package/lib/classes/turkic-language.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Base class for Turkic languages with shared grammar patterns.
+ *
+ * This class provides a reusable implementation for Turkic languages that share:
+ * - Space-separated number combinations
+ * - Implicit 'bir' (one) before hundreds and thousands
+ * - Simple multiplication/addition logic
+ * - Consistent magnitude handling
+ * - Inherits decimal handling from AbstractLanguage via GreedyScaleLanguage
+ *   (supports both grouped and per-digit modes via the `usePerDigitDecimals` class property).
+ *
+ * Used by: Turkish (TR), Azerbaijani (AZ)
+ *
+ * Subclasses MUST define (from GreedyScaleLanguage requirements):
+ * - `scaleWords` array of [value, word] tuples as a class property (ordered descending by value).
+ * Optionally, language-specific class properties (e.g., `negativeWord`, `zeroWord`, `decimalSeparatorWord`, `wordSeparator`).
+ *
+ * TurkicLanguage provides a default `combineWordSets()` implementation; subclasses may override
+ * if specialized combine logic is needed (unlikely for Turkic languages).
+ *
+ * @abstract
+ * @extends GreedyScaleLanguage
+ */
+export class TurkicLanguage extends GreedyScaleLanguage {
+}
+import { GreedyScaleLanguage } from './greedy-scale-language.js';

package/lib/classes/turkic-language.js

@@ -1,10 +1,4 @@
-import GreedyScaleLanguage from './greedy-scale-language.js'
-
-/**
- * @typedef {Object} TurkicWordPair
- * @property {string} word - The Turkic word or phrase
- * @property {bigint} value - The numeric value represented by the word
- */
+import { GreedyScaleLanguage } from './greedy-scale-language.js'
 
 /**
  * Base class for Turkic languages with shared grammar patterns.
@@ -15,49 +9,51 @@ import GreedyScaleLanguage from './greedy-scale-language.js'
  * - Simple multiplication/addition logic
  * - Consistent magnitude handling
  * - Inherits decimal handling from AbstractLanguage via GreedyScaleLanguage
- *   (supports both grouped and per-digit modes via the `convertDecimalsPerDigit` class property).
+ *   (supports both grouped and per-digit modes via the `usePerDigitDecimals` class property).
  *
  * Used by: Turkish (TR), Azerbaijani (AZ)
  *
  * Subclasses MUST define (from GreedyScaleLanguage requirements):
- * - `scaleWordPairs` array of [value, word] pairs as a class property (ordered descending by value).
+ * - `scaleWords` array of [value, word] tuples as a class property (ordered descending by value).
  * Optionally, language-specific class properties (e.g., `negativeWord`, `zeroWord`, `decimalSeparatorWord`, `wordSeparator`).
  *
- * TurkicLanguage provides a default `mergeScales()` implementation; subclasses may override
- * if specialized merge logic is needed (unlikely for Turkic languages).
+ * TurkicLanguage provides a default `combineWordSets()` implementation; subclasses may override
+ * if specialized combine logic is needed (unlikely for Turkic languages).
  *
  * @abstract
  * @extends GreedyScaleLanguage
  */
-class TurkicLanguage extends GreedyScaleLanguage {
+export class TurkicLanguage extends GreedyScaleLanguage {
+  // ============================================================================
+  // Inherited Implementation (overrides GreedyScaleLanguage)
+  // ============================================================================
+
   /**
-   * Merges two adjacent word-number pairs according to Turkic grammar rules.
+   * Combines two adjacent word-sets according to Turkic grammar rules.
    *
    * Shared Turkic patterns:
    * - Implicit 'bir' (one) before hundreds and thousands
    * - Space separator (wordSeparator property) for all combinations
-   * - Multiplies when right > left (crossing magnitude boundary)
+   * - Multiplies when following > preceding (crossing magnitude boundary)
    * - Adds otherwise (combining same-magnitude components)
    *
-   * @param {Object} leftPair The left operand as `{ word: bigint }`.
-   * @param {Object} rightPair The right operand as `{ word: bigint }`.
-   * @returns {Object} Merged pair with combined word and resulting number (bigint).
+   * @param {Object} preceding Preceding word-set as { word: bigint }.
+   * @param {Object} following Following word-set as { word: bigint }.
+   * @returns {Object} Combined word-set with merged word and resulting number.
    */
-  mergeScales (leftPair, rightPair) {
-    const [[leftWord, leftNumber]] = Object.entries(leftPair)
-    const [[rightWord, rightNumber]] = Object.entries(rightPair)
+  combineWordSets (preceding, following) {
+    const [[precedingWord, precedingValue]] = Object.entries(preceding)
+    const [[followingWord, followingValue]] = Object.entries(following)
 
     // Implicit 'bir' (one) before certain magnitudes:
     // Omit '1' before hundreds (100n) and thousands (1000n) to form natural combinations
-    if (leftNumber === 1n && (rightNumber <= 100n || rightNumber === 1000n)) {
-      return rightPair // Return just the magnitude word (e.g., "yüz", not "bir yüz")
+    if (precedingValue === 1n && (followingValue <= 100n || followingValue === 1000n)) {
+      return following // Return just the magnitude word (e.g., "yüz", not "bir yüz")
     }
 
     // Combine numbers with space separator (wordSeparator from GreedyScaleLanguage):
     // Multiply when crossing magnitude boundary, add otherwise
-    const mergedNumber = rightNumber > leftNumber ? leftNumber * rightNumber : leftNumber + rightNumber
-    return { [`${leftWord}${this.wordSeparator}${rightWord}`]: mergedNumber }
+    const resultNumber = followingValue > precedingValue ? precedingValue * followingValue : precedingValue + followingValue
+    return { [`${precedingWord}${this.wordSeparator}${followingWord}`]: resultNumber }
   }
 }
-
-export default TurkicLanguage

package/lib/languages/ar.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Arabic language converter.
+ *
+ * Supports:
+ * - Gender agreement (masculine/feminine forms)
+ * - Complex pluralization (singular/dual/plural)
+ * - Traditional Arabic number naming conventions
+ * - Right-to-left text orientation
+ */
+export class Arabic extends AbstractLanguage {
+    constructor(options?: {});
+    tensWords: string[];
+    hundredsWords: string[];
+    scaleWords: string[];
+    scaleAppendedWords: string[];
+    scalePluralWords: string[];
+    dualWords: string[];
+    dualAppendedWords: string[];
+    ones: {
+        masculine: string[];
+        feminine: string[];
+    };
+    /** Selects masculine or feminine number forms based on options. */
+    get selectedOnes(): string[];
+    /** Converts a 3-digit segment (0-999) to Arabic words with gender/plural rules. */
+    segmentToWords(groupNumber: any, groupLevel: any, fullNumber: any): string;
+    /** Converts integer part to Arabic words by processing 3-digit groups. */
+    integerToWords(integerPart: any): string;
+}
+import { AbstractLanguage } from '../classes/abstract-language.js';

package/lib/languages/ar.js

@@ -1,129 +1,63 @@
-import AbstractLanguage from '../classes/abstract-language.js'
-
-/**
- * @typedef {Object} ArabicOptions
- * @property {string} [negativeWord='ناقص'] Word for negative numbers (minus).
- * @property {boolean} [feminine=false] Use feminine forms for numbers.
- */
+import { AbstractLanguage } from '../classes/abstract-language.js'
 
 /**
  * Arabic language converter.
  *
- * Converts numbers to Arabic words with full grammatical support:
+ * Supports:
  * - Gender agreement (masculine/feminine forms)
- * - Complex pluralization rules (singular, dual, plural forms)
- * - Special handling for hundreds, thousands, millions, etc.
- * - Right-to-left text orientation
+ * - Complex pluralization (singular/dual/plural)
  * - Traditional Arabic number naming conventions
- *
- * Key Features:
- * - Gender-aware number forms (واحد masculine vs واحدة feminine)
- * - Dual forms: اثنان/اثنتان (two masculine/feminine)
- * - Complex rule system for numbers 3-10 (requiring feminine when referring to countables)
- * - Group-based algorithm: splits number by powers of 1000 (ones, thousands, millions, billions)
- * - Tanween (nunation) for indefinite numbers
- * - Sophisticated pluralization with singular, dual, and plural forms
- *
- * Algorithm:
- * 1. Break number into groups of 3 digits (right to left)
- * 2. For each non-zero group, convert to words using gender and plural rules
- * 3. Append the appropriate magnitude word (ألف/مليون/مليار) with proper plural form
- * 4. Join all groups with spaces
- *
- * Features:
- * - Support for gender-aware number forms
- * - Proper handling of Arabic dual forms (اثنان/اثنتان)
- * - Complex group processing for large numbers
  * - Right-to-left text orientation
- * - Traditional Arabic number naming conventions
  */
 export class Arabic extends AbstractLanguage {
+  negativeWord = 'ناقص'
   decimalSeparatorWord = 'فاصلة'
   zeroWord = 'صفر'
-  arabicTens = ['عشرون', 'ثلاثون', 'أربعون', 'خمسون', 'ستون', 'سبعون', 'ثمانون', 'تسعون']
-  arabicHundreds = ['', 'مائة', 'مئتان', 'ثلاثمائة', 'أربعمائة', 'خمسمائة', 'ستمائة', 'سبعمائة', 'ثمانمائة', 'تسعمائة']
-  arabicAppendedTwos = ['مئتا', 'ألفا', 'مليونا', 'مليارا', 'تريليونا', 'كوادريليونا', 'كوينتليونا', 'سكستيليونا']
-  arabicTwos = ['مئتان', 'ألفان', 'مليونان', 'ملياران', 'تريليونان', 'كوادريليونان', 'كوينتليونان', 'سكستيليونان']
-  arabicGroup = ['مائة', 'ألف', 'مليون', 'مليار', 'تريليون', 'كوادريليون', 'كوينتليون', 'سكستيليون']
-  arabicAppendedGroup = ['', 'ألفاً', 'مليوناً', 'ملياراً', 'تريليوناً', 'كوادريليوناً', 'كوينتليوناً', 'سكستيليوناً']
-  arabicPluralGroups = ['', 'آلاف', 'ملايين', 'مليارات', 'تريليونات', 'كوادريليونات', 'كوينتليونات', 'سكستيليونات']
+
+  tensWords = ['عشرون', 'ثلاثون', 'أربعون', 'خمسون', 'ستون', 'سبعون', 'ثمانون', 'تسعون']
+  hundredsWords = ['', 'مائة', 'مئتان', 'ثلاثمائة', 'أربعمائة', 'خمسمائة', 'ستمائة', 'سبعمائة', 'ثمانمائة', 'تسعمائة']
+
+  // Magnitude words with three forms: singular, appended (tanween), plural
+  scaleWords = ['مائة', 'ألف', 'مليون', 'مليار', 'تريليون', 'كوادريليون', 'كوينتليون', 'سكستيليون']
+  scaleAppendedWords = ['', 'ألفاً', 'مليوناً', 'ملياراً', 'تريليوناً', 'كوادريليوناً', 'كوينتليوناً', 'سكستيليوناً']
+  scalePluralWords = ['', 'آلاف', 'ملايين', 'مليارات', 'تريليونات', 'كوادريليونات', 'كوينتليونات', 'سكستيليونات']
+
+  // Dual forms (Arabic has singular, dual, plural)
+  dualWords = ['مئتان', 'ألفان', 'مليونان', 'ملياران', 'تريليونان', 'كوادريليونان', 'كوينتليونان', 'سكستيليونان']
+  dualAppendedWords = ['مئتا', 'ألفا', 'مليونا', 'مليارا', 'تريليونا', 'كوادريليونا', 'كوينتليونا', 'سكستيليونا']
+
+  // Gender-specific number words (1-19)
   ones = {
     masculine: [
-      'واحد',
-      'اثنان',
-      'ثلاثة',
-      'أربعة',
-      'خمسة',
-      'ستة',
-      'سبعة',
-      'ثمانية',
-      'تسعة',
-      'عشرة',
-      'أحد عشر',
-      'اثنا عشر',
-      'ثلاثة عشر',
-      'أربعة عشر',
-      'خمسة عشر',
-      'ستة عشر',
-      'سبعة عشر',
-      'ثمانية عشر',
-      'تسعة عشر'
+      'واحد', 'اثنان', 'ثلاثة', 'أربعة', 'خمسة', 'ستة', 'سبعة', 'ثمانية', 'تسعة', 'عشرة',
+      'أحد عشر', 'اثنا عشر', 'ثلاثة عشر', 'أربعة عشر', 'خمسة عشر', 'ستة عشر', 'سبعة عشر', 'ثمانية عشر', 'تسعة عشر'
     ],
     feminine: [
-      'واحدة',
-      'اثنتان',
-      'ثلاث',
-      'أربع',
-      'خمس',
-      'ست',
-      'سبع',
-      'ثمان',
-      'تسع',
-      'عشر',
-      'إحدى عشرة',
-      'اثنتا عشرة',
-      'ثلاث عشرة',
-      'أربع عشرة',
-      'خمس عشرة',
-      'ست عشرة',
-      'سبع عشرة',
-      'ثماني عشرة',
-      'تسع عشرة'
+      'واحدة', 'اثنتان', 'ثلاث', 'أربع', 'خمس', 'ست', 'سبع', 'ثمان', 'تسع', 'عشر',
+      'إحدى عشرة', 'اثنتا عشرة', 'ثلاث عشرة', 'أربع عشرة', 'خمس عشرة', 'ست عشرة', 'سبع عشرة', 'ثماني عشرة', 'تسع عشرة'
     ]
   }
 
-  /**
-   * Initializes the Arabic converter with language-specific options.
-   *
-   * @param {ArabicOptions} [options={}] Configuration options.
-   */
-  constructor ({ negativeWord = 'ناقص', feminine = false } = {}) {
+  constructor (options = {}) {
     super()
 
-    this.feminine = feminine
-    this.negativeWord = negativeWord
+    this.setOptions({
+      gender: 'masculine'
+    }, options)
 
-    this.selectedOnes = this.ones[this.feminine ? 'feminine' : 'masculine']
+    // Allow custom negativeWord via options
+    if (options.negativeWord !== undefined) {
+      this.negativeWord = options.negativeWord
+    }
   }
 
-  /**
-   * Returns the feminine status of a given digit (1-9).
-   *
-   * @param {number} digit - The digit to check (1-9).
-   * @returns {string} The word form of the digit based on feminine status.
-   */
-  digitFeminineStatus (digit) {
-    return this.selectedOnes[digit - 1]
+  /** Selects masculine or feminine number forms based on options. */
+  get selectedOnes () {
+    return this.ones[this.options.gender === 'feminine' ? 'feminine' : 'masculine']
   }
 
-  /**
-   * Processes the Arabic group number and returns the corresponding Arabic representation.
-   * @param {number} groupNumber - The number to process. (Range: 1-999)
-   * @param {number} groupLevel - Group level to process. (See example)
-   * @returns {string} The Arabic representation of the group number.
-   * @example 12345678 is processed in blocks of 3: '678' (group 0), '345' (group 1), '12' (group 2).
-   */
-  processArabicGroup (groupNumber, groupLevel, fullNumber) {
+  /** Converts a 3-digit segment (0-999) to Arabic words with gender/plural rules. */
+  segmentToWords (groupNumber, groupLevel, fullNumber) {
     const tens = groupNumber % 100
     const hundredsRaw = groupNumber / 100
     const hundreds = Math.trunc(hundredsRaw)
@@ -132,9 +66,9 @@ export class Arabic extends AbstractLanguage {
     // Process hundreds
     if (hundreds > 0) {
       if (tens === 0 && hundreds === 2) {
-        returnValue = this.arabicTwos[0]
+        returnValue = this.dualWords[0]
       } else {
-        const hundredsWord = this.arabicHundreds[hundreds]
+        const hundredsWord = this.hundredsWords[hundreds]
         if (hundredsWord) {
           returnValue = hundredsWord
           if (tens !== 0) {
@@ -152,12 +86,12 @@ export class Arabic extends AbstractLanguage {
           const numValue = Number(fullNumber)
           const pow = Math.trunc(Math.log10(numValue))
           if (pow % 3 === 0 && fullNumber === BigInt(2 * Math.pow(10, pow))) {
-            returnValue = groupNumber === 2 ? this.arabicTwos[groupLevel] : this.arabicAppendedTwos[groupLevel]
+            returnValue = groupNumber === 2 ? this.dualWords[groupLevel] : this.dualAppendedWords[groupLevel]
           } else {
-            returnValue = this.arabicTwos[groupLevel]
+            returnValue = this.dualWords[groupLevel]
           }
         } else if (tens === 1 && groupLevel > 0) {
-          returnValue += this.arabicGroup[groupLevel]
+          returnValue += this.scaleWords[groupLevel]
         } else {
           returnValue += this.selectedOnes[tens - 1]
         }
@@ -169,24 +103,19 @@ export class Arabic extends AbstractLanguage {
           returnValue += this.selectedOnes[ones - 1]
           returnValue += ' و'
         }
-        returnValue += this.arabicTens[tensIndex]
+        returnValue += this.tensWords[tensIndex]
       }
     }
 
     return returnValue
   }
 
-  /**
-   * Converts a number to its cardinal representation in Arabic.
-   * It process by blocks of 3 digits.
-   * @param {bigint} number - The number to convert.
-   * @returns {string} The cardinal representation of the number in Arabic.
-   */
-  convertWholePart (number) {
-    if (number === 0n) {
+  /** Converts integer part to Arabic words by processing 3-digit groups. */
+  integerToWords (integerPart) {
+    if (integerPart === 0n) {
       return this.zeroWord
     }
-    let temp = number
+    let temp = integerPart
     let group = 0
     let result = ''
 
@@ -196,7 +125,7 @@ export class Arabic extends AbstractLanguage {
       temp = temp / 1000n
 
       if (numberToProcess > 0) {
-        const groupDescription = this.processArabicGroup(numberToProcess, group, number)
+        const groupDescription = this.segmentToWords(numberToProcess, group, integerPart)
 
         if (groupDescription) {
           // Add group name for thousands, millions, etc.
@@ -208,11 +137,11 @@ export class Arabic extends AbstractLanguage {
             if (numberToProcess > 2) {
               const remainder = numberToProcess % 100
               if (remainder === 1) {
-                result = this.arabicGroup[group] + ' ' + result
+                result = this.scaleWords[group] + ' ' + result
               } else if (numberToProcess >= 3 && numberToProcess <= 10) {
-                result = this.arabicPluralGroups[group] + ' ' + result
+                result = this.scalePluralWords[group] + ' ' + result
               } else {
-                result = (result ? this.arabicAppendedGroup[group] : this.arabicGroup[group]) + ' ' + result
+                result = (result ? this.scaleAppendedWords[group] : this.scaleWords[group]) + ' ' + result
               }
             }
           }
@@ -228,16 +157,3 @@ export class Arabic extends AbstractLanguage {
     return result.replace(/\s+/g, ' ').trim()
   }
 }
-
-/**
- * Converts a number to Arabic cardinal (written) form.
- *
- * @param {number|string|bigint} value The number to convert.
- * @param {ArabicOptions} [options={}] Configuration options.
- * @returns {string} The number expressed in Arabic words.
- * @throws {TypeError} If value is NaN or invalid type.
- * @throws {Error} If value is an invalid number string.
- */
-export default function convertToWords (value, options = {}) {
-  return new Arabic(options).convertToWords(value)
-}

package/lib/languages/az.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Azerbaijani language converter.
+ *
+ * Supports:
+ * - Implicit "bir" (one) omission before hundreds and thousands
+ * - Turkic language number patterns
+ * - Large numbers up to quintillion
+ */
+export class Azerbaijani extends TurkicLanguage {
+    scaleWords: (string | bigint)[][];
+}
+import { TurkicLanguage } from '../classes/turkic-language.js';

package/lib/languages/az.js

@@ -1,18 +1,19 @@
-import TurkicLanguage from '../classes/turkic-language.js'
+import { TurkicLanguage } from '../classes/turkic-language.js'
 
 /**
  * Azerbaijani language converter.
  *
- * Inherits from TurkicLanguage shared patterns:
- * - Space-separated number combinations
- * - Omits '1' before hundreds and thousands
- * - Supports flexible word spacing configuration
+ * Supports:
+ * - Implicit "bir" (one) omission before hundreds and thousands
+ * - Turkic language number patterns
+ * - Large numbers up to quintillion
  */
 export class Azerbaijani extends TurkicLanguage {
   negativeWord = 'mənfi'
   decimalSeparatorWord = 'nöqtə'
   zeroWord = 'sıfır'
-  scaleWordPairs = [[1_000_000_000_000_000_000n, 'kentilyon'],
+
+  scaleWords = [[1_000_000_000_000_000_000n, 'kentilyon'],
     [1_000_000_000_000_000n, 'katrilyon'],
     [1_000_000_000_000n, 'trilyon'],
     [1_000_000_000n, 'milyar'],
@@ -39,20 +40,3 @@ export class Azerbaijani extends TurkicLanguage {
     [1n, 'bir'],
     [0n, 'sıfır']]
 }
-
-/**
- * Converts a number to Azerbaijani cardinal (written) form.
- *
- * @param {number|string|bigint} value The number to convert.
- * @param {Object} [options] Conversion options (see AZ class).
- * @returns {string} The number expressed in Azerbaijani words.
- * @throws {TypeError} If value is NaN or invalid type.
- * @throws {Error} If value is an invalid number string.
- *
- * @example
- * convertToWords(42, { lang: 'az' }); // 'qırx iki'
- * convertToWords(1000, { lang: 'az' }); // 'min'
- */
-export default function convertToWords (value, options = {}) {
-  return new Azerbaijani(options).convertToWords(value)
-}

package/lib/languages/bn.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Bangla language converter.
+ *
+ * Supports:
+ * - Indian numbering system (হাজার, লাখ, কোটি)
+ * - Bangla script (Bengali)
+ * - Complete word forms for 0-99
+ */
+export class Bangla extends SouthAsianLanguage {
+}
+import { SouthAsianLanguage } from '../classes/south-asian-language.js';

package/lib/languages/bn.js

@@ -1,11 +1,20 @@
-import SouthAsianLanguage from '../classes/south-asian-language.js'
+import { SouthAsianLanguage } from '../classes/south-asian-language.js'
 
-class Bengali extends SouthAsianLanguage {
+/**
+ * Bangla language converter.
+ *
+ * Supports:
+ * - Indian numbering system (হাজার, লাখ, কোটি)
+ * - Bangla script (Bengali)
+ * - Complete word forms for 0-99
+ */
+export class Bangla extends SouthAsianLanguage {
   negativeWord = 'মাইনাস'
   decimalSeparatorWord = 'দশমিক'
   zeroWord = 'শূন্য'
   hundredWord = 'শত'
-  belowHundred = [
+
+  belowHundredWords = [
     'শূন্য',
     'এক',
     'দুই',
@@ -120,7 +129,3 @@ class Bengali extends SouthAsianLanguage {
     'শঙ্খ'
   ]
 }
-
-export default function convertToWords (value, options = {}) {
-  return new Bengali(options).convertToWords(value)
-}

package/lib/languages/cs.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Czech language converter.
+ *
+ * Supports:
+ * - Three-form pluralization (one/few/many)
+ * - Dynamic decimal separator (celá/celé/celých)
+ * - Gender agreement in number words
+ */
+export class Czech extends SlavicLanguage {
+    constructor(options?: {});
+    onesWords: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    onesFeminineWords: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    teensWords: {
+        0: string;
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    twentiesWords: {
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    hundredsWords: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    pluralForms: {
+        1: string[];
+        2: string[];
+        3: string[];
+        4: string[];
+        5: string[];
+        6: string[];
+        7: string[];
+        8: string[];
+        9: string[];
+        10: string[];
+    };
+    /** Returns decimal separator word based on integer part (celá/celé/celých). */
+    get decimalSeparatorWord(): "celá" | "celé" | "celých";
+    /**
+     * Override toWords to cache integer part before decimal separator is accessed.
+     */
+    toWords(isNegative: any, integerPart: any, decimalPart: any): string;
+    /** Selects Czech plural form: 1 = singular, 2-4 = few, else = many. */
+    pluralize(n: any, forms: any): any;
+    #private;
+}
+import { SlavicLanguage } from '../classes/slavic-language.js';