n2words 5.1.0 → 5.1.2

package/src/lt-LT.d.ts

@@ -1,21 +1,32 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
 /**
- * @typedef {object} CardinalOptions
- * @property {('masculine'|'feminine')} [gender] - Gender for numbers < 1000
+ * Lithuanian (Lithuania) language converter
+ *
+ * CLDR: lt-LT | Lithuanian as used in Lithuania
+ *
+ * Key features:
+ * - Three-form pluralization (singular/plural/genitive)
+ * - Gender agreement (masculine/feminine for numbers < 1000)
+ * - Two-form hundreds (šimtas/šimtai)
+ * - Long scale naming
  */
-/** @type {Required<CardinalOptions>} */
-export const cardinalDefaults: Required<CardinalOptions>;
-/** @type {{ gender: ReadonlyArray<Required<CardinalOptions>['gender']> }} */
-export const cardinalValues: {
-    gender: ReadonlyArray<Required<CardinalOptions>["gender"]>;
-};
+export declare const cardinalMax: bigint;
+export declare const ordinalMax: bigint;
+export declare const currencyMax: bigint;
 export type CardinalOptions = {
     /**
      * - Gender for numbers < 1000
      */
-    gender?: "feminine" | "masculine" | undefined;
+    gender?: ('masculine' | 'feminine');
+};
+/**
+ * @typedef {object} CardinalOptions
+ * @property {('masculine'|'feminine')} [gender] - Gender for numbers < 1000
+ */
+/** @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 Lithuanian words.
@@ -29,7 +40,7 @@ export type CardinalOptions = {
  * toCardinal(1, { gender: 'feminine' })   // 'viena'
  * toCardinal(1000000)                     // 'vienas milijonas'
  */
-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 Lithuanian ordinal words (masculine nominative).
  * @param {number | string | bigint} value - The numeric value to convert (must be a positive integer)
@@ -43,7 +54,7 @@ export function toCardinal(value: number | string | bigint, options?: CardinalOp
  * toOrdinal(100)  // 'šimtasis'
  * toOrdinal(1000) // 'tūkstantasis'
  */
-export function toOrdinal(value: number | string | bigint): string;
+declare function toOrdinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Lithuanian currency words (Euro).
  * @param {number | string | bigint} value - The currency amount to convert
@@ -56,4 +67,5 @@ export function toOrdinal(value: number | string | bigint): string;
  * toCurrency(1.50)   // 'vienas euras penkiasdešimt centų'
  * toCurrency(-5)     // 'minus penki eurai'
  */
-export function toCurrency(value: number | string | bigint): string;
+declare function toCurrency(value: number | string | bigint): string;
+export { toCardinal, toOrdinal, toCurrency };

package/src/lv-LV.d.ts

@@ -1,21 +1,33 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
 /**
- * @typedef {object} CardinalOptions
- * @property {('masculine'|'feminine')} [gender] - Gender for numbers < 1000
+ * Latvian (Latvia) language converter
+ *
+ * CLDR: lv-LV | Latvian as used in Latvia
+ *
+ * Key features:
+ * - Two-form pluralization (singular for 1 except 11, plural otherwise)
+ * - Gender agreement (masculine/feminine for numbers < 1000)
+ * - Special hundreds forms (simts/simti/simtu)
+ * - Omit "one" before scale words
+ * - Long scale naming
  */
-/** @type {Required<CardinalOptions>} */
-export const cardinalDefaults: Required<CardinalOptions>;
-/** @type {{ gender: ReadonlyArray<Required<CardinalOptions>['gender']> }} */
-export const cardinalValues: {
-    gender: ReadonlyArray<Required<CardinalOptions>["gender"]>;
-};
+export declare const cardinalMax: bigint;
+export declare const ordinalMax: bigint;
+export declare const currencyMax: bigint;
 export type CardinalOptions = {
     /**
      * - Gender for numbers < 1000
      */
-    gender?: "feminine" | "masculine" | undefined;
+    gender?: ('masculine' | 'feminine');
+};
+/**
+ * @typedef {object} CardinalOptions
+ * @property {('masculine'|'feminine')} [gender] - Gender for numbers < 1000
+ */
+/** @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 Latvian words.
@@ -29,7 +41,7 @@ export type CardinalOptions = {
  * toCardinal(1, { gender: 'feminine' })   // 'viena'
  * toCardinal(1000)                        // 'tūkstotis'
  */
-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 Latvian ordinal words (masculine nominative).
  * @param {number | string | bigint} value - The numeric value to convert (must be a positive integer)
@@ -43,7 +55,7 @@ export function toCardinal(value: number | string | bigint, options?: CardinalOp
  * toOrdinal(100)  // 'simtais'
  * toOrdinal(1000) // 'tūkstošais'
  */
-export function toOrdinal(value: number | string | bigint): string;
+declare function toOrdinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Latvian currency words (Euro).
  * @param {number | string | bigint} value - The currency amount to convert
@@ -56,4 +68,5 @@ export function toOrdinal(value: number | string | bigint): string;
  * toCurrency(1.50)   // 'viens eiro piecdesmit centu'
  * toCurrency(-5)     // 'mīnus pieci eiro'
  */
-export function toCurrency(value: number | string | bigint): string;
+declare function toCurrency(value: number | string | bigint): string;
+export { toCardinal, toOrdinal, toCurrency };

package/src/mr-IN.d.ts

@@ -1,12 +1,24 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
+/**
+ * Marathi (India) language converter
+ *
+ * CLDR: mr-IN | Marathi as used in India
+ *
+ * Key features:
+ * - Indian numbering system (हजार, लाख, कोटी)
+ * - Devanagari script
+ * - 3-2-2 grouping pattern (last 3 digits, then groups of 2)
+ * - Complete word forms for 0-99
+ * - Per-digit decimal reading
+ */
+export declare const cardinalMax: bigint;
+export declare const ordinalMax: bigint;
+export declare const currencyMax: bigint;
 /**
  * Converts a numeric value to Marathi words.
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The number in Marathi words
  */
-export function toCardinal(value: number | string | bigint): string;
+declare function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Marathi ordinal words.
  * @param {number | string | bigint} value - The numeric value to convert (positive integer)
@@ -19,7 +31,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 Marathi currency words (Indian Rupee).
  * @param {number | string | bigint} value - The currency amount to convert
@@ -31,4 +43,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/ms-MY.d.ts

@@ -1,12 +1,23 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
+/**
+ * Malay (Malaysia) language converter
+ *
+ * CLDR: ms-MY | Malay (Bahasa Melayu) as used in Malaysia
+ *
+ * Key features:
+ * - "Se-" prefix for ALL singular scale units (seratus, seribu, sejuta, sebilion)
+ * - Regular patterns (puluh for tens, ratus for hundreds)
+ * - Teens with "belas" suffix
+ * - Note: "lapan" (8) differs from Indonesian "delapan"
+ */
+export declare const cardinalMax: bigint;
+export declare const ordinalMax: bigint;
+export declare const currencyMax: bigint;
 /**
  * Converts a numeric value to Malay words.
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The number in Malay words
  */
-export function toCardinal(value: number | string | bigint): string;
+declare function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Malay ordinal words.
  * @param {number | string | bigint} value - The numeric value to convert (positive integer)
@@ -18,7 +29,7 @@ export function toCardinal(value: number | string | bigint): string;
  * toOrdinal(2)    // 'kedua'
  * toOrdinal(10)   // 'kesepuluh'
  */
-export function toOrdinal(value: number | string | bigint): string;
+declare function toOrdinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Malay currency words (Ringgit).
  *
@@ -32,4 +43,5 @@ export function toOrdinal(value: number | string | bigint): string;
  * toCurrency(1.50)   // 'satu ringgit lima puluh sen'
  * toCurrency(-5)     // 'minus lima ringgit'
  */
-export function toCurrency(value: number | string | bigint): string;
+declare function toCurrency(value: number | string | bigint): string;
+export { toCardinal, toOrdinal, toCurrency };

package/src/nb-NO.d.ts

@@ -1,6 +1,17 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
+/**
+ * Norwegian Bokmål (Norway) language converter
+ *
+ * CLDR: nb-NO | Norwegian Bokmål as used in Norway
+ *
+ * Key features:
+ * - Hyphenated tens+ones: "tjue-en" (21)
+ * - "og" conjunction after hundreds
+ * - Comma separator after thousands before hundreds
+ * - Short scale: million, milliard, billion, etc.
+ */
+export declare const cardinalMax: bigint;
+export declare const ordinalMax: bigint;
+export declare const currencyMax: bigint;
 /**
  * Converts a numeric value to Norwegian Bokmål words.
  * @param {number | string | bigint} value - The numeric value to convert
@@ -12,7 +23,7 @@ export const currencyMax: bigint;
  * toCardinal(101)      // 'en hundre og en'
  * toCardinal(1000000)  // 'en million'
  */
-export function toCardinal(value: number | string | bigint): string;
+declare function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Norwegian Bokmål ordinal words.
  * @param {number | string | bigint} value - The numeric value to convert (positive integer)
@@ -24,7 +35,7 @@ export function toCardinal(value: number | string | bigint): string;
  * toOrdinal(2)    // 'andre'
  * toOrdinal(21)   // 'tjue-ende'
  */
-export function toOrdinal(value: number | string | bigint): string;
+declare function toOrdinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Norwegian currency words (Norwegian Krone).
  *
@@ -38,4 +49,5 @@ export function toOrdinal(value: number | string | bigint): string;
  * toCurrency(42)     // 'førti-to kroner'
  * toCurrency(1.50)   // 'en krone og femti øre'
  */
-export function toCurrency(value: number | string | bigint): string;
+declare function toCurrency(value: number | string | bigint): string;
+export { toCardinal, toOrdinal, toCurrency };

package/src/nl-NL.d.ts

@@ -1,40 +1,42 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
 /**
- * @typedef {object} CardinalOptions
- * @property {boolean} [accentOne] - Use "één" instead of "een"
- * @property {boolean} [includeOptionalAnd] - Include "en" before small numbers
- * @property {boolean} [noHundredPairing] - Disable hundred pairing (1104→duizend honderdvier)
- */
-/** @type {Required<CardinalOptions>} */
-export const cardinalDefaults: Required<CardinalOptions>;
-/**
- * @typedef {object} CurrencyOptions
- * @property {boolean} [and] - Include "en" between euros and cents
+ * Dutch (Netherlands) language converter
+ *
+ * CLDR: nl-NL | Dutch as used in the Netherlands
+ *
+ * Dutch-specific rules:
+ * - Inverted tens-ones: eenentwintig (one-and-twenty)
+ * - "ën" connector when ones ends in 'e' (twee, drie)
+ * - Compound words without spaces
+ * - Hundred pairing for 1100-9999 (elfhonderd style)
+ * - "één" vs "een" (accentOne option)
+ * - Optional "en" separator (includeOptionalAnd option)
+ * - Long scale with -ard forms
  */
-/** @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 "één" instead of "een"
      */
-    accentOne?: boolean | undefined;
+    accentOne?: boolean;
     /**
      * - Include "en" before small numbers
      */
-    includeOptionalAnd?: boolean | undefined;
+    includeOptionalAnd?: boolean;
     /**
      * - Disable hundred pairing (1104→duizend honderdvier)
      */
-    noHundredPairing?: boolean | undefined;
-};
-export type CurrencyOptions = {
-    /**
-     * - Include "en" between euros and cents
-     */
-    and?: boolean | undefined;
+    noHundredPairing?: boolean;
 };
+/**
+ * @typedef {object} CardinalOptions
+ * @property {boolean} [accentOne] - Use "één" instead of "een"
+ * @property {boolean} [includeOptionalAnd] - Include "en" before small numbers
+ * @property {boolean} [noHundredPairing] - Disable hundred pairing (1104→duizend honderdvier)
+ */
+/** @type {Required<CardinalOptions>} */
+export declare const cardinalDefaults: Required<CardinalOptions>;
 /**
  * Converts a numeric value to Dutch words.
  *
@@ -51,7 +53,7 @@ export type CurrencyOptions = {
  * toCardinal(1, {accentOne: false})     // 'een'
  * toCardinal(1104)                      // 'elfhonderd vier'
  */
-export function toCardinal(value: number | string | bigint, options?: CardinalOptions): string;
+declare function toCardinal(value: number | string | bigint, options?: CardinalOptions): string;
 /**
  * Converts a number to Dutch ordinal words.
  * @param {number | string | bigint} value - The number to convert
@@ -61,7 +63,19 @@ export function toCardinal(value: number | string | bigint, options?: CardinalOp
  * toOrdinal(21)    // 'eenentwintigste'
  * toOrdinal(100)   // 'honderdste'
  */
-export function toOrdinal(value: number | string | bigint): string;
+declare function toOrdinal(value: number | string | bigint): string;
+export type CurrencyOptions = {
+    /**
+     * - Include "en" between euros and cents
+     */
+    and?: boolean;
+};
+/**
+ * @typedef {object} CurrencyOptions
+ * @property {boolean} [and] - Include "en" between euros and cents
+ */
+/** @type {Required<CurrencyOptions>} */
+export declare const currencyDefaults: Required<CurrencyOptions>;
 /**
  * Converts a number to Dutch currency words (Euro).
  * @param {number | string | bigint} value - The amount to convert
@@ -72,4 +86,5 @@ export function toOrdinal(value: number | string | bigint): string;
  * toCurrency(1)      // 'één euro'
  * toCurrency(0.01)   // 'één 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/pa-IN.d.ts

@@ -1,12 +1,23 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
+/**
+ * Punjabi (India) language converter
+ *
+ * CLDR: pa-IN | Punjabi (Gurmukhi) as used in India
+ *
+ * Key features:
+ * - Indian numbering system (ਹਜ਼ਾਰ, ਲੱਖ, ਕਰੋੜ)
+ * - Gurmukhi script
+ * - 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 Punjabi words.
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The number in Punjabi words
  */
-export function toCardinal(value: number | string | bigint): string;
+declare function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Punjabi 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 Punjabi currency words (Indian Rupee).
  * @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/pl-PL.d.ts

@@ -1,21 +1,33 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
 /**
- * @typedef {object} CardinalOptions
- * @property {('masculine'|'feminine')} [gender] - Gender for numbers < 1000
+ * Polish (Poland) language converter
+ *
+ * CLDR: pl-PL | Polish as used in Poland
+ *
+ * Polish-specific rules:
+ * - Three-form pluralization: 1 = singular, 2-4 = few, 5+ = many
+ * - Gender agreement (masculine/feminine for numbers < 1000)
+ * - Omit "jeden" before scale words (tysiąc, milion, etc.)
+ * - Irregular hundreds: dwieście, trzysta, czterysta, pięćset...
+ * - Long scale with -ard forms: miliard, biliard, tryliard
  */
-/** @type {Required<CardinalOptions>} */
-export const cardinalDefaults: Required<CardinalOptions>;
-/** @type {{ gender: ReadonlyArray<Required<CardinalOptions>['gender']> }} */
-export const cardinalValues: {
-    gender: ReadonlyArray<Required<CardinalOptions>["gender"]>;
-};
+export declare const cardinalMax: bigint;
+export declare const ordinalMax: bigint;
+export declare const currencyMax: bigint;
 export type CardinalOptions = {
     /**
      * - Gender for numbers < 1000
      */
-    gender?: "feminine" | "masculine" | undefined;
+    gender?: ('masculine' | 'feminine');
+};
+/**
+ * @typedef {object} CardinalOptions
+ * @property {('masculine'|'feminine')} [gender] - Gender for numbers < 1000
+ */
+/** @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 Polish words.
@@ -33,7 +45,7 @@ export type CardinalOptions = {
  * toCardinal(1000)                       // 'tysiąc'
  * toCardinal(2000)                       // 'dwa tysiące'
  */
-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 Polish ordinal words (masculine nominative).
  * @param {number | string | bigint} value - The numeric value to convert (must be a positive integer)
@@ -49,7 +61,7 @@ export function toCardinal(value: number | string | bigint, options?: CardinalOp
  * toOrdinal(100)  // 'setny'
  * toOrdinal(1000) // 'tysięczny'
  */
-export function toOrdinal(value: number | string | bigint): string;
+declare function toOrdinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Polish currency words (Polish Złoty).
  * @param {number | string | bigint} value - The currency amount to convert
@@ -62,4 +74,5 @@ export function toOrdinal(value: number | string | bigint): string;
  * toCurrency(1.50)   // 'jeden złoty pięćdziesiąt groszy'
  * toCurrency(-5)     // 'minus pięć złotych'
  */
-export function toCurrency(value: number | string | bigint): string;
+declare function toCurrency(value: number | string | bigint): string;
+export { toCardinal, toOrdinal, toCurrency };

package/src/pt-BR.d.ts

@@ -1,35 +1,47 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
 /**
- * @typedef {object} CurrencyOptions
- * @property {boolean} [and] - Include "e" between major and minor units
- * @property {string} [currency] - Currency code (e.g., 'BRL', 'USD'); empty means auto-detect for pt-BR
+ * Portuguese (Brazil) language converter
+ *
+ * CLDR: pt-BR | Brazilian Portuguese as used in Brazil
+ *
+ * Portuguese-specific rules:
+ * - "e" conjunction between units, tens and hundreds: vinte e um, cento e um
+ * - "cem" for exact 100, "cento" for 100+ remainder
+ * - Irregular hundreds: duzentos, trezentos, quatrocentos, etc.
+ * - Short scale: milhão (10^6), bilhão (10^9), trilhão (10^12)
+ * - Omit "um" before "mil"
  */
-/** @type {Required<CurrencyOptions>} */
-export const currencyDefaults: Required<CurrencyOptions>;
-export type CurrencyOptions = {
-    /**
-     * - Include "e" between major and minor units
-     */
-    and?: boolean | undefined;
-    /**
-     * - Currency code (e.g., 'BRL', 'USD'); empty means auto-detect for pt-BR
-     */
-    currency?: string | undefined;
-};
+export declare const cardinalMax: bigint;
+export declare const ordinalMax: bigint;
+export declare const currencyMax: bigint;
 /**
  * Converts a numeric value to Portuguese words.
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The number in Portuguese words
  */
-export function toCardinal(value: number | string | bigint): string;
+declare function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a number to Portuguese ordinal words.
  * @param {number | string | bigint} value - The number to convert
  * @returns {string} Portuguese ordinal words
  */
-export function toOrdinal(value: number | string | bigint): string;
+declare function toOrdinal(value: number | string | bigint): string;
+export type CurrencyOptions = {
+    /**
+     * - Include "e" between major and minor units
+     */
+    and?: boolean;
+    /**
+     * - Currency code (e.g., 'BRL', 'USD'); empty means auto-detect for pt-BR
+     */
+    currency?: string;
+};
+/**
+ * @typedef {object} CurrencyOptions
+ * @property {boolean} [and] - Include "e" between major and minor units
+ * @property {string} [currency] - Currency code (e.g., 'BRL', 'USD'); empty means auto-detect for pt-BR
+ */
+/** @type {Required<CurrencyOptions>} */
+export declare const currencyDefaults: Required<CurrencyOptions>;
 /**
  * Converts a number to Brazilian Portuguese currency words.
  * @param {number | string | bigint} value - The amount to convert
@@ -39,4 +51,5 @@ export function toOrdinal(value: number | string | bigint): string;
  * toCurrency(42.50)                    // 'quarenta e dois reais e cinquenta centavos'
  * toCurrency(42.50, {currency: 'USD'}) // 'quarenta e dois dólares e cinquenta centavos'
  */
-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/pt-PT.d.ts

@@ -1,18 +1,18 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
 /**
- * @typedef {object} CurrencyOptions
- * @property {boolean} [and] - Include "e" between euros and cents
+ * Portuguese (Portugal) language converter
+ *
+ * CLDR: pt-PT | European Portuguese as used in Portugal
+ *
+ * Portuguese-specific rules:
+ * - "e" conjunction everywhere: vinte e um, cento e um, mil e um
+ * - "cem" for exact 100, "cento" for 100+ remainder
+ * - Irregular hundreds: duzentos, trezentos, quatrocentos, etc.
+ * - Long scale: milhão (10^6), mil milhões (10^9), bilião (10^12)
+ * - Omit "um" before "mil"
  */
-/** @type {Required<CurrencyOptions>} */
-export const currencyDefaults: Required<CurrencyOptions>;
-export type CurrencyOptions = {
-    /**
-     * - Include "e" 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 Portuguese words.
  *
@@ -27,7 +27,7 @@ export type CurrencyOptions = {
  * toCardinal(100)          // 'cem'
  * toCardinal(1000000)      // 'um milhão'
  */
-export function toCardinal(value: number | string | bigint): string;
+declare function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a number to Portuguese ordinal words.
  * @param {number | string | bigint} value - The number to convert
@@ -37,7 +37,19 @@ export function toCardinal(value: number | string | bigint): string;
  * toOrdinal(21)    // 'vigésimo primeiro'
  * toOrdinal(100)   // 'centésimo'
  */
-export function toOrdinal(value: number | string | bigint): string;
+declare function toOrdinal(value: number | string | bigint): string;
+export type CurrencyOptions = {
+    /**
+     * - Include "e" between euros and cents
+     */
+    and?: boolean;
+};
+/**
+ * @typedef {object} CurrencyOptions
+ * @property {boolean} [and] - Include "e" between euros and cents
+ */
+/** @type {Required<CurrencyOptions>} */
+export declare const currencyDefaults: Required<CurrencyOptions>;
 /**
  * Converts a number to Portuguese currency words (Euro).
  * @param {number | string | bigint} value - The amount to convert
@@ -48,4 +60,5 @@ export function toOrdinal(value: number | string | bigint): string;
  * toCurrency(1)      // 'um euro'
  * toCurrency(0.01)   // 'um cêntimo'
  */
-export function toCurrency(value: number | string | bigint, options?: CurrencyOptions): string;
+declare function toCurrency(value: number | string | bigint, options?: CurrencyOptions): string;
+export { toCardinal, toOrdinal, toCurrency };