@attrx/role-morphic 0.1.0 → 0.2.0

package/dist/cast.d.ts

@@ -0,0 +1,678 @@
+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, o as DateVariant } from './types-mbeS1e-k.js';
+
+/**
+ * Area Role - Cast Pillar
+ *
+ * Normaliza input sujo para número tipado.
+ * Detecta unidades em strings e converte se necessário.
+ *
+ * @example
+ * import { castArea, castAreaStrict, detectAreaUnit } from '@attrx/role-morphic/area/cast';
+ *
+ * castArea('100 ha', 'hectare');     // 100
+ * castArea('100 ha', 'acre');        // 247.105... (converte)
+ * castAreaStrict('100 ha');          // 100 (não converte)
+ * detectAreaUnit('100 hectares');    // 'hectare'
+ */
+
+type Result$f<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Faz cast de input para número, detectando e convertendo unidade se presente
+ *
+ * @param input - Valor de entrada (number, string, etc)
+ * @param targetVariant - Unidade alvo para conversão
+ * @returns Número ou null se não puder converter
+ *
+ * @example
+ * castArea(100, 'hectare');            // 100
+ * castArea('100', 'hectare');          // 100
+ * castArea('100 ha', 'hectare');       // 100
+ * castArea('100 ha', 'acre');          // 247.105... (converte)
+ * castArea('100 acres', 'hectare');    // 40.4686... (converte)
+ * castArea('invalid', 'hectare');      // null
+ */
+declare function castArea(input: unknown, targetVariant?: AreaUnit): number | null;
+/**
+ * Versão safe de castArea que retorna Result
+ */
+declare function tryCastArea(input: unknown, targetVariant?: AreaUnit): Result$f<number>;
+
+/**
+ * Length Role - Cast Pillar
+ *
+ * Normaliza input sujo para número tipado.
+ * Detecta unidades em strings e converte se necessário.
+ *
+ * @example
+ * import { castLength, castLengthStrict, detectLengthUnit } from '@attrx/role-morphic/length/cast';
+ *
+ * castLength('100 km', 'kilometer');     // 100
+ * castLength('100 km', 'mile');          // 62.1371... (converte)
+ * castLengthStrict('100 km');            // 100 (não converte)
+ * detectLengthUnit('100 meters');        // 'meter'
+ */
+
+type Result$e<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Faz cast de input para número, detectando e convertendo unidade se presente
+ *
+ * @param input - Valor de entrada (number, string, etc)
+ * @param targetVariant - Unidade alvo para conversão
+ * @returns Número ou null se não puder converter
+ *
+ * @example
+ * castLength(100, 'meter');              // 100
+ * castLength('100', 'meter');            // 100
+ * castLength('100 km', 'kilometer');     // 100
+ * castLength('100 km', 'mile');          // 62.1371... (converte)
+ * castLength('1 mile', 'kilometer');     // 1.609344 (converte)
+ * castLength('invalid', 'meter');        // null
+ */
+declare function castLength(input: unknown, targetVariant?: LengthUnit): number | null;
+/**
+ * Versão safe de castLength que retorna Result
+ */
+declare function tryCastLength(input: unknown, targetVariant?: LengthUnit): Result$e<number>;
+
+/**
+ * Mass Role - Cast Pillar
+ *
+ * Normaliza input sujo para número tipado.
+ * Detecta unidades em strings e converte se necessário.
+ *
+ * @example
+ * import { castMass, castMassStrict, detectMassUnit } from '@attrx/role-morphic/mass/cast';
+ *
+ * castMass('100 kg', 'kilogram');     // 100
+ * castMass('100 lb', 'kilogram');     // 45.359237 (converte)
+ * castMassStrict('100 kg');           // 100 (não converte)
+ * detectMassUnit('100 pounds');       // 'pound'
+ */
+
+type Result$d<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Faz cast de input para número, detectando e convertendo unidade se presente
+ *
+ * @param input - Valor de entrada (number, string, etc)
+ * @param targetVariant - Unidade alvo para conversão
+ * @returns Número ou null se não puder converter
+ *
+ * @example
+ * castMass(100, 'kilogram');            // 100
+ * castMass('100', 'kilogram');          // 100
+ * castMass('100 kg', 'kilogram');       // 100
+ * castMass('100 lb', 'kilogram');       // 45.359237 (converte)
+ * castMass('100 pounds', 'gram');       // 45359.237 (converte)
+ * castMass('invalid', 'kilogram');      // null
+ */
+declare function castMass(input: unknown, targetVariant?: MassUnit): number | null;
+/**
+ * Versão safe de castMass que retorna Result
+ */
+declare function tryCastMass(input: unknown, targetVariant?: MassUnit): Result$d<number>;
+
+/**
+ * Temperature Role - Cast Pillar
+ *
+ * Normaliza input sujo para número tipado.
+ * Detecta unidades em strings e converte se necessário.
+ *
+ * @example
+ * import { castTemperature, castTemperatureStrict, detectTemperatureUnit } from '@attrx/role-morphic/temperature/cast';
+ *
+ * castTemperature('100 °C', 'celsius');       // 100
+ * castTemperature('32 °F', 'celsius');        // 0 (converte)
+ * castTemperatureStrict('100 °C');            // 100 (não converte)
+ * detectTemperatureUnit('100 degrees F');     // 'fahrenheit'
+ */
+
+type Result$c<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Faz cast de input para número, detectando e convertendo unidade se presente
+ *
+ * @param input - Valor de entrada (number, string, etc)
+ * @param targetVariant - Unidade alvo para conversão
+ * @returns Número ou null se não puder converter
+ *
+ * @example
+ * castTemperature(100, 'celsius');            // 100
+ * castTemperature('100', 'celsius');          // 100
+ * castTemperature('100 °C', 'celsius');       // 100
+ * castTemperature('32 °F', 'celsius');        // 0 (converte F → C)
+ * castTemperature('273.15 K', 'celsius');     // 0 (converte K → C)
+ * castTemperature('invalid', 'celsius');      // null
+ */
+declare function castTemperature(input: unknown, targetVariant?: TemperatureUnit): number | null;
+/**
+ * Versão safe de castTemperature que retorna Result
+ */
+declare function tryCastTemperature(input: unknown, targetVariant?: TemperatureUnit): Result$c<number>;
+
+/**
+ * Volume Role - Cast Pillar
+ *
+ * Normaliza input sujo para número tipado.
+ * Detecta unidades em strings e converte se necessário.
+ *
+ * @example
+ * import { castVolume, castVolumeStrict, detectVolumeUnit } from '@attrx/role-morphic/volume/cast';
+ *
+ * castVolume('500 ml', 'liter');       // 0.5 (converte)
+ * castVolume('1 gal', 'liter');        // 3.785411784 (converte)
+ * castVolumeStrict('500 ml');          // 500 (não converte)
+ * detectVolumeUnit('2 gallons');       // 'gallon_us'
+ */
+
+type Result$b<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Faz cast de input para número, detectando e convertendo unidade se presente
+ *
+ * @param input - Valor de entrada (number, string, etc)
+ * @param targetVariant - Unidade alvo para conversão
+ * @returns Número ou null se não puder converter
+ *
+ * @example
+ * castVolume(100, 'liter');              // 100
+ * castVolume('100', 'liter');            // 100
+ * castVolume('500 ml', 'liter');         // 0.5 (converte)
+ * castVolume('1 gal', 'liter');          // 3.785411784 (converte)
+ * castVolume('invalid', 'liter');        // null
+ */
+declare function castVolume(input: unknown, targetVariant?: VolumeUnit): number | null;
+/**
+ * Versão safe de castVolume que retorna Result
+ */
+declare function tryCastVolume(input: unknown, targetVariant?: VolumeUnit): Result$b<number>;
+
+/**
+ * Speed Role - Cast Pillar
+ *
+ * Normaliza input sujo para número tipado.
+ * Detecta unidades em strings e converte se necessário.
+ *
+ * @example
+ * import { castSpeed, castSpeedStrict, detectSpeedUnit } from '@attrx/role-morphic/speed/cast';
+ *
+ * castSpeed('100 km/h', 'meter_per_second');   // 27.7778... (converte)
+ * castSpeed('60 mph', 'kilometer_per_hour');   // 96.5606... (converte)
+ * castSpeedStrict('100 km/h');                 // 100 (não converte)
+ * detectSpeedUnit('60 miles per hour');        // 'mile_per_hour'
+ */
+
+type Result$a<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Faz cast de input para número, detectando e convertendo unidade se presente
+ *
+ * @param input - Valor de entrada (number, string, etc)
+ * @param targetVariant - Unidade alvo para conversão
+ * @returns Número ou null se não puder converter
+ *
+ * @example
+ * castSpeed(100, 'meter_per_second');              // 100
+ * castSpeed('100', 'meter_per_second');            // 100
+ * castSpeed('100 km/h', 'meter_per_second');       // 27.7778... (converte)
+ * castSpeed('60 mph', 'kilometer_per_hour');       // 96.5606... (converte)
+ * castSpeed('invalid', 'meter_per_second');        // null
+ */
+declare function castSpeed(input: unknown, targetVariant?: SpeedUnit): number | null;
+/**
+ * Versão safe de castSpeed que retorna Result
+ */
+declare function tryCastSpeed(input: unknown, targetVariant?: SpeedUnit): Result$a<number>;
+
+/**
+ * Energy Role - Cast Pillar
+ *
+ * Normaliza input sujo para número tipado.
+ * Detecta unidades em strings e converte se necessário.
+ *
+ * @example
+ * import { castEnergy, castEnergyStrict, detectEnergyUnit } from '@attrx/role-morphic/energy/cast';
+ *
+ * castEnergy('100 kWh', 'kilowatt_hour');     // 100
+ * castEnergy('100 BTU', 'joule');             // 105505.59 (converte)
+ * castEnergyStrict('100 kWh');                // 100 (não converte)
+ * detectEnergyUnit('100 kilocalories');       // 'kilocalorie'
+ */
+
+type Result$9<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Faz cast de input para número, detectando e convertendo unidade se presente
+ *
+ * @param input - Valor de entrada (number, string, etc)
+ * @param targetVariant - Unidade alvo para conversão
+ * @returns Número ou null se não puder converter
+ *
+ * @example
+ * castEnergy(100, 'joule');                   // 100
+ * castEnergy('100', 'joule');                 // 100
+ * castEnergy('100 kWh', 'kilowatt_hour');     // 100
+ * castEnergy('100 BTU', 'joule');             // 105505.59 (converte)
+ * castEnergy('1 kcal', 'kilojoule');          // 4.1868 (converte)
+ * castEnergy('invalid', 'joule');             // null
+ */
+declare function castEnergy(input: unknown, targetVariant?: EnergyUnit): number | null;
+/**
+ * Versão safe de castEnergy que retorna Result
+ */
+declare function tryCastEnergy(input: unknown, targetVariant?: EnergyUnit): Result$9<number>;
+
+/**
+ * Power Role - Cast Pillar
+ *
+ * Normaliza input sujo para número, com detecção automática de unidade.
+ *
+ * @example
+ * import { castPower, castPowerStrict, detectPowerUnit } from '@attrx/role-morphic/power/cast';
+ *
+ * castPower('100 kW');                      // 100000 (converted to watts)
+ * castPower('100 kW', 'kilowatt');          // 100 (kept as kilowatts)
+ * castPowerStrict('100');                   // 100 (no conversion)
+ * detectPowerUnit('100 hp');                // 'horsepower_mechanical'
+ */
+
+type Result$8<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Faz cast de input para número, com conversão opcional para unidade alvo
+ *
+ * @param input - Valor de entrada (number, string, etc)
+ * @param targetVariant - Unidade alvo (default: watt)
+ * @returns Número ou null se não puder converter
+ *
+ * @example
+ * castPower('100 kW');                 // 100000 (watts)
+ * castPower('100 kW', 'kilowatt');     // 100
+ * castPower('100');                    // 100
+ * castPower(100);                      // 100
+ * castPower('invalid');                // null
+ */
+declare function castPower(input: unknown, targetVariant?: PowerUnit): number | null;
+/**
+ * Versão safe de castPower que retorna Result
+ */
+declare function tryCastPower(input: unknown, targetVariant?: PowerUnit): Result$8<number>;
+
+/**
+ * Pressure Role - Cast Pillar
+ *
+ * Normaliza input sujo para número, com detecção automática de unidade.
+ *
+ * @example
+ * import { castPressure, castPressureStrict, detectPressureUnit } from '@attrx/role-morphic/pressure/cast';
+ *
+ * castPressure('1 bar');                      // 100000 (converted to pascals)
+ * castPressure('1 bar', 'bar');               // 1 (kept as bar)
+ * castPressureStrict('100');                  // 100 (no conversion)
+ * detectPressureUnit('14.7 psi');             // 'psi'
+ */
+
+type Result$7<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Faz cast de input para número, com conversão opcional para unidade alvo
+ *
+ * @param input - Valor de entrada (number, string, etc)
+ * @param targetVariant - Unidade alvo (default: pascal)
+ * @returns Número ou null se não puder converter
+ *
+ * @example
+ * castPressure('1 bar');            // 100000 (pascals)
+ * castPressure('1 bar', 'bar');     // 1
+ * castPressure('100');              // 100
+ * castPressure(100);                // 100
+ * castPressure('invalid');          // null
+ */
+declare function castPressure(input: unknown, targetVariant?: PressureUnit): number | null;
+/**
+ * Versão safe de castPressure que retorna Result
+ */
+declare function tryCastPressure(input: unknown, targetVariant?: PressureUnit): Result$7<number>;
+
+/**
+ * Frequency Role - Cast Pillar
+ *
+ * Normaliza input sujo para número, com detecção automática de unidade.
+ *
+ * @example
+ * import { castFrequency, castFrequencyStrict, detectFrequencyUnit } from '@attrx/role-morphic/frequency/cast';
+ *
+ * castFrequency('2.4 GHz');                    // 2400000000 (converted to hertz)
+ * castFrequency('2.4 GHz', 'gigahertz');       // 2.4 (kept as gigahertz)
+ * castFrequencyStrict('100');                  // 100 (no conversion)
+ * detectFrequencyUnit('3600 rpm');             // 'rpm'
+ */
+
+type Result$6<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Faz cast de input para número, com conversão opcional para unidade alvo
+ *
+ * @param input - Valor de entrada (number, string, etc)
+ * @param targetVariant - Unidade alvo (default: hertz)
+ * @returns Número ou null se não puder converter
+ *
+ * @example
+ * castFrequency('2.4 GHz');               // 2400000000 (hertz)
+ * castFrequency('2.4 GHz', 'gigahertz');  // 2.4
+ * castFrequency('100');                   // 100
+ * castFrequency(100);                     // 100
+ * castFrequency('invalid');               // null
+ */
+declare function castFrequency(input: unknown, targetVariant?: FrequencyUnit): number | null;
+/**
+ * Versão safe de castFrequency que retorna Result
+ */
+declare function tryCastFrequency(input: unknown, targetVariant?: FrequencyUnit): Result$6<number>;
+
+/**
+ * Angle Role - Cast Pillar
+ *
+ * Normaliza input sujo para número, com detecção automática de unidade.
+ *
+ * @example
+ * import { castAngle, castAngleStrict, detectAngleUnit } from '@attrx/role-morphic/angle/cast';
+ *
+ * castAngle('90°');                    // 90 (degrees)
+ * castAngle('3.14159 rad', 'degree');  // ~180 (converted to degrees)
+ * castAngleStrict('90');               // 90 (no conversion)
+ * detectAngleUnit('45°');              // 'degree'
+ */
+
+type Result$5<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Faz cast de input para número, com conversão opcional para unidade alvo
+ *
+ * @param input - Valor de entrada (number, string, etc)
+ * @param targetVariant - Unidade alvo (default: degree)
+ * @returns Número ou null se não puder converter
+ *
+ * @example
+ * castAngle('90°');                    // 90
+ * castAngle('3.14159 rad', 'degree');  // ~180
+ * castAngle('100');                    // 100
+ * castAngle(45);                       // 45
+ * castAngle('invalid');                // null
+ */
+declare function castAngle(input: unknown, targetVariant?: AngleUnit): number | null;
+/**
+ * Versão safe de castAngle que retorna Result
+ */
+declare function tryCastAngle(input: unknown, targetVariant?: AngleUnit): Result$5<number>;
+
+/**
+ * Time Role - Cast Pillar
+ *
+ * Normaliza input sujo para número, com detecção automática de unidade.
+ *
+ * @example
+ * import { castTime, castTimeStrict, detectTimeUnit } from '@attrx/role-morphic/time/cast';
+ *
+ * castTime('5 min');                    // 300 (converted to seconds)
+ * castTime('5 min', 'minute');          // 5 (kept as minutes)
+ * castTimeStrict('100');                // 100 (no conversion)
+ * detectTimeUnit('2 hours');            // 'hour'
+ */
+
+type Result$4<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Faz cast de input para número, com conversão opcional para unidade alvo
+ *
+ * @param input - Valor de entrada (number, string, etc)
+ * @param targetVariant - Unidade alvo (default: second)
+ * @returns Número ou null se não puder converter
+ *
+ * @example
+ * castTime('5 min');            // 300 (seconds)
+ * castTime('5 min', 'minute');  // 5
+ * castTime('100');              // 100
+ * castTime(100);                // 100
+ * castTime('invalid');          // null
+ */
+declare function castTime(input: unknown, targetVariant?: TimeUnit): number | null;
+/**
+ * Versão safe de castTime que retorna Result
+ */
+declare function tryCastTime(input: unknown, targetVariant?: TimeUnit): Result$4<number>;
+
+/**
+ * Digital Role - Cast Pillar
+ *
+ * Normaliza input sujo para número, com detecção automática de unidade.
+ *
+ * @example
+ * import { castDigital, castDigitalStrict, detectDigitalUnit } from '@attrx/role-morphic/digital/cast';
+ *
+ * castDigital('1 MB');                     // 1000000 (converted to bytes)
+ * castDigital('1 MB', 'megabyte');         // 1 (kept as megabytes)
+ * castDigitalStrict('100');                // 100 (no conversion)
+ * detectDigitalUnit('2 GiB');              // 'gibibyte'
+ */
+
+type Result$3<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Faz cast de input para número, com conversão opcional para unidade alvo
+ *
+ * @param input - Valor de entrada (number, string, etc)
+ * @param targetVariant - Unidade alvo (default: byte)
+ * @returns Número ou null se não puder converter
+ *
+ * @example
+ * castDigital('1 MB');             // 1000000 (bytes)
+ * castDigital('1 MB', 'megabyte'); // 1
+ * castDigital('100');              // 100
+ * castDigital(100);                // 100
+ * castDigital('invalid');          // null
+ */
+declare function castDigital(input: unknown, targetVariant?: DigitalUnit): number | null;
+/**
+ * Versão safe de castDigital que retorna Result
+ */
+declare function tryCastDigital(input: unknown, targetVariant?: DigitalUnit): Result$3<number>;
+
+/**
+ * Color Role - Cast Pillar
+ *
+ * Normaliza input sujo para uma variante de cor específica.
+ *
+ * @example
+ * import { castColor, tryCastColor, detectColorFormat } from '@attrx/role-morphic/color/cast';
+ *
+ * castColor('hex', 'red');                     // '#ff0000'
+ * castColor('rgb_object', '#ff0000');          // { r: 255, g: 0, b: 0 }
+ * castColor('hsl_string', { r: 255, g: 0, b: 0 }); // 'hsl(0, 100%, 50%)'
+ */
+
+type Result$2<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Faz cast de qualquer input para uma variante de cor
+ *
+ * @param variant - Variante de destino
+ * @param input - Valor de entrada (string, object, etc)
+ * @returns Valor na variante de destino ou null se não puder converter
+ *
+ * @example
+ * castColor('hex', 'red');                     // '#ff0000'
+ * castColor('rgb_object', '#ff0000');          // { r: 255, g: 0, b: 0 }
+ * castColor('hsl_string', { r: 255, g: 0, b: 0 }); // 'hsl(0, 100%, 50%)'
+ * castColor('hex', 'invalid');                 // null
+ */
+declare function castColor<T = unknown>(variant: ColorVariant, input: unknown): T | null;
+/**
+ * Versão safe de castColor que retorna Result
+ */
+declare function tryCastColor<T = unknown>(variant: ColorVariant, input: unknown): Result$2<T>;
+
+/**
+ * Date Role - Cast Pillar
+ *
+ * Normaliza input sujo para o tipo esperado de cada variante.
+ *
+ * @example
+ * import { castDate, castIso, castTimestamp, castEpoch } from '@attrx/role-morphic/date/cast';
+ *
+ * castDate('iso', '2024-12-05');                // '2024-12-05T00:00:00.000Z'
+ * castDate('timestamp', '2024-12-05');          // 1733356800000
+ * castDate('epoch', new Date());                // 1733425800
+ */
+
+type Result$1<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Faz cast de input para uma variante de data
+ *
+ * @param variant - Variante de destino ("iso", "timestamp", "epoch")
+ * @param input - Valor de entrada
+ * @returns Valor convertido ou null se não for possível
+ *
+ * @example
+ * castDate('iso', '2024-12-05');      // '2024-12-05T00:00:00.000Z'
+ * castDate('timestamp', new Date());  // timestamp atual
+ * castDate('epoch', '2024-12-05');    // 1733356800
+ */
+declare function castDate<T = unknown>(variant: DateVariant, input: unknown): T | null;
+/**
+ * Versão safe de castDate que retorna Result
+ */
+declare function tryCastDate<T = unknown>(variant: DateVariant, input: unknown): Result$1<T>;
+
+/**
+ * Currency Role - Cast Pillar
+ *
+ * Normaliza input monetário sujo para número.
+ * Extrai o valor numérico de strings formatadas como moeda.
+ *
+ * NÃO infere a moeda - apenas extrai o valor numérico.
+ * A moeda deve ser conhecida via metadata.
+ *
+ * @example
+ * import { castCurrency, castCurrencyStrict } from '@attrx/role-morphic/currency/cast';
+ *
+ * castCurrency('R$ 1.500,50');     // 1500.50
+ * castCurrency('$1,000.00');       // 1000
+ * castCurrency('€ 99,99');         // 99.99
+ * castCurrency('1500');            // 1500
+ * castCurrency(1500.50);           // 1500.50
+ */
+type Result<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Faz cast de input monetário para número
+ *
+ * Suporta diversos formatos:
+ * - Brasileiro: R$ 1.500,50
+ * - Americano: $1,000.00
+ * - Europeu: € 99,99 ou 99,99 €
+ * - Sem símbolo: 1500.50 ou 1500,50
+ *
+ * @param input - Valor de entrada (number, string, etc)
+ * @returns Número ou null se não puder converter
+ *
+ * @example
+ * castCurrency('R$ 1.500,50');     // 1500.50
+ * castCurrency('$1,000.00');       // 1000
+ * castCurrency('€ 99,99');         // 99.99
+ * castCurrency('1.500,50');        // 1500.50 (brasileiro)
+ * castCurrency('1,500.50');        // 1500.50 (americano)
+ * castCurrency('-R$ 50,00');       // -50
+ * castCurrency('invalid');         // null
+ */
+declare function castCurrency(input: unknown): number | null;
+/**
+ * Versão safe de castCurrency que retorna Result
+ */
+declare function tryCastCurrency(input: unknown): Result<number>;
+
+export { castAngle, castArea, castColor, castCurrency, castDate, castDigital, castEnergy, castFrequency, castLength, castMass, castPower, castPressure, castSpeed, castTemperature, castTime, castVolume, tryCastAngle, tryCastArea, tryCastColor, tryCastCurrency, tryCastDate, tryCastDigital, tryCastEnergy, tryCastFrequency, tryCastLength, tryCastMass, tryCastPower, tryCastPressure, tryCastSpeed, tryCastTemperature, tryCastTime, tryCastVolume };