import { V as ValidationResult, B as BaseFormatOptions, R as RoleSpec, P as ParsedVariantId, a as VariantSpec, C as ConversionResult, b as ReversibilityResult, M as MorpherSpec, T as TemperatureUnit, D as DateTimestamp, c as DateFormatOptions, d as RGBA, e as ColorFormatOptions } from './types-mbeS1e-k.mjs';
export { m as CastFn, n as CastResult, s as ColorHex, v as ColorHslObject, w as ColorHslString, t as ColorRgbObject, u as ColorRgbString, r as ColorVariant, q as DateEpoch, p as DateIso, o as DateVariant, k as FormatFn, i as FormatOptions, j as FormatSpec, F as FromBaseFn, g as MorpherFn, h as MorpherKey, f as ToBaseFn, l as ValidationRule } from './types-mbeS1e-k.mjs';
import { CurrencyValidationConfig } from './validate.mjs';
export { AREA_VALIDATION_CONFIG, AngleValidationConfig, AreaValidationConfig, CURRENCY_VALIDATION_CONFIG, DIGITAL_VALIDATION_CONFIG, DigitalValidationConfig, ENERGY_VALIDATION_CONFIG, EnergyValidationConfig, FREQUENCY_VALIDATION_CONFIG, FrequencyValidationConfig, LENGTH_VALIDATION_CONFIG, LengthValidationConfig, MASS_VALIDATION_CONFIG, MassValidationConfig, POWER_VALIDATION_CONFIG, PRESSURE_VALIDATION_CONFIG, PowerValidationConfig, PressureValidationConfig, SpeedValidationConfig, TIME_VALIDATION_CONFIG, TemperatureValidationConfig, TimeValidationConfig, VOLUME_VALIDATION_CONFIG, VolumeValidationConfig, isValidAngle, isValidArea, isValidColorVariant, isValidCurrency, isValidDate, isValidDigital, isValidEnergy, isValidFrequency, isValidLength, isValidMass, isValidPower, isValidPressure, isValidSpeed, isValidTemperature, isValidTime, isValidVolume, validateAngle, validateArea, validateColor, validateCurrency, validateDate, validateDigital, validateEnergy, validateFrequency, validateLength, validateMass, validatePower, validatePressure, validateSpeed, validateTemperature, validateTime, validateVolume } from './validate.mjs';
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 } from './convert.mjs';
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 } from './cast.mjs';
import { C as CurrencyFormatOptions, a as CurrencyCode } from './format-o4Y3jPH-.mjs';
export { r as CurrencyConfig, l as formatAngle, f as formatArea, o as formatColor, q as formatCurrency, p as formatDate, n as formatDigital, h as formatEnergy, k as formatFrequency, b as formatLength, c as formatMass, i as formatPower, j as formatPressure, g as formatSpeed, d as formatTemperature, m as formatTime, e as formatVolume } from './format-o4Y3jPH-.mjs';
import { A as AreaUnit, L as LengthUnit, M as MassUnit, a as AngleUnit, E as EnergyUnit, P as PowerUnit, S as SpeedUnit, V as VolumeUnit, T as TimeUnit, D as DigitalUnit, F as FrequencyUnit, b as PressureUnit } from './constants-BZdBwuvJ.mjs';

/**
 * IRole - Interface principal que todas as Roles devem implementar
 *
 * Define o contrato dos 4 pilares: Convert, Cast, Validate, Format
 *
 * @example
 * class AreaRole implements IRole { ... }
 * class ColorRole implements IRole { ... }
 */

/**
 * Resultado de operação que pode falhar
 */
type Result<T> = {
    ok: true;
    value: T;
} | {
    ok: false;
    error: string;
};
/**
 * Interface que TODA Role deve implementar.
 *
 * Uma Role representa um conceito semântico (área, cor, data) que pode
 * ser expresso em múltiplas variantes (m², hectare, acre).
 *
 * Os 4 pilares:
 * - **Convert**: Transforma entre variantes (via base)
 * - **Cast**: Normaliza input sujo para o tipo esperado
 * - **Validate**: Verifica regras semânticas
 * - **Format**: Apresenta como string legível
 */
interface IRole<TBase = unknown> {
    /** Nome único da role (ex: "area", "color", "temperature") */
    readonly name: string;
    /** Nome da variante base/pivot (ex: "square_meter", "rgb_object") */
    readonly base: string;
    /** Retorna lista de todas as variantes disponíveis */
    getVariants(): string[];
    /** Verifica se uma variante existe */
    hasVariant(variant: string): boolean;
    /**
     * Converte valor entre variantes da mesma role.
     * Usa arquitetura hub-and-spoke: from → base → to
     *
     * @throws Error se variante não existir
     *
     * @example
     * areaRole.convert('hectare', 'acre', 1) // 2.47105
     */
    convert<TFrom = unknown, TTo = unknown>(from: string, to: string, value: TFrom): TTo;
    /**
     * Versão safe do convert que retorna Result ao invés de throw
     *
     * @example
     * const result = areaRole.tryConvert('hectare', 'acre', 1);
     * if (result.ok) console.log(result.value);
     */
    tryConvert<TFrom = unknown, TTo = unknown>(from: string, to: string, value: TFrom): Result<TTo>;
    /**
     * Converte qualquer variante para a base
     *
     * @example
     * areaRole.toBase('hectare', 1) // 10000 (m²)
     */
    toBase<T = unknown>(variant: string, value: T): TBase;
    /**
     * Converte da base para qualquer variante
     *
     * @example
     * areaRole.fromBase('hectare', 10000) // 1
     */
    fromBase<T = unknown>(variant: string, baseValue: TBase): T;
    /**
     * Tenta normalizar um input desconhecido para o tipo esperado pela variante.
     * Retorna null se não conseguir fazer o cast.
     *
     * @example
     * areaRole.cast('hectare', "100 ha")     // 100
     * areaRole.cast('hectare', "100")        // 100
     * areaRole.cast('hectare', 100)          // 100
     * areaRole.cast('hectare', "invalid")    // null
     */
    cast<T = unknown>(variant: string, input: unknown): T | null;
    /**
     * Versão safe do cast que retorna Result
     *
     * @example
     * const result = areaRole.tryCast('hectare', "100 ha");
     * if (result.ok) console.log(result.value);
     */
    tryCast<T = unknown>(variant: string, input: unknown): Result<T>;
    /**
     * Valida se um valor atende às regras semânticas da variante.
     * Retorna objeto com valid: boolean e errors: string[]
     *
     * @example
     * areaRole.validate('hectare', 100)  // { valid: true, errors: [] }
     * areaRole.validate('hectare', -5)   // { valid: false, errors: ['Area cannot be negative'] }
     */
    validate(variant: string, value: unknown): ValidationResult;
    /**
     * Versão simplificada que retorna apenas boolean
     *
     * @example
     * areaRole.isValid('hectare', 100) // true
     * areaRole.isValid('hectare', -5)  // false
     */
    isValid(variant: string, value: unknown): boolean;
    /**
     * Formata valor para apresentação humana.
     *
     * @example
     * areaRole.format('hectare', 2.5)                        // "2.5 ha"
     * areaRole.format('hectare', 2.5, { verbose: true })     // "2.5 hectares"
     * areaRole.format('hectare', 1000, { locale: 'pt-BR' })  // "1.000 ha"
     */
    format(variant: string, value: unknown, options?: BaseFormatOptions): string;
    /**
     * Gera RoleSpec para registro no RoleMorphic (backward compatible).
     * Permite usar a nova arquitetura de classes com a API existente.
     *
     * @example
     * const morph = new RoleMorphic();
     * morph.register('area', areaRole.toSpec());
     */
    toSpec(): RoleSpec<TBase>;
}

/**
 * IVariant - Interface para variantes de ComplexRole
 *
 * Cada variante complexa (hex, rgb:object, hsl:string) implementa esta interface.
 * Usada quando variantes têm tipos/estruturas diferentes.
 *
 * @example
 * class HexVariant implements IVariant<string, RGBA> { ... }
 * class RgbObjectVariant implements IVariant<RGBA, RGBA> { ... }
 */

/**
 * Interface para uma variante de ComplexRole.
 *
 * @typeParam TValue - Tipo do valor nesta variante (ex: string para hex, RGBA para rgb:object)
 * @typeParam TBase - Tipo da base da role (ex: RGBA para color)
 *
 * @example
 * // Variante hex de Color
 * class HexVariant implements IVariant<string, RGBA> {
 *   name = 'hex';
 *   type = 'string';
 *
 *   toBase(hex: string): RGBA { ... }
 *   fromBase(rgba: RGBA): string { ... }
 *   cast(input: unknown): string | null { ... }
 *   validate(hex: string): ValidationResult { ... }
 *   format(hex: string, opts?): string { ... }
 * }
 */
interface IVariant<TValue = unknown, TBase = unknown> {
    /** Nome da variante (ex: "hex", "rgb:object", "hsl:string") */
    readonly name: string;
    /** Tipo primitivo do valor (ex: "string", "object") */
    readonly type: "string" | "number" | "boolean" | "object" | "array";
    /**
     * Converte valor desta variante para o formato base da role.
     *
     * @example
     * hexVariant.toBase('#ff0000') // { r: 255, g: 0, b: 0, a: 1 }
     */
    toBase(value: TValue): TBase;
    /**
     * Converte do formato base para esta variante.
     *
     * @example
     * hexVariant.fromBase({ r: 255, g: 0, b: 0, a: 1 }) // '#ff0000ff'
     */
    fromBase(base: TBase): TValue;
    /**
     * Tenta normalizar um input desconhecido para o tipo desta variante.
     * Retorna null se não conseguir.
     *
     * @example
     * hexVariant.cast('ff0000')        // '#ff0000'
     * hexVariant.cast('red')           // '#ff0000'
     * hexVariant.cast('rgb(255,0,0)')  // '#ff0000'
     * hexVariant.cast(123)             // null
     */
    cast(input: unknown): TValue | null;
    /**
     * Versão safe que retorna Result
     */
    tryCast(input: unknown): Result<TValue>;
    /**
     * Valida se um valor atende às regras desta variante.
     *
     * @example
     * hexVariant.validate('#ff0000')   // { valid: true, errors: [] }
     * hexVariant.validate('#gg0000')   // { valid: false, errors: ['Invalid hex character'] }
     */
    validate(value: TValue): ValidationResult;
    /**
     * Versão simplificada que retorna boolean
     */
    isValid(value: TValue): boolean;
    /**
     * Formata valor para apresentação humana.
     *
     * @example
     * hexVariant.format('#ff0000')                      // '#ff0000'
     * hexVariant.format('#ff0000', { uppercase: true }) // '#FF0000'
     */
    format(value: TValue, options?: BaseFormatOptions): string;
}

/**
 * SimpleRole - Classe base abstrata para roles numéricas
 *
 * Para roles onde TODAS as variantes são do mesmo tipo (geralmente number).
 * Implementa os 4 pilares com lógica compartilhada via fatores de conversão.
 *
 * Roles que estendem: Area, Length, Mass, Volume, Speed, Pressure, Energy, etc.
 *
 * @example
 * class AreaRole extends SimpleRole<number> {
 *   readonly name = 'area';
 *   readonly base = 'square_meter';
 *   readonly factors = { square_meter: 1, hectare: 10000, acre: 4046.86 };
 *   readonly symbols = { square_meter: 'm²', hectare: 'ha', acre: 'ac' };
 * }
 */

/**
 * Configuração de uma unidade em SimpleRole
 */
interface SimpleUnitConfig {
    /** Fator de conversão para a base (ou função para temperatura) */
    factor?: number;
    /** Fórmula de conversão para base (para temperatura) */
    toBase?: (value: number) => number;
    /** Fórmula de conversão da base (para temperatura) */
    fromBase?: (value: number) => number;
    /** Símbolo da unidade (ex: "m²", "ha") */
    symbol: string;
    /** Nome singular (ex: "hectare") */
    singular?: string;
    /** Nome plural (ex: "hectares") */
    plural?: string;
    /** Se true, não adiciona espaço antes do símbolo (ex: 45° ao invés de 45 °) */
    noSpace?: boolean;
}
/**
 * Configuração de validação para SimpleRole
 */
interface SimpleValidationConfig {
    /** Valor mínimo permitido */
    min?: number;
    /** Valor máximo permitido */
    max?: number;
    /** Deve ser inteiro */
    integer?: boolean;
    /** Mensagem de erro customizada para min */
    minError?: string;
    /** Mensagem de erro customizada para max */
    maxError?: string;
}
/**
 * Alias para reconhecimento no cast
 */
type UnitAliases = Record<string, string>;
/**
 * Classe base abstrata para roles numéricas simples.
 *
 * Subclasses devem definir:
 * - name: Nome da role
 * - base: Variante base
 * - units: Configuração de cada unidade
 * - aliases: (opcional) Aliases para cast
 * - validation: (opcional) Regras de validação
 */
declare abstract class SimpleRole implements IRole<number> {
    /** Nome único da role */
    abstract readonly name: string;
    /** Nome da variante base */
    abstract readonly base: string;
    /** Configuração de cada unidade */
    abstract readonly units: Record<string, SimpleUnitConfig>;
    /** Aliases para reconhecimento no cast (ex: "ha" → "hectare") */
    readonly aliases: UnitAliases;
    /** Regras de validação */
    readonly validation: SimpleValidationConfig;
    getVariants(): string[];
    hasVariant(variant: string): boolean;
    convert<TFrom = number, TTo = number>(from: string, to: string, value: TFrom): TTo;
    tryConvert<TFrom = number, TTo = number>(from: string, to: string, value: TFrom): Result<TTo>;
    toBase<T = number>(variant: string, value: T): number;
    fromBase<T = number>(variant: string, baseValue: number): T;
    cast<T = number>(variant: string, input: unknown): T | null;
    tryCast<T = number>(variant: string, input: unknown): Result<T>;
    /**
     * Parseia string para número, detectando unidade se presente.
     * Subclasses podem sobrescrever para lógica customizada.
     */
    protected parseString(input: string, targetVariant: string): number | null;
    /**
     * Parseia string numérica considerando formatos brasileiro e americano
     */
    protected parseNumber(numStr: string): number | null;
    /**
     * Detecta unidade a partir de string (símbolo ou alias)
     */
    protected detectUnit(unitStr: string): string | null;
    validate(variant: string, value: unknown): ValidationResult;
    isValid(variant: string, value: unknown): boolean;
    format(variant: string, value: unknown, options?: BaseFormatOptions): string;
    toSpec(): RoleSpec<number>;
}

/**
 * ComplexRole - Classe base abstrata para roles com variantes heterogêneas
 *
 * Para roles onde cada variante tem tipo/estrutura diferente.
 * Cada variante é implementada como sua própria classe (IVariant).
 *
 * Roles que estendem: Color, Date, etc.
 *
 * @example
 * class ColorRole extends ComplexRole<RGBA> {
 *   readonly name = 'color';
 *   readonly base = 'rgb_object';
 *
 *   protected createVariants() {
 *     return {
 *       'hex': new HexVariant(),
 *       'rgb_object': new RgbObjectVariant(),
 *       'rgb_string': new RgbStringVariant(),
 *       'hsl_object': new HslObjectVariant(),
 *     };
 *   }
 * }
 */

/**
 * Classe base abstrata para roles com variantes heterogêneas.
 *
 * Subclasses devem definir:
 * - name: Nome da role
 * - base: Variante base
 * - createVariants(): Factory que retorna mapa de variantes
 *
 * @typeParam TBase - Tipo do valor na variante base
 */
declare abstract class ComplexRole<TBase = unknown> implements IRole<TBase> {
    /** Nome único da role */
    abstract readonly name: string;
    /** Nome da variante base */
    abstract readonly base: string;
    /** Cache das variantes */
    private _variants;
    /**
     * Factory method para criar variantes.
     * Subclasses devem implementar.
     */
    protected abstract createVariants(): Record<string, IVariant<unknown, TBase>>;
    /**
     * Retorna mapa de variantes (lazy initialization)
     */
    protected get variants(): Map<string, IVariant<unknown, TBase>>;
    /**
     * Retorna uma variante específica
     */
    protected getVariant(name: string): IVariant<unknown, TBase>;
    getVariants(): string[];
    hasVariant(variant: string): boolean;
    convert<TFrom = unknown, TTo = unknown>(from: string, to: string, value: TFrom): TTo;
    tryConvert<TFrom = unknown, TTo = unknown>(from: string, to: string, value: TFrom): Result<TTo>;
    toBase<T = unknown>(variant: string, value: T): TBase;
    fromBase<T = unknown>(variant: string, baseValue: TBase): T;
    cast<T = unknown>(variant: string, input: unknown): T | null;
    tryCast<T = unknown>(variant: string, input: unknown): Result<T>;
    validate(variant: string, value: unknown): ValidationResult;
    isValid(variant: string, value: unknown): boolean;
    format(variant: string, value: unknown, options?: BaseFormatOptions): string;
    toSpec(): RoleSpec<TBase>;
}

/**
 * RoleMorphic
 *
 * Motor de conversão polimórfica de valores.
 * Permite que um valor assuma múltiplas formas (variantes) mantendo sua identidade semântica.
 *
 * Arquitetura Hub-and-Spoke:
 * - Cada role tem uma variante BASE que serve como pivot
 * - Toda conversão passa pela base: origem -> base -> destino
 * - Isso reduz a complexidade de N² para 2N conversões
 */

declare class RoleMorphic {
    /** Registry de roles */
    private roles;
    /** Registry de morphers (transformações cross-role) */
    private morphers;
    /**
     * Registra uma nova role
     */
    register<TBase = unknown>(roleId: string, spec: RoleSpec<TBase>): this;
    /**
     * Remove uma role registrada
     */
    unregister(roleId: string): boolean;
    /**
     * Verifica se uma role está registrada
     */
    hasRole(roleId: string): boolean;
    /**
     * Obtém a spec de uma role
     */
    getRole(roleId: string): RoleSpec | undefined;
    /**
     * Lista todas as roles registradas
     */
    listRoles(): string[];
    /**
     * Parseia um identificador de variante
     *
     * "color:rgb:object" => { role: "color", variant: "rgb:object" }
     * "area:m2" => { role: "area", variant: "m2" }
     */
    parseVariantId(fullId: string): ParsedVariantId;
    /**
     * Verifica se uma variante existe
     */
    hasVariant(fullId: string): boolean;
    /**
     * Obtém a spec de uma variante
     */
    getVariant(fullId: string): VariantSpec | undefined;
    /**
     * Lista todas as variantes de uma role
     */
    listVariants(roleId: string): string[];
    /**
     * Lista variantes para as quais uma variante pode converter
     */
    getConvertibleVariants(fullId: string): string[];
    /**
     * Converte um valor de uma variante para outra (mesma role)
     *
     * @param from - Identificador da variante de origem (ex: "color:hex")
     * @param to - Identificador da variante de destino (ex: "color:rgb:object")
     * @param value - Valor a converter
     * @returns Valor convertido
     * @throws Error se a conversão não for possível
     */
    convert<TFrom = unknown, TTo = unknown>(from: string, to: string, value: TFrom): TTo;
    /**
     * Tenta converter, retornando Result ao invés de throw
     */
    tryConvert<TFrom = unknown, TTo = unknown>(from: string, to: string, value: TFrom): ConversionResult<TTo>;
    /**
     * Verifica se uma conversão é reversível (sem perda de dados)
     */
    isReversible<T = unknown>(from: string, to: string, value: T): boolean;
    /**
     * Retorna detalhes sobre a reversibilidade de uma conversão
     */
    checkReversibility<T = unknown>(from: string, to: string, value: T): ReversibilityResult;
    /**
     * Converte apenas se a conversão for reversível
     *
     * @throws Error se a conversão causar perda de dados
     */
    convertSafe<TFrom = unknown, TTo = unknown>(from: string, to: string, value: TFrom): TTo;
    /**
     * Registra um morpher para transformação entre roles diferentes
     */
    registerMorpher<TFrom = unknown, TTo = unknown>(spec: MorpherSpec<TFrom, TTo>): this;
    /**
     * Remove um morpher
     */
    unregisterMorpher(from: string, to: string): boolean;
    /**
     * Verifica se existe um morpher para a transformação
     */
    hasMorpher(from: string, to: string): boolean;
    /**
     * Lista morphers disponíveis a partir de uma variante
     */
    getMorphersFrom(from: string): string[];
    /**
     * Transforma um valor de uma role para outra usando um morpher registrado
     */
    morph<TFrom = unknown, TTo = unknown>(from: string, to: string, value: TFrom): TTo;
    /**
     * Tenta transformar, retornando Result ao invés de throw
     */
    tryMorph<TFrom = unknown, TTo = unknown>(from: string, to: string, value: TFrom): ConversionResult<TTo>;
    /**
     * Converte ou transforma automaticamente
     *
     * - Se mesma role: usa convert()
     * - Se roles diferentes: usa morph()
     */
    auto<TFrom = unknown, TTo = unknown>(from: string, to: string, value: TFrom): TTo;
    /**
     * Converte um valor para a variante base da sua role
     */
    toBase<T = unknown, TBase = unknown>(fullId: string, value: T): TBase;
    /**
     * Converte um valor da base para uma variante específica
     */
    fromBase<TBase = unknown, T = unknown>(fullId: string, baseValue: TBase): T;
}

declare class AreaRole extends SimpleRole {
    readonly name = "area";
    readonly base = "square_meter";
    readonly units: Record<AreaUnit, SimpleUnitConfig>;
    readonly aliases: UnitAliases;
    readonly validation: SimpleValidationConfig;
}
/** Instância singleton da AreaRole */
declare const areaRole: AreaRole;

declare class LengthRole extends SimpleRole {
    readonly name = "length";
    readonly base = "meter";
    readonly units: Record<LengthUnit, SimpleUnitConfig>;
    readonly aliases: UnitAliases;
    readonly validation: SimpleValidationConfig;
}
/** Instância singleton da LengthRole */
declare const lengthRole: LengthRole;

declare class MassRole extends SimpleRole {
    readonly name = "mass";
    readonly base = "kilogram";
    readonly units: Record<MassUnit, SimpleUnitConfig>;
    readonly aliases: UnitAliases;
    readonly validation: SimpleValidationConfig;
}
/** Instância singleton da MassRole */
declare const massRole: MassRole;

declare class TemperatureRole extends SimpleRole {
    readonly name = "temperature";
    readonly base = "celsius";
    readonly units: Record<TemperatureUnit, SimpleUnitConfig>;
    readonly aliases: UnitAliases;
    readonly validation: SimpleValidationConfig;
    /**
     * Override validate para considerar o zero absoluto na escala correta
     */
    validate(variant: string, value: unknown): {
        valid: boolean;
        errors: string[];
    };
    /**
     * Retorna o zero absoluto na escala especificada
     */
    private getAbsoluteZero;
}
/** Instância singleton da TemperatureRole */
declare const temperatureRole: TemperatureRole;

declare class AngleRole extends SimpleRole {
    readonly name = "angle";
    readonly base = "degree";
    readonly units: Record<AngleUnit, SimpleUnitConfig>;
    readonly aliases: UnitAliases;
}
/** Instância singleton da AngleRole */
declare const angleRole: AngleRole;

declare class EnergyRole extends SimpleRole {
    readonly name = "energy";
    readonly base = "joule";
    readonly units: Record<EnergyUnit, SimpleUnitConfig>;
    readonly aliases: UnitAliases;
    readonly validation: SimpleValidationConfig;
}
/** Instância singleton da EnergyRole */
declare const energyRole: EnergyRole;

declare class PowerRole extends SimpleRole {
    readonly name = "power";
    readonly base = "watt";
    readonly units: Record<PowerUnit, SimpleUnitConfig>;
    readonly aliases: UnitAliases;
    readonly validation: SimpleValidationConfig;
}
/** Instância singleton da PowerRole */
declare const powerRole: PowerRole;

declare class SpeedRole extends SimpleRole {
    readonly name = "speed";
    readonly base = "meter_per_second";
    readonly units: Record<SpeedUnit, SimpleUnitConfig>;
    readonly aliases: UnitAliases;
}
/** Instância singleton da SpeedRole */
declare const speedRole: SpeedRole;

/**
 * DateRole - Role para conversão e manipulação de datas
 *
 * ComplexRole com 3 variantes:
 * - iso: string ISO 8601 ("2024-12-05T19:30:00.000Z")
 * - timestamp: number em milissegundos (1733425800000)
 * - epoch: number em segundos (1733425800)
 *
 * @example
 * const date = new DateRole();
 * date.convert('iso', 'epoch', '2024-12-05T19:30:00.000Z')  // 1733425800
 * date.convert('epoch', 'iso', 1733425800)                  // '2024-12-05T19:30:00.000Z'
 * date.cast('iso', '2024-12-05')                            // '2024-12-05T00:00:00.000Z'
 * date.format('iso', '2024-12-05T19:30:00.000Z', { dateStyle: 'full', locale: 'pt-BR' })
 */

declare class DateRole extends ComplexRole<DateTimestamp> {
    readonly name = "date";
    readonly base = "timestamp";
    protected createVariants(): Record<string, IVariant<unknown, DateTimestamp>>;
    /**
     * Override format to accept DateFormatOptions
     */
    format(variant: string, value: unknown, options?: DateFormatOptions): string;
}
/** Instância singleton da DateRole */
declare const dateRole: DateRole;

declare class VolumeRole extends SimpleRole {
    readonly name = "volume";
    readonly base = "liter";
    readonly units: Record<VolumeUnit, SimpleUnitConfig>;
    readonly aliases: UnitAliases;
    readonly validation: SimpleValidationConfig;
}
/** Instância singleton da VolumeRole */
declare const volumeRole: VolumeRole;

declare class TimeRole extends SimpleRole {
    readonly name = "time";
    readonly base = "second";
    readonly units: Record<TimeUnit, SimpleUnitConfig>;
    readonly aliases: UnitAliases;
    readonly validation: SimpleValidationConfig;
}
/** Instância singleton da TimeRole */
declare const timeRole: TimeRole;

declare class DigitalRole extends SimpleRole {
    readonly name = "digital";
    readonly base = "byte";
    readonly units: Record<DigitalUnit, SimpleUnitConfig>;
    readonly aliases: UnitAliases;
    readonly validation: SimpleValidationConfig;
}
/** Instância singleton da DigitalRole */
declare const digitalRole: DigitalRole;

declare class FrequencyRole extends SimpleRole {
    readonly name = "frequency";
    readonly base = "hertz";
    readonly units: Record<FrequencyUnit, SimpleUnitConfig>;
    readonly aliases: UnitAliases;
    readonly validation: SimpleValidationConfig;
}
/** Instância singleton da FrequencyRole */
declare const frequencyRole: FrequencyRole;

declare class PressureRole extends SimpleRole {
    readonly name = "pressure";
    readonly base = "pascal";
    readonly units: Record<PressureUnit, SimpleUnitConfig>;
    readonly aliases: UnitAliases;
    readonly validation: SimpleValidationConfig;
}
/** Instância singleton da PressureRole */
declare const pressureRole: PressureRole;

/**
 * ColorRole - Role para conversão e manipulação de cores
 *
 * ComplexRole com 5 variantes:
 * - hex: string hexadecimal ("#ff0000", "#ff0000ff")
 * - rgb_object: objeto { r, g, b, a? }
 * - rgb_string: string "rgb(255, 0, 0)" ou "rgba(255, 0, 0, 0.5)"
 * - hsl_object: objeto { h, s, l, a? }
 * - hsl_string: string "hsl(0, 100%, 50%)" ou "hsla(0, 100%, 50%, 0.5)"
 *
 * @example
 * const color = new ColorRole();
 * color.convert('hex', 'rgb_object', '#ff0000')  // { r: 255, g: 0, b: 0 }
 * color.convert('rgb_object', 'hsl_string', { r: 255, g: 0, b: 0 })  // "hsl(0, 100%, 50%)"
 * color.cast('hex', 'red')                        // '#ff0000'
 * color.format('hex', '#ff0000', { uppercase: true })  // '#FF0000'
 */

declare class ColorRole extends ComplexRole<RGBA> {
    readonly name = "color";
    readonly base = "rgb_object";
    protected createVariants(): Record<string, IVariant<unknown, RGBA>>;
    /**
     * Override format to accept ColorFormatOptions
     */
    format(variant: string, value: unknown, options?: ColorFormatOptions): string;
}
/** Instância singleton da ColorRole */
declare const colorRole: ColorRole;

/**
 * CurrencyRole - Role para valores monetários
 *
 * IMPORTANTE: Currency é diferente das outras roles!
 * - NÃO tem convert (conversão entre moedas é operação de negócio)
 * - O tipo de moeda (BRL, USD) é METADATA, não variante
 * - Apenas 3 pilares: validate, cast, format
 *
 * @example
 * // Functional style (preferido)
 * import { validateCurrency, castCurrency, formatCurrency } from '@attrx/role-morphic/currency';
 *
 * validateCurrency(100.50);                      // { valid: true, errors: [] }
 * castCurrency('R$ 1.500,50');                   // 1500.50
 * formatCurrency(1500.50, { currency: 'BRL' }); // "R$ 1.500,50"
 */

/**
 * CurrencyRole - classe wrapper para os 3 pilares
 *
 * Nota: Currency não estende SimpleRole porque não tem convert.
 * É uma role especial com apenas validate, cast e format.
 */
declare class CurrencyRole {
    readonly name = "currency";
    /**
     * Valida um valor monetário
     */
    validate(value: unknown, config?: CurrencyValidationConfig): {
        valid: boolean;
        errors: string[];
    };
    /**
     * Verifica se um valor monetário é válido
     */
    isValid(value: unknown, config?: CurrencyValidationConfig): boolean;
    /**
     * Faz cast de input para número
     */
    cast(input: unknown): number | null;
    /**
     * Versão safe de cast que retorna Result
     */
    tryCast(input: unknown): {
        ok: true;
        value: number;
    } | {
        ok: false;
        error: string;
    };
    /**
     * Formata valor monetário
     */
    format(value: number, options: CurrencyFormatOptions): string;
    /**
     * Lista códigos de moeda disponíveis
     */
    getCurrencyCodes(): CurrencyCode[];
    /**
     * Verifica se um código de moeda é válido
     */
    hasCurrency(code: string): code is CurrencyCode;
}
/** Instância singleton da CurrencyRole */
declare const currencyRole: CurrencyRole;

export { AngleRole, AngleUnit, AreaRole, AreaUnit, BaseFormatOptions, ColorRole, ConversionResult, CurrencyCode, CurrencyFormatOptions, CurrencyRole, CurrencyValidationConfig, DateRole, DateTimestamp, DigitalRole, DigitalUnit, EnergyRole, EnergyUnit, FrequencyRole, FrequencyUnit, LengthRole, LengthUnit, MassRole, MassUnit, MorpherSpec, ParsedVariantId, PowerRole, PowerUnit, PressureRole, PressureUnit, RGBA, ReversibilityResult, RoleMorphic, RoleSpec, SpeedRole, SpeedUnit, TemperatureRole, TemperatureUnit, TimeRole, TimeUnit, ValidationResult, VariantSpec, VolumeRole, VolumeUnit, angleRole, areaRole, colorRole, currencyRole, dateRole, digitalRole, energyRole, frequencyRole, lengthRole, massRole, powerRole, pressureRole, speedRole, temperatureRole, timeRole, volumeRole };