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.mjs';
import { T as TemperatureUnit, r as ColorVariant, o as DateVariant } from './types-mbeS1e-k.mjs';

/**
 * 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 };