@attrx/role-morphic 0.1.0 → 0.2.1

package/dist/convert.d.ts

@@ -0,0 +1,1157 @@
+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 - Convert Pillar
+ *
+ * Conversão entre unidades de área usando arquitetura hub-and-spoke.
+ * Base: square_meter (m²)
+ *
+ * @example
+ * import { convertArea, toBaseArea, fromBaseArea } from '@attrx/role-morphic/area/convert';
+ *
+ * convertArea('hectare', 'acre', 1);     // 2.47105...
+ * toBaseArea('hectare', 1);              // 10000
+ * fromBaseArea('acre', 10000);           // 2.47105...
+ */
+
+type Result$e<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/** Variante base para conversões */
+declare const AREA_BASE: AreaUnit;
+/**
+ * Converte valor para a unidade base (square_meter)
+ *
+ * @param variant - Unidade de origem
+ * @param value - Valor a converter
+ * @returns Valor em square_meter
+ *
+ * @example
+ * toBaseArea('hectare', 1);     // 10000
+ * toBaseArea('acre', 1);        // 4046.8564224
+ */
+declare function toBaseArea(variant: AreaUnit, value: number): number;
+/**
+ * Converte valor da unidade base (square_meter) para outra unidade
+ *
+ * @param variant - Unidade de destino
+ * @param baseValue - Valor em square_meter
+ * @returns Valor na unidade de destino
+ *
+ * @example
+ * fromBaseArea('hectare', 10000);  // 1
+ * fromBaseArea('acre', 4046.86);   // ~1
+ */
+declare function fromBaseArea(variant: AreaUnit, baseValue: number): number;
+/**
+ * Converte entre duas unidades de área
+ *
+ * @param from - Unidade de origem
+ * @param to - Unidade de destino
+ * @param value - Valor a converter
+ * @returns Valor convertido
+ *
+ * @example
+ * convertArea('hectare', 'acre', 1);           // 2.47105...
+ * convertArea('square_meter', 'hectare', 10000); // 1
+ */
+declare function convertArea(from: AreaUnit, to: AreaUnit, value: number): number;
+/**
+ * Versão safe de convertArea que retorna Result
+ *
+ * @example
+ * tryConvertArea('hectare', 'acre', 1);
+ * // { ok: true, value: 2.47105... }
+ *
+ * tryConvertArea('invalid', 'acre', 1);
+ * // { ok: false, error: 'Unknown area variant: invalid' }
+ */
+declare function tryConvertArea(from: AreaUnit, to: AreaUnit, value: number): Result$e<number>;
+/**
+ * Verifica se uma variante existe
+ */
+declare function hasAreaVariant(variant: string): variant is AreaUnit;
+/**
+ * Lista todas as variantes disponíveis
+ */
+declare function getAreaVariants(): AreaUnit[];
+
+/**
+ * Length Role - Convert Pillar
+ *
+ * Conversão entre unidades de comprimento usando arquitetura hub-and-spoke.
+ * Base: meter (m)
+ *
+ * @example
+ * import { convertLength, toBaseLength, fromBaseLength } from '@attrx/role-morphic/length/convert';
+ *
+ * convertLength('kilometer', 'mile', 1);     // 0.621371...
+ * toBaseLength('kilometer', 1);              // 1000
+ * fromBaseLength('mile', 1000);              // 0.621371...
+ */
+
+type Result$d<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/** Variante base para conversões */
+declare const LENGTH_BASE: LengthUnit;
+/**
+ * Converte valor para a unidade base (meter)
+ *
+ * @param variant - Unidade de origem
+ * @param value - Valor a converter
+ * @returns Valor em meters
+ *
+ * @example
+ * toBaseLength('kilometer', 1);  // 1000
+ * toBaseLength('mile', 1);       // 1609.344
+ */
+declare function toBaseLength(variant: LengthUnit, value: number): number;
+/**
+ * Converte valor da unidade base (meter) para outra unidade
+ *
+ * @param variant - Unidade de destino
+ * @param baseValue - Valor em meters
+ * @returns Valor na unidade de destino
+ *
+ * @example
+ * fromBaseLength('kilometer', 1000);  // 1
+ * fromBaseLength('mile', 1609.344);   // 1
+ */
+declare function fromBaseLength(variant: LengthUnit, baseValue: number): number;
+/**
+ * Converte entre duas unidades de comprimento
+ *
+ * @param from - Unidade de origem
+ * @param to - Unidade de destino
+ * @param value - Valor a converter
+ * @returns Valor convertido
+ *
+ * @example
+ * convertLength('kilometer', 'mile', 1);     // 0.621371...
+ * convertLength('foot', 'meter', 1);         // 0.3048
+ */
+declare function convertLength(from: LengthUnit, to: LengthUnit, value: number): number;
+/**
+ * Versão safe de convertLength que retorna Result
+ *
+ * @example
+ * tryConvertLength('kilometer', 'mile', 1);
+ * // { ok: true, value: 0.621371... }
+ *
+ * tryConvertLength('invalid', 'mile', 1);
+ * // { ok: false, error: 'Unknown length variant: invalid' }
+ */
+declare function tryConvertLength(from: LengthUnit, to: LengthUnit, value: number): Result$d<number>;
+/**
+ * Verifica se uma variante existe
+ */
+declare function hasLengthVariant(variant: string): variant is LengthUnit;
+/**
+ * Lista todas as variantes disponíveis
+ */
+declare function getLengthVariants(): LengthUnit[];
+
+/**
+ * Mass Role - Convert Pillar
+ *
+ * Conversão entre unidades de massa usando arquitetura hub-and-spoke.
+ * Base: kilogram (kg)
+ *
+ * @example
+ * import { convertMass, toBaseMass, fromBaseMass } from '@attrx/role-morphic/mass/convert';
+ *
+ * convertMass('kilogram', 'pound', 1);     // 2.20462...
+ * toBaseMass('pound', 1);                  // 0.45359237
+ * fromBaseMass('pound', 0.45359237);       // 1
+ */
+
+type Result$c<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/** Variante base para conversões */
+declare const MASS_BASE: MassUnit;
+/**
+ * Converte valor para a unidade base (kilogram)
+ *
+ * @param variant - Unidade de origem
+ * @param value - Valor a converter
+ * @returns Valor em kilogram
+ *
+ * @example
+ * toBaseMass('pound', 1);     // 0.45359237
+ * toBaseMass('gram', 1000);   // 1
+ */
+declare function toBaseMass(variant: MassUnit, value: number): number;
+/**
+ * Converte valor da unidade base (kilogram) para outra unidade
+ *
+ * @param variant - Unidade de destino
+ * @param baseValue - Valor em kilogram
+ * @returns Valor na unidade de destino
+ *
+ * @example
+ * fromBaseMass('pound', 1);        // 2.20462...
+ * fromBaseMass('gram', 1);         // 1000
+ */
+declare function fromBaseMass(variant: MassUnit, baseValue: number): number;
+/**
+ * Converte entre duas unidades de massa
+ *
+ * @param from - Unidade de origem
+ * @param to - Unidade de destino
+ * @param value - Valor a converter
+ * @returns Valor convertido
+ *
+ * @example
+ * convertMass('kilogram', 'pound', 1);     // 2.20462...
+ * convertMass('pound', 'kilogram', 2.2);   // ~1
+ * convertMass('gram', 'milligram', 1);     // 1000
+ */
+declare function convertMass(from: MassUnit, to: MassUnit, value: number): number;
+/**
+ * Versão safe de convertMass que retorna Result
+ *
+ * @example
+ * tryConvertMass('kilogram', 'pound', 1);
+ * // { ok: true, value: 2.20462... }
+ *
+ * tryConvertMass('invalid', 'pound', 1);
+ * // { ok: false, error: 'Unknown mass variant: invalid' }
+ */
+declare function tryConvertMass(from: MassUnit, to: MassUnit, value: number): Result$c<number>;
+/**
+ * Verifica se uma variante existe
+ */
+declare function hasMassVariant(variant: string): variant is MassUnit;
+/**
+ * Lista todas as variantes disponíveis
+ */
+declare function getMassVariants(): MassUnit[];
+
+/**
+ * Temperature Role - Convert Pillar
+ *
+ * Conversão entre unidades de temperatura usando arquitetura hub-and-spoke.
+ * Base: celsius (°C)
+ *
+ * IMPORTANTE: Diferente de outras roles, temperatura usa FÓRMULAS
+ * ao invés de fatores multiplicativos (escalas têm offsets diferentes).
+ *
+ * Fórmulas de conversão:
+ * - Celsius ↔ Fahrenheit: °F = °C × 9/5 + 32
+ * - Celsius ↔ Kelvin: K = °C + 273.15
+ * - Celsius ↔ Rankine: °R = (°C + 273.15) × 9/5
+ *
+ * @example
+ * import { convertTemperature, toBaseTemperature, fromBaseTemperature } from '@attrx/role-morphic/temperature/convert';
+ *
+ * convertTemperature('celsius', 'fahrenheit', 0);   // 32
+ * convertTemperature('celsius', 'kelvin', 0);       // 273.15
+ * toBaseTemperature('fahrenheit', 32);              // 0
+ * fromBaseTemperature('kelvin', 0);                 // 273.15
+ */
+
+type Result$b<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/** Variante base para conversões */
+declare const TEMPERATURE_BASE: TemperatureUnit;
+/**
+ * Converte valor para a unidade base (celsius)
+ *
+ * @param variant - Unidade de origem
+ * @param value - Valor a converter
+ * @returns Valor em celsius
+ *
+ * @example
+ * toBaseTemperature('fahrenheit', 32);   // 0
+ * toBaseTemperature('kelvin', 273.15);   // 0
+ * toBaseTemperature('rankine', 491.67);  // 0
+ */
+declare function toBaseTemperature(variant: TemperatureUnit, value: number): number;
+/**
+ * Converte valor da unidade base (celsius) para outra unidade
+ *
+ * @param variant - Unidade de destino
+ * @param baseValue - Valor em celsius
+ * @returns Valor na unidade de destino
+ *
+ * @example
+ * fromBaseTemperature('fahrenheit', 0);   // 32
+ * fromBaseTemperature('kelvin', 0);       // 273.15
+ * fromBaseTemperature('rankine', 0);      // 491.67
+ */
+declare function fromBaseTemperature(variant: TemperatureUnit, baseValue: number): number;
+/**
+ * Converte entre duas unidades de temperatura
+ *
+ * @param from - Unidade de origem
+ * @param to - Unidade de destino
+ * @param value - Valor a converter
+ * @returns Valor convertido
+ *
+ * @example
+ * convertTemperature('celsius', 'fahrenheit', 0);     // 32
+ * convertTemperature('celsius', 'fahrenheit', 100);   // 212
+ * convertTemperature('fahrenheit', 'celsius', 32);    // 0
+ * convertTemperature('celsius', 'kelvin', 0);         // 273.15
+ * convertTemperature('kelvin', 'rankine', 0);         // 0
+ */
+declare function convertTemperature(from: TemperatureUnit, to: TemperatureUnit, value: number): number;
+/**
+ * Versão safe de convertTemperature que retorna Result
+ *
+ * @example
+ * tryConvertTemperature('celsius', 'fahrenheit', 0);
+ * // { ok: true, value: 32 }
+ *
+ * tryConvertTemperature('invalid', 'fahrenheit', 0);
+ * // { ok: false, error: 'Unknown temperature variant: invalid' }
+ */
+declare function tryConvertTemperature(from: TemperatureUnit, to: TemperatureUnit, value: number): Result$b<number>;
+/**
+ * Verifica se uma variante existe
+ */
+declare function hasTemperatureVariant(variant: string): variant is TemperatureUnit;
+/**
+ * Lista todas as variantes disponíveis
+ */
+declare function getTemperatureVariants(): TemperatureUnit[];
+
+/**
+ * Volume Role - Convert Pillar
+ *
+ * Conversão entre unidades de volume usando arquitetura hub-and-spoke.
+ * Base: liter (L)
+ *
+ * @example
+ * import { convertVolume, toBaseVolume, fromBaseVolume } from '@attrx/role-morphic/volume/convert';
+ *
+ * convertVolume('gallon_us', 'liter', 1);     // 3.785411784
+ * toBaseVolume('milliliter', 500);            // 0.5
+ * fromBaseVolume('gallon_us', 3.785411784);   // 1
+ */
+
+type Result$a<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/** Variante base para conversões */
+declare const VOLUME_BASE: VolumeUnit;
+/**
+ * Converte valor para a unidade base (liter)
+ *
+ * @param variant - Unidade de origem
+ * @param value - Valor a converter
+ * @returns Valor em liter
+ *
+ * @example
+ * toBaseVolume('milliliter', 500);     // 0.5
+ * toBaseVolume('gallon_us', 1);        // 3.785411784
+ */
+declare function toBaseVolume(variant: VolumeUnit, value: number): number;
+/**
+ * Converte valor da unidade base (liter) para outra unidade
+ *
+ * @param variant - Unidade de destino
+ * @param baseValue - Valor em liter
+ * @returns Valor na unidade de destino
+ *
+ * @example
+ * fromBaseVolume('milliliter', 0.5);        // 500
+ * fromBaseVolume('gallon_us', 3.785411784); // 1
+ */
+declare function fromBaseVolume(variant: VolumeUnit, baseValue: number): number;
+/**
+ * Converte entre duas unidades de volume
+ *
+ * @param from - Unidade de origem
+ * @param to - Unidade de destino
+ * @param value - Valor a converter
+ * @returns Valor convertido
+ *
+ * @example
+ * convertVolume('gallon_us', 'liter', 1);        // 3.785411784
+ * convertVolume('milliliter', 'liter', 500);    // 0.5
+ * convertVolume('cup_us', 'tablespoon_us', 1);  // 16
+ */
+declare function convertVolume(from: VolumeUnit, to: VolumeUnit, value: number): number;
+/**
+ * Versão safe de convertVolume que retorna Result
+ *
+ * @example
+ * tryConvertVolume('gallon_us', 'liter', 1);
+ * // { ok: true, value: 3.785411784 }
+ *
+ * tryConvertVolume('invalid', 'liter', 1);
+ * // { ok: false, error: 'Unknown volume variant: invalid' }
+ */
+declare function tryConvertVolume(from: VolumeUnit, to: VolumeUnit, value: number): Result$a<number>;
+/**
+ * Verifica se uma variante existe
+ */
+declare function hasVolumeVariant(variant: string): variant is VolumeUnit;
+/**
+ * Lista todas as variantes disponíveis
+ */
+declare function getVolumeVariants(): VolumeUnit[];
+
+/**
+ * Speed Role - Convert Pillar
+ *
+ * Conversão entre unidades de velocidade usando arquitetura hub-and-spoke.
+ * Base: meter_per_second (m/s)
+ *
+ * @example
+ * import { convertSpeed, toBaseSpeed, fromBaseSpeed } from '@attrx/role-morphic/speed/convert';
+ *
+ * convertSpeed('kilometer_per_hour', 'mile_per_hour', 100);  // 62.1371...
+ * toBaseSpeed('kilometer_per_hour', 100);                    // 27.7778...
+ * fromBaseSpeed('mile_per_hour', 27.7778);                   // ~62.14
+ */
+
+type Result$9<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/** Variante base para conversões */
+declare const SPEED_BASE: SpeedUnit;
+/**
+ * Converte valor para a unidade base (meter_per_second)
+ *
+ * @param variant - Unidade de origem
+ * @param value - Valor a converter
+ * @returns Valor em meter_per_second
+ *
+ * @example
+ * toBaseSpeed('kilometer_per_hour', 100);  // 27.7778...
+ * toBaseSpeed('mile_per_hour', 60);        // 26.8224
+ */
+declare function toBaseSpeed(variant: SpeedUnit, value: number): number;
+/**
+ * Converte valor da unidade base (meter_per_second) para outra unidade
+ *
+ * @param variant - Unidade de destino
+ * @param baseValue - Valor em meter_per_second
+ * @returns Valor na unidade de destino
+ *
+ * @example
+ * fromBaseSpeed('kilometer_per_hour', 27.7778);  // ~100
+ * fromBaseSpeed('mile_per_hour', 26.8224);       // ~60
+ */
+declare function fromBaseSpeed(variant: SpeedUnit, baseValue: number): number;
+/**
+ * Converte entre duas unidades de velocidade
+ *
+ * @param from - Unidade de origem
+ * @param to - Unidade de destino
+ * @param value - Valor a converter
+ * @returns Valor convertido
+ *
+ * @example
+ * convertSpeed('kilometer_per_hour', 'mile_per_hour', 100);  // 62.1371...
+ * convertSpeed('knot', 'kilometer_per_hour', 1);             // 1.852
+ * convertSpeed('mach', 'kilometer_per_hour', 1);             // 1225.044
+ */
+declare function convertSpeed(from: SpeedUnit, to: SpeedUnit, value: number): number;
+/**
+ * Versão safe de convertSpeed que retorna Result
+ *
+ * @example
+ * tryConvertSpeed('kilometer_per_hour', 'mile_per_hour', 100);
+ * // { ok: true, value: 62.1371... }
+ *
+ * tryConvertSpeed('invalid', 'mile_per_hour', 100);
+ * // { ok: false, error: 'Unknown speed variant: invalid' }
+ */
+declare function tryConvertSpeed(from: SpeedUnit, to: SpeedUnit, value: number): Result$9<number>;
+/**
+ * Verifica se uma variante existe
+ */
+declare function hasSpeedVariant(variant: string): variant is SpeedUnit;
+/**
+ * Lista todas as variantes disponíveis
+ */
+declare function getSpeedVariants(): SpeedUnit[];
+
+/**
+ * Energy Role - Convert Pillar
+ *
+ * Conversão entre unidades de energia usando arquitetura hub-and-spoke.
+ * Base: joule (J)
+ *
+ * @example
+ * import { convertEnergy, toBaseEnergy, fromBaseEnergy } from '@attrx/role-morphic/energy/convert';
+ *
+ * convertEnergy('kilocalorie', 'kilojoule', 1);   // 4.1868
+ * toBaseEnergy('kilowatt_hour', 1);               // 3600000
+ * fromBaseEnergy('btu', 1055.06);                 // ~1
+ */
+
+type Result$8<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/** Variante base para conversões */
+declare const ENERGY_BASE: EnergyUnit;
+/**
+ * Converte valor para a unidade base (joule)
+ *
+ * @param variant - Unidade de origem
+ * @param value - Valor a converter
+ * @returns Valor em joule
+ *
+ * @example
+ * toBaseEnergy('kilowatt_hour', 1);   // 3600000
+ * toBaseEnergy('kilocalorie', 1);     // 4186.8
+ */
+declare function toBaseEnergy(variant: EnergyUnit, value: number): number;
+/**
+ * Converte valor da unidade base (joule) para outra unidade
+ *
+ * @param variant - Unidade de destino
+ * @param baseValue - Valor em joule
+ * @returns Valor na unidade de destino
+ *
+ * @example
+ * fromBaseEnergy('kilowatt_hour', 3600000);   // 1
+ * fromBaseEnergy('kilocalorie', 4186.8);      // 1
+ */
+declare function fromBaseEnergy(variant: EnergyUnit, baseValue: number): number;
+/**
+ * Converte entre duas unidades de energia
+ *
+ * @param from - Unidade de origem
+ * @param to - Unidade de destino
+ * @param value - Valor a converter
+ * @returns Valor convertido
+ *
+ * @example
+ * convertEnergy('kilocalorie', 'kilojoule', 1);      // 4.1868
+ * convertEnergy('kilowatt_hour', 'megajoule', 1);    // 3.6
+ * convertEnergy('btu', 'joule', 1);                  // 1055.056...
+ */
+declare function convertEnergy(from: EnergyUnit, to: EnergyUnit, value: number): number;
+/**
+ * Versão safe de convertEnergy que retorna Result
+ *
+ * @example
+ * tryConvertEnergy('kilocalorie', 'kilojoule', 1);
+ * // { ok: true, value: 4.1868 }
+ *
+ * tryConvertEnergy('invalid', 'joule', 1);
+ * // { ok: false, error: 'Unknown energy variant: invalid' }
+ */
+declare function tryConvertEnergy(from: EnergyUnit, to: EnergyUnit, value: number): Result$8<number>;
+/**
+ * Verifica se uma variante existe
+ */
+declare function hasEnergyVariant(variant: string): variant is EnergyUnit;
+/**
+ * Lista todas as variantes disponíveis
+ */
+declare function getEnergyVariants(): EnergyUnit[];
+
+/**
+ * Power Role - Convert Pillar
+ *
+ * Conversão entre unidades de potência usando hub-and-spoke (via watt).
+ *
+ * @example
+ * import { convertPower, toBasePower, fromBasePower } from '@attrx/role-morphic/power/convert';
+ *
+ * convertPower('horsepower_mechanical', 'kilowatt', 1);  // 0.7457
+ * toBasePower('kilowatt', 2.5);                          // 2500 (watts)
+ * fromBasePower('kilowatt', 2500);                       // 2.5
+ */
+
+type Result$7<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/** Unidade base para conversões (hub) */
+declare const POWER_BASE: PowerUnit;
+/**
+ * Converte valor para a unidade base (watt)
+ *
+ * @param variant - Unidade de origem
+ * @param value - Valor a converter
+ * @returns Valor em watts
+ *
+ * @example
+ * toBasePower('kilowatt', 2.5);             // 2500
+ * toBasePower('horsepower_mechanical', 1);  // 745.7
+ */
+declare function toBasePower(variant: PowerUnit, value: number): number;
+/**
+ * Converte valor da unidade base (watt) para outra unidade
+ *
+ * @param variant - Unidade de destino
+ * @param baseValue - Valor em watts
+ * @returns Valor na unidade de destino
+ *
+ * @example
+ * fromBasePower('kilowatt', 2500);  // 2.5
+ * fromBasePower('watt', 100);       // 100
+ */
+declare function fromBasePower(variant: PowerUnit, baseValue: number): number;
+/**
+ * Converte entre duas unidades de potência
+ *
+ * @param from - Unidade de origem
+ * @param to - Unidade de destino
+ * @param value - Valor a converter
+ * @returns Valor convertido
+ *
+ * @example
+ * convertPower('horsepower_mechanical', 'kilowatt', 1);  // 0.7457
+ * convertPower('kilowatt', 'watt', 2.5);                 // 2500
+ */
+declare function convertPower(from: PowerUnit, to: PowerUnit, value: number): number;
+/**
+ * Versão safe de convertPower que retorna Result
+ *
+ * @example
+ * tryConvertPower('kilowatt', 'watt', 1);  // { ok: true, value: 1000 }
+ * tryConvertPower('invalid', 'watt', 1);   // { ok: false, error: '...' }
+ */
+declare function tryConvertPower(from: PowerUnit, to: PowerUnit, value: number): Result$7<number>;
+/**
+ * Verifica se uma variante existe
+ *
+ * @example
+ * hasPowerVariant('kilowatt');  // true
+ * hasPowerVariant('invalid');   // false
+ */
+declare function hasPowerVariant(variant: string): variant is PowerUnit;
+/**
+ * Retorna lista de todas as variantes disponíveis
+ *
+ * @example
+ * getPowerVariants();  // ['gigawatt', 'megawatt', 'kilowatt', ...]
+ */
+declare function getPowerVariants(): PowerUnit[];
+
+/**
+ * Pressure Role - Convert Pillar
+ *
+ * Conversão entre unidades de pressão usando hub-and-spoke (via pascal).
+ *
+ * @example
+ * import { convertPressure, toBasePressure, fromBasePressure } from '@attrx/role-morphic/pressure/convert';
+ *
+ * convertPressure('bar', 'pascal', 1);      // 100000
+ * toBasePressure('bar', 2.5);               // 250000 (pascals)
+ * fromBasePressure('bar', 250000);          // 2.5
+ */
+
+type Result$6<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/** Unidade base para conversões (hub) */
+declare const PRESSURE_BASE: PressureUnit;
+/**
+ * Converte valor para a unidade base (pascal)
+ *
+ * @param variant - Unidade de origem
+ * @param value - Valor a converter
+ * @returns Valor em pascals
+ *
+ * @example
+ * toBasePressure('bar', 2.5);        // 250000
+ * toBasePressure('atmosphere', 1);   // 101325
+ */
+declare function toBasePressure(variant: PressureUnit, value: number): number;
+/**
+ * Converte valor da unidade base (pascal) para outra unidade
+ *
+ * @param variant - Unidade de destino
+ * @param baseValue - Valor em pascals
+ * @returns Valor na unidade de destino
+ *
+ * @example
+ * fromBasePressure('bar', 250000);      // 2.5
+ * fromBasePressure('atmosphere', 101325); // 1
+ */
+declare function fromBasePressure(variant: PressureUnit, baseValue: number): number;
+/**
+ * Converte entre duas unidades de pressão
+ *
+ * @param from - Unidade de origem
+ * @param to - Unidade de destino
+ * @param value - Valor a converter
+ * @returns Valor convertido
+ *
+ * @example
+ * convertPressure('bar', 'pascal', 1);      // 100000
+ * convertPressure('atmosphere', 'psi', 1);  // 14.696
+ */
+declare function convertPressure(from: PressureUnit, to: PressureUnit, value: number): number;
+/**
+ * Versão safe de convertPressure que retorna Result
+ *
+ * @example
+ * tryConvertPressure('bar', 'pascal', 1);  // { ok: true, value: 100000 }
+ * tryConvertPressure('invalid', 'pascal', 1);   // { ok: false, error: '...' }
+ */
+declare function tryConvertPressure(from: PressureUnit, to: PressureUnit, value: number): Result$6<number>;
+/**
+ * Verifica se uma variante existe
+ *
+ * @example
+ * hasPressureVariant('bar');     // true
+ * hasPressureVariant('invalid'); // false
+ */
+declare function hasPressureVariant(variant: string): variant is PressureUnit;
+/**
+ * Retorna lista de todas as variantes disponíveis
+ *
+ * @example
+ * getPressureVariants();  // ['megapascal', 'kilopascal', 'hectopascal', ...]
+ */
+declare function getPressureVariants(): PressureUnit[];
+
+/**
+ * Frequency Role - Convert Pillar
+ *
+ * Conversão entre unidades de frequência usando hub-and-spoke (via hertz).
+ *
+ * @example
+ * import { convertFrequency, toBaseFrequency, fromBaseFrequency } from '@attrx/role-morphic/frequency/convert';
+ *
+ * convertFrequency('megahertz', 'hertz', 1);  // 1000000
+ * toBaseFrequency('megahertz', 2.4);          // 2400000 (hertz)
+ * fromBaseFrequency('megahertz', 2400000);    // 2.4
+ */
+
+type Result$5<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/** Unidade base para conversões (hub) */
+declare const FREQUENCY_BASE: FrequencyUnit;
+/**
+ * Converte valor para a unidade base (hertz)
+ *
+ * @param variant - Unidade de origem
+ * @param value - Valor a converter
+ * @returns Valor em hertz
+ *
+ * @example
+ * toBaseFrequency('megahertz', 2.4);  // 2400000
+ * toBaseFrequency('rpm', 60);         // 1
+ */
+declare function toBaseFrequency(variant: FrequencyUnit, value: number): number;
+/**
+ * Converte valor da unidade base (hertz) para outra unidade
+ *
+ * @param variant - Unidade de destino
+ * @param baseValue - Valor em hertz
+ * @returns Valor na unidade de destino
+ *
+ * @example
+ * fromBaseFrequency('megahertz', 2400000);  // 2.4
+ * fromBaseFrequency('rpm', 1);              // 60
+ */
+declare function fromBaseFrequency(variant: FrequencyUnit, baseValue: number): number;
+/**
+ * Converte entre duas unidades de frequência
+ *
+ * @param from - Unidade de origem
+ * @param to - Unidade de destino
+ * @param value - Valor a converter
+ * @returns Valor convertido
+ *
+ * @example
+ * convertFrequency('megahertz', 'hertz', 1);  // 1000000
+ * convertFrequency('rpm', 'hertz', 60);       // 1
+ */
+declare function convertFrequency(from: FrequencyUnit, to: FrequencyUnit, value: number): number;
+/**
+ * Versão safe de convertFrequency que retorna Result
+ *
+ * @example
+ * tryConvertFrequency('megahertz', 'hertz', 1);  // { ok: true, value: 1000000 }
+ * tryConvertFrequency('invalid', 'hertz', 1);    // { ok: false, error: '...' }
+ */
+declare function tryConvertFrequency(from: FrequencyUnit, to: FrequencyUnit, value: number): Result$5<number>;
+/**
+ * Verifica se uma variante existe
+ *
+ * @example
+ * hasFrequencyVariant('hertz');    // true
+ * hasFrequencyVariant('invalid');  // false
+ */
+declare function hasFrequencyVariant(variant: string): variant is FrequencyUnit;
+/**
+ * Retorna lista de todas as variantes disponíveis
+ *
+ * @example
+ * getFrequencyVariants();  // ['terahertz', 'gigahertz', 'megahertz', ...]
+ */
+declare function getFrequencyVariants(): FrequencyUnit[];
+
+/**
+ * Angle Role - Convert Pillar
+ *
+ * Conversão entre unidades de ângulo usando hub-and-spoke (via degree).
+ *
+ * @example
+ * import { convertAngle, toBaseAngle, fromBaseAngle } from '@attrx/role-morphic/angle/convert';
+ *
+ * convertAngle('degree', 'radian', 180);  // π ≈ 3.14159
+ * toBaseAngle('turn', 1);                 // 360 (degrees)
+ * fromBaseAngle('radian', 180);           // π ≈ 3.14159
+ */
+
+type Result$4<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/** Unidade base para conversões (hub) */
+declare const ANGLE_BASE: AngleUnit;
+/**
+ * Converte valor para a unidade base (degree)
+ *
+ * @param variant - Unidade de origem
+ * @param value - Valor a converter
+ * @returns Valor em degrees
+ *
+ * @example
+ * toBaseAngle('turn', 1);      // 360
+ * toBaseAngle('radian', Math.PI); // 180
+ */
+declare function toBaseAngle(variant: AngleUnit, value: number): number;
+/**
+ * Converte valor da unidade base (degree) para outra unidade
+ *
+ * @param variant - Unidade de destino
+ * @param baseValue - Valor em degrees
+ * @returns Valor na unidade de destino
+ *
+ * @example
+ * fromBaseAngle('radian', 180);  // π ≈ 3.14159
+ * fromBaseAngle('turn', 360);    // 1
+ */
+declare function fromBaseAngle(variant: AngleUnit, baseValue: number): number;
+/**
+ * Converte entre duas unidades de ângulo
+ *
+ * @param from - Unidade de origem
+ * @param to - Unidade de destino
+ * @param value - Valor a converter
+ * @returns Valor convertido
+ *
+ * @example
+ * convertAngle('degree', 'radian', 180);  // π ≈ 3.14159
+ * convertAngle('turn', 'degree', 1);      // 360
+ */
+declare function convertAngle(from: AngleUnit, to: AngleUnit, value: number): number;
+/**
+ * Versão safe de convertAngle que retorna Result
+ *
+ * @example
+ * tryConvertAngle('degree', 'radian', 180);  // { ok: true, value: π }
+ * tryConvertAngle('invalid', 'radian', 180); // { ok: false, error: '...' }
+ */
+declare function tryConvertAngle(from: AngleUnit, to: AngleUnit, value: number): Result$4<number>;
+/**
+ * Verifica se uma variante existe
+ *
+ * @example
+ * hasAngleVariant('degree');   // true
+ * hasAngleVariant('invalid');  // false
+ */
+declare function hasAngleVariant(variant: string): variant is AngleUnit;
+/**
+ * Retorna lista de todas as variantes disponíveis
+ *
+ * @example
+ * getAngleVariants();  // ['turn', 'degree', 'arcminute', ...]
+ */
+declare function getAngleVariants(): AngleUnit[];
+
+/**
+ * Time Role - Convert Pillar
+ *
+ * Conversão entre unidades de tempo usando hub-and-spoke (via second).
+ *
+ * @example
+ * import { convertTime, toBaseTime, fromBaseTime } from '@attrx/role-morphic/time/convert';
+ *
+ * convertTime('hour', 'minute', 1);  // 60
+ * toBaseTime('minute', 5);           // 300 (seconds)
+ * fromBaseTime('hour', 3600);        // 1
+ */
+
+type Result$3<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/** Unidade base para conversões (hub) */
+declare const TIME_BASE: TimeUnit;
+/**
+ * Converte valor para a unidade base (second)
+ *
+ * @param variant - Unidade de origem
+ * @param value - Valor a converter
+ * @returns Valor em seconds
+ *
+ * @example
+ * toBaseTime('minute', 5);  // 300
+ * toBaseTime('hour', 1);    // 3600
+ */
+declare function toBaseTime(variant: TimeUnit, value: number): number;
+/**
+ * Converte valor da unidade base (second) para outra unidade
+ *
+ * @param variant - Unidade de destino
+ * @param baseValue - Valor em seconds
+ * @returns Valor na unidade de destino
+ *
+ * @example
+ * fromBaseTime('minute', 300);  // 5
+ * fromBaseTime('hour', 3600);   // 1
+ */
+declare function fromBaseTime(variant: TimeUnit, baseValue: number): number;
+/**
+ * Converte entre duas unidades de tempo
+ *
+ * @param from - Unidade de origem
+ * @param to - Unidade de destino
+ * @param value - Valor a converter
+ * @returns Valor convertido
+ *
+ * @example
+ * convertTime('hour', 'minute', 1);  // 60
+ * convertTime('day', 'hour', 1);     // 24
+ */
+declare function convertTime(from: TimeUnit, to: TimeUnit, value: number): number;
+/**
+ * Versão safe de convertTime que retorna Result
+ *
+ * @example
+ * tryConvertTime('hour', 'minute', 1);   // { ok: true, value: 60 }
+ * tryConvertTime('invalid', 'minute', 1); // { ok: false, error: '...' }
+ */
+declare function tryConvertTime(from: TimeUnit, to: TimeUnit, value: number): Result$3<number>;
+/**
+ * Verifica se uma variante existe
+ *
+ * @example
+ * hasTimeVariant('second');   // true
+ * hasTimeVariant('invalid');  // false
+ */
+declare function hasTimeVariant(variant: string): variant is TimeUnit;
+/**
+ * Retorna lista de todas as variantes disponíveis
+ *
+ * @example
+ * getTimeVariants();  // ['nanosecond', 'microsecond', 'millisecond', ...]
+ */
+declare function getTimeVariants(): TimeUnit[];
+
+/**
+ * Digital Role - Convert Pillar
+ *
+ * Conversão entre unidades de armazenamento digital usando hub-and-spoke (via byte).
+ *
+ * @example
+ * import { convertDigital, toBaseDigital, fromBaseDigital } from '@attrx/role-morphic/digital/convert';
+ *
+ * convertDigital('kilobyte', 'byte', 1);     // 1000
+ * convertDigital('kibibyte', 'byte', 1);     // 1024
+ * toBaseDigital('megabyte', 1);              // 1000000 (bytes)
+ * fromBaseDigital('mebibyte', 1048576);      // 1
+ */
+
+type Result$2<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/** Unidade base para conversões (hub) */
+declare const DIGITAL_BASE: DigitalUnit;
+/**
+ * Converte valor para a unidade base (byte)
+ *
+ * @param variant - Unidade de origem
+ * @param value - Valor a converter
+ * @returns Valor em bytes
+ *
+ * @example
+ * toBaseDigital('kilobyte', 1);   // 1000
+ * toBaseDigital('kibibyte', 1);   // 1024
+ */
+declare function toBaseDigital(variant: DigitalUnit, value: number): number;
+/**
+ * Converte valor da unidade base (byte) para outra unidade
+ *
+ * @param variant - Unidade de destino
+ * @param baseValue - Valor em bytes
+ * @returns Valor na unidade de destino
+ *
+ * @example
+ * fromBaseDigital('kilobyte', 1000);   // 1
+ * fromBaseDigital('kibibyte', 1024);   // 1
+ */
+declare function fromBaseDigital(variant: DigitalUnit, baseValue: number): number;
+/**
+ * Converte entre duas unidades de armazenamento digital
+ *
+ * @param from - Unidade de origem
+ * @param to - Unidade de destino
+ * @param value - Valor a converter
+ * @returns Valor convertido
+ *
+ * @example
+ * convertDigital('kilobyte', 'byte', 1);     // 1000
+ * convertDigital('kibibyte', 'byte', 1);     // 1024
+ * convertDigital('gigabyte', 'gibibyte', 1); // ~0.931
+ */
+declare function convertDigital(from: DigitalUnit, to: DigitalUnit, value: number): number;
+/**
+ * Versão safe de convertDigital que retorna Result
+ *
+ * @example
+ * tryConvertDigital('kilobyte', 'byte', 1);    // { ok: true, value: 1000 }
+ * tryConvertDigital('invalid', 'byte', 1);     // { ok: false, error: '...' }
+ */
+declare function tryConvertDigital(from: DigitalUnit, to: DigitalUnit, value: number): Result$2<number>;
+/**
+ * Verifica se uma variante existe
+ *
+ * @example
+ * hasDigitalVariant('byte');     // true
+ * hasDigitalVariant('invalid');  // false
+ */
+declare function hasDigitalVariant(variant: string): variant is DigitalUnit;
+/**
+ * Retorna lista de todas as variantes disponíveis
+ *
+ * @example
+ * getDigitalVariants();  // ['bit', 'byte', 'kibibyte', ...]
+ */
+declare function getDigitalVariants(): DigitalUnit[];
+
+/**
+ * Color Role - Convert Pillar
+ *
+ * Conversão entre variantes de cor usando hub-and-spoke (via rgb_object/RGBA).
+ *
+ * @example
+ * import { convertColor, hexToRgba, rgbaToHex } from '@attrx/role-morphic/color/convert';
+ *
+ * convertColor('hex', 'rgb_object', '#ff0000');  // { r: 255, g: 0, b: 0, a: 1 }
+ * convertColor('rgb_object', 'hsl_string', { r: 255, g: 0, b: 0 }); // "hsl(0, 100%, 50%)"
+ */
+
+type Result$1<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Converte entre duas variantes de cor
+ *
+ * @param from - Variante de origem
+ * @param to - Variante de destino
+ * @param value - Valor a converter
+ * @returns Valor convertido
+ *
+ * @example
+ * convertColor('hex', 'rgb_object', '#ff0000');
+ * // { r: 255, g: 0, b: 0 }
+ */
+declare function convertColor<TFrom = unknown, TTo = unknown>(from: ColorVariant, to: ColorVariant, value: TFrom): TTo;
+/**
+ * Versão safe de convertColor que retorna Result
+ */
+declare function tryConvertColor<TFrom = unknown, TTo = unknown>(from: ColorVariant, to: ColorVariant, value: TFrom): Result$1<TTo>;
+
+/**
+ * Date Role - Convert Pillar
+ *
+ * Conversão entre variantes de data usando hub-and-spoke (via timestamp).
+ *
+ * @example
+ * import { convertDate, isoToTimestamp, epochToIso } from '@attrx/role-morphic/date/convert';
+ *
+ * convertDate('iso', 'epoch', '2024-12-05T19:30:00.000Z');  // 1733425800
+ * convertDate('epoch', 'iso', 1733425800);                  // '2024-12-05T19:30:00.000Z'
+ * isoToTimestamp('2024-12-05T19:30:00.000Z');               // 1733425800000
+ */
+
+type Result<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Converte entre duas variantes de data
+ *
+ * @param from - Variante de origem
+ * @param to - Variante de destino
+ * @param value - Valor a converter
+ * @returns Valor convertido
+ *
+ * @example
+ * convertDate('iso', 'epoch', '2024-12-05T19:30:00.000Z');  // 1733425800
+ * convertDate('epoch', 'iso', 1733425800);                  // '2024-12-05T19:30:00.000Z'
+ */
+declare function convertDate<TFrom = unknown, TTo = unknown>(from: DateVariant, to: DateVariant, value: TFrom): TTo;
+/**
+ * Versão safe de convertDate que retorna Result
+ */
+declare function tryConvertDate<TFrom = unknown, TTo = unknown>(from: DateVariant, to: DateVariant, value: TFrom): Result<TTo>;
+
+export { ANGLE_BASE, AREA_BASE, DIGITAL_BASE, ENERGY_BASE, FREQUENCY_BASE, LENGTH_BASE, MASS_BASE, POWER_BASE, PRESSURE_BASE, SPEED_BASE, TEMPERATURE_BASE, TIME_BASE, VOLUME_BASE, convertAngle, convertArea, convertColor, convertDate, convertDigital, convertEnergy, convertFrequency, convertLength, convertMass, convertPower, convertPressure, convertSpeed, convertTemperature, convertTime, convertVolume, fromBaseAngle, fromBaseArea, fromBaseDigital, fromBaseEnergy, fromBaseFrequency, fromBaseLength, fromBaseMass, fromBasePower, fromBasePressure, fromBaseSpeed, fromBaseTemperature, fromBaseTime, fromBaseVolume, getAngleVariants, getAreaVariants, getDigitalVariants, getEnergyVariants, getFrequencyVariants, getLengthVariants, getMassVariants, getPowerVariants, getPressureVariants, getSpeedVariants, getTemperatureVariants, getTimeVariants, getVolumeVariants, hasAngleVariant, hasAreaVariant, hasDigitalVariant, hasEnergyVariant, hasFrequencyVariant, hasLengthVariant, hasMassVariant, hasPowerVariant, hasPressureVariant, hasSpeedVariant, hasTemperatureVariant, hasTimeVariant, hasVolumeVariant, toBaseAngle, toBaseArea, toBaseDigital, toBaseEnergy, toBaseFrequency, toBaseLength, toBaseMass, toBasePower, toBasePressure, toBaseSpeed, toBaseTemperature, toBaseTime, toBaseVolume, tryConvertAngle, tryConvertArea, tryConvertColor, tryConvertDate, tryConvertDigital, tryConvertEnergy, tryConvertFrequency, tryConvertLength, tryConvertMass, tryConvertPower, tryConvertPressure, tryConvertSpeed, tryConvertTemperature, tryConvertTime, tryConvertVolume };