n2words 1.23.0 → 1.24.0

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

@@ -0,0 +1,101 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,93 @@
+/**
+ * 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

@@ -0,0 +1,25 @@
+/**
+ * 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

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

package/typings/languages/cs.d.ts

@@ -0,0 +1,120 @@
+/**
+ * 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';

package/typings/languages/da.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Converts a number to Danish cardinal (written) form.
+ *
+ * @param {number|string|bigint} value The number to convert.
+ * @param {Object} [options] Conversion options (see Danish class options).
+ * @param {boolean} [options.ordFlag=false] Enable ordinal number conversion.
+ * @returns {string} The number expressed in Danish words.
+ * @throws {TypeError} If value is NaN or invalid type.
+ * @throws {Error} If value is an invalid number string.
+ *
+ * @example
+ * convertToWords(25); // 'femogtyve' (five-and-twenty)
+ * convertToWords(50); // 'halvtreds' (half-third-times-twenty)
+ */
+export default function convertToWords(value: number | string | bigint, options?: {
+    ordFlag?: boolean;
+}): string;
+/**
+ * @typedef {Object} DanishOptions
+ * @property {boolean} [ordFlag=false] Enable ordinal number conversion.
+ */
+/**
+ * Danish language converter.
+ *
+ * GreedyScaleLanguage with Danish-specific extensions:
+ * - Unique vigesimal (base-20) number system for 50-90
+ * - Special composition rules ("og" for "and" between units and tens)
+ * - Reverse digit order (e.g., "fem-og-tyve" = five-and-twenty = 25)
+ * - Support for ordinal numbers via ordFlag option
+ *
+ * Key Features:
+ * - Vigesimal tens: halvtreds (50), treds (60), halvfjerds (70), firs (80), halvfems (90)
+ * - Units-before-tens pattern (e.g., "tre-og-tyve" = 23)
+ * - "et" prefix for hundreds/thousands (not "en")
+ * - Optional ordinal number conversion via ordFlag option
+ * - Inline merge logic tailored for Danish ordering
+ */
+export class Danish extends GreedyScaleLanguage {
+    /**
+     * Initializes the Danish converter with language-specific options.
+     *
+     * @param {DanishOptions} [options={}] Configuration options.
+     */
+    constructor({ ordFlag }?: DanishOptions);
+    ordFlag: boolean;
+}
+export type DanishOptions = {
+    /**
+     * Enable ordinal number conversion.
+     */
+    ordFlag?: boolean;
+};
+import GreedyScaleLanguage from '../classes/greedy-scale-language.js';

package/typings/languages/de.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Converts a number to German cardinal (written) form.
+ *
+ * @param {number|string|bigint} value The number to convert.
+ * @param {Object} [options] Conversion options (see German class options).
+ * @returns {string} The number expressed in German words.
+ * @throws {TypeError} If value is NaN or invalid type.
+ * @throws {Error} If value is an invalid number string.
+ *
+ * @example
+ * convertToWords(42); // 'zweiundvierzig'
+ * convertToWords('1.5'); // 'eins komma fünf'
+ */
+export default function convertToWords(value: number | string | bigint, options?: any): string;
+/**
+ * German language converter.
+ *
+ * Handles German grammatical features:
+ * - "eins" vs "ein" and "eine" forms for 1
+ * - Compound words without separators (e.g., "einundzwanzig" = 21)
+ * - Million/Billion pluralization
+ * - Special characters (e.g., "ü", "ö", "ß")
+ */
+export class German extends GreedyScaleLanguage {
+}
+import GreedyScaleLanguage from '../classes/greedy-scale-language.js';

package/typings/languages/el.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Converts a number to its word representation in Greek.
+ * @param {number|string|bigint} value - The number to convert
+ * @param {Object} [options={}] - Conversion options
+ * @returns {string} The word representation of the number
+ * @example
+ * convertToWords(42) // 'σαράντα δύο'
+ * convertToWords(1000) // 'χίλια'
+ * convertToWords(2000) // 'δύο χίλια'
+ */
+export default function convertToWords(value: number | string | bigint, options?: any): string;

package/typings/languages/en.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Converts a number to English cardinal (written) form.
+ *
+ * @param {number|string|bigint} value The number to convert.
+ * @param {Object} [options] Conversion options (see English class options).
+ * @returns {string} The number expressed in English words.
+ * @throws {TypeError} If value is NaN or invalid type.
+ * @throws {Error} If value is an invalid number string.
+ *
+ * @example
+ * convertToWords(42); // 'forty-two'
+ * convertToWords('1.5'); // 'one point five'
+ */
+export default function convertToWords(value: number | string | bigint, options?: any): string;
+/**
+ * English language converter.
+ *
+ * Converts numbers to English words, supporting:
+ * - Negative numbers (prepended with "minus")
+ * - Decimal numbers (word "point" between whole and fractional parts)
+ * - Numbers up to octillions
+ *
+ * Merge rules:
+ * - Hyphenated for compound tens (e.g., "twenty-three")
+ * - "and" after hundreds (e.g., "one hundred and one")
+ * - Space-separated for larger composites (e.g., "one thousand twenty-three")
+ */
+export class English extends GreedyScaleLanguage {
+}
+import GreedyScaleLanguage from '../classes/greedy-scale-language.js';

package/typings/languages/es.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Converts a number to Spanish cardinal (written) form.
+ *
+ * @param {number|string|bigint} value The number to convert.
+ * @param {Object} [options] Conversion options (see ES class).
+ * @returns {string} The number expressed in Spanish words.
+ * @throws {TypeError} If value is NaN or invalid type.
+ * @throws {Error} If value is an invalid number string.
+ *
+ * @example
+ * convertToWords(42, { lang: 'es' }); // 'cuarenta y dos'
+ * convertToWords(100, { lang: 'es' }); // 'cien'
+ */
+export default function convertToWords(value: number | string | bigint, options?: any): string;
+/**
+ * @typedef {Object} SpanishOptions
+ * @property {string} [genderStem='o'] Masculine 'o' or feminine 'a' ending.
+ */
+/**
+ * Spanish language converter.
+ *
+ * Handles Spanish grammatical features:
+ * - Gender agreement for numbers (masculine by default, feminine via `genderStem`)
+ * - "y" (and) between tens and units (e.g., "veinte y uno")
+ * - Special forms for hundreds (e.g., "cien", "ciento", "doscientos")
+ * - Million pluralization
+ */
+export class Spanish extends GreedyScaleLanguage {
+    /**
+     * Initializes the Spanish converter.
+     *
+     * @param {SpanishOptions} [options={}] Configuration options.
+     */
+    constructor({ genderStem }?: SpanishOptions);
+    genderStem: string;
+}
+export type SpanishOptions = {
+    /**
+     * Masculine 'o' or feminine 'a' ending.
+     */
+    genderStem?: string;
+};
+import GreedyScaleLanguage from '../classes/greedy-scale-language.js';

package/typings/languages/fa.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Converts a number to Persian cardinal (written) form.
+ *
+ * @param {number|string|bigint} value The number to convert.
+ * @param {Object} [options={}] Configuration options.
+ * @returns {string} The number expressed in Persian 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?: any): string;
+/**
+ * Persian (Farsi) language converter.
+ *
+ * Converts numbers to Persian words using Persian-Arabic numerals:
+ * - Right-to-left script orientation
+ * - Base-10 decimal system with Persian number words
+ * - Conjunction "و" (va/and) for compound numbers
+ * - Traditional Persian number naming conventions
+ *
+ * Key Features:
+ * - Named number lookup table (namedNumbers) for direct mapping 0-999
+ * - Group-based algorithm for numbers >= 1000:
+ *   1. Split into groups of 3 digits
+ *   2. Convert each group to words using named table or recursion
+ *   3. Append magnitude word (هزار/میلیون/میلیارد)
+ *   4. Join with "و" (and) conjunction
+ * - Special compound forms (دویست for 200, سیصد for 300)
+ * - Proper Persian grammatical structure
+ * - Support for large numbers (thousands, millions, billions, trillions)
+ *
+ * Features:
+ * - Native Persian digits and words
+ * - Special compound forms (e.g., دویست for 200, سیصد for 300)
+ * - Support for large numbers (thousands, millions)
+ * - Proper Persian grammatical structure
+ */
+export class Farsi extends AbstractLanguage {
+    namedNumbers: {
+        0: string;
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+        10: string;
+        11: string;
+        12: string;
+        13: string;
+        14: string;
+        15: string;
+        16: string;
+        17: string;
+        18: string;
+        19: string;
+        20: string;
+        30: string;
+        40: string;
+        50: string;
+        60: string;
+        70: string;
+        80: string;
+        90: string;
+        100: string;
+        200: string;
+        300: string;
+        400: string;
+        500: string;
+        600: string;
+        700: string;
+        800: string;
+        900: string;
+        1000: string;
+        1000000: string;
+    };
+    convertWholePart(number: any): any;
+}
+import AbstractLanguage from '../classes/abstract-language.js';

package/typings/languages/fil.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Convert a number to Filipino words
+ *
+ * @param {number|string|bigint} value - The number to convert
+ * @param {Object} [options={}] - Conversion options
+ * @returns {string} The Filipino word representation
+ * @example
+ * convertToWords(42) // 'apatnapu dalawa'
+ * convertToWords(1000) // 'isang libo'
+ * convertToWords(123456) // 'isang daang dalawampung tatlong libong apat na daang limampung anim'
+ */
+export default function convertToWords(value: number | string | bigint, options?: any): string;