@attrx/role-morphic 0.1.0 → 0.2.0

package/dist/format-Be15LzfS.d.ts

@@ -0,0 +1,668 @@
+import { A as AreaUnit, L as LengthUnit, M as MassUnit, V as VolumeUnit, S as SpeedUnit, E as EnergyUnit, P as PowerUnit, b as PressureUnit, F as FrequencyUnit, a as AngleUnit, T as TimeUnit, D as DigitalUnit } from './constants-BZdBwuvJ.js';
+import { T as TemperatureUnit, r as ColorVariant, e as ColorFormatOptions, o as DateVariant, c as DateFormatOptions } from './types-mbeS1e-k.js';
+
+/**
+ * Area Role - Format Pillar
+ *
+ * Formata valores de área para apresentação.
+ *
+ * @example
+ * import { formatArea } from '@attrx/role-morphic/area/format';
+ *
+ * formatArea('hectare', 2.5);                      // "2.5 ha"
+ * formatArea('hectare', 2.5, { verbose: true });   // "2.5 hectares"
+ * formatArea('hectare', 1000, { locale: 'pt-BR' }); // "1.000 ha"
+ */
+
+interface AreaFormatOptions {
+    /** Casas decimais (default: 2) */
+    decimals?: number;
+    /** Usa nome completo ao invés de símbolo */
+    verbose?: boolean;
+    /** Locale para formatação de número */
+    locale?: string;
+    /** Notação numérica */
+    notation?: "standard" | "scientific" | "compact";
+}
+/**
+ * Formata valor de área para apresentação
+ *
+ * @param variant - Unidade do valor
+ * @param value - Valor numérico
+ * @param options - Opções de formatação
+ * @returns String formatada
+ *
+ * @example
+ * formatArea('hectare', 2.5);                        // "2.5 ha"
+ * formatArea('hectare', 2.5, { verbose: true });     // "2.5 hectares"
+ * formatArea('hectare', 1, { verbose: true });       // "1 hectare"
+ * formatArea('hectare', 1000, { locale: 'pt-BR' });  // "1.000 ha"
+ * formatArea('hectare', 1500, { decimals: 0 });      // "1500 ha"
+ */
+declare function formatArea(variant: AreaUnit, value: number, options?: AreaFormatOptions): string;
+
+/**
+ * Length Role - Format Pillar
+ *
+ * Formata valores de comprimento para apresentação.
+ *
+ * @example
+ * import { formatLength } from '@attrx/role-morphic/length/format';
+ *
+ * formatLength('kilometer', 42.195);                      // "42.2 km"
+ * formatLength('kilometer', 42.195, { verbose: true });   // "42.2 kilometers"
+ * formatLength('meter', 1000, { locale: 'pt-BR' });       // "1.000 m"
+ */
+
+interface LengthFormatOptions {
+    /** Casas decimais (default: 2) */
+    decimals?: number;
+    /** Usa nome completo ao invés de símbolo */
+    verbose?: boolean;
+    /** Locale para formatação de número */
+    locale?: string;
+    /** Notação numérica */
+    notation?: "standard" | "scientific" | "compact";
+}
+/**
+ * Formata valor de comprimento para apresentação
+ *
+ * @param variant - Unidade do valor
+ * @param value - Valor numérico
+ * @param options - Opções de formatação
+ * @returns String formatada
+ *
+ * @example
+ * formatLength('kilometer', 42.195);                        // "42.2 km"
+ * formatLength('kilometer', 42.195, { verbose: true });     // "42.2 kilometers"
+ * formatLength('kilometer', 1, { verbose: true });          // "1 kilometer"
+ * formatLength('meter', 1000, { locale: 'pt-BR' });         // "1.000 m"
+ * formatLength('meter', 1500, { decimals: 0 });             // "1500 m"
+ */
+declare function formatLength(variant: LengthUnit, value: number, options?: LengthFormatOptions): string;
+
+/**
+ * Mass Role - Format Pillar
+ *
+ * Formata valores de massa para apresentação.
+ *
+ * @example
+ * import { formatMass } from '@attrx/role-morphic/mass/format';
+ *
+ * formatMass('kilogram', 75.5);                      // "75.5 kg"
+ * formatMass('kilogram', 75.5, { verbose: true });   // "75.5 kilograms"
+ * formatMass('pound', 1000, { locale: 'en-US' });    // "1,000 lb"
+ */
+
+interface MassFormatOptions {
+    /** Casas decimais (default: 2) */
+    decimals?: number;
+    /** Usa nome completo ao invés de símbolo */
+    verbose?: boolean;
+    /** Locale para formatação de número */
+    locale?: string;
+    /** Notação numérica */
+    notation?: "standard" | "scientific" | "compact";
+}
+/**
+ * Formata valor de massa para apresentação
+ *
+ * @param variant - Unidade do valor
+ * @param value - Valor numérico
+ * @param options - Opções de formatação
+ * @returns String formatada
+ *
+ * @example
+ * formatMass('kilogram', 75.5);                        // "75.5 kg"
+ * formatMass('kilogram', 75.5, { verbose: true });     // "75.5 kilograms"
+ * formatMass('kilogram', 1, { verbose: true });        // "1 kilogram"
+ * formatMass('pound', 1000, { locale: 'en-US' });      // "1,000 lb"
+ * formatMass('gram', 1500, { decimals: 0 });           // "1500 g"
+ */
+declare function formatMass(variant: MassUnit, value: number, options?: MassFormatOptions): string;
+
+/**
+ * Temperature Role - Format Pillar
+ *
+ * Formata valores de temperatura para apresentação.
+ *
+ * @example
+ * import { formatTemperature } from '@attrx/role-morphic/temperature/format';
+ *
+ * formatTemperature('celsius', 37);                        // "37°C"
+ * formatTemperature('fahrenheit', 98.6, { verbose: true }); // "98.6 degrees Fahrenheit"
+ * formatTemperature('kelvin', 273.15);                     // "273.15 K"
+ */
+
+interface TemperatureFormatOptions {
+    /** Casas decimais (default: 2) */
+    decimals?: number;
+    /** Usa nome completo ao invés de símbolo */
+    verbose?: boolean;
+    /** Locale para formatação de número */
+    locale?: string;
+    /** Notação numérica */
+    notation?: "standard" | "scientific" | "compact";
+}
+/**
+ * Formata valor de temperatura para apresentação
+ *
+ * @param variant - Unidade do valor
+ * @param value - Valor numérico
+ * @param options - Opções de formatação
+ * @returns String formatada
+ *
+ * @example
+ * formatTemperature('celsius', 37);                          // "37°C"
+ * formatTemperature('fahrenheit', 98.6);                     // "98.6°F"
+ * formatTemperature('kelvin', 273.15);                       // "273.15 K"
+ * formatTemperature('celsius', 37, { verbose: true });       // "37 degrees Celsius"
+ * formatTemperature('celsius', 1000, { locale: 'pt-BR' });   // "1.000°C"
+ */
+declare function formatTemperature(variant: TemperatureUnit, value: number, options?: TemperatureFormatOptions): string;
+
+/**
+ * Volume Role - Format Pillar
+ *
+ * Formata valores de volume para apresentação.
+ *
+ * @example
+ * import { formatVolume } from '@attrx/role-morphic/volume/format';
+ *
+ * formatVolume('liter', 2.5);                      // "2.5 L"
+ * formatVolume('liter', 2.5, { verbose: true });   // "2.5 liters"
+ * formatVolume('milliliter', 1000, { locale: 'pt-BR' }); // "1.000 mL"
+ */
+
+interface VolumeFormatOptions {
+    /** Casas decimais (default: 2) */
+    decimals?: number;
+    /** Usa nome completo ao invés de símbolo */
+    verbose?: boolean;
+    /** Locale para formatação de número */
+    locale?: string;
+    /** Notação numérica */
+    notation?: "standard" | "scientific" | "compact";
+}
+/**
+ * Formata valor de volume para apresentação
+ *
+ * @param variant - Unidade do valor
+ * @param value - Valor numérico
+ * @param options - Opções de formatação
+ * @returns String formatada
+ *
+ * @example
+ * formatVolume('liter', 2.5);                        // "2.5 L"
+ * formatVolume('liter', 2.5, { verbose: true });     // "2.5 liters"
+ * formatVolume('liter', 1, { verbose: true });       // "1 liter"
+ * formatVolume('milliliter', 1000, { locale: 'pt-BR' }); // "1.000 mL"
+ * formatVolume('gallon_us', 5, { decimals: 0 });     // "5 gal"
+ */
+declare function formatVolume(variant: VolumeUnit, value: number, options?: VolumeFormatOptions): string;
+
+/**
+ * Speed Role - Format Pillar
+ *
+ * Formata valores de velocidade para apresentação.
+ *
+ * @example
+ * import { formatSpeed } from '@attrx/role-morphic/speed/format';
+ *
+ * formatSpeed('kilometer_per_hour', 120);                        // "120 km/h"
+ * formatSpeed('kilometer_per_hour', 120, { verbose: true });     // "120 kilometers per hour"
+ * formatSpeed('mile_per_hour', 60);                              // "60 mph"
+ */
+
+interface SpeedFormatOptions {
+    /** Casas decimais (default: 2) */
+    decimals?: number;
+    /** Usa nome completo ao invés de símbolo */
+    verbose?: boolean;
+    /** Locale para formatação de número */
+    locale?: string;
+    /** Notação numérica */
+    notation?: "standard" | "scientific" | "compact";
+}
+/**
+ * Formata valor de velocidade para apresentação
+ *
+ * @param variant - Unidade do valor
+ * @param value - Valor numérico
+ * @param options - Opções de formatação
+ * @returns String formatada
+ *
+ * @example
+ * formatSpeed('kilometer_per_hour', 120);                        // "120 km/h"
+ * formatSpeed('kilometer_per_hour', 120, { verbose: true });     // "120 kilometers per hour"
+ * formatSpeed('kilometer_per_hour', 1, { verbose: true });       // "1 kilometer per hour"
+ * formatSpeed('mile_per_hour', 1000, { locale: 'en-US' });       // "1,000 mph"
+ */
+declare function formatSpeed(variant: SpeedUnit, value: number, options?: SpeedFormatOptions): string;
+
+/**
+ * Energy Role - Format Pillar
+ *
+ * Formata valores de energia para apresentação.
+ *
+ * @example
+ * import { formatEnergy } from '@attrx/role-morphic/energy/format';
+ *
+ * formatEnergy('kilowatt_hour', 2.5);                      // "2.5 kWh"
+ * formatEnergy('kilowatt_hour', 2.5, { verbose: true });   // "2.5 kilowatt-hours"
+ * formatEnergy('joule', 1000, { locale: 'pt-BR' });        // "1.000 J"
+ */
+
+interface EnergyFormatOptions {
+    /** Casas decimais (default: 2) */
+    decimals?: number;
+    /** Usa nome completo ao invés de símbolo */
+    verbose?: boolean;
+    /** Locale para formatação de número */
+    locale?: string;
+    /** Notação numérica */
+    notation?: "standard" | "scientific" | "compact";
+}
+/**
+ * Formata valor de energia para apresentação
+ *
+ * @param variant - Unidade do valor
+ * @param value - Valor numérico
+ * @param options - Opções de formatação
+ * @returns String formatada
+ *
+ * @example
+ * formatEnergy('kilowatt_hour', 2.5);                        // "2.5 kWh"
+ * formatEnergy('kilowatt_hour', 2.5, { verbose: true });     // "2.5 kilowatt-hours"
+ * formatEnergy('kilowatt_hour', 1, { verbose: true });       // "1 kilowatt-hour"
+ * formatEnergy('joule', 1000, { locale: 'pt-BR' });          // "1.000 J"
+ * formatEnergy('kilocalorie', 1500, { decimals: 0 });        // "1500 kcal"
+ */
+declare function formatEnergy(variant: EnergyUnit, value: number, options?: EnergyFormatOptions): string;
+
+/**
+ * Power Role - Format Pillar
+ *
+ * Formatação de valores de potência para exibição.
+ *
+ * @example
+ * import { formatPower, getPowerSymbol, getPowerName } from '@attrx/role-morphic/power/format';
+ *
+ * formatPower('kilowatt', 2.5);                     // "2.5 kW"
+ * formatPower('kilowatt', 2.5, { verbose: true });  // "2.5 kilowatts"
+ * getPowerSymbol('kilowatt');                       // "kW"
+ * getPowerName('kilowatt', 2);                      // "kilowatts"
+ */
+
+interface PowerFormatOptions {
+    /** Número de casas decimais */
+    decimals?: number;
+    /** Usar nome completo ao invés de símbolo */
+    verbose?: boolean;
+    /** Locale para formatação numérica */
+    locale?: string;
+    /** Notação: standard, scientific, compact */
+    notation?: "standard" | "scientific" | "compact";
+}
+/**
+ * Formata valor de potência para exibição
+ *
+ * @param variant - Unidade
+ * @param value - Valor numérico
+ * @param options - Opções de formatação
+ * @returns String formatada
+ *
+ * @example
+ * formatPower('kilowatt', 2.5);                     // "2.5 kW"
+ * formatPower('kilowatt', 2.5, { verbose: true });  // "2.5 kilowatts"
+ * formatPower('kilowatt', 1, { verbose: true });    // "1 kilowatt"
+ * formatPower('watt', 1000, { decimals: 0 });       // "1000 W"
+ */
+declare function formatPower(variant: PowerUnit, value: number, options?: PowerFormatOptions): string;
+
+/**
+ * Pressure Role - Format Pillar
+ *
+ * Formatação de valores de pressão para exibição.
+ *
+ * @example
+ * import { formatPressure, getPressureSymbol, getPressureName } from '@attrx/role-morphic/pressure/format';
+ *
+ * formatPressure('bar', 2.5);                     // "2.5 bar"
+ * formatPressure('bar', 2.5, { verbose: true });  // "2.5 bar"
+ * getPressureSymbol('pascal');                    // "Pa"
+ * getPressureName('atmosphere', 2);               // "atmospheres"
+ */
+
+interface PressureFormatOptions {
+    /** Número de casas decimais */
+    decimals?: number;
+    /** Usar nome completo ao invés de símbolo */
+    verbose?: boolean;
+    /** Locale para formatação numérica */
+    locale?: string;
+    /** Notação: standard, scientific, compact */
+    notation?: "standard" | "scientific" | "compact";
+}
+/**
+ * Formata valor de pressão para exibição
+ *
+ * @param variant - Unidade
+ * @param value - Valor numérico
+ * @param options - Opções de formatação
+ * @returns String formatada
+ *
+ * @example
+ * formatPressure('bar', 2.5);                     // "2.5 bar"
+ * formatPressure('bar', 2.5, { verbose: true });  // "2.5 bar"
+ * formatPressure('atmosphere', 1, { verbose: true }); // "1 atmosphere"
+ * formatPressure('pascal', 1000, { decimals: 0 }); // "1000 Pa"
+ */
+declare function formatPressure(variant: PressureUnit, value: number, options?: PressureFormatOptions): string;
+
+/**
+ * Frequency Role - Format Pillar
+ *
+ * Formatação de valores de frequência para exibição.
+ *
+ * @example
+ * import { formatFrequency, getFrequencySymbol, getFrequencyName } from '@attrx/role-morphic/frequency/format';
+ *
+ * formatFrequency('gigahertz', 2.4);                     // "2.4 GHz"
+ * formatFrequency('gigahertz', 2.4, { verbose: true });  // "2.4 gigahertz"
+ * getFrequencySymbol('megahertz');                       // "MHz"
+ * getFrequencyName('hertz', 2);                          // "hertz"
+ */
+
+interface FrequencyFormatOptions {
+    /** Número de casas decimais */
+    decimals?: number;
+    /** Usar nome completo ao invés de símbolo */
+    verbose?: boolean;
+    /** Locale para formatação numérica */
+    locale?: string;
+    /** Notação: standard, scientific, compact */
+    notation?: "standard" | "scientific" | "compact";
+}
+/**
+ * Formata valor de frequência para exibição
+ *
+ * @param variant - Unidade
+ * @param value - Valor numérico
+ * @param options - Opções de formatação
+ * @returns String formatada
+ *
+ * @example
+ * formatFrequency('gigahertz', 2.4);                     // "2.4 GHz"
+ * formatFrequency('gigahertz', 2.4, { verbose: true });  // "2.4 gigahertz"
+ * formatFrequency('hertz', 1, { verbose: true });        // "1 hertz"
+ * formatFrequency('megahertz', 100, { decimals: 0 });    // "100 MHz"
+ */
+declare function formatFrequency(variant: FrequencyUnit, value: number, options?: FrequencyFormatOptions): string;
+
+/**
+ * Angle Role - Format Pillar
+ *
+ * Formatação de valores de ângulo para exibição.
+ *
+ * @example
+ * import { formatAngle, getAngleSymbol, getAngleName } from '@attrx/role-morphic/angle/format';
+ *
+ * formatAngle('degree', 45);                     // "45°"
+ * formatAngle('degree', 45, { verbose: true });  // "45 degrees"
+ * getAngleSymbol('degree');                      // "°"
+ * getAngleName('degree', 2);                     // "degrees"
+ */
+
+interface AngleFormatOptions {
+    /** Número de casas decimais */
+    decimals?: number;
+    /** Usar nome completo ao invés de símbolo */
+    verbose?: boolean;
+    /** Locale para formatação numérica */
+    locale?: string;
+    /** Notação: standard, scientific, compact */
+    notation?: "standard" | "scientific" | "compact";
+}
+/**
+ * Formata valor de ângulo para exibição
+ *
+ * @param variant - Unidade
+ * @param value - Valor numérico
+ * @param options - Opções de formatação
+ * @returns String formatada
+ *
+ * @example
+ * formatAngle('degree', 45);                     // "45°"
+ * formatAngle('degree', 45, { verbose: true });  // "45 degrees"
+ * formatAngle('radian', 3.14159);                // "3.14159 rad"
+ * formatAngle('degree', 90, { decimals: 0 });    // "90°"
+ */
+declare function formatAngle(variant: AngleUnit, value: number, options?: AngleFormatOptions): string;
+
+/**
+ * Time Role - Format Pillar
+ *
+ * Formatação de valores de tempo para exibição.
+ *
+ * @example
+ * import { formatTime, getTimeSymbol, getTimeName } from '@attrx/role-morphic/time/format';
+ *
+ * formatTime('hour', 2.5);                     // "2.5 h"
+ * formatTime('hour', 2.5, { verbose: true });  // "2.5 hours"
+ * getTimeSymbol('minute');                     // "min"
+ * getTimeName('hour', 2);                      // "hours"
+ */
+
+interface TimeFormatOptions {
+    /** Número de casas decimais */
+    decimals?: number;
+    /** Usar nome completo ao invés de símbolo */
+    verbose?: boolean;
+    /** Locale para formatação numérica */
+    locale?: string;
+    /** Notação: standard, scientific, compact */
+    notation?: "standard" | "scientific" | "compact";
+}
+/**
+ * Formata valor de tempo para exibição
+ *
+ * @param variant - Unidade
+ * @param value - Valor numérico
+ * @param options - Opções de formatação
+ * @returns String formatada
+ *
+ * @example
+ * formatTime('hour', 2.5);                     // "2.5 h"
+ * formatTime('hour', 2.5, { verbose: true });  // "2.5 hours"
+ * formatTime('second', 1, { verbose: true });  // "1 second"
+ * formatTime('millisecond', 100, { decimals: 0 }); // "100 ms"
+ */
+declare function formatTime(variant: TimeUnit, value: number, options?: TimeFormatOptions): string;
+
+/**
+ * Digital Role - Format Pillar
+ *
+ * Formatação de valores de armazenamento digital para exibição.
+ *
+ * @example
+ * import { formatDigital, getDigitalSymbol, getDigitalName } from '@attrx/role-morphic/digital/format';
+ *
+ * formatDigital('gigabyte', 2.5);                     // "2.5 GB"
+ * formatDigital('gigabyte', 2.5, { verbose: true });  // "2.5 gigabytes"
+ * getDigitalSymbol('mebibyte');                       // "MiB"
+ * getDigitalName('byte', 2);                          // "bytes"
+ */
+
+interface DigitalFormatOptions {
+    /** Número de casas decimais */
+    decimals?: number;
+    /** Usar nome completo ao invés de símbolo */
+    verbose?: boolean;
+    /** Locale para formatação numérica */
+    locale?: string;
+    /** Notação: standard, scientific, compact */
+    notation?: "standard" | "scientific" | "compact";
+}
+/**
+ * Formata valor de armazenamento digital para exibição
+ *
+ * @param variant - Unidade
+ * @param value - Valor numérico
+ * @param options - Opções de formatação
+ * @returns String formatada
+ *
+ * @example
+ * formatDigital('gigabyte', 2.5);                     // "2.5 GB"
+ * formatDigital('gigabyte', 2.5, { verbose: true });  // "2.5 gigabytes"
+ * formatDigital('byte', 1, { verbose: true });        // "1 byte"
+ * formatDigital('mebibyte', 100, { decimals: 0 });    // "100 MiB"
+ */
+declare function formatDigital(variant: DigitalUnit, value: number, options?: DigitalFormatOptions): string;
+
+/**
+ * Color Role - Format Pillar
+ *
+ * Formatação de cores para apresentação.
+ *
+ * @example
+ * import { formatColor } from '@attrx/role-morphic/color/format';
+ *
+ * formatColor('hex', '#ff0000', { uppercase: true }); // '#FF0000'
+ * formatColor('rgb_string', { r: 255, g: 0, b: 0 });  // 'rgb(255, 0, 0)'
+ */
+
+/**
+ * Formata cor para apresentação
+ *
+ * @param variant - Variante de saída
+ * @param value - Valor da cor (qualquer variante)
+ * @param options - Opções de formatação
+ * @returns String formatada
+ *
+ * @example
+ * formatColor('hex', '#ff0000', { uppercase: true });
+ * // '#FF0000'
+ *
+ * formatColor('rgb_string', { r: 255, g: 0, b: 0 });
+ * // 'rgb(255, 0, 0)'
+ *
+ * formatColor('hex', '#ff0000', { compact: true });
+ * // '#f00'
+ */
+declare function formatColor(variant: ColorVariant, value: unknown, options?: ColorFormatOptions): string;
+
+/**
+ * Date Role - Format Pillar
+ *
+ * Formatação de datas para apresentação.
+ *
+ * @example
+ * import { formatDate, formatIso, formatTimestamp } from '@attrx/role-morphic/date/format';
+ *
+ * formatDate('iso', '2024-12-05T19:30:00.000Z', { dateStyle: 'full', locale: 'pt-BR' });
+ * // "quinta-feira, 5 de dezembro de 2024"
+ */
+
+/**
+ * Formata data para apresentação
+ *
+ * @param variant - Variante da data ("iso", "timestamp", "epoch")
+ * @param value - Valor da data
+ * @param options - Opções de formatação
+ * @returns String formatada
+ *
+ * @example
+ * formatDate('iso', '2024-12-05T19:30:00.000Z', { dateStyle: 'full', locale: 'pt-BR' });
+ * // 'quinta-feira, 5 de dezembro de 2024'
+ *
+ * formatDate('timestamp', 1733425800000, { dateOnly: true, dateStyle: 'medium' });
+ * // 'Dec 5, 2024'
+ */
+declare function formatDate(variant: DateVariant, value: unknown, options?: DateFormatOptions): string;
+
+/**
+ * Currency Role - Constants
+ *
+ * Códigos de moeda, símbolos e configurações de formatação.
+ *
+ * Currency é sobre VALOR MONETÁRIO, não sobre tipos de moeda.
+ * O código da moeda (BRL, USD, etc) é METADATA usado apenas para formatação.
+ *
+ * NÃO há conversão entre moedas - isso é operação de negócio com taxas externas.
+ */
+/**
+ * Códigos de moeda ISO 4217
+ */
+type CurrencyCode = "USD" | "EUR" | "GBP" | "JPY" | "CHF" | "CNY" | "CAD" | "AUD" | "BRL" | "MXN" | "ARS" | "CLP" | "COP" | "INR" | "KRW" | "RUB" | "TRY" | "ZAR";
+/**
+ * Configuração de uma moeda para formatação
+ */
+interface CurrencyConfig {
+    /** Código ISO 4217 */
+    code: CurrencyCode;
+    /** Símbolo da moeda */
+    symbol: string;
+    /** Nome singular */
+    singular: string;
+    /** Nome plural */
+    plural: string;
+    /** Casas decimais padrão */
+    decimals: number;
+    /** Símbolo vem antes do valor? */
+    symbolFirst: boolean;
+    /** Separador de milhares */
+    thousandsSeparator: string;
+    /** Separador decimal */
+    decimalSeparator: string;
+}
+
+/**
+ * Currency Role - Format Pillar
+ *
+ * Formata valores monetários para apresentação.
+ * Usa metadata (código da moeda) para determinar formatação.
+ *
+ * @example
+ * import { formatCurrency } from '@attrx/role-morphic/currency/format';
+ *
+ * formatCurrency(1500.50, { currency: 'BRL' });  // "R$ 1.500,50"
+ * formatCurrency(1000, { currency: 'USD' });     // "$1,000.00"
+ * formatCurrency(99.99, { currency: 'EUR' });    // "99,99 €"
+ */
+
+interface CurrencyFormatOptions {
+    /** Código da moeda (obrigatório) */
+    currency: CurrencyCode;
+    /** Casas decimais (default: decimais padrão da moeda) */
+    decimals?: number;
+    /** Usa nome completo ao invés de símbolo */
+    verbose?: boolean;
+    /** Esconde símbolo, retorna só o número formatado */
+    hideSymbol?: boolean;
+    /** Força símbolo antes do valor */
+    symbolFirst?: boolean;
+    /** Usa Intl.NumberFormat com locale */
+    locale?: string;
+    /** Mostra sinal de positivo para valores positivos */
+    showPositiveSign?: boolean;
+}
+/**
+ * Formata valor monetário para apresentação
+ *
+ * @param value - Valor numérico
+ * @param options - Opções de formatação (currency obrigatório)
+ * @returns String formatada
+ *
+ * @example
+ * formatCurrency(1500.50, { currency: 'BRL' });                    // "R$ 1.500,50"
+ * formatCurrency(1000, { currency: 'USD' });                       // "$1,000.00"
+ * formatCurrency(99.99, { currency: 'EUR' });                      // "99,99 €"
+ * formatCurrency(1500, { currency: 'JPY' });                       // "¥1,500"
+ * formatCurrency(1500.50, { currency: 'BRL', verbose: true });     // "1.500,50 Brazilian reais"
+ * formatCurrency(1500.50, { currency: 'BRL', hideSymbol: true });  // "1.500,50"
+ * formatCurrency(1500.50, { currency: 'BRL', locale: 'pt-BR' });   // "R$ 1.500,50" (via Intl)
+ */
+declare function formatCurrency(value: number, options: CurrencyFormatOptions): string;
+
+export { type CurrencyFormatOptions as C, type CurrencyCode as a, formatLength as b, formatMass as c, formatTemperature as d, formatVolume as e, formatArea as f, formatSpeed as g, formatEnergy as h, formatPower as i, formatPressure as j, formatFrequency as k, formatAngle as l, formatTime as m, formatDigital as n, formatColor as o, formatDate as p, formatCurrency as q, type CurrencyConfig as r };