n2words 1.24.0 → 2.0.0

package/typings/classes/greedy-scale-language.d.ts

@@ -1,148 +0,0 @@
-export default GreedyScaleLanguage;
-export type WordSet = {
-    /**
-     * - The language word or phrase
-     */
-    word: string;
-    /**
-     * - The numeric value represented by the word
-     */
-    value: bigint;
-};
-/**
- * Array of scale word pairs in descending order. Each pair contains:
- * - [0]: BigInt numeric value
- * - [1]: String word representation
- * Must be ordered largest to smallest for the greedy algorithm.
- */
-export type ScaleWordPairs = Array<Array<(bigint | string)>>;
-/**
- * @typedef {Object} WordSet
- * @property {string} word - The language word or phrase
- * @property {bigint} value - The numeric value represented by the word
- */
-/**
- * @typedef {Array.<Array.<(bigint|string)>>} ScaleWordPairs
- * Array of scale word pairs in descending order. Each pair contains:
- * - [0]: BigInt numeric value
- * - [1]: String word representation
- * Must be ordered largest to smallest for the greedy algorithm.
- */
-/**
- * Greedy scale language converter implementing the "highest-matching scale word" algorithm.
- *
- * Responsibilities:
- * - Decompose a whole-number value into a sequence of scale word-sets.
- * - Provide helpers to merge and post-process matched word-sets.
- * - Inherits decimal handling from AbstractLanguage (supports grouped and per-digit
- *   modes via the `convertDecimalsPerDigit` class property).
- *
- * Subclass requirements:
- * - Define `scaleWordPairs` (ordered descending) as `[BigInt, string]` tuples.
- * - Implement `mergeScales(leftWordSet, rightWordSet)` to combine adjacent word-sets
- *   per language grammar.
- *
- * Scale words specification:
- * - `scaleWordPairs` is an Array of 2-tuples: `[BigInt, string]` where the first element
- *   is the numeric value (BigInt) and the second is the word used for that value.
- * - Scale words MUST be ordered from largest to smallest (descending) for the algorithm
- *   to function correctly.
- *
- * @abstract
- * @extends AbstractLanguage
- * @example
- * // Example `scaleWordPairs` for English (descending order):
- * // [[1000000000n, 'billion'], [1000000n, 'million'], [1000n, 'thousand'], [100n, 'hundred'], ..., [1n, 'one']]
- */
-declare class GreedyScaleLanguage extends AbstractLanguage {
-    /**
-     * Array of scale word pairs mapping numeric values to their word representations.
-     *
-     * Each element is a 2-tuple: `[BigInt, string]` where the first element is the
-     * numeric value and the second is the word for that value. The array MUST be
-     * ordered from largest to smallest (descending) for the greedy algorithm to work correctly.
-     *
-     * @type {Array.<Array.<(bigint|string)>>}
-     * @example
-     * // English scale words (descending order):
-     * // [[1000000000n, 'billion'], [1000000n, 'million'], [1000n, 'thousand'], [100n, 'hundred'], ..., [1n, 'one']]
-     */
-    scaleWordPairs: Array<Array<(bigint | string)>>;
-    /**
-     * Return the word associated with an exact scale word-set numeric value.
-     *
-     * @param {bigint|number} scaleValue Numeric word-set object key (prefer BigInt for exact matching).
-     * @returns {string|undefined} The word for the provided scale value, or `undefined`.
-     */
-    getScaleWord(scaleValue: bigint | number): string | undefined;
-    /**
-     * Decompose a whole-number into a sequence of scale word-sets.
-     *
-     * This internal helper returns a nested structure that represents quantities and
-     * their matching scale words (e.g. `[{ 'one': 1n }, { 'hundred': 100n }, ...]`).
-     * The result is designed to be reduced by `mergeWordSets()` using language-specific `mergeScales()`.
-     *
-     * For quantities > 1, the multiplier is recursively decomposed. For quantity = 1,
-     * the implicit "one" is represented with `{ 'one': 1n }` and typically omitted during mergeScales().
-     *
-     * @protected
-     * @param {bigint} wholeNumber The integer value to decompose (BigInt preferred).
-     * @returns {Array<Object|Array>} An array of word-set objects and possibly nested arrays.
-     */
-    protected decomposeToScales(wholeNumber: bigint): Array<any | any[]>;
-    /**
-     * Reduce a nested array of word-sets into a single merged word-set object.
-     *
-     * This method repeatedly applies the subclass `mergeScales()` operation until a single
-     * object remains. It normalizes nested arrays by recursively merging them.
-     *
-     * @protected
-     * @param {Array<Object|Array>} mergeWordSetsList Array of word-set objects and nested arrays.
-     * @returns {Object} Merged word-set where the single object key is the language string
-     *   and its value is the numeric BigInt result for that string.
-     */
-    protected mergeWordSets(mergeWordSetsList: Array<any | any[]>): any;
-    /**
-     * Combine two adjacent word-sets into a single merged word-set.
-     *
-     * This is the core language-specific method that must be implemented by subclasses
-     * to define how adjacent word-sets are combined according to the language's grammar.
-     * For example, English combines "twenty" + "three" → "twenty-three", while
-     * French might combine "quatre-vingts" + "dix" → "quatre-vingt-dix".
-     *
-     * @abstract
-     * @protected
-     * @param {Object} leftWordSet Left operand as `{ word: bigint }` pair.
-     * @param {Object} rightWordSet Right operand as `{ word: bigint }` pair.
-     * @returns {Object} Single merged word-set object with combined text and numeric value.
-     *
-     * @example
-     * // English implementation might handle:
-     * // mergeScales({ 'twenty': 20n }, { 'three': 3n }) → { 'twenty-three': 23n }
-     * // mergeScales({ 'one': 1n }, { 'hundred': 100n }) → { 'one hundred': 100n }
-     */
-    protected mergeScales(leftWordSet: any, rightWordSet: any): any;
-    /**
-     * Final string post-processing hook.
-     *
-     * Subclasses may override to apply language-specific whitespace, punctuation or
-     * orthographic corrections.
-     *
-     * @protected
-     * @param {string} output Merged language string produced by `convertWholePart` flow.
-     * @returns {string} Final formatted string.
-     */
-    protected finalizeWords(output: string): string;
-    /**
-     * Convert an integer value to its language-specific cardinal words.
-     *
-     * This method orchestrates decomposition, merging and final formatting. It does
-     * not handle decimals or sign; those concerns are implemented in
-     * `AbstractLanguage.convertToWords` which calls this helper for the whole-number part.
-     *
-     * @param {bigint|number} wholeNumber Whole-number value to convert (BigInt is preferred).
-     * @returns {string} The cardinal representation for `value` in the language.
-     */
-    convertWholePart(wholeNumber: bigint | number): string;
-}
-import AbstractLanguage from './abstract-language.js';

package/typings/classes/slavic-language.d.ts

@@ -1,145 +0,0 @@
-export default SlavicLanguage;
-/**
- * Array of three plural forms for Slavic languages:
- * - [0]: Singular form (for numbers ending in 1, except 11)
- * - [1]: Few form (for numbers ending in 2-4, except 12-14)
- * - [2]: Many form (for all other numbers: 0, 5-20, and numbers ending in 0, 5-9, 11-19)
- */
-export type SlavicPluralForms = string[];
-/**
- * Mapping from power indices to their plural forms.
- * Example: { '0': ['тысяча', 'тысячи', 'тысяч'], '1': ['миллион', 'миллиона', 'миллионов'] }
- */
-export type SlavicThousandsMap = {
-    [x: string]: SlavicPluralForms;
-};
-/**
- * @typedef {string[]} SlavicPluralForms
- * Array of three plural forms for Slavic languages:
- * - [0]: Singular form (for numbers ending in 1, except 11)
- * - [1]: Few form (for numbers ending in 2-4, except 12-14)
- * - [2]: Many form (for all other numbers: 0, 5-20, and numbers ending in 0, 5-9, 11-19)
- */
-/**
- * @typedef {Object.<string, SlavicPluralForms>} SlavicThousandsMap
- * Mapping from power indices to their plural forms.
- * Example: { '0': ['тысяча', 'тысячи', 'тысяч'], '1': ['миллион', 'миллиона', 'миллионов'] }
- */
-/**
- * Base class for Slavic and related languages with complex pluralization.
- *
- * This class provides a reusable implementation for languages that share:
- * - Three-form pluralization (singular/few/many)
- * - Gender-aware number forms (masculine/feminine for 1, 2)
- * - Hundreds, tens, ones decomposition
- * - Chunk-based large number handling (thousands, millions, etc.)
- * - Inherits decimal handling from AbstractLanguage (supports both grouped and
- *   per-digit modes via the `convertDecimalsPerDigit` class property).
- *
- * Used by: Russian, Czech, Polish, Ukrainian, Serbian, Croatian,
- * as well as Baltic (Lithuanian, Latvian) and Hebrew languages.
- *
- * Subclasses MUST define these properties with language-specific vocabulary:
- * - `ones` - Object mapping 1-9 to masculine forms
- * - `onesFeminine` - Object mapping 1-9 to feminine forms
- * - `tens` - Object mapping 0-9 to teen numbers (10-19)
- * - `twenties` - Object mapping 2-9 to tens (20-90)
- * - `hundreds` - Object mapping 1-9 to hundreds (100-900)
- * - `thousands` - Object mapping power indices to [singular, few, many] forms
- * - `feminine` - Boolean indicating if feminine forms should be used (optional)
- *
- * @abstract
- * @extends AbstractLanguage
- */
-declare class SlavicLanguage extends AbstractLanguage {
-    /**
-     * Initializes the Slavic language converter with language-specific options.
-     *
-     * @param {Object} [options={}] Configuration options.
-     * @param {boolean} [options.feminine=false] Use feminine forms for numbers (affects gender agreement).
-     */
-    constructor({ feminine }?: {
-        feminine?: boolean;
-    });
-    /**
-     * Masculine forms for digits 1-9.
-     *
-     * @type {object}
-     */
-    ones: object;
-    /**
-     * Feminine forms for digits 1-9.
-     *
-     * @type {object}
-     */
-    onesFeminine: object;
-    /**
-     * Words for tens (10, 20, 30, etc.).
-     *
-     * @type {object}
-     */
-    tens: object;
-    /**
-     * Special forms for 21-29 in some languages.
-     *
-     * @type {object}
-     */
-    twenties: object;
-    /**
-     * Words for hundreds (100, 200, 300, etc.).
-     *
-     * @type {object}
-     */
-    hundreds: object;
-    /**
-     * Scale words for thousands, millions, etc.
-     *
-     * @type {object}
-     */
-    thousands: object;
-    /**
-     * Use feminine forms for numbers (affects 1-9).
-     *
-     * @type {boolean}
-     */
-    feminine: boolean;
-    /**
-     * Splits a number string into chunks of X digits.
-     *
-     * Example: splitByX('1234567', 3) => [1n, 234n, 567n]
-     *
-     * @param {string} numberString The number as a string.
-     * @param {number} chunkSize Chunk size (typically 3 for thousands grouping).
-     * @returns {bigint[]} Array of BigInt chunks.
-     */
-    splitByX(numberString: string, chunkSize: number): bigint[];
-    /**
-     * Extracts individual digits from a number (units, tens, hundreds).
-     *
-     * Returns digits in reverse order: [ones, tens, hundreds]
-     * Example: 456 => [6n, 5n, 4n]
-     *
-     * @param {bigint} value The number to extract digits from (0-999).
-     * @returns {bigint[]} Array of [ones, tens, hundreds] as BigInts.
-     */
-    getDigits(value: bigint): bigint[];
-    /**
-     * Selects the correct plural form based on Slavic pluralization rules.
-     *
-     * Slavic languages use three forms:
-     * - Form 0 (singular): numbers ending in 1 (but not 11)
-     * - Form 1 (few): numbers ending in 2-4 (but not 12-14)
-     * - Form 2 (many): all other numbers (0, 5-20, 25-30, etc.)
-     *
-     * Examples (Russian):
-     * - 1, 21, 31... => тысяча (form 0)
-     * - 2-4, 22-24, 32-34... => тысячи (form 1)
-     * - 0, 5-20, 25-30... => тысяч (form 2)
-     *
-     * @param {bigint} n The number to check.
-     * @param {string[]} forms Array of [singular, few, many] forms.
-     * @returns {string} The appropriate form for the number.
-     */
-    pluralize(number: any, pluralForms: any): string;
-}
-import AbstractLanguage from './abstract-language.js';

package/typings/classes/south-asian-language.d.ts

@@ -1,101 +0,0 @@
-export default SouthAsianLanguage;
-/**
- * Array of scale words for the Indian numbering system, in ascending order.
- * - Index 0: Usually empty/unused (ones place)
- * - Index 1: Thousands (hazaar/হাজার/हजार)
- * - Index 2: Lakhs (lakh/লাখ/लाख)
- * - Index 3: Crores (crore/কোটি/करोड़)
- * - Index 4: Arabs (arab/আরব/अरब)
- * Each index i represents the scale word for groups at position i in the Indian system.
- */
-export type SouthAsianScaleWords = Array<string>;
-/**
- * Array of words for numbers 0-99, indexed directly.
- * belowHundred[0] = word for 0, belowHundred[42] = word for 42, etc.
- */
-export type SouthAsianBelowHundred = Array<string>;
-/**
- * @typedef {Array<string>} SouthAsianScaleWords
- * Array of scale words for the Indian numbering system, in ascending order.
- * - Index 0: Usually empty/unused (ones place)
- * - Index 1: Thousands (hazaar/হাজার/हजार)
- * - Index 2: Lakhs (lakh/লাখ/लाख)
- * - Index 3: Crores (crore/কোটি/करोड़)
- * - Index 4: Arabs (arab/আরব/अरब)
- * Each index i represents the scale word for groups at position i in the Indian system.
- */
-/**
- * @typedef {Array<string>} SouthAsianBelowHundred
- * Array of words for numbers 0-99, indexed directly.
- * belowHundred[0] = word for 0, belowHundred[42] = word for 42, etc.
- */
-/**
- * Base class for South Asian languages with shared grouping patterns.
- *
- * This class provides a reusable implementation for South Asian languages that share:
- * - Indian-style number grouping: last 3 digits, then 2-2 (1,23,45,67,89)
- * - Lakh (100,000), Crore (10,000,000), Arab (1,000,000,000) scale words
- * - Standard negative and decimal handling (inherits AbstractLanguage decimal logic,
- *   including `convertDecimalsPerDigit` support when set by subclasses)
- *
- * Used by: Hindi (hi), Bengali (bn), Urdu (ur), Punjabi (pa), Marathi (mr), Gujarati (gu), Kannada (kn)
- *
- * Subclasses MUST define language-specific vocabulary via class properties:
- * - `belowHundred` array with digit and teen words (0-99)
- * - `hundredWord` string used inside `convertBelowThousand`
- * - `scaleWords` array with grouping words (hazaar, lakh, crore, etc.) indexed by grouping level
- * - `negativeWord`, `decimalSeparatorWord`, `zeroWord`, `wordSeparator`
- *
- * @abstract
- * @extends AbstractLanguage
- */
-declare class SouthAsianLanguage extends AbstractLanguage {
-    /**
-     * Array of words for numbers 0-99 (digits and teens).
-     * Index directly: belowHundred[0] through belowHundred[99].
-     * @type {Array<string>}
-     */
-    belowHundred: Array<string>;
-    /**
-     * Word for "hundred" in the language (e.g., 'सौ' in Hindi, 'শত' in Bengali).
-     * Used to construct hundreds (e.g., "1 hundred", "2 hundred").
-     * @type {string}
-     */
-    hundredWord: string;
-    /**
-     * Array of scale words for Indian-style grouping (hazaar, lakh, crore, arab, etc.).
-     * Index 0 is typically unused (ones place, no scale word).
-     * Index 1 is for thousands, Index 2 for lakhs, Index 3 for crores, etc.
-     * @type {Array<string>}
-     */
-    scaleWords: Array<string>;
-    /**
-     * Split a number into Indian numbering system groups.
-     *
-     * The Indian system groups differently than Western (3-3-3) systems:
-     * - First group (rightmost): Up to 3 digits (ones, tens, hundreds)
-     * - Subsequent groups: Exactly 2 digits each (thousands, lakhs, crores, etc.)
-     *
-     * This creates the familiar Indian comma pattern: 1,23,45,67,890
-     *
-     * @protected
-     * @param {bigint} number The number to split into groups
-     * @returns {Array<number>} Array of groups from most significant to least significant
-     *
-     * @example
-     * // splitToGroups(1234567n) → [12, 34, 567]
-     * // Reads as: 12 lakhs, 34 thousands, 567 units
-     * // splitToGroups(98765432n) → [9, 87, 65, 432]
-     * // Reads as: 9 crores, 87 lakhs, 65 thousands, 432 units
-     */
-    protected splitToGroups(number: bigint): Array<number>;
-    /**
-     * Convert a number below 1000 to words (0-999).
-     *
-     * @protected
-     * @param {number} number Value between 0 and 999
-     * @returns {string} Language-specific word representation
-     */
-    protected convertBelowThousand(number: number): string;
-}
-import AbstractLanguage from './abstract-language.js';

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

@@ -1,42 +0,0 @@
-export default TurkicLanguage;
-export type TurkicWordPair = {
-    /**
-     * - The Turkic word or phrase
-     */
-    word: string;
-    /**
-     * - The numeric value represented by the word
-     */
-    value: bigint;
-};
-/**
- * @typedef {Object} TurkicWordPair
- * @property {string} word - The Turkic word or phrase
- * @property {bigint} value - The numeric value represented by the word
- */
-/**
- * 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 `convertDecimalsPerDigit` 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).
- * 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).
- *
- * @abstract
- * @extends GreedyScaleLanguage
- */
-declare class TurkicLanguage extends GreedyScaleLanguage {
-}
-import GreedyScaleLanguage from './greedy-scale-language.js';

package/typings/languages/ar.d.ts

@@ -1,93 +0,0 @@
-/**
- * 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: number | string | bigint, options?: ArabicOptions): string;
-/**
- * @typedef {Object} ArabicOptions
- * @property {string} [negativeWord='ناقص'] Word for negative numbers (minus).
- * @property {boolean} [feminine=false] Use feminine forms for numbers.
- */
-/**
- * Arabic language converter.
- *
- * Converts numbers to Arabic words with full grammatical support:
- * - Gender agreement (masculine/feminine forms)
- * - Complex pluralization rules (singular, dual, plural forms)
- * - Special handling for hundreds, thousands, millions, etc.
- * - Right-to-left text orientation
- * - 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 {
-    /**
-     * Initializes the Arabic converter with language-specific options.
-     *
-     * @param {ArabicOptions} [options={}] Configuration options.
-     */
-    constructor({ negativeWord, feminine }?: ArabicOptions);
-    arabicTens: string[];
-    arabicHundreds: string[];
-    arabicAppendedTwos: string[];
-    arabicTwos: string[];
-    arabicGroup: string[];
-    arabicAppendedGroup: string[];
-    arabicPluralGroups: string[];
-    ones: {
-        masculine: string[];
-        feminine: string[];
-    };
-    feminine: boolean;
-    selectedOnes: string[];
-    /**
-     * 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: number): string;
-    /**
-     * 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: number, groupLevel: number, fullNumber: any): string;
-}
-export type ArabicOptions = {
-    /**
-     * Word for negative numbers (minus).
-     */
-    negativeWord?: string;
-    /**
-     * Use feminine forms for numbers.
-     */
-    feminine?: boolean;
-};
-import AbstractLanguage from '../classes/abstract-language.js';

package/typings/languages/az.d.ts

@@ -1,25 +0,0 @@
-/**
- * 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: number | string | bigint, options?: any): string;
-/**
- * Azerbaijani language converter.
- *
- * Inherits from TurkicLanguage shared patterns:
- * - Space-separated number combinations
- * - Omits '1' before hundreds and thousands
- * - Supports flexible word spacing configuration
- */
-export class Azerbaijani extends TurkicLanguage {
-}
-import TurkicLanguage from '../classes/turkic-language.js';

package/typings/languages/bn.d.ts

@@ -1 +0,0 @@
-export default function convertToWords(value: any, options?: {}): string;

package/typings/languages/cs.d.ts

@@ -1,120 +0,0 @@
-/**
- * Converts a number to Czech cardinal (written) form.
- *
- * @param {number|string|bigint} value The number to convert.
- * @param {SlavicOptions} [options={}] Configuration options.
- * @returns {string} The number expressed in Czech words.
- * @throws {TypeError} If value is NaN or invalid type.
- * @throws {Error} If value is an invalid number string.
- */
-export default function convertToWords(value: number | string | bigint, options?: SlavicOptions): string;
-/**
- * @typedef {Object} SlavicOptions
- * @property {boolean} [feminine=false] Use feminine forms for numbers.
- */
-/**
- * Czech language converter.
- *
- * Implements Czech number words using the Slavic language pattern:
- * - Czech number words (jedna, dva, tři, čtyři, pět...)
- * - Slavic three-form pluralization (tisíc/tisíce/tisíc)
- * - Gender agreement for numbers 1-2
- * - Czech-specific number word endings
- *
- * Key Features:
- * - Three-form pluralization system shared across Slavic languages
- *   * Form 1 (singular): 1 (e.g., "tisíc")
- *   * Form 2 (few): 2-4, 22-24, 32-34... excluding teens (e.g., "tisíce")
- *   * Form 3 (many): all other numbers (e.g., "tisíc")
- * - Chunk-based decomposition (splits into groups of 3 digits: ones, thousands, millions, etc.)
- * - Large number handling via thousands[] array with indexed [singular, few, many] forms
- *
- * Inherits from SlavicLanguage:
- * - Complex pluralization rules (one/few/many forms)
- * - Group-based large number handling (chunk decomposition via splitByX())
- * - Proper declension patterns via pluralize() method
- */
-export class Czech extends SlavicLanguage {
-    ones: {
-        1: string;
-        2: string;
-        3: string;
-        4: string;
-        5: string;
-        6: string;
-        7: string;
-        8: string;
-        9: string;
-    };
-    tens: {
-        0: string;
-        1: string;
-        2: string;
-        3: string;
-        4: string;
-        5: string;
-        6: string;
-        7: string;
-        8: string;
-        9: string;
-    };
-    twenties: {
-        2: string;
-        3: string;
-        4: string;
-        5: string;
-        6: string;
-        7: string;
-        8: string;
-        9: string;
-    };
-    hundreds: {
-        1: string;
-        2: string;
-        3: string;
-        4: string;
-        5: string;
-        6: string;
-        7: string;
-        8: string;
-        9: string;
-    };
-    thousands: {
-        1: string[];
-        2: string[];
-        3: string[];
-        4: string[];
-        5: string[];
-        6: string[];
-        7: string[];
-        8: string[];
-        9: string[];
-        10: string[];
-    };
-    /**
-     * Returns the Czech word for the decimal separator based on the whole number.
-     *
-     * @returns {string} The Czech word for the decimal separator.
-     */
-    get decimalSeparatorWord(): string;
-    /**
-     * Implements Czech-specific three-form pluralization rules.
-     *
-     * Czech three-form system:
-     * - Form 1 (singular): exactly n=1 (e.g., "tisíc")
-     * - Form 2 (few): n ends in 2-4, excluding teens (22-24, 32-34...) (e.g., "tisíce")
-     * - Form 3 (many): all other numbers (e.g., "tisíc" for 0, 5+)
-     *
-     * @param {bigint} n The number to classify.
-     * @param {Array<string>} forms Array of [singular, few, many] word forms.
-     * @returns {string} The appropriate form for the number n.
-     */
-    pluralize(n: bigint, forms: Array<string>): string;
-}
-export type SlavicOptions = {
-    /**
-     * Use feminine forms for numbers.
-     */
-    feminine?: boolean;
-};
-import SlavicLanguage from '../classes/slavic-language.js';