@attrx/role-morphic 0.1.0 → 0.2.0

package/dist/index.d.mts

@@ -1,303 +1,12 @@
-/**
- * RoleMorphic Types
- *
- * Sistema de tipos para conversão polimórfica de valores.
- * Um valor pode assumir múltiplas formas (variantes) mantendo sua identidade semântica.
- *
- * Os 4 Pilares:
- * - Cast: Normaliza input sujo para o tipo esperado
- * - Validate: Verifica regras semânticas do valor
- * - Convert: Transforma entre variantes (via base)
- * - Format: Apresenta o valor como string legível
- */
-/**
- * Função que converte um valor para o formato base da role
- */
-type ToBaseFn<TValue = unknown, TBase = unknown> = (value: TValue) => TBase;
-/**
- * Função que converte do formato base para uma variante específica
- */
-type FromBaseFn<TBase = unknown, TValue = unknown> = (base: TBase) => TValue;
-/**
- * Função que tenta normalizar um input desconhecido para o tipo esperado
- * Retorna null se não conseguir fazer o cast
- */
-type CastFn<TValue = unknown> = (input: unknown) => TValue | null;
-/**
- * Resultado de uma operação de cast
- */
-type CastResult<T> = {
-    ok: true;
-    value: T;
-} | {
-    ok: false;
-    error: string;
-};
-/**
- * Regras de validação para uma variante
- */
-type ValidationRule = {
-    /** Valor mínimo permitido (para números) */
-    min?: number;
-    /** Valor máximo permitido (para números) */
-    max?: number;
-    /** Deve ser inteiro (para números) */
-    integer?: boolean;
-    /** Pattern regex (para strings) */
-    pattern?: RegExp;
-    /** Função de validação customizada - retorna mensagem de erro ou null se válido */
-    custom?: (value: unknown) => string | null;
-};
-/**
- * Resultado de uma validação
- */
-type ValidationResult = {
-    valid: boolean;
-    errors: string[];
-};
-/**
- * Opções base de formatação (compartilhadas por todas as roles)
- */
-type BaseFormatOptions = {
-    /** Número de casas decimais */
-    decimals?: number;
-    /** Locale para formatação (ex: 'pt-BR', 'en-US') */
-    locale?: string;
-    /** Tipo de notação */
-    notation?: "standard" | "scientific" | "compact";
-    /** Usar nome completo ao invés de símbolo */
-    verbose?: boolean;
-};
-/**
- * Opções de formatação genéricas
- * @deprecated Use BaseFormatOptions ou tipos específicos (ColorFormatOptions, DateFormatOptions)
- */
-type FormatOptions = BaseFormatOptions;
-/**
- * Função de formatação customizada
- */
-type FormatFn<TValue = unknown> = (value: TValue, options?: BaseFormatOptions) => string;
-/**
- * Especificação de formatação para uma variante
- */
-type FormatSpec<TValue = unknown> = {
-    /** Símbolo da unidade (ex: "m²", "ha", "°C") */
-    symbol: string;
-    /** Nome singular (ex: "meter", "hectare") */
-    singular?: string;
-    /** Nome plural (ex: "meters", "hectares") */
-    plural?: string;
-    /** Formatador customizado (override do padrão) */
-    formatter?: FormatFn<TValue>;
-};
-/**
- * Definição de uma variante dentro de uma role
- *
- * Cada variante implementa os 4 pilares:
- * - Convert: toBase/fromBase (obrigatório)
- * - Cast: cast (opcional, usa default por type)
- * - Validate: validate (opcional)
- * - Format: format (opcional)
- */
-type VariantSpec<TValue = unknown, TBase = unknown> = {
-    /** Tipo primitivo do valor nesta variante */
-    type: "string" | "number" | "boolean" | "object" | "array";
-    /** Converte o valor desta variante para o formato base */
-    toBase: ToBaseFn<TValue, TBase>;
-    /** Converte do formato base para esta variante */
-    fromBase: FromBaseFn<TBase, TValue>;
-    /** Tenta normalizar um input desconhecido para o tipo esperado */
-    cast?: CastFn<TValue>;
-    /** Regras de validação semântica */
-    validate?: ValidationRule;
-    /** Especificação de formatação */
-    format?: FormatSpec<TValue>;
-};
-/**
- * Definição completa de uma Role
- *
- * Uma Role representa um conceito semântico (cor, área, data) que pode
- * ser expresso em múltiplas variantes (hex, rgb, hsl para cor).
- */
-type RoleSpec<TBase = unknown> = {
-    /** Nome da variante que serve como pivot para todas as conversões */
-    base: string;
-    /** Mapa de variantes disponíveis para esta role */
-    variants: Record<string, VariantSpec<unknown, TBase>>;
-};
-/**
- * Identificador de variante parseado
- *
- * "color:rgb:object" => { role: "color", variant: "rgb:object" }
- */
-type ParsedVariantId = {
-    role: string;
-    variant: string;
-};
-/**
- * Resultado de uma conversão que pode falhar
- */
-type ConversionResult<T> = {
-    ok: true;
-    value: T;
-} | {
-    ok: false;
-    error: string;
-};
-/**
- * Resultado de validação de reversibilidade
- */
-type ReversibilityResult = {
-    reversible: boolean;
-    original: unknown;
-    converted: unknown;
-    reconverted: unknown;
-};
-/**
- * Função que transforma um valor de uma role para outra
- */
-type MorpherFn<TFrom = unknown, TTo = unknown> = (value: TFrom) => TTo;
-/**
- * Chave de um morpher: "fromRole:fromVariant->toRole:toVariant"
- */
-type MorpherKey = `${string}->${string}`;
-/**
- * Definição de um morpher
- */
-type MorpherSpec<TFrom = unknown, TTo = unknown> = {
-    from: string;
-    to: string;
-    transform: MorpherFn<TFrom, TTo>;
-};
-
-/**
- * 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;
-}
+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
@@ -686,17 +395,133 @@ declare abstract class ComplexRole<TBase = unknown> implements IRole<TBase> {
 }
 
 /**
- * Area Role - Constants
+ * RoleMorphic
  *
- * Fatores de conversão, símbolos e aliases para unidades de área.
+ * Motor de conversão polimórfica de valores.
+ * Permite que um valor assuma múltiplas formas (variantes) mantendo sua identidade semântica.
  *
- * Fontes:
- * - NIST SP 811 (2008)
- * - International Yard and Pound Agreement (1959)
- * - SI Brochure, 9th Edition (2019)
+ * 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
  */
 
-type AreaUnit = "square_kilometer" | "hectare" | "are" | "square_meter" | "square_decimeter" | "square_centimeter" | "square_millimeter" | "square_mile" | "acre" | "square_yard" | "square_foot" | "square_inch";
+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";
@@ -708,45 +533,16 @@ declare class AreaRole extends SimpleRole {
 /** Instância singleton da AreaRole */
 declare const areaRole: AreaRole;
 
-/**
- * Length Role - Constants
- *
- * Fatores de conversão, símbolos e aliases para unidades de comprimento.
- *
- * Fontes:
- * - NIST SP 811 (2008)
- * - International Yard and Pound Agreement (1959)
- * - SI Brochure, 9th Edition (2019)
- */
-
-type LengthUnit = "kilometer" | "hectometer" | "decameter" | "meter" | "decimeter" | "centimeter" | "millimeter" | "micrometer" | "nanometer" | "inch" | "foot" | "yard" | "mile" | "nautical_mile" | "fathom" | "furlong" | "league";
-
 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;
 
-/**
- * Mass Role - Constants
- *
- * Fatores de conversão, símbolos e aliases para unidades de massa.
- *
- * Fontes:
- * - NIST SP 811 (2008)
- * - International Yard and Pound Agreement (1959)
- * - SI Brochure, 9th Edition (2019)
- *
- * Nota: Massa ≠ Peso
- * - Massa: quantidade de matéria (invariante)
- * - Peso: força gravitacional (varia com localização)
- */
-
-type MassUnit = "metric_ton" | "kilogram" | "hectogram" | "decagram" | "gram" | "decigram" | "centigram" | "milligram" | "microgram" | "long_ton" | "short_ton" | "stone" | "pound" | "ounce" | "dram" | "grain" | "troy_pound" | "troy_ounce" | "pennyweight";
-
 declare class MassRole extends SimpleRole {
     readonly name = "mass";
     readonly base = "kilogram";
@@ -757,21 +553,6 @@ declare class MassRole extends SimpleRole {
 /** Instância singleton da MassRole */
 declare const massRole: MassRole;
 
-/**
- * Temperature Role - Constants
- *
- * Fórmulas de conversão, símbolos e aliases para unidades de temperatura.
- *
- * IMPORTANTE: Temperatura usa FÓRMULAS, não fatores multiplicativos.
- * Isso porque as escalas têm offsets diferentes (0°C ≠ 0°F ≠ 0K).
- *
- * Fontes:
- * - NIST SP 811 (2008)
- * - SI Brochure, 9th Edition (2019)
- */
-
-type TemperatureUnit = "celsius" | "fahrenheit" | "kelvin" | "rankine";
-
 declare class TemperatureRole extends SimpleRole {
     readonly name = "temperature";
     readonly base = "celsius";
@@ -793,21 +574,6 @@ declare class TemperatureRole extends SimpleRole {
 /** Instância singleton da TemperatureRole */
 declare const temperatureRole: TemperatureRole;
 
-/**
- * Angle Role - Constants
- *
- * Fatores de conversão, símbolos e aliases para unidades de ângulo.
- *
- * Base: degree (grau) - mais comum em aplicações práticas.
- * Nota: Embora radiano seja a unidade SI, grau é mais intuitivo para a maioria dos casos.
- *
- * Fontes:
- * - SI Brochure, 9th Edition (2019)
- * - NIST SP 811 (2008)
- */
-
-type AngleUnit = "turn" | "degree" | "arcminute" | "arcsecond" | "milliarcsecond" | "radian" | "milliradian" | "gradian";
-
 declare class AngleRole extends SimpleRole {
     readonly name = "angle";
     readonly base = "degree";
@@ -817,19 +583,6 @@ declare class AngleRole extends SimpleRole {
 /** Instância singleton da AngleRole */
 declare const angleRole: AngleRole;
 
-/**
- * Energy Role - Constants
- *
- * Fatores de conversão, símbolos e aliases para unidades de energia.
- *
- * Fontes:
- * - NIST SP 811 (2008)
- * - SI Brochure, 9th Edition (2019)
- * - CODATA 2018 (electronvolt)
- */
-
-type EnergyUnit = "gigajoule" | "megajoule" | "kilojoule" | "joule" | "millijoule" | "calorie" | "kilocalorie" | "watt_hour" | "kilowatt_hour" | "megawatt_hour" | "gigawatt_hour" | "btu" | "therm" | "electronvolt" | "kiloelectronvolt" | "megaelectronvolt" | "erg" | "foot_pound";
-
 declare class EnergyRole extends SimpleRole {
     readonly name = "energy";
     readonly base = "joule";
@@ -840,18 +593,6 @@ declare class EnergyRole extends SimpleRole {
 /** Instância singleton da EnergyRole */
 declare const energyRole: EnergyRole;
 
-/**
- * Power Role - Constants
- *
- * Fatores de conversão, símbolos e aliases para unidades de potência.
- *
- * Fontes:
- * - NIST SP 811 (2008)
- * - SI Brochure, 9th Edition (2019)
- */
-
-type PowerUnit = "gigawatt" | "megawatt" | "kilowatt" | "watt" | "milliwatt" | "microwatt" | "horsepower_mechanical" | "horsepower_metric" | "horsepower_electric" | "horsepower_boiler" | "btu_per_hour" | "btu_per_second" | "ton_of_refrigeration" | "foot_pound_per_second" | "calorie_per_second" | "kilocalorie_per_hour";
-
 declare class PowerRole extends SimpleRole {
     readonly name = "power";
     readonly base = "watt";
@@ -862,19 +603,6 @@ declare class PowerRole extends SimpleRole {
 /** Instância singleton da PowerRole */
 declare const powerRole: PowerRole;
 
-/**
- * Speed Role - Constants
- *
- * Fatores de conversão, símbolos e aliases para unidades de velocidade.
- *
- * Fontes:
- * - NIST SP 811 (2008)
- * - SI Brochure, 9th Edition (2019)
- * - International Yard and Pound Agreement (1959)
- */
-
-type SpeedUnit = "meter_per_second" | "kilometer_per_hour" | "mile_per_hour" | "foot_per_second" | "knot" | "mach" | "speed_of_light";
-
 declare class SpeedRole extends SimpleRole {
     readonly name = "speed";
     readonly base = "meter_per_second";
@@ -884,49 +612,6 @@ declare class SpeedRole extends SimpleRole {
 /** Instância singleton da SpeedRole */
 declare const speedRole: SpeedRole;
 
-/**
- * Date Role - Types
- *
- * Tipos para representação de datas nas diferentes variantes.
- */
-/**
- * Tipo base para Date: timestamp em milissegundos (como JavaScript Date.getTime())
- *
- * @example
- * const ts: DateTimestamp = 1733425800000; // 2024-12-05T19:30:00.000Z
- */
-type DateTimestamp = number;
-/**
- * Variante ISO 8601
- *
- * @example
- * "2024-12-05T19:30:00.000Z"
- * "2024-12-05T19:30:00.000-03:00"
- * "2024-12-05"
- */
-type DateIso = string;
-/**
- * Variante Epoch (segundos desde 1970-01-01T00:00:00Z)
- *
- * @example
- * 1733425800 // 2024-12-05T19:30:00Z
- */
-type DateEpoch = number;
-type DateVariant = "iso" | "timestamp" | "epoch";
-
-interface DateFormatOptions extends BaseFormatOptions {
-    /** Estilo de data: "full", "long", "medium", "short" */
-    dateStyle?: "full" | "long" | "medium" | "short";
-    /** Estilo de hora: "full", "long", "medium", "short" */
-    timeStyle?: "full" | "long" | "medium" | "short";
-    /** Timezone (ex: "America/Sao_Paulo", "UTC") */
-    timeZone?: string;
-    /** Se true, mostra apenas data (sem hora) */
-    dateOnly?: boolean;
-    /** Se true, mostra apenas hora (sem data) */
-    timeOnly?: boolean;
-}
-
 /**
  * DateRole - Role para conversão e manipulação de datas
  *
@@ -955,24 +640,6 @@ declare class DateRole extends ComplexRole<DateTimestamp> {
 /** Instância singleton da DateRole */
 declare const dateRole: DateRole;
 
-/**
- * Volume Role - Constants
- *
- * Fatores de conversão, símbolos e aliases para unidades de volume.
- *
- * Fontes:
- * - NIST SP 811 (2008)
- * - NIST Handbook 44 (2024)
- * - SI Brochure, 9th Edition (2019)
- *
- * Notas:
- * - Base: liter (L) - unidade aceita para uso com o SI
- * - 1 L = 1 dm³ = 0.001 m³
- * - Galão US vs UK: ~20% diferença (UK é maior)
- */
-
-type VolumeUnit = "cubic_meter" | "cubic_decimeter" | "cubic_centimeter" | "cubic_millimeter" | "hectoliter" | "decaliter" | "liter" | "deciliter" | "centiliter" | "milliliter" | "microliter" | "gallon_us" | "quart_us" | "pint_us" | "cup_us" | "fluid_ounce_us" | "tablespoon_us" | "teaspoon_us" | "gallon_uk" | "quart_uk" | "pint_uk" | "fluid_ounce_uk" | "barrel_oil" | "cubic_inch" | "cubic_foot" | "cubic_yard";
-
 declare class VolumeRole extends SimpleRole {
     readonly name = "volume";
     readonly base = "liter";
@@ -983,18 +650,6 @@ declare class VolumeRole extends SimpleRole {
 /** Instância singleton da VolumeRole */
 declare const volumeRole: VolumeRole;
 
-/**
- * Time Role - Constants
- *
- * Fatores de conversão, símbolos e aliases para unidades de tempo/duração.
- *
- * Fontes:
- * - SI Brochure, 9th Edition (2019)
- * - Gregorian calendar (365.2425 dias/ano)
- */
-
-type TimeUnit = "nanosecond" | "microsecond" | "millisecond" | "second" | "minute" | "hour" | "day" | "week" | "month" | "year" | "decade" | "century" | "millennium";
-
 declare class TimeRole extends SimpleRole {
     readonly name = "time";
     readonly base = "second";
@@ -1005,22 +660,6 @@ declare class TimeRole extends SimpleRole {
 /** Instância singleton da TimeRole */
 declare const timeRole: TimeRole;
 
-/**
- * Digital Storage Role - Constants
- *
- * Fatores de conversão, símbolos e aliases para unidades de armazenamento digital.
- *
- * Fontes:
- * - IEC 60027-2 (prefixos binários)
- * - SI Brochure, 9th Edition (2019)
- *
- * IMPORTANTE: Esta biblioteca suporta AMBOS os sistemas:
- * - SI (decimal): kB, MB, GB, TB (base 1000)
- * - IEC (binário): KiB, MiB, GiB, TiB (base 1024)
- */
-
-type DigitalUnit = "bit" | "byte" | "kibibyte" | "mebibyte" | "gibibyte" | "tebibyte" | "pebibyte" | "exbibyte" | "kilobyte" | "megabyte" | "gigabyte" | "terabyte" | "petabyte" | "exabyte";
-
 declare class DigitalRole extends SimpleRole {
     readonly name = "digital";
     readonly base = "byte";
@@ -1031,18 +670,6 @@ declare class DigitalRole extends SimpleRole {
 /** Instância singleton da DigitalRole */
 declare const digitalRole: DigitalRole;
 
-/**
- * Frequency Role - Constants
- *
- * Fatores de conversão, símbolos e aliases para unidades de frequência.
- *
- * Fontes:
- * - SI Brochure, 9th Edition (2019)
- * - NIST SP 811
- */
-
-type FrequencyUnit = "terahertz" | "gigahertz" | "megahertz" | "kilohertz" | "hertz" | "millihertz" | "microhertz" | "rpm" | "bpm" | "radians_per_second" | "cycles_per_minute";
-
 declare class FrequencyRole extends SimpleRole {
     readonly name = "frequency";
     readonly base = "hertz";
@@ -1053,19 +680,6 @@ declare class FrequencyRole extends SimpleRole {
 /** Instância singleton da FrequencyRole */
 declare const frequencyRole: FrequencyRole;
 
-/**
- * Pressure Role - Constants
- *
- * Fatores de conversão, símbolos e aliases para unidades de pressão.
- *
- * Fontes:
- * - SI Brochure, 9th Edition (2019)
- * - NIST SP 811
- * - 10th CGPM (1954) - definição da atmosfera padrão
- */
-
-type PressureUnit = "megapascal" | "kilopascal" | "hectopascal" | "pascal" | "bar" | "millibar" | "atmosphere" | "torr" | "mmhg" | "inhg" | "psi" | "ksi" | "cmh2o" | "inh2o";
-
 declare class PressureRole extends SimpleRole {
     readonly name = "pressure";
     readonly base = "pascal";
@@ -1076,87 +690,6 @@ declare class PressureRole extends SimpleRole {
 /** Instância singleton da PressureRole */
 declare const pressureRole: PressureRole;
 
-/**
- * Color Role - Types
- *
- * Tipos para representação de cores nas diferentes variantes.
- */
-/**
- * Tipo base para Color: objeto RGBA com valores 0-255 e alpha 0-1
- *
- * @example
- * const red: RGBA = { r: 255, g: 0, b: 0, a: 1 };
- * const semiTransparent: RGBA = { r: 0, g: 0, b: 255, a: 0.5 };
- */
-interface RGBA {
-    r: number;
-    g: number;
-    b: number;
-    a: number;
-}
-/**
- * Variante Hex
- *
- * @example
- * "#ff0000"     // RGB (6 chars)
- * "#ff0000ff"   // RGBA (8 chars)
- * "#f00"        // RGB shorthand (3 chars)
- * "#f00f"       // RGBA shorthand (4 chars)
- */
-type ColorHex = string;
-/**
- * Variante RGB Object
- *
- * @example
- * { r: 255, g: 0, b: 0 }
- * { r: 255, g: 0, b: 0, a: 0.5 }
- */
-interface ColorRgbObject {
-    r: number;
-    g: number;
-    b: number;
-    a?: number;
-}
-/**
- * Variante RGB String
- *
- * @example
- * "rgb(255, 0, 0)"
- * "rgba(255, 0, 0, 0.5)"
- */
-type ColorRgbString = string;
-/**
- * Variante HSL Object
- *
- * @example
- * { h: 0, s: 100, l: 50 }        // Red
- * { h: 0, s: 100, l: 50, a: 0.5 } // Semi-transparent red
- */
-interface ColorHslObject {
-    h: number;
-    s: number;
-    l: number;
-    a?: number;
-}
-/**
- * Variante HSL String
- *
- * @example
- * "hsl(0, 100%, 50%)"
- * "hsla(0, 100%, 50%, 0.5)"
- */
-type ColorHslString = string;
-type ColorVariant = "hex" | "rgb_object" | "rgb_string" | "hsl_object" | "hsl_string";
-
-interface ColorFormatOptions extends BaseFormatOptions {
-    /** Se true, usa letras maiúsculas para hex */
-    uppercase?: boolean;
-    /** Se true, inclui alpha mesmo quando é 1 */
-    includeAlpha?: boolean;
-    /** Se true, usa formato compacto (shorthand hex, sem espaços em rgb) */
-    compact?: boolean;
-}
-
 /**
  * ColorRole - Role para conversão e manipulação de cores
  *
@@ -1187,4 +720,70 @@ declare class ColorRole extends ComplexRole<RGBA> {
 /** Instância singleton da ColorRole */
 declare const colorRole: ColorRole;
 
-export { AngleRole, type AngleUnit, AreaRole, type AreaUnit, type BaseFormatOptions, type CastFn, type CastResult, type ColorHex, type ColorHslObject, type ColorHslString, type ColorRgbObject, type ColorRgbString, ColorRole, type ColorVariant, type ConversionResult, type DateEpoch, type DateIso, DateRole, type DateTimestamp, type DateVariant, DigitalRole, type DigitalUnit, EnergyRole, type EnergyUnit, type FormatFn, type FormatOptions, type FormatSpec, FrequencyRole, type FrequencyUnit, type FromBaseFn, LengthRole, type LengthUnit, MassRole, type MassUnit, type MorpherFn, type MorpherKey, type MorpherSpec, type ParsedVariantId, PowerRole, type PowerUnit, PressureRole, type PressureUnit, type RGBA, type ReversibilityResult, RoleMorphic, type RoleSpec, SpeedRole, type SpeedUnit, TemperatureRole, type TemperatureUnit, TimeRole, type TimeUnit, type ToBaseFn, type ValidationResult, type ValidationRule, type VariantSpec, VolumeRole, type VolumeUnit, angleRole, areaRole, colorRole, dateRole, digitalRole, energyRole, frequencyRole, lengthRole, massRole, powerRole, pressureRole, speedRole, temperatureRole, timeRole, volumeRole };
+/**
+ * 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 };