ThingConfigurationUpdateResult handleConfigurationUpdate(Map<String, Object> configurationParameters, Locale locale);

public interface ConfigValidator {
     /* config error consists of parameterName:String (the affected config parameter) and a message:String (the internationalized error message) */
    Collection<ConfigError> validate(String entityId, Locale locale)

    /* returns true if this config validator can validate the entity to be identified by the given entityId (e.g. thing uid) */
    boolean canValidate(String entityId);
}

public ConfigValidationResult validate(String entityId, Locale locale) 

public class ConfigValidationResult {

    private final SetMultimap<String, String> configErrors = HashMultimap.create();

    public void addConfigError(ConfigError configError) {
        configErrors.put(configError.parameterName, configError.message);
    }

    public void addConfigErrors(Collection<ConfigError> configErrors) {
        for (ConfigError configError : configErrors) {
            addConfigError(configError);
        }
    }

    public Collection<String> getConfigErrorMessages(String parameterName) {
        Collection<String> configErrorMessages = configErrors.get(parameterName);
        if (configErrorMessages != null) {
            return Collections.unmodifiableCollection(configErrorMessages);
        }
        return Collections.emptyList();
    }

    public Map<String, Collection<String>> getConfigErrors() {
        return ImmutableMap.copyOf(configErrors.asMap());
    }
}

@POST
@Path("/{thingUID}/config/validation")
public Response validateConfiguration(@HeaderParam(HttpHeaders.ACCEPT_LANGUAGE) String language,  @PathParam("thingUID") String thingUID) throws IOException {
    ConfigValidationResult result = configValidationService.validate(thingUID, LocaleUtil.getLocale(language));
    return Response.ok(result.getConfigErrors()).build();
}

public class ConfigDescriptionValidator implements ConfigValidator {
...
    private List<ConfigProvider> configProviders = new CopyOnWriteArrayList<>();
    private ConfigDescriptionRegistry configDescriptionRegistry;
    private I18nProvider i18nProvider;

    @Override
    public boolean canValidate(String entityId) {
        return true;
    }
    @Override
    public Collection<ConfigError> validate(String entityId, Locale locale) {
        List<ConfigError> configErrors = new ArrayList<>();
        ValidationData validationData = getValidationData(entityId); // validation data is an internal class of this validator; containing only configuration and its description
        if (validationData != null) {
            Configuration config = validationData.configuration;
            for (ConfigDescriptionParameter configDescriptionParameter : validationData.configDescription
                    .getParameters()) {
                if (configDescriptionParameter.isRequired()) {
                    validateRequired(configDescriptionParameter.getName(), config, configErrors, locale);
                }
                // add more validations here
            }
        }
        return configErrors;
    }

    private ValidationData getValidationData(String entityId) {
        for (ConfigProvider configProvider : configProviders) {
            Configuration configuration = configProvider.getConfiguration(entityId);
            ConfigDescription configDescription = getConfigDescription(entityId, configProvider);
            if (configuration != null && configDescription != null) {
                return new ValidationData(configuration, configDescription);
            }
        }
        return null;
    }
 ...

    Configuration getConfiguration(String entityId);
    URI getConfigDescriptionURI(String entityId);

public ConfigValidationResult validate(String entityId, Locale locale,
            Map<String, Object> configurationParameters) {
        for (ConfigProvider configProvider : configProviders) {
            ConfigDescription configDescription = getConfigDescription(entityId, configProvider);
            if (configDescription != null) {
                Configuration configuration = new Configuration(configurationParameters);
                Map<String, ConfigDescriptionParameter> map = toMap(configDescription);
                List<ConfigError> configErrors = new ArrayList<>();
                for (String key : configuration.keySet()) {
                    ConfigDescriptionParameter configDescriptionParameter = map.get(key);
                    if (configDescriptionParameter != null) {
                        if (configDescriptionParameter.isRequired()) {
                            validateRequired(configDescriptionParameter.getName(), configuration, configErrors, locale);
                        }
                        // add more validations here
                    }
                }
                return new ConfigValidationResult(configErrors);
            }
        }
        return new ConfigValidationResult();
    }

try {
            ConfigValidationResult result = configDescriptionValidator.validate(thingUID,
                    LocaleUtil.getLocale(language), configurationParameters);
            if (result.hasConfigErrors()) {
                return Response.status(Status.BAD_REQUEST).entity(result.getConfigErrors()).build();
            }

            thingRegistry.updateConfiguration(new ThingUID(thingUID),
                    convertDoublesToBigDecimal(configurationParameters));
        } catch ....