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