export function generateAllowedListDescription(allowed: any): string;
/**
 * Generate description for numeric ranges
 * @param {number} min - Minimum value
 * @param {number} max - Maximum value
 * @param {string} [unit] - Optional unit suffix
 * @returns {string} Description like "number between 0 and 1"
 */
export function generateRangeDescription(min: number, max: number, unit?: string): string;
/**
 * Generate description for platform-specific units
 * @param {string[]} units - Array of supported units
 * @returns {string} Description of supported units
 */
export function generateUnitsDescription(units: string[]): string;
/**
 * Validate value against an allowed list
 * @param {string} value - Value to validate
 * @param {string[]} allowed - Array of allowed values
 * @returns {{ valid: boolean }}
 */
export function validateFromAllowedList(value: string, allowed: string[]): {
    valid: boolean;
};
/**
 * Validate numeric value within a range
 * @param {string|number} value - Value to validate
 * @param {number} min - Minimum allowed value
 * @param {number} max - Maximum allowed value
 * @returns {{ valid: boolean }}
 */
export function validateNumericRange(value: string | number, min: number, max: number): {
    valid: boolean;
};
/**
 * Validate non-empty string values
 * @param {string} value - Value to validate
 * @returns {{ valid: boolean }}
 */
export function validateNonEmptyString(value: string): {
    valid: boolean;
};
/**
 * Validate numeric range with optional keyword support
 * @param {string|number} value - Value to validate
 * @param {Object} rule - Rule configuration containing range and keywords
 * @param {boolean} [caseInsensitive=false] - Match keywords case-insensitively
 * @returns {{ valid: boolean }}
 */
export function validateRangeWithKeywords(value: string | number, rule: any, caseInsensitive?: boolean): {
    valid: boolean;
};
/**
 * Build size validation options from rule configuration
 * @param {Object} rule - Rule config
 * @param {Object} defaults - Default options for a platform
 * @returns {Object} Final validation options
 */
export function buildSizeOptions(rule?: any, defaults?: any): any;
/**
 * Validate size values with platform-specific unit support
 * @param {string} value - Value to validate
 * @param {Object} options - Validation options
 * @param {boolean} [options.allowNegative=false] - Allow negative values
 * @param {boolean} [options.allowUnitless=true] - Allow unitless numbers
 * @param {boolean} [options.allowPercent=false] - Allow percentage values
 * @param {string[]} [options.allowedUnits=['px']] - Allowed CSS units
 * @param {string[]} [options.allowedKeywords=[]] - Allowed keyword values
 * @returns {{ valid: boolean }}
 */
export function validateSizeValue(value: string, options?: {
    allowNegative?: boolean | undefined;
    allowUnitless?: boolean | undefined;
    allowPercent?: boolean | undefined;
    allowedUnits?: string[] | undefined;
    allowedKeywords?: string[] | undefined;
}): {
    valid: boolean;
};
/**
 * Validate space-separated multi-value strings
 * @param {string} value - Space-separated values
 * @param {Function} validator - Function to validate each individual value
 * @param {Object} [validatorOptions] - Options to pass to validator
 * @returns {{ valid: boolean }}
 */
export function validateMultiValue(value: string, validator: Function, validatorOptions?: any): {
    valid: boolean;
};
/**
 * Create standardized error response
 * @param {string} subtype - Token subtype
 * @param {string} value - Invalid value
 * @param {string} expectedFormat - Expected format description
 * @param {string} platform - Platform identifier
 * @returns {{ valid: false, errorObject: Object }}
 */
export function createErrorResponse(subtype: string, value: string, expectedFormat: string, platform: string): {
    valid: false;
    errorObject: any;
};
export function createSuccessResponse(): {
    valid: boolean;
};
export function validateFontFamily(value: any, config?: {}): {
    valid: boolean;
};
/**
 * Common validator for font weight - validates range with keywords
 * @param {string} value - Value to validate
 * @param {Object} rule - Rule configuration with range and keywords
 * @param {boolean} [requireMultipleOf100] - Whether to require multiples of 100
 * @returns {{ valid: boolean }} Validation result
 */
export function validateFontWeight(value: string, rule: any, requireMultipleOf100?: boolean): {
    valid: boolean;
};
/**
 * Common validator for opacity - validates numeric range
 * @param {string} value - Value to validate
 * @param {Object} rule - Rule configuration with min/max
 * @returns {{ valid: boolean }} Validation result
 */
export function validateOpacity(value: string, rule: any): {
    valid: boolean;
};
/**
 * Platform-specific size value validator
 * @param {string} value - Value to validate
 * @param {Object} rule - Rule configuration
 * @param {string[]} defaultUnits - Default allowed units for platform
 * @returns {{ valid: boolean }} Validation result
 */
export function validatePlatformSizeValue(value: string, rule?: any, defaultUnits?: string[]): {
    valid: boolean;
};
/**
 * Platform-specific space value validator (supports multi-value)
 * @param {string} value - Value to validate
 * @param {Object} rule - Rule configuration
 * @param {string[]} defaultUnits - Default allowed units for platform
 * @returns {{ valid: boolean }} Validation result
 */
export function validatePlatformSpaceValue(value: string, rule?: any, defaultUnits?: string[]): {
    valid: boolean;
};
/**
 * Get description for a rule, using customDescription if available or generating dynamically
 * @param {Object} rule - Rule configuration
 * @returns {string} Description for the rule
 */
export function getRuleDescription(rule: any): string;
/** Split "a, rgba(1,2,3), b" by commas NOT inside parentheses */
export function splitByTopLevelComma(value: any): string[];
/**
 * Extract a color token from a shadow string.
 * Handles function-form colors (rgb, rgba, hsl, hsla) which may contain
 * internal commas and spaces, as well as hex (#rrggbb) and named colors.
 *
 * @param {string} s - Shadow string after stripping inset keyword
 * @returns {{ color: string|null, remainder: string }}
 */
export function extractColor(s: string): {
    color: string | null;
    remainder: string;
};
/**
 * Validate a box-shadow / elevation value.
 * Shared by all platforms — callers supply the color validator and allowed length units.
 *
 * @param {string} value
 * @param {Object} options
 * @param {boolean}  [options.allowNone=false]    - Accept the keyword "none"
 * @param {Function} options.colorValidator       - (color: string) => boolean
 * @param {string[]} options.lengthUnits          - e.g. ["px"] or ["px","rem","em"]
 * @returns {{ valid: boolean }}
 */
export function validateShadowValue(value: string, { allowNone, colorValidator, lengthUnits }: {
    allowNone?: boolean | undefined;
    colorValidator: Function;
    lengthUnits: string[];
}): {
    valid: boolean;
};
export namespace COMMON_VALIDATORS {
    export { validateFromAllowedList };
    export { validatePlatformSizeValue };
    export { validatePlatformSpaceValue };
    export { validateFontFamily };
    export { validateOpacity };
    export { validateFontWeight };
}
