@attrx/role-morphic 0.1.0 → 0.2.0

package/dist/validate.d.ts

@@ -0,0 +1,884 @@
+import { T as TemperatureUnit, r as ColorVariant, o as DateVariant } from './types-mbeS1e-k.js';
+export { V as ValidationResult } from './types-mbeS1e-k.js';
+
+/**
+ * Area Role - Validate Pillar
+ *
+ * Validação semântica de valores de área.
+ * Zero dependências externas - pode ser usado standalone.
+ *
+ * @example
+ * import { validateArea, isValidArea } from '@attrx/role-morphic/area/validate';
+ *
+ * validateArea(100);   // { valid: true, errors: [] }
+ * validateArea(-5);    // { valid: false, errors: ['Area cannot be negative'] }
+ * isValidArea(100);    // true
+ */
+interface ValidationResult$f {
+    valid: boolean;
+    errors: string[];
+}
+interface AreaValidationConfig {
+    min?: number;
+    max?: number;
+    integer?: boolean;
+    minError?: string;
+    maxError?: string;
+}
+/**
+ * Configuração padrão de validação para área
+ */
+declare const AREA_VALIDATION_CONFIG: AreaValidationConfig;
+/**
+ * Valida um valor de área
+ *
+ * @param value - Valor a ser validado
+ * @param config - Configuração customizada (opcional)
+ * @returns Resultado da validação com erros se houver
+ *
+ * @example
+ * validateArea(100);              // { valid: true, errors: [] }
+ * validateArea(-5);               // { valid: false, errors: ['Area cannot be negative'] }
+ * validateArea(150, { max: 100 }) // { valid: false, errors: ['Value must be at most 100'] }
+ */
+declare function validateArea(value: unknown, config?: AreaValidationConfig): ValidationResult$f;
+/**
+ * Verifica se um valor de área é válido
+ *
+ * @param value - Valor a ser validado
+ * @param config - Configuração customizada (opcional)
+ * @returns true se válido, false caso contrário
+ *
+ * @example
+ * isValidArea(100);  // true
+ * isValidArea(-5);   // false
+ */
+declare function isValidArea(value: unknown, config?: AreaValidationConfig): boolean;
+
+/**
+ * Length Role - Validate Pillar
+ *
+ * Validação semântica de valores de comprimento.
+ * Zero dependências externas - pode ser usado standalone.
+ *
+ * @example
+ * import { validateLength, isValidLength } from '@attrx/role-morphic/length/validate';
+ *
+ * validateLength(100);   // { valid: true, errors: [] }
+ * validateLength(-5);    // { valid: false, errors: ['Length cannot be negative'] }
+ * isValidLength(100);    // true
+ */
+interface ValidationResult$e {
+    valid: boolean;
+    errors: string[];
+}
+interface LengthValidationConfig {
+    min?: number;
+    max?: number;
+    integer?: boolean;
+    minError?: string;
+    maxError?: string;
+}
+/**
+ * Configuração padrão de validação para comprimento
+ * Length é magnitude escalar, portanto não-negativo por padrão
+ */
+declare const LENGTH_VALIDATION_CONFIG: LengthValidationConfig;
+/**
+ * Valida um valor de comprimento
+ *
+ * @param value - Valor a ser validado
+ * @param config - Configuração customizada (opcional)
+ * @returns Resultado da validação com erros se houver
+ *
+ * @example
+ * validateLength(100);                    // { valid: true, errors: [] }
+ * validateLength(-5);                     // { valid: false, errors: ['Length cannot be negative'] }
+ * validateLength(-5, { min: undefined }); // { valid: true, errors: [] } - permite negativo
+ */
+declare function validateLength(value: unknown, config?: LengthValidationConfig): ValidationResult$e;
+/**
+ * Verifica se um valor de comprimento é válido
+ *
+ * @param value - Valor a ser validado
+ * @param config - Configuração customizada (opcional)
+ * @returns true se válido, false caso contrário
+ *
+ * @example
+ * isValidLength(100);  // true
+ * isValidLength(-5);   // false
+ */
+declare function isValidLength(value: unknown, config?: LengthValidationConfig): boolean;
+
+/**
+ * Mass Role - Validate Pillar
+ *
+ * Validação semântica de valores de massa.
+ * Zero dependências externas - pode ser usado standalone.
+ *
+ * @example
+ * import { validateMass, isValidMass } from '@attrx/role-morphic/mass/validate';
+ *
+ * validateMass(100);   // { valid: true, errors: [] }
+ * validateMass(-5);    // { valid: false, errors: ['Mass cannot be negative'] }
+ * isValidMass(100);    // true
+ */
+interface ValidationResult$d {
+    valid: boolean;
+    errors: string[];
+}
+interface MassValidationConfig {
+    min?: number;
+    max?: number;
+    integer?: boolean;
+    minError?: string;
+    maxError?: string;
+}
+/**
+ * Configuração padrão de validação para massa
+ */
+declare const MASS_VALIDATION_CONFIG: MassValidationConfig;
+/**
+ * Valida um valor de massa
+ *
+ * @param value - Valor a ser validado
+ * @param config - Configuração customizada (opcional)
+ * @returns Resultado da validação com erros se houver
+ *
+ * @example
+ * validateMass(100);              // { valid: true, errors: [] }
+ * validateMass(-5);               // { valid: false, errors: ['Mass cannot be negative'] }
+ * validateMass(150, { max: 100 }) // { valid: false, errors: ['Value must be at most 100'] }
+ */
+declare function validateMass(value: unknown, config?: MassValidationConfig): ValidationResult$d;
+/**
+ * Verifica se um valor de massa é válido
+ *
+ * @param value - Valor a ser validado
+ * @param config - Configuração customizada (opcional)
+ * @returns true se válido, false caso contrário
+ *
+ * @example
+ * isValidMass(100);  // true
+ * isValidMass(-5);   // false
+ */
+declare function isValidMass(value: unknown, config?: MassValidationConfig): boolean;
+
+/**
+ * Temperature Role - Validate Pillar
+ *
+ * Validação semântica de valores de temperatura.
+ * Zero dependências externas - pode ser usado standalone.
+ *
+ * IMPORTANTE: Temperatura não pode ser abaixo do zero absoluto.
+ * O zero absoluto varia por escala:
+ * - Celsius: -273.15°C
+ * - Fahrenheit: -459.67°F
+ * - Kelvin: 0K
+ * - Rankine: 0°R
+ *
+ * @example
+ * import { validateTemperature, isValidTemperature } from '@attrx/role-morphic/temperature/validate';
+ *
+ * validateTemperature(100, 'celsius');     // { valid: true, errors: [] }
+ * validateTemperature(-300, 'celsius');    // { valid: false, errors: ['...below absolute zero...'] }
+ * validateTemperature(-10, 'kelvin');      // { valid: false, errors: ['...below absolute zero...'] }
+ * isValidTemperature(100, 'celsius');      // true
+ */
+
+interface ValidationResult$c {
+    valid: boolean;
+    errors: string[];
+}
+interface TemperatureValidationConfig {
+    /** Permite temperaturas abaixo do zero absoluto (default: false) */
+    allowBelowAbsoluteZero?: boolean;
+    /** Valor máximo permitido */
+    max?: number;
+    /** Mensagem de erro para max */
+    maxError?: string;
+}
+/**
+ * Valida um valor de temperatura
+ *
+ * @param value - Valor a ser validado
+ * @param unit - Unidade do valor (default: celsius)
+ * @param config - Configuração customizada (opcional)
+ * @returns Resultado da validação com erros se houver
+ *
+ * @example
+ * validateTemperature(100, 'celsius');              // { valid: true, errors: [] }
+ * validateTemperature(-300, 'celsius');             // { valid: false, errors: ['...below absolute zero...'] }
+ * validateTemperature(-10, 'kelvin');               // { valid: false, errors: ['...below absolute zero...'] }
+ * validateTemperature(0, 'kelvin');                 // { valid: true, errors: [] } (0K = zero absoluto)
+ * validateTemperature(-459.67, 'fahrenheit');       // { valid: true, errors: [] } (zero absoluto em °F)
+ */
+declare function validateTemperature(value: unknown, unit?: TemperatureUnit, config?: TemperatureValidationConfig): ValidationResult$c;
+/**
+ * Verifica se um valor de temperatura é válido
+ *
+ * @param value - Valor a ser validado
+ * @param unit - Unidade do valor (default: celsius)
+ * @param config - Configuração customizada (opcional)
+ * @returns true se válido, false caso contrário
+ *
+ * @example
+ * isValidTemperature(100, 'celsius');   // true
+ * isValidTemperature(-300, 'celsius');  // false
+ * isValidTemperature(-10, 'kelvin');    // false
+ */
+declare function isValidTemperature(value: unknown, unit?: TemperatureUnit, config?: TemperatureValidationConfig): boolean;
+
+/**
+ * Volume Role - Validate Pillar
+ *
+ * Validação semântica de valores de volume.
+ * Zero dependências externas - pode ser usado standalone.
+ *
+ * @example
+ * import { validateVolume, isValidVolume } from '@attrx/role-morphic/volume/validate';
+ *
+ * validateVolume(100);   // { valid: true, errors: [] }
+ * validateVolume(-5);    // { valid: false, errors: ['Volume cannot be negative'] }
+ * isValidVolume(100);    // true
+ */
+interface ValidationResult$b {
+    valid: boolean;
+    errors: string[];
+}
+interface VolumeValidationConfig {
+    min?: number;
+    max?: number;
+    integer?: boolean;
+    minError?: string;
+    maxError?: string;
+}
+/**
+ * Configuração padrão de validação para volume
+ */
+declare const VOLUME_VALIDATION_CONFIG: VolumeValidationConfig;
+/**
+ * Valida um valor de volume
+ *
+ * @param value - Valor a ser validado
+ * @param config - Configuração customizada (opcional)
+ * @returns Resultado da validação com erros se houver
+ *
+ * @example
+ * validateVolume(100);              // { valid: true, errors: [] }
+ * validateVolume(-5);               // { valid: false, errors: ['Volume cannot be negative'] }
+ * validateVolume(150, { max: 100 }) // { valid: false, errors: ['Value must be at most 100'] }
+ */
+declare function validateVolume(value: unknown, config?: VolumeValidationConfig): ValidationResult$b;
+/**
+ * Verifica se um valor de volume é válido
+ *
+ * @param value - Valor a ser validado
+ * @param config - Configuração customizada (opcional)
+ * @returns true se válido, false caso contrário
+ *
+ * @example
+ * isValidVolume(100);  // true
+ * isValidVolume(-5);   // false
+ */
+declare function isValidVolume(value: unknown, config?: VolumeValidationConfig): boolean;
+
+/**
+ * Speed Role - Validate Pillar
+ *
+ * Validação semântica de valores de velocidade.
+ * Zero dependências externas - pode ser usado standalone.
+ *
+ * Nota: Velocidade pode ser negativa (movimento em direção oposta).
+ *
+ * @example
+ * import { validateSpeed, isValidSpeed } from '@attrx/role-morphic/speed/validate';
+ *
+ * validateSpeed(100);   // { valid: true, errors: [] }
+ * validateSpeed(-50);   // { valid: true, errors: [] } (negativo é válido)
+ * isValidSpeed(100);    // true
+ */
+interface ValidationResult$a {
+    valid: boolean;
+    errors: string[];
+}
+interface SpeedValidationConfig {
+    min?: number;
+    max?: number;
+    integer?: boolean;
+    minError?: string;
+    maxError?: string;
+}
+/**
+ * Valida um valor de velocidade
+ *
+ * @param value - Valor a ser validado
+ * @param config - Configuração customizada (opcional)
+ * @returns Resultado da validação com erros se houver
+ *
+ * @example
+ * validateSpeed(100);              // { valid: true, errors: [] }
+ * validateSpeed(-50);              // { valid: true, errors: [] }
+ * validateSpeed(150, { max: 120 }) // { valid: false, errors: ['Value must be at most 120'] }
+ */
+declare function validateSpeed(value: unknown, config?: SpeedValidationConfig): ValidationResult$a;
+/**
+ * Verifica se um valor de velocidade é válido
+ *
+ * @param value - Valor a ser validado
+ * @param config - Configuração customizada (opcional)
+ * @returns true se válido, false caso contrário
+ *
+ * @example
+ * isValidSpeed(100);   // true
+ * isValidSpeed(-50);   // true (negativo é válido)
+ */
+declare function isValidSpeed(value: unknown, config?: SpeedValidationConfig): boolean;
+
+/**
+ * Energy Role - Validate Pillar
+ *
+ * Validação semântica de valores de energia.
+ * Zero dependências externas - pode ser usado standalone.
+ *
+ * @example
+ * import { validateEnergy, isValidEnergy } from '@attrx/role-morphic/energy/validate';
+ *
+ * validateEnergy(100);   // { valid: true, errors: [] }
+ * validateEnergy(-5);    // { valid: false, errors: ['Energy cannot be negative'] }
+ * isValidEnergy(100);    // true
+ */
+interface ValidationResult$9 {
+    valid: boolean;
+    errors: string[];
+}
+interface EnergyValidationConfig {
+    min?: number;
+    max?: number;
+    integer?: boolean;
+    minError?: string;
+    maxError?: string;
+}
+/**
+ * Configuração padrão de validação para energia
+ */
+declare const ENERGY_VALIDATION_CONFIG: EnergyValidationConfig;
+/**
+ * Valida um valor de energia
+ *
+ * @param value - Valor a ser validado
+ * @param config - Configuração customizada (opcional)
+ * @returns Resultado da validação com erros se houver
+ *
+ * @example
+ * validateEnergy(100);              // { valid: true, errors: [] }
+ * validateEnergy(-5);               // { valid: false, errors: ['Energy cannot be negative'] }
+ * validateEnergy(150, { max: 100 }) // { valid: false, errors: ['Value must be at most 100'] }
+ */
+declare function validateEnergy(value: unknown, config?: EnergyValidationConfig): ValidationResult$9;
+/**
+ * Verifica se um valor de energia é válido
+ *
+ * @param value - Valor a ser validado
+ * @param config - Configuração customizada (opcional)
+ * @returns true se válido, false caso contrário
+ *
+ * @example
+ * isValidEnergy(100);  // true
+ * isValidEnergy(-5);   // false
+ */
+declare function isValidEnergy(value: unknown, config?: EnergyValidationConfig): boolean;
+
+/**
+ * Power Role - Validate Pillar
+ *
+ * Validação de valores de potência.
+ * ZERO dependências de outros pilares - totalmente standalone.
+ *
+ * @example
+ * import { validatePower, isValidPower } from '@attrx/role-morphic/power/validate';
+ *
+ * validatePower(100);   // { valid: true, errors: [] }
+ * validatePower(-5);    // { valid: false, errors: ['Power cannot be negative'] }
+ * isValidPower(100);    // true
+ */
+interface PowerValidationConfig {
+    /** Valor mínimo permitido (default: 0) */
+    min?: number;
+    /** Valor máximo permitido */
+    max?: number;
+    /** Mensagem de erro para valor abaixo do mínimo */
+    minError?: string;
+    /** Mensagem de erro para valor acima do máximo */
+    maxError?: string;
+    /** Permitir valores negativos (default: false) */
+    allowNegative?: boolean;
+}
+interface ValidationResult$8 {
+    valid: boolean;
+    errors: string[];
+}
+declare const POWER_VALIDATION_CONFIG: PowerValidationConfig;
+/**
+ * Valida um valor de potência
+ *
+ * @param value - Valor a validar
+ * @param config - Configuração de validação (opcional)
+ * @returns Resultado da validação com lista de erros
+ *
+ * @example
+ * validatePower(100);                    // { valid: true, errors: [] }
+ * validatePower(-5);                     // { valid: false, errors: ['Power cannot be negative'] }
+ * validatePower(-5, { allowNegative: true }); // { valid: true, errors: [] }
+ * validatePower(1000, { max: 500 });     // { valid: false, errors: ['Value must be at most 500'] }
+ */
+declare function validatePower(value: unknown, config?: PowerValidationConfig): ValidationResult$8;
+/**
+ * Verifica se valor de potência é válido (helper booleano)
+ *
+ * @param value - Valor a validar
+ * @param config - Configuração de validação (opcional)
+ * @returns true se válido, false caso contrário
+ *
+ * @example
+ * isValidPower(100);  // true
+ * isValidPower(-5);   // false
+ */
+declare function isValidPower(value: unknown, config?: PowerValidationConfig): boolean;
+
+/**
+ * Pressure Role - Validate Pillar
+ *
+ * Validação de valores de pressão.
+ * ZERO dependências de outros pilares - totalmente standalone.
+ *
+ * @example
+ * import { validatePressure, isValidPressure } from '@attrx/role-morphic/pressure/validate';
+ *
+ * validatePressure(100);   // { valid: true, errors: [] }
+ * validatePressure(-5);    // { valid: false, errors: ['Pressure cannot be negative'] }
+ * isValidPressure(100);    // true
+ */
+interface PressureValidationConfig {
+    /** Valor mínimo permitido (default: 0) */
+    min?: number;
+    /** Valor máximo permitido */
+    max?: number;
+    /** Mensagem de erro para valor abaixo do mínimo */
+    minError?: string;
+    /** Mensagem de erro para valor acima do máximo */
+    maxError?: string;
+    /** Permitir valores negativos (default: false) */
+    allowNegative?: boolean;
+}
+interface ValidationResult$7 {
+    valid: boolean;
+    errors: string[];
+}
+declare const PRESSURE_VALIDATION_CONFIG: PressureValidationConfig;
+/**
+ * Valida um valor de pressão
+ *
+ * @param value - Valor a validar
+ * @param config - Configuração de validação (opcional)
+ * @returns Resultado da validação com lista de erros
+ *
+ * @example
+ * validatePressure(100);                    // { valid: true, errors: [] }
+ * validatePressure(-5);                     // { valid: false, errors: ['Pressure cannot be negative'] }
+ * validatePressure(-5, { allowNegative: true }); // { valid: true, errors: [] }
+ * validatePressure(1000, { max: 500 });     // { valid: false, errors: ['Value must be at most 500'] }
+ */
+declare function validatePressure(value: unknown, config?: PressureValidationConfig): ValidationResult$7;
+/**
+ * Verifica se valor de pressão é válido (helper booleano)
+ *
+ * @param value - Valor a validar
+ * @param config - Configuração de validação (opcional)
+ * @returns true se válido, false caso contrário
+ *
+ * @example
+ * isValidPressure(100);  // true
+ * isValidPressure(-5);   // false
+ */
+declare function isValidPressure(value: unknown, config?: PressureValidationConfig): boolean;
+
+/**
+ * Frequency Role - Validate Pillar
+ *
+ * Validação de valores de frequência.
+ * ZERO dependências de outros pilares - totalmente standalone.
+ *
+ * @example
+ * import { validateFrequency, isValidFrequency } from '@attrx/role-morphic/frequency/validate';
+ *
+ * validateFrequency(100);   // { valid: true, errors: [] }
+ * validateFrequency(-5);    // { valid: false, errors: ['Frequency cannot be negative'] }
+ * isValidFrequency(100);    // true
+ */
+interface FrequencyValidationConfig {
+    /** Valor mínimo permitido (default: 0) */
+    min?: number;
+    /** Valor máximo permitido */
+    max?: number;
+    /** Mensagem de erro para valor abaixo do mínimo */
+    minError?: string;
+    /** Mensagem de erro para valor acima do máximo */
+    maxError?: string;
+    /** Permitir valores negativos (default: false) */
+    allowNegative?: boolean;
+}
+interface ValidationResult$6 {
+    valid: boolean;
+    errors: string[];
+}
+declare const FREQUENCY_VALIDATION_CONFIG: FrequencyValidationConfig;
+/**
+ * Valida um valor de frequência
+ *
+ * @param value - Valor a validar
+ * @param config - Configuração de validação (opcional)
+ * @returns Resultado da validação com lista de erros
+ *
+ * @example
+ * validateFrequency(100);                    // { valid: true, errors: [] }
+ * validateFrequency(-5);                     // { valid: false, errors: ['Frequency cannot be negative'] }
+ * validateFrequency(-5, { allowNegative: true }); // { valid: true, errors: [] }
+ * validateFrequency(1000, { max: 500 });     // { valid: false, errors: ['Value must be at most 500'] }
+ */
+declare function validateFrequency(value: unknown, config?: FrequencyValidationConfig): ValidationResult$6;
+/**
+ * Verifica se valor de frequência é válido (helper booleano)
+ *
+ * @param value - Valor a validar
+ * @param config - Configuração de validação (opcional)
+ * @returns true se válido, false caso contrário
+ *
+ * @example
+ * isValidFrequency(100);  // true
+ * isValidFrequency(-5);   // false
+ */
+declare function isValidFrequency(value: unknown, config?: FrequencyValidationConfig): boolean;
+
+/**
+ * Angle Role - Validate Pillar
+ *
+ * Validação de valores de ângulo.
+ * ZERO dependências de outros pilares - totalmente standalone.
+ *
+ * Nota: Ângulos podem ser negativos (rotação anti-horária) e maiores que 360° (múltiplas voltas).
+ *
+ * @example
+ * import { validateAngle, isValidAngle } from '@attrx/role-morphic/angle/validate';
+ *
+ * validateAngle(90);    // { valid: true, errors: [] }
+ * validateAngle(-45);   // { valid: true, errors: [] }
+ * validateAngle(720);   // { valid: true, errors: [] }
+ * isValidAngle(90);     // true
+ */
+interface AngleValidationConfig {
+    /** Valor mínimo permitido */
+    min?: number;
+    /** Valor máximo permitido */
+    max?: number;
+    /** Mensagem de erro para valor abaixo do mínimo */
+    minError?: string;
+    /** Mensagem de erro para valor acima do máximo */
+    maxError?: string;
+}
+interface ValidationResult$5 {
+    valid: boolean;
+    errors: string[];
+}
+/**
+ * Valida um valor de ângulo
+ *
+ * @param value - Valor a validar
+ * @param config - Configuração de validação (opcional)
+ * @returns Resultado da validação com lista de erros
+ *
+ * @example
+ * validateAngle(90);                    // { valid: true, errors: [] }
+ * validateAngle(-45);                   // { valid: true, errors: [] }
+ * validateAngle(90, { max: 180 });      // { valid: true, errors: [] }
+ * validateAngle(270, { max: 180 });     // { valid: false, errors: ['...'] }
+ */
+declare function validateAngle(value: unknown, config?: AngleValidationConfig): ValidationResult$5;
+/**
+ * Verifica se valor de ângulo é válido (helper booleano)
+ *
+ * @param value - Valor a validar
+ * @param config - Configuração de validação (opcional)
+ * @returns true se válido, false caso contrário
+ *
+ * @example
+ * isValidAngle(90);   // true
+ * isValidAngle(-45);  // true
+ * isValidAngle(NaN);  // false
+ */
+declare function isValidAngle(value: unknown, config?: AngleValidationConfig): boolean;
+
+/**
+ * Time Role - Validate Pillar
+ *
+ * Validação de valores de tempo/duração.
+ * ZERO dependências de outros pilares - totalmente standalone.
+ *
+ * @example
+ * import { validateTime, isValidTime } from '@attrx/role-morphic/time/validate';
+ *
+ * validateTime(100);   // { valid: true, errors: [] }
+ * validateTime(-5);    // { valid: false, errors: ['Time cannot be negative'] }
+ * isValidTime(100);    // true
+ */
+interface TimeValidationConfig {
+    /** Valor mínimo permitido (default: 0) */
+    min?: number;
+    /** Valor máximo permitido */
+    max?: number;
+    /** Mensagem de erro para valor abaixo do mínimo */
+    minError?: string;
+    /** Mensagem de erro para valor acima do máximo */
+    maxError?: string;
+    /** Permitir valores negativos (default: false) */
+    allowNegative?: boolean;
+}
+interface ValidationResult$4 {
+    valid: boolean;
+    errors: string[];
+}
+declare const TIME_VALIDATION_CONFIG: TimeValidationConfig;
+/**
+ * Valida um valor de tempo
+ *
+ * @param value - Valor a validar
+ * @param config - Configuração de validação (opcional)
+ * @returns Resultado da validação com lista de erros
+ *
+ * @example
+ * validateTime(100);                    // { valid: true, errors: [] }
+ * validateTime(-5);                     // { valid: false, errors: ['Time cannot be negative'] }
+ * validateTime(-5, { allowNegative: true }); // { valid: true, errors: [] }
+ */
+declare function validateTime(value: unknown, config?: TimeValidationConfig): ValidationResult$4;
+/**
+ * Verifica se valor de tempo é válido (helper booleano)
+ *
+ * @param value - Valor a validar
+ * @param config - Configuração de validação (opcional)
+ * @returns true se válido, false caso contrário
+ *
+ * @example
+ * isValidTime(100);  // true
+ * isValidTime(-5);   // false
+ */
+declare function isValidTime(value: unknown, config?: TimeValidationConfig): boolean;
+
+/**
+ * Digital Role - Validate Pillar
+ *
+ * Validação de valores de armazenamento digital.
+ * ZERO dependências de outros pilares - totalmente standalone.
+ *
+ * @example
+ * import { validateDigital, isValidDigital } from '@attrx/role-morphic/digital/validate';
+ *
+ * validateDigital(100);   // { valid: true, errors: [] }
+ * validateDigital(-5);    // { valid: false, errors: ['Digital storage cannot be negative'] }
+ * isValidDigital(100);    // true
+ */
+interface DigitalValidationConfig {
+    /** Valor mínimo permitido (default: 0) */
+    min?: number;
+    /** Valor máximo permitido */
+    max?: number;
+    /** Mensagem de erro para valor abaixo do mínimo */
+    minError?: string;
+    /** Mensagem de erro para valor acima do máximo */
+    maxError?: string;
+    /** Permitir valores negativos (default: false) */
+    allowNegative?: boolean;
+}
+interface ValidationResult$3 {
+    valid: boolean;
+    errors: string[];
+}
+declare const DIGITAL_VALIDATION_CONFIG: DigitalValidationConfig;
+/**
+ * Valida um valor de armazenamento digital
+ *
+ * @param value - Valor a validar
+ * @param config - Configuração de validação (opcional)
+ * @returns Resultado da validação com lista de erros
+ *
+ * @example
+ * validateDigital(100);                    // { valid: true, errors: [] }
+ * validateDigital(-5);                     // { valid: false, errors: ['Digital storage cannot be negative'] }
+ * validateDigital(-5, { allowNegative: true }); // { valid: true, errors: [] }
+ */
+declare function validateDigital(value: unknown, config?: DigitalValidationConfig): ValidationResult$3;
+/**
+ * Verifica se valor de armazenamento digital é válido (helper booleano)
+ *
+ * @param value - Valor a validar
+ * @param config - Configuração de validação (opcional)
+ * @returns true se válido, false caso contrário
+ *
+ * @example
+ * isValidDigital(100);  // true
+ * isValidDigital(-5);   // false
+ */
+declare function isValidDigital(value: unknown, config?: DigitalValidationConfig): boolean;
+
+/**
+ * Color Role - Validate Pillar
+ *
+ * Validação de valores de cor.
+ * ZERO dependências de outros pilares - totalmente standalone.
+ *
+ * @example
+ * import { validateColor, isValidColor } from '@attrx/role-morphic/color/validate';
+ *
+ * validateColor('hex', '#ff0000');           // { valid: true, errors: [] }
+ * validateColor('rgb_object', { r: 255, g: 0, b: 0 }); // { valid: true, errors: [] }
+ * validateColor('hex', 'invalid');           // { valid: false, errors: [...] }
+ */
+
+type ValidationResult$2 = {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Valida valor de cor para uma variante específica
+ *
+ * @param variant - Variante a validar
+ * @param value - Valor a validar
+ * @returns Resultado da validação
+ *
+ * @example
+ * validateColor('hex', '#ff0000');
+ * // { valid: true, errors: [] }
+ *
+ * validateColor('hex', 'invalid');
+ * // { valid: false, errors: ['Invalid hex color format'] }
+ */
+declare function validateColor(variant: ColorVariant, value: unknown): ValidationResult$2;
+/**
+ * Verifica se valor é válido para uma variante específica (retorna boolean)
+ *
+ * @example
+ * isValidColorVariant('hex', '#ff0000');  // true
+ * isValidColorVariant('hex', 'invalid');  // false
+ */
+declare function isValidColorVariant(variant: ColorVariant, value: unknown): boolean;
+
+/**
+ * Date Role - Validate Pillar
+ *
+ * Validação de valores de data.
+ * ZERO dependências de outros pilares - totalmente standalone.
+ *
+ * @example
+ * import { validateDate, isValidDate } from '@attrx/role-morphic/date/validate';
+ *
+ * validateDate('iso', '2024-12-05T19:30:00.000Z');  // { valid: true, errors: [] }
+ * validateDate('timestamp', 1733425800000);         // { valid: true, errors: [] }
+ * validateDate('epoch', 1733425800);                // { valid: true, errors: [] }
+ */
+
+type ValidationResult$1 = {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Valida valor de data para uma variante específica
+ *
+ * @param variant - Variante a validar ("iso", "timestamp", "epoch")
+ * @param value - Valor a validar
+ * @returns Resultado da validação
+ *
+ * @example
+ * validateDate('iso', '2024-12-05T19:30:00.000Z');
+ * // { valid: true, errors: [] }
+ *
+ * validateDate('iso', 'invalid');
+ * // { valid: false, errors: ['Invalid ISO 8601 format'] }
+ */
+declare function validateDate(variant: DateVariant, value: unknown): ValidationResult$1;
+/**
+ * Verifica se valor é válido (retorna boolean)
+ *
+ * @example
+ * isValidDate('iso', '2024-12-05T19:30:00.000Z');  // true
+ * isValidDate('iso', 'invalid');                   // false
+ */
+declare function isValidDate(variant: DateVariant, value: unknown): boolean;
+
+/**
+ * Currency Role - Validate Pillar
+ *
+ * Validação semântica de valores monetários.
+ * Zero dependências externas - pode ser usado standalone.
+ *
+ * Currency valida o VALOR NUMÉRICO, não o tipo de moeda.
+ * O código da moeda é metadata, usado apenas para formatação.
+ *
+ * @example
+ * import { validateCurrency, isValidCurrency } from '@attrx/role-morphic/currency/validate';
+ *
+ * validateCurrency(100.50);              // { valid: true, errors: [] }
+ * validateCurrency(-50);                 // { valid: false, errors: ['Currency value cannot be negative'] }
+ * validateCurrency(100.999, { decimals: 2 }); // { valid: false, errors: ['...too many decimal places'] }
+ * isValidCurrency(100.50);               // true
+ */
+interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+interface CurrencyValidationConfig {
+    /** Valor mínimo permitido (default: 0) */
+    min?: number;
+    /** Valor máximo permitido */
+    max?: number;
+    /** Máximo de casas decimais (default: sem limite) */
+    decimals?: number;
+    /** Permite valores negativos? (default: false) */
+    allowNegative?: boolean;
+    /** Mensagem de erro para min */
+    minError?: string;
+    /** Mensagem de erro para max */
+    maxError?: string;
+}
+/**
+ * Configuração padrão de validação para currency
+ */
+declare const CURRENCY_VALIDATION_CONFIG: CurrencyValidationConfig;
+/**
+ * Valida um valor monetário
+ *
+ * @param value - Valor a ser validado
+ * @param config - Configuração customizada (opcional)
+ * @returns Resultado da validação com erros se houver
+ *
+ * @example
+ * validateCurrency(100.50);                      // { valid: true, errors: [] }
+ * validateCurrency(-50);                         // { valid: false, errors: ['Currency value cannot be negative'] }
+ * validateCurrency(100.999, { decimals: 2 });    // { valid: false, errors: ['Value has too many decimal places (max: 2)'] }
+ * validateCurrency(1000000, { max: 10000 });     // { valid: false, errors: ['Value must be at most 10000'] }
+ * validateCurrency(-50, { allowNegative: true }); // { valid: true, errors: [] }
+ */
+declare function validateCurrency(value: unknown, config?: CurrencyValidationConfig): ValidationResult;
+/**
+ * Verifica se um valor monetário é válido
+ *
+ * @param value - Valor a ser validado
+ * @param config - Configuração customizada (opcional)
+ * @returns true se válido, false caso contrário
+ *
+ * @example
+ * isValidCurrency(100.50);   // true
+ * isValidCurrency(-50);      // false
+ */
+declare function isValidCurrency(value: unknown, config?: CurrencyValidationConfig): boolean;
+
+export { AREA_VALIDATION_CONFIG, type AngleValidationConfig, type AreaValidationConfig, CURRENCY_VALIDATION_CONFIG, type CurrencyValidationConfig, DIGITAL_VALIDATION_CONFIG, type DigitalValidationConfig, ENERGY_VALIDATION_CONFIG, type EnergyValidationConfig, FREQUENCY_VALIDATION_CONFIG, type FrequencyValidationConfig, LENGTH_VALIDATION_CONFIG, type LengthValidationConfig, MASS_VALIDATION_CONFIG, type MassValidationConfig, POWER_VALIDATION_CONFIG, PRESSURE_VALIDATION_CONFIG, type PowerValidationConfig, type PressureValidationConfig, type SpeedValidationConfig, TIME_VALIDATION_CONFIG, type TemperatureValidationConfig, type TimeValidationConfig, VOLUME_VALIDATION_CONFIG, type 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 };