Consider rename of project to just validation

Does the "bean" really add anything?

No it does not.

Makes it unambiguous it does not concern servlet/jaxrs/forms (except for what are beans), jsonschema, xmlschema,..., ie anything outside the scope of beans?
Validation sounds quite vague no?
Just my 2cts indeed but in Java "validation" is quite a large scope compared to what the spec covers so can make sense to keep it from my window.

Big +1 for me. I always found "bean validation" confusing and off-putting

Big +1 for me as well.

Hi there.
I don't have a strong opinion there. Originally, the bean was both about Java Beans (i.e. getters and setters convention) and CDI beans but I can see how calling it Jakarta Validation could be less of a mouthful (and consistent with the name of the GA).
My only concern is about the work that it will require in all the components. The search and replace is easy, checking everything is in order, not so much (I have done it for Bean Validation -> Jakarta Bean Vaidation and it wasn't fun).

As of right now:
find . -name .git -prune -o -type f -exec grep -i bean {} \; -print
 * Jakarta Bean Validation API
		public T getRootBean() {
		public Class<T> getRootBeanClass() {
		public Object getLeafBean() {
./src/test/java/jakarta/validation/ConstraintViolationExceptionTest.java
 * Jakarta Bean Validation API
./src/test/java/jakarta/validation/ValidationTest.java
 * Jakarta Bean Validation API
./src/test/java/jakarta/validation/FooValidationProvider.java
 * Jakarta Bean Validation API
			case BEAN:
./src/test/java/jakarta/validation/examples/NodeTraversalTest.java
 * Jakarta Bean Validation API
		//Build a constraint violation on the default path + the bean stored
		            .addBeanNode()
		// Edgy case where simple types are considered beans
		            .addBeanNode() //bean node for a primitive type
		//ie. the Address bean hosted in the "home" key of the "otherAddresses" map parameter
		            .addBeanNode()
		//ie. on the "city" property of the Address bean hosted in
./src/test/java/jakarta/validation/examples/ConstraintValidationNodeBuilderTest.java
 * Jakarta Bean Validation API
./src/test/java/jakarta/validation/BarValidationProvider.java
 * Jakarta Bean Validation API
./src/test/java/jakarta/validation/NonRegisteredValidationProvider.java
# Jakarta Bean Validation API
./src/main/scripts/gencopyright.sh
 * Jakarta Bean Validation API
./src/main/java/module-info.java
 * Jakarta Bean Validation API
 * Base exception of all Jakarta Bean Validation "unexpected" problems.
./src/main/java/jakarta/validation/ValidationException.java
 * Jakarta Bean Validation API
 * Defines the state used to bootstrap Jakarta Bean Validation and
./src/main/java/jakarta/validation/bootstrap/ProviderSpecificBootstrap.java
 * Jakarta Bean Validation API
 * Defines the state used to bootstrap Jakarta Bean Validation and
	 * @throws NoProviderFoundException if no Jakarta Bean Validation provider was found
	 * @throws ValidationException if a Jakarta Bean Validation provider was found but the
./src/main/java/jakarta/validation/bootstrap/GenericBootstrap.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/bootstrap/package-info.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/ConstraintDefinitionException.java
 * Jakarta Bean Validation API
	 * provider-specific APIs. If the Jakarta Bean Validation provider
./src/main/java/jakarta/validation/ValidatorFactory.java
 * Jakarta Bean Validation API
 * Jakarta Bean Validation provider and builds the appropriate {@link ValidatorFactory}.
	 * Add a stream describing constraint mapping in the Jakarta Bean Validation XML
	 * {@link ValidatorFactory} has been built. The Jakarta Bean Validation provider
	 *        mark/reset contract by the Jakarta Bean Validation provider
./src/main/java/jakarta/validation/Configuration.java
 * Jakarta Bean Validation API
		 * provider-specific APIs. If the Jakarta Bean Validation provider
./src/main/java/jakarta/validation/MessageInterpolator.java
 * Jakarta Bean Validation API
 * Default Jakarta Bean Validation group.
./src/main/java/jakarta/validation/groups/Default.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/groups/ConvertGroup.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/groups/package-info.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/ConstraintViolationException.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/ConstraintValidator.java
 * Jakarta Bean Validation API
	 * being used by the Jakarta Bean Validation provider.
./src/main/java/jakarta/validation/ConstraintValidatorFactory.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/BootstrapConfiguration.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/executable/ValidateOnExecution.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/executable/package-info.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/executable/ExecutableValidator.java
 * Jakarta Bean Validation API
	 * JavaBeans specification is a method whose:
	 * JavaBeans specification is a method whose:
./src/main/java/jakarta/validation/executable/ExecutableType.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/ReportAsSingleViolation.java
 * Jakarta Bean Validation API
 * @param <T> the type of the root bean
	 * Returns the root bean being validated. For method validation, returns
	T getRootBean();
	 * Returns the class of the root bean being validated.
	 * @return the class of the root bean or of the object hosting the validated element
	Class<T> getRootBeanClass();
	 *
the bean instance the constraint is applied on if it is
	 *     a bean constraint

	 *
the bean instance hosting the property the constraint
	 * @return the leaf bean
	Object getLeafBean();
	 * @return the property path to the value from {@code rootBean}
	 * provider-specific APIs. If the Jakarta Bean Validation provider
./src/main/java/jakarta/validation/ConstraintViolation.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/GroupDefinitionException.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/GroupSequence.java
 * Jakarta Bean Validation API
 * Used by the Jakarta Bean Validation runtime when creating constraint violation
./src/main/java/jakarta/validation/ParameterNameProvider.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/UnexpectedTypeException.java
 * Jakarta Bean Validation API
 * Marks an annotation as being a Jakarta Bean Validation constraint.
./src/main/java/jakarta/validation/Constraint.java
 * Jakarta Bean Validation API
 * Contract determining if a property can be accessed by the Jakarta Bean Validation provider.
	 * Determines if the Jakarta Bean Validation provider is allowed to reach the property state.
	 * @param rootBeanType type of the root object passed to the Validator
	 *        (using the path specification defined by Bean Validation)
	 * @return {@code true} if the Jakarta Bean Validation provider is allowed to
						Class<?> rootBeanType,
	 * Determines if the Jakarta Bean Validation provider is allowed to cascade validation on
	 * the bean instance returned by the property value
	 * @param rootBeanType type of the root object passed to the Validator
	 *        (using the path specification defined by Bean Validation)
	 * @return {@code true} if the Jakarta Bean Validation provider is allowed to
						 Class<?> rootBeanType,
./src/main/java/jakarta/validation/TraversableResolver.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/ClockProvider.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/Valid.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/ConstraintDeclarationException.java
 * Jakarta Bean Validation API
 * Determines the list of Jakarta Bean Validation providers available in the runtime environment
 * Jakarta Bean Validation providers are identified by the presence of
./src/main/java/jakarta/validation/ValidationProviderResolver.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/constraintvalidation/package-info.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/constraintvalidation/SupportedValidationTarget.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/constraintvalidation/ValidationTarget.java
 * Jakarta Bean Validation API
 * Top level package of the Jakarta Bean Validation API.
 *
{@link jakarta.validation.Validation}: the entry point to bootstrap Jakarta Bean Validation

 *
{@link jakarta.validation.ValidatorFactory}: the bootstrapped Jakarta Bean Validation engine

 *
{@link jakarta.validation.Validator}: contract to validate beans and access the metadata

./src/main/java/jakarta/validation/package-info.java
 * Jakarta Bean Validation API
		 *
{@code null} if it is a leaf node which represents an entity / bean.
		 *
{@link ElementKind#BEAN}: {@link BeanNode}

	 * Node representing a bean.
	interface BeanNode extends Node {
./src/main/java/jakarta/validation/Path.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/Payload.java
 * Jakarta Bean Validation API
 * This class is the entry point for Jakarta Bean Validation.
	 * default Jakarta Bean Validation provider and following the XML configuration.
	 * @throws NoProviderFoundException if no Jakarta Bean Validation provider was found
	 * @throws ValidationException if a Jakarta Bean Validation provider was found but the
	 * ACME Jakarta Bean Validation provider. and {@code ACMEProvider} is the
	 * Not a public API; it can be used reflectively by code that integrates with Jakarta Bean Validation, e.g. application
				String msg = "Unable to create a Configuration, because no Jakarta Bean Validation provider could be found." +
	 * Jakarta Bean Validation specification. This implementation first uses thread's context classloader to locate providers.
./src/main/java/jakarta/validation/Validation.java
 * Jakarta Bean Validation API
 * Enum of possible kinds of elements encountered in Jakarta Bean Validation.
	 * A Java Bean or object.
	BEAN,
	 * A property of a Java Bean.
./src/main/java/jakarta/validation/ElementKind.java
 * Jakarta Bean Validation API
	 * contain the same contextual information (root bean, path and so on) unless
	 * //Build a constraint violation on the default path + the bean stored
	 *             .addBeanNode()
	 * //i.e. the Address bean hosted in the "home" key of the "otherAddresses" map parameter
	 *             .addBeanNode()
	 * //i.e. on the "city" property of the Address bean hosted in
	 * provider-specific APIs. If the Jakarta Bean Validation provider
		 *             {@link #addBeanNode()} and {@link #addParameterNode(int)}
		 * Adds a bean node (class-level) to the path the {@link ConstraintViolation}
		 * Note that bean nodes are always leaf nodes.
		 * @return a builder representing the bean node
		LeafNodeBuilderCustomizableContext addBeanNode();
			 *             and {@link #addBeanNode()}
			 * Adds a bean node (class-level) to the path the {@link ConstraintViolation}
			 * Note that bean nodes are always leaf nodes.
			 * @return a builder representing the bean node
			LeafNodeBuilderCustomizableContext addBeanNode();
			 *             and {@link #addBeanNode()}
			 * Adds a bean node (class-level) to the path the {@link ConstraintViolation}
			 * Note that bean nodes are always leaf nodes.
			 * @return a builder representing the bean node
			LeafNodeBuilderCustomizableContext addBeanNode();
			 *             and {@link #addBeanNode()}
			 * Adds a bean node (class-level) to the path the {@link ConstraintViolation}
			 * Note that bean nodes are always leaf nodes.
			 * @return a builder representing the bean node
			LeafNodeBuilderCustomizableContext addBeanNode();
			 * Adds a bean node (class-level) to the path the {@link ConstraintViolation}
			 * Note that bean nodes are always leaf nodes.
			 * @return a builder representing the bean node
			LeafNodeBuilderCustomizableContext addBeanNode();
			 * Adds a bean node (class-level) to the path the {@link ConstraintViolation}
			 * Note that bean nodes are always leaf nodes.
			 * @return a builder representing the bean node
			LeafNodeBuilderCustomizableContext addBeanNode();
			 * Adds a bean node (class-level) to the path the {@link ConstraintViolation}
			 * Note that bean nodes are always leaf nodes.
			 * @return a builder representing the bean node
			LeafNodeBuilderCustomizableContext addBeanNode();
./src/main/java/jakarta/validation/ConstraintValidatorContext.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/ValidatorContext.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/metadata/MethodDescriptor.java
 * Jakarta Bean Validation API
 * Describes a Java Bean property hosting validation constraints.
	 * Name of the property according to the Java Bean specification.
./src/main/java/jakarta/validation/metadata/PropertyDescriptor.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/metadata/ExecutableDescriptor.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/metadata/ConstructorDescriptor.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/metadata/ReturnValueDescriptor.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/metadata/ContainerDescriptor.java
 * Jakarta Bean Validation API
	 * If the Jakarta Bean Validation provider implementation does not support the specified class,
./src/main/java/jakarta/validation/metadata/ConstraintDescriptor.java
 * Jakarta Bean Validation API
 * Describes a constrained Java Bean and the constraints associated to it. All
public interface BeanDescriptor extends ElementDescriptor {
	 * Returns {@code true} if the bean involves validation:
	 *
a constraint is hosted on the bean itself

	 *
a constraint is hosted on one of the bean properties

	 *
or a bean property is marked for cascaded validation ({@link Valid})

	 * @return {@code true} if the bean involves validation, {@code false} otherwise
	boolean isBeanConstrained();
	 * Returns a set with descriptors for the constrained methods of the bean
	 * @return a set with descriptors for the constrained methods of this bean;
	 *         will be empty if this bean has no constrained methods of the considered
	 * bean represented by this descriptor.
	 *         bean; will be empty if this bean has no constrained constructor
./src/main/java/jakarta/validation/metadata/BeanDescriptor.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/metadata/ElementDescriptor.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/metadata/ContainerElementTypeDescriptor.java
 * Jakarta Bean Validation API
	 * JavaBeans specification is a method whose:
	 * JavaBeans specification is a method whose:
./src/main/java/jakarta/validation/metadata/MethodType.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/metadata/GroupConversionDescriptor.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/metadata/package-info.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/metadata/CrossParameterDescriptor.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/metadata/ParameterDescriptor.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/metadata/Scope.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/metadata/CascadableDescriptor.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/metadata/ValidateUnwrappedValue.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/valueextraction/ExtractedValue.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/valueextraction/UnwrapByDefault.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/valueextraction/ValueExtractorDefinitionException.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/valueextraction/ValueExtractorDeclarationException.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/valueextraction/package-info.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/valueextraction/ValueExtractor.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/valueextraction/Unwrapping.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/spi/BootstrapState.java
 * Jakarta Bean Validation API
 * Jakarta Bean Validation bootstrapping process and Jakarta Bean Validation providers.
./src/main/java/jakarta/validation/spi/package-info.java
 * Jakarta Bean Validation API
	 * by the Jakarta Bean Validation provider.
./src/main/java/jakarta/validation/spi/ConfigurationState.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/spi/ValidationProvider.java
 * Jakarta Bean Validation API
import jakarta.validation.metadata.BeanDescriptor;
 * Validates bean instances. Implementations of this interface must be thread-safe.
	 * of the class {@code beanType} would the property value be {@code value}.
	 * {@link ConstraintViolation#getRootBean()} and
	 * {@link ConstraintViolation#getLeafBean()}.
	 * @param beanType the bean type
	 * @throws IllegalArgumentException if {@code beanType} is {@code null},
	<T> Set<ConstraintViolation<T>> validateValue(Class<T> beanType,
	 * Returns the descriptor object describing bean constraints.
	 * @return the bean descriptor for the specified class
	BeanDescriptor getConstraintsForClass(Class<?> clazz);
	 * If the Jakarta Bean Validation provider implementation does not support
./src/main/java/jakarta/validation/Validator.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/ConstraintTarget.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/OverridesAttribute.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/constraints/FutureOrPresent.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/constraints/Negative.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/constraints/Positive.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/constraints/NotBlank.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/constraints/Past.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/constraints/AssertFalse.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/constraints/PastOrPresent.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/constraints/Digits.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/constraints/Null.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/constraints/Pattern.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/constraints/Max.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/constraints/Min.java
 * Jakarta Bean Validation API
 * Contains all the Jakarta Bean Validation provided constraints
./src/main/java/jakarta/validation/constraints/package-info.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/constraints/Future.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/constraints/NegativeOrZero.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/constraints/Size.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/constraints/DecimalMin.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/constraints/DecimalMax.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/constraints/AssertTrue.java
 * Jakarta Bean Validation API
 * email address are left to Jakarta Bean Validation providers. Accepts {@code CharSequence}.
./src/main/java/jakarta/validation/constraints/Email.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/constraints/NotEmpty.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/constraints/NotNull.java
 * Jakarta Bean Validation API
./src/main/java/jakarta/validation/constraints/PositiveOrZero.java
 * Jakarta Bean Validation API
 * Exception raised if no Jakarta Bean Validation provider could be found.
./src/main/java/jakarta/validation/NoProviderFoundException.java
  ~ Jakarta Bean Validation API
            This is the XML Schema for Jakarta Bean Validation constraint mapping files.
            Jakarta Bean Validation constraint mapping files must indicate the Jakarta Bean Validation
            <xs:element type="map:beanType"
                        name="bean"
    <xs:complexType name="beanType">
./src/main/xsd/validation-mapping-3.0.xsd
  ~ Jakarta Bean Validation API
            This is the XML Schema for the Jakarta Bean Validation configuration file.
            Jakarta Bean Validation configuration files must indicate the Jakarta Bean Validation
./src/main/xsd/validation-configuration-2.0.xsd
  ~ Jakarta Bean Validation API
            <xs:element type="map:beanType"
                        name="bean"
    <xs:complexType name="beanType">
./src/main/xsd/validation-mapping-1.0.xsd
  ~ Jakarta Bean Validation API
            This is the XML Schema for the Jakarta Bean Validation configuration file.
            Jakarta Bean Validation configuration files must indicate the Jakarta Bean Validation
./src/main/xsd/validation-configuration-1.1.xsd
  ~ Jakarta Bean Validation API
            This is the XML Schema for Jakarta Bean Validation constraint mapping files.
            Jakarta Bean Validation constraint mapping files must indicate the Jakarta Bean Validation
            <xs:element type="map:beanType"
                        name="bean"
    <xs:complexType name="beanType">
./src/main/xsd/validation-mapping-2.0.xsd
  ~ Jakarta Bean Validation API
./src/main/xsd/validation-configuration-1.0.xsd
  ~ Jakarta Bean Validation API
            This is the XML Schema for the Jakarta Bean Validation configuration file.
            Jakarta Bean Validation configuration files must indicate the Jakarta Bean Validation
./src/main/xsd/validation-configuration-3.0.xsd
  ~ Jakarta Bean Validation API
            This is the XML Schema for Jakarta Bean Validation constraint mapping files.
            Jakarta Bean Validation constraint mapping files must indicate the Jakarta Bean Validation
            <xs:element type="map:beanType"
                        name="bean"
    <xs:complexType name="beanType">
./src/main/xsd/validation-mapping-1.1.xsd
# NetBeans specific files/directories
/beanvalidation-release-scripts
./.gitignore
Jakarta Bean Validation API
./license/license.header
  ~ Jakarta Bean Validation API
./license/java-header-style.xml
  ~ Jakarta Bean Validation API
./license/xml-header-style.xml
# Jakarta Bean Validation API
This repository contains the Java Jakarta Bean Validation 3.0 API.
Jakarta Bean Validation defines a metadata model and API for JavaBean and method validation.
* Official website: <https://beanvalidation.org/>
* Latest draft of the spec: <https://beanvalidation.org/latest-draft/spec/>
The Jakarta Bean Validation API is provided and distributed under the Apache Software License 2.0.
Refer to [license.txt](https://github.com/eclipse-ee4j/beanvalidation-api/blob/master/license.txt) for more information.
You can build the Jakarta Bean Validation API from source by cloning the git repository https://github.com/eclipse-ee4j/beanvalidation-api.git.
Want to join us? You can find all the relevant information about contributing to Jakarta Bean Validation on the [website](https://beanvalidation.org/contribute/).
The official Continuous Integration service for the project is hosted on [ci.eclipse.org](https://ci.eclipse.org/bean-validation/).
./README.md
# Notices for Eclipse Jakarta Bean Validation
This content is produced and maintained by the Eclipse Jakarta Bean Validation
* Project home: https://projects.eclipse.org/projects/ee4j.bean-validation
 Jakarta Bean Validation is a trademark of the Eclipse Foundation.
 * [The specification repository](https://github.com/eclipse-ee4j/beanvalidation-spec)
 * [The API repository](https://github.com/eclipse-ee4j/beanvalidation-api)
 * [The TCK repository](https://github.com/eclipse-ee4j/beanvalidation-tck)
./NOTICE.md
# Contributing to Eclipse Jakarta Bean Validation
Bean Validation defines a metadata model and API for JavaBean and method validation.
* https://beanvalidation.org/
* https://projects.eclipse.org/projects/ee4j.bean-validation
Contributions from the community are essential in keeping Jakarta Bean Validation strong and successful.
Please see the following pages to learn more about contributing to the Jakarta Bean Validation spec, its API, TCK and website:
* [General contribution guide](https://beanvalidation.org/contribute/)
* [Contributing to the specification](https://beanvalidation.org/contribute/specification/)
* [Contributing to the API and the TCK](https://beanvalidation.org/contribute/coding)
* [Contributing to the website](https://beanvalidation.org/contribute/site)
e.g. by sending a mail to the [bean-validation-dev](https://accounts.eclipse.org/mailing-list/bean-validation-dev) mailing list.
 * [The specification repository](https://github.com/eclipse-ee4j/beanvalidation-spec)
 * [The API repository](https://github.com/eclipse-ee4j/beanvalidation-api)
 * [The TCK repository](https://github.com/eclipse-ee4j/beanvalidation-tck)
* https://accounts.eclipse.org/mailing-list/bean-validation-dev
./CONTRIBUTING.md
  ~ Jakarta Bean Validation API
    <name>Jakarta Bean Validation API</name>
    <url>https://beanvalidation.org</url>
        Jakarta Bean Validation API
        <connection>scm:git:git://github.com/eclipse-ee4j/beanvalidation-api.git</connection>
        <developerConnection>scm:git:git@github.com:eclipse-ee4j/beanvalidation-api.git</developerConnection>
        <url>https://github.com/eclipse-ee4j/beanvalidation-api</url>
                    <packagesheader>Jakarta Bean Validation API Packages</packagesheader>
                    <doctitle>Jakarta Bean Validation API ${project.version}</doctitle>
                    <windowtitle>Jakarta Bean Validation API ${project.version}</windowtitle>
Comments to: <a href="mailto:bean-validation-dev<EMAIL_ADDRESS>./pom.xml

The API is the easy part. Then you have the spec, the website, the reference implementation, and probably a lot of other things.

The API is the easy part. Then you have the spec, the website, the reference implementation, and probably a lot of other things.

True, but we went in JSF from JSF to Jakarta Server Faces and then to Jakarta Faces. Very similar process.

@gsmet yes, but it is WIP. I am about to continue iterating in validation-spec.
find . -name .git -prune -o -type f -exec grep -i bean {} \; -print
  ~ Jakarta Bean Validation: constrain once, validate everywhere.
	<property name="base.name" value="bean-validation-specification"/>

./build.xml
sed -i 's@<property name="logo" value=".*" />@<property name="logo" value="beanvalidation_logo.png[align=left,pdfwidth=20%]" />@' build.xml
./prepare-release.sh
// Jakarta Bean Validation
A [classname]`Validator` instance is able to validate instances of beans and their associated objects if any. It is recommended to leave the caching of [classname]`Validator` instances to the [classname]`ValidatorFactory`. [tck-not-testable]#[classname]`Validator` implementations must be thread-safe.#
The methods [methodname]`validate()`, [methodname]`validateProperty()` and [methodname]`validateValue()` are used for the validation of Java beans respectively single bean properties. See the next section for more details.
[tck-testable]#[methodname]`<T> Set<ConstraintViolation<T>> validateProperty(T object, String propertyName, Class<?>\... groups)` validates a given field or property of an object.# [tck-testable]#An [classname]`IllegalArgumentException` is thrown when [methodname]`validateProperty()` is called and [varname]`object` is null or [varname]`propertyName` is null, empty or invalid or null is passed to the varargs [varname]`groups` parameter.# [tck-testable]#The property name is the JavaBeans property name (as defined by the JavaBeans [classname]`Introspector` class).# This method implements the logic described in <<constraintdeclarationvalidationprocess-validationroutine>> but only to the given property. [tck-testable]#`@Valid` is not honored by this method.# This method is useful for partial object validation.
[tck-testable]#[methodname]`<T> Set<ConstraintViolation<T>> validateValue(Class<T> beanType, String propertyName, Object value, Class<?>\... groups)` validates the property referenced by [parameter]`propertyName` present on `beanType` or any of its superclasses, if the property value were [parameter]`value`.# [tck-testable]#An [classname]`IllegalArgumentException` is thrown when [methodname]`validateValue()` is called and [varname]`beanType` is null or [varname]`propertyName` is null, empty or invalid or null is passed to the varargs [varname]`groups` parameter.# This method implements the logic described in <<constraintdeclarationvalidationprocess-validationroutine>> and apply it only to the given property and for the given value. [tck-testable]#`@Valid` is not honored by this method.# This method is useful for ahead of time validation (i.e. before the JavaBean is populated or updated).
[tck-testable]#The [methodname]`getRootBean()` method returns the root object being validated that led to the failing constraint# (i.e. the object the client code passes to the [methodname]`Validator.validate()` method). [tck-testable]#For method validation, returns the object the method is executed on. For constructors or when [methodname]`Validator.validateValue()` is used, returns `null`.#
[tck-testable]#The [methodname]`getRootBeanClass()` method returns the class of the root bean being validated. For method validation, this is the object class the method is executed on. For constructor validation, this is the class the constructor is declared on.#
The [methodname]`getLeafBean()` method returns the following object:
* If a bean constraint, the bean instance the constraint is applied on.
* If a property constraint or a <<constraintdeclarationvalidationprocess-containerelementconstraints,container element constraint>> hosted on a property, the bean instance hosting the property the constraint is applied on.
** `null` if it is a leaf node which represents an entity / bean. In particular, the node representing the root object.
* [classname]`BeanNode`
`BeanNode`, `PropertyNode` and `ContainerElementNode` host `getContainerClass()` and `getTypeArgumentIndex()`.
case BEAN:
* [tck-testable]#If the failing object is the root object, a [classname]`BeanNode` with name set to [classname]`null` is added to the [classname]`Path`. The [classname]`ElementKind` of the node is [varname]`ElementKind.BEAN`.#
** [tck-testable]#a [classname]`PropertyNode` object whose `name` equals the name of the association property (field name or Java Bean property name) is added to [classname]`Path`. The [classname]`ElementKind` of the node is [varname]`ElementKind.PROPERTY`.#
** a [classname]`PropertyNode` object is added to [classname]`Path` whose `name` equals the name of the property (field name or Java Bean property name). The [classname]`ElementKind` of the node is [varname]`ElementKind.PROPERTY`.
** a [classname]`BeanNode` object is added to [classname]`Path` whose `name` is null. The [classname]`ElementKind` of the node is [varname]`ElementKind.BEAN`.
* if the default path ends with a [classname]`BeanNode`, this node is removed and the first added node (a [classname]`PropertyNode`) inherits its `inIterable`, `key` and `index` values. `inIterable`, `key` and `index` value must not be specified directly on this first node by the user.
** [tck-testable]#A [classname]`BeanNode` is appended in case [methodname]`addBeanNode()` is invoked. The node name is `null`. The [classname]`ElementKind` of the node is `ElementKind.BEAN`.#
From [methodname]`getRootBean()`, [methodname]`getPropertyPath()`, [methodname]`getExecutableParameters()` and [methodname]`getExecutableReturnValue()`, it is possible to rebuild the context of the failure.
BeanNode(name=null, inIterable=false, index=null, key=null, containerClass=null, typeArgumentIndex=null, kind=ElementKind.BEAN)
BeanNode(name=null, inIterable=true, index=3, key=null, containerClass=List.class, typeArgumentIndex=0, kind=ElementKind.BEAN)
[tck-not-testable]#{spec-name-bv} implementations should ensure that a [classname]`ConstraintViolation` implementation is [classname]`Serializable` provided that the root bean, the leaf bean, the invalid value and keys in the [classname]`Path` object are [classname]`Serializable` objects.#
include::{spec-examples-source-dir}org/beanvalidation/specexamples/validationapi/NonEmpty.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/validationapi/Author.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/validationapi/Book.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/validationapi/ValidationApiTest.java[tags=invocation]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/validationapi/ValidationApiTest.java[tags=title]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/validationapi/ValidationApiTest.java[tags=lastName]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/validationapi/ValidationApiTest.java[tags=tags]
assert library == constraintViolation.getRootBean();
assert Library.class == constraintViolation.getRootBeanClass();
assert library == constraintViolation.getLeafBean();
assert library == constraintViolation.getRootBean();
assert Library.class == constraintViolation.getRootBeanClass();
assert book == constraintViolation.getLeafBean();
assert user == constraintViolation.getRootBean();
assert User.class == constraintViolation.getRootBeanClass();
assert user == getLeafBean();
assert null == constraintViolation.getRootBean();
assert Library.class == constraintViolation.getRootBeanClass();
assert null == constraintViolation.getLeafBean();
assert library == constraintViolation.getRootBean();
assert Library.class == constraintViolation.getRootBeanClass();
assert book == constraintViolation.getLeafBean();
assert null == constraintViolation.getRootBean();
assert Library.class == constraintViolation.getRootBeanClass();
assert publicLibrary == constraintViolation.getLeafBean();
[tck-testable]#The default message interpolation allows the use of {spec-name-expressionlanguage}.# [tck-testable]#Expressions to be evaluated by {spec-name-expressionlanguage} need to be enclosed in `${}` within the message descriptor# . The following properties and beans have to be made available in the {spec-name-expressionlanguage} context:
* [tck-testable]#a bean mapped to the name `formatter` exposing the vararg method [methodname]`format(String format, Object\... args)`. This method must behave like [methodname]`java.util.Formatter.format(String format, Object\... args)`. The locale used for formatting is defined by <<validationapi-message-defaultmessageinterpolation-locale>>. The `formatter` bean allows to format property values, for example in the case of the validated value being 98.12345678, `${formatter.format('%1$.2f', validatedValue)}` would format it to 98.12 (two digits after the decimal point, where the use of '.' vs ',' would be locale specific).#
{spec-name-bv} itself doesn't trigger the evaluation of method constraints. That is, just annotating any methods or constructors with parameter or return value constraints doesn't automatically enforce these constraints, just as annotating any fields or properties with bean constraints doesn't enforce these either.
Instead method constraints must be validated by invoking the appropriate methods on [classname]`jakarta.validation.executable.ExecutableValidator`. Typically this won't happen by manually calling these methods but rather automatically upon invocation of the constrained methods or constructors, using approaches and techniques such as {spec-name-di}/{spec-name-enterprisebeans} interceptors, aspect-oriented programming or dynamic proxies.
    BeanDescriptor bean = validator.getConstraintsForClass( type );
    MethodDescriptor methodDescriptor = bean.getConstraintsForMethod(
    BeanDescriptor bean = validator.getConstraintsForClass( type );
    MethodDescriptor methodDescriptor = bean.getConstraintsForMethod(
    BeanDescriptor bean = validator.getConstraintsForClass( type );
    MethodDescriptor methodDescriptor = bean.getConstraintsForMethod(
    BeanDescriptor bean = validator.getConstraintsForClass( type );
    return bean.getConstrainedConstructors().size() > 0;
    BeanDescriptor bean = validator.getConstraintsForClass( type );
    ConstructorDescriptor constructorDescriptor = bean.getConstraintsForConstructor(
    BeanDescriptor bean = validator.getConstraintsForClass( type );
    ConstructorDescriptor constructorDescriptor = bean.getConstraintsForConstructor(
    BeanDescriptor bean = validator.getConstraintsForClass( type );
    ConstructorDescriptor constructorDescriptor = bean.getConstraintsForConstructor(
./sources/validation-api.asciidoc
// Jakarta Bean Validation
The {spec-name-bv} specification defines a framework for declaring constraints on JavaBean classes, fields and properties. Constraints are declared on types and evaluated against instances or graphs of instances.
* [tck-testable]#Properties to be validated must follow the method signature conventions for JavaBeans read properties, as defined by the link:$$http://download.oracle.com/otndocs/jcp/7224-javabeans-1.01-fr-spec-oth-JSpec/$$[JavaBeans specification]. These properties are commonly referred as getters.#
The JavaBeans specification specifies that a getter is a method whose
When using field access strategy, the {spec-name-bv} provider accesses the instance variable directly. When using the property access strategy, the {spec-name-bv} provider accesses the state via the property accessor method. It is required that the class follows the method signature conventions for JavaBeans read properties (as defined by the JavaBeans [classname]`Introspector` class) for constrained properties when constrained properties are used. In this case, for every constraint property of type [classname]`T`, there is a getter method named [methodname]`get<Property-name>`. The method must have no parameters. For [code]`boolean` properties, [methodname]`is<Property-name>` is an alternative name for the getter method. Specifically, if [methodname]`getX` is the name of the getter method, where [classname]`X` is a string, the name of the persistent property is defined by the result of [code]`java.beans.Introspector.decapitalize(X)`.
[tck-testable]#Consider the situation where bean [classname]`X` contains a field of type [classname]`Y`. By annotating field [classname]`Y` with the [classname]`@Valid` annotation, the Validator will validate [classname]`Y` (and its properties) when [classname]`X` is validated.# [tck-testable]#The exact type [classname]`Z` of the value contained in the field declared of type [classname]`Y` (subclass, implementation) is determined at runtime. The constraint definitions of [classname]`Z` are used.# This ensures proper polymorphic behavior for associations marked with [classname]`@Valid`.
    // preferred style as of Jakarta Bean Validation 2.0
    // preferred style as of Jakarta Bean Validation 2.0
Constraint declarations are placed on classes or interfaces primarily through annotations. A constraint annotation (see <<constraintsdefinitionimplementation-constraintdefinition>>), can be applied to a type, on any of the type's fields or on any of the JavaBeans-compliant properties.
Method constraints are declared by adding constraint annotations directly to methods or constructors and/or their parameters. In the former case, all the parameters of an executable (cross-parameter constraint) or the return value is constrained, in the latter individual parameters are constrained. As with bean constraints, this can be done using either actual Java annotations or using an XML constraint mapping file (see <<xml-mapping-constraintdeclarationinxml-methodleveloverriding>>). {spec-name-bv} providers are free to provide additional means of defining method constraints such as an API-based approach.
[tck-testable]#The [classname]`@Valid` annotation is used to declare that a cascaded validation of the given method/constructor parameters or return values is performed by the {spec-name-bv} provider. When marked, the parameter or return value is considered a bean object to validate.# The same rules as for standard object graph validation (see <<constraintdeclarationvalidationprocess-validationroutine-graphvalidation>>) apply, in particular
For a given group, the validation routine applied on a given bean instance is expected to execute the following constraint validations in no particular order:
[tck-testable]#`rootBeanType` is the class of the root being validated, i.e. either the type of the object passed to the [methodname]`validate` method or the type declaring the validated method/constructor in case of method validation.#
[tck-testable]#`pathToTraversableObject` is the [classname]`Path` from the [methodname]`rootBeanType` down to the [methodname]`traversableObject`. If the root object is [classname]`traversableObject`, [classname]`pathToTraversableObject` is composed of a single Node whose name is `null`. The path is described following the conventions described in <<validationapi-constraintviolation>> ([methodname]`getPropertyPath`).#
* the bean instance validated
                               Class<?> rootBeanType,
                               Class<?> rootBeanType,
* [methodname]`rootBeanType`: [classname]`Address.class`. The type of the root object being validated.
* [methodname]`rootBeanType`: [classname]`Address.class`. The type of the root object being validated.
* `pathtoTraversableObject`: a [classname]`Path` containing a single [classname]`BeanNode` whose name is `null`.
* [methodname]`rootBeanType`: [classname]`AddressService.class`. The type of the root object being validated.
* [methodname]`rootBeanType`: [classname]`AddressService.class`. The type of the root object being validated.
* [tck-testable]#If the constraint is subject to implicit unwrapping (see <<constraintdeclarationvalidationprocess-containerelementconstraints-implicitunwrapping>>) and the applicable value extractor is defined for a generic type (e.g. `javafx.beans.value.ObservableValue`), the targeted type is the type captured for the type parameter handled by the value extractor (e.g. `String` if the constraint is placed on a `StringProperty`).#
The first example demonstrates how beans, fields and getters are annotated to express some constraints.
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintdeclarationvalidation/resolution/NonEmpty.java[tags=include]
./sources/constraint-declaration-validation.asciidoc
// Jakarta Bean Validation
./sources/appendix-standardresolvermessages.asciidoc
// Jakarta Bean Validation
./sources/builtin-constraints.asciidoc
// Jakarta Bean Validation
./sources/exception.asciidoc
// Jakarta Bean Validation
./sources/license.asciidoc
// Jakarta Bean Validation
A constraint on a JavaBean is expressed through one or more annotations. [tck-not-testable]#An annotation is considered a constraint definition if its retention policy contains `RUNTIME` and if the annotation itself is annotated with `jakarta.validation.Constraint`# .
A constraint is said to be generic if it has at least one constraint validator targeting the element annotated i.e. targeting the (returned) element annotated by the constraint (a bean, a field, a getter, a method/constructor return value or a method/constructor parameter). A constraint is said to be cross-parameter if it has one constraint validator targeting the array of parameters of a method or constructor (to validate the consistency of several method/constructor parameters). A {spec-name-bv} constraint is most of the time either a generic constraint or a cross-parameter constraint. In rare situations, a constraint can be both.
* `TYPE` for constrained beans
[tck-testable]#A constraint definition may have attributes that are specified at the time the constraint is applied to a JavaBean.# The properties are mapped as annotation elements. The annotation element names `message`, `groups`, `validationAppliesTo` and `payload` are considered reserved names; [tck-testable]#annotation elements starting with `valid` are not allowed# ; a constraint may use any other element name for its attributes.
Groups are typically used to control the order in which constraints are evaluated, or to perform validation of the partial state of a JavaBean.
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintdefinition/annotation/OrderNumber.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintdefinition/annotation/DateParametersConsistent.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintdefinition/annotation/ELAssert.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintdefinition/annotation/Audible.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintdefinition/annotation/Acceptable.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintdefinition/multivaluedconstraint/ZipCode.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintdefinition/multivaluedconstraint/Address.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintdefinition/multivaluedconstraint/explicitlist/Address.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintdefinition/constraintcomposition/FrenchZipCode.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintdefinition/constraintcomposition/single/FrenchZipCode.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintdefinition/constraintcomposition/FrenchZipCode.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintdefinition/constraintcomposition/overriding/FrenchZipCode.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintdefinition/constraintcomposition/overriding/interpreted/FrenchZipCode.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintdefinition/constraintcomposition/overriding/constraintindex/EmmanuelsEmail.java[tags=include]
This object is built from the default constraint message template as defined by the constraint declaration and the context in which the constraint declaration is placed (bean, property, executable parameter, cross-parameter, executable return value or container element).#
[tck-testable]#By default, the [classname]`Path` exposed on the [classname]`ConstraintViolation` represents the path to the bean, property, parameter, cross-parameter, return value or container element hosting the constraint (see <<validationapi-constraintviolation>> for more information).# [tck-testable]#You can point it to a subpath of this default path by using the constraint violation builder fluent API.#
//Build a constraint violation on the default path + the bean stored
            .addBeanNode()
//i.e. the Address bean hosted in the "home" key of the "otherAddresses" map parameter
            .addBeanNode()
//i.e. on the "city" property of the Address bean hosted in
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintdefinition/validator/BeginsWithValidator.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintdefinition/validator/DateParametersConsistentValidator.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintdefinition/validator/SerialNumberValidator.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintdefinition/temporal/PastValidatorForZonedDateTime.java[tags=include]
./sources/constraint-definition.asciidoc
// Jakarta Bean Validation
Constraint:: A restriction on a bean instance, the value of a field or the value of a JavaBean property.
Constraint declaration:: Assignment of a constraint to a target (bean, field, property) for a specific class. Typically by declaring an annotation on the target but can also be done through a XML deployment descriptor.
Constraint metadata API:: API exposing the constraints applied to a given bean type. Also considered one of the integration points with other specification or frameworks.
jakarta.validation.ConstraintViolation:: Interface describing a given constraint failure on a given bean.
./sources/terminology.asciidoc
// Jakarta Bean Validation
    * [BVAL-690] - Clarify getLeafBean() for container element constraints
    * [BVAL-585] - Add descriptions of build goals to beanvalidation-spec/README.md
    * [BVAL-460] - Set ignore-annotation default value for beans to true in XSD to document
    * [BVAL-423] - Clarify behavior of ConstraintViolation#getLeafBean() for validateValue()
    * [BVAL-362] - Reference the various specs (JPA, JSF, CDI, JavaBeans)
    * [BVAL-405] - Clarify what isBeanConstrained does and add hasExecutableConstrained
    * [BVAL-410] - Make node creation suppress the cross-param and bean-level node in case of
    * [BVAL-415] - Make sure maven plugins are set in beanvalidation-api
    * [BVAL-191] - Introduce a addBeanNode() method to the fluent node builder API
    * [BVAL-334] - Refer to CDI provided beans as "built-in" beans
    * [BVAL-307] - Decide how CDI and Bean Validation is integrated
    * [BVAL-212] - Wrong closing  element in javadocs of BeanDescriptor
    * [BVAL-270] - Specify that Bean Validation 1.1 providers must support deployment
    * [BVAL-258] - Clean introduction section to reflect Bean Validation 1.1
    * [BVAL-279] - Update POM file for Bean Validation API to use latest Git repo urls and
    * [BVAL-132] - Define behaviour for BeanDescriptor.getConstraintsForProperty(null)
                   (BeanDescriptor, ElementDescriptor, PropertyDescriptor,
    * [BVAL-166] - IllegalArgumentException raised on BeanDescriptor.getConstraintsForProperty
    * [BVAL-150] - Add ConstraintViolation.getRootBeanClass
    * [BVAL-140] - BeanDescriptor.getConstrainedProperties() returns Set<PropertyDescriptor>
    * [BVAL-73] - Rename ConstraintViolation.getBeanClass() to CV. getRootClass() or simply
    * [BVAL-1] - Remove references to 'beancheck' in the spec
./sources/changelog.asciidoc
// Jakarta Bean Validation
[tck-testable]#A given JavaBean is described by the [classname]`bean` element.# [tck-testable]#The name of the class is mandatory.# [tck-testable]#By default, all constraint declarations expressed via annotations are ignored for classes described in XML.# [tck-testable]#You can force {spec-name-bv} to consider both annotations and XML constraint declarations by using `ignore-annotations="false"` on `bean`.#
The `ignore-annotations` setting is not inherited from nor by the class hierarchy. In other words, it applies to the current bean only.
.Example of bean XML declaration
    <bean class="Customer" ignore-annotations="false">
    </bean>
    <bean class="com.acme.common.model.Address">
    </bean>
Class level annotations are described via the `class` element. [tck-testable]#If `ignore-annotations` is declared, {spec-name-bv} must honor the explicit value for this element.# [tck-testable]#If not declared, the default value defined in the encapsulating [classname]`bean` element is considered.#
    <bean class="Customer" ignore-annotations="false">
    </bean>
    <bean class="com.acme.common.model.Address">
    </bean>
Field level annotations are described via the `field` element. The `name` attribute corresponds to the name of the field considered. [tck-testable]#If `ignore-annotations` is declared, {spec-name-bv} must honor the explicit value for this element.# [tck-testable]#If not declared, the default value defined in the encapsulating [classname]`bean` element is considered.#
[tck-testable]#If the name of the field does not correspond to a field in the given bean a [classname]`ValidationException` is raised.#
    <bean class="Customer" ignore-annotations="false">
    </bean>
Property-level annotations are described via the `getter` element. [tck-testable]#The `name` attribute corresponds to the name of the property considered as defined in <<constraintdeclarationvalidationprocess-requirements-propertyvalidation>> (for example a getter `String getAge()` would have `<getter name="age"/>` as a corresponding descriptor). If `ignore-annotations` is declared, {spec-name-bv} must honor the explicit value for this element.# [tck-testable]#If not declared, the default value defined in the encapsulating [classname]`bean` element is considered.#
[tck-testable]#If the name of the property does not correspond to a property in the given bean a [classname]`ValidationException` is raised.#
    <bean class="Customer" ignore-annotations="false">
    </bean>
[tck-testable]#If no constructor with the specified parameter types exists in the given bean a [classname]`ValidationException` is raised.#
[tck-testable]#If `ignore-annotations` is declared on the `parameter`, `cross-parameter` or `return-value` element, {spec-name-bv} must honor the explicit value for this element. Otherwise, if `ignore-annotations` is declared for the `constructor` element, {spec-name-bv} must honor this value. Otherwise, the default value declared in the encapsulating `bean` element is considered.#
    <bean class="Customer" ignore-annotations="false">
    </bean>
[tck-testable]#A given getter method representing a JavaBeans property may either be configured using the `getter` or the `method` element, but not both. If a `getter` element and a `method` element referring to the same method are detected by the {spec-name-bv} provider, a [classname]`ValidationException` is raised.#
[tck-testable]#If no method with the specified name and parameter types exists in the given bean a [classname]`ValidationException` is raised.#
[tck-testable]#If `ignore-annotations` is declared on the `parameter`, `cross-parameter` or `return-value` element, {spec-name-bv} must honor the explicit value for this element. Otherwise, if `ignore-annotations` is declared for the `method` element, {spec-name-bv} must honor this value. Otherwise, the default value declared in the encapsulating `bean` element is considered.#
    <bean class="Customer" ignore-annotations="false">
    </bean>
    <bean class="Customer" ignore-annotations="false">
    </bean>
    <bean class="Customer" ignore-annotations="false">
    </bean>
    <bean class="Customer" ignore-annotations="false">
    </bean>
   <bean class="com.acme.common.model.Address">
    </bean>
            This is the XML Schema for Jakarta Bean Validation constraint mapping files.
            Jakarta Bean Validation constraint mapping files must indicate the Jakarta Bean Validation
            <xs:element type="map:beanType"
                        name="bean"
    <xs:complexType name="beanType">
            This is the XML Schema for the Jakarta Bean Validation configuration file.
            Jakarta Bean Validation configuration files must indicate the Jakarta Bean Validation
./sources/xml-descriptor.asciidoc
// Jakarta Bean Validation
This document is the specification of the Java API for JavaBean validation in {spec-name-eeplatform} and Java SE. The technical objective of this work is to provide an object level constraint declaration and validation facility for the Java application developer, as well as a constraint metadata repository and query API.
The following persons have actively contributed to Bean Validation 2.0 as members of the JSR 380 expert group and the community at large in alphabetical order:
The following persons have actively contributed to Bean Validation 1.1 as members of the JSR 349 expert group and the community at large in alphabetical order:
This specification defines a metadata model and API for JavaBean validation. The default metadata source is annotations, with the ability to override and extend the metadata through the use of XML validation descriptors.
The validation API developed by this specification is not intended for use in any one tier or programming model. It is specifically not tied to either the web tier or the persistence tier, and is available for both server-side application programming, as well as rich client Swing application developers. This API is seen as a general extension to the JavaBeans object model, and as such is expected to be used as a core component in other specifications. Ease of use and flexibility have influenced the design of this specification.
<<constraintdeclarationvalidationprocess>> describes how a JavaBean class is decorated with annotations to describe constraints.
<<validationapi>> describes how to programmatically validate a JavaBean.
The expert group is eager to receive feedback from readers. Feel free to contact us. You can get all the details at http://beanvalidation.org/contribute/.
./sources/introduction.asciidoc
// Jakarta Bean Validation
[tck-testable]#[methodname]`getConstraintsForClass()` returns a [classname]`BeanDescriptor` object describing the bean level constraints (see <<constraintdeclarationvalidationprocess-requirements-objectvalidation>>) and providing access to the property level constraints metadata.# [tck-testable]#An [classname]`IllegalArgumentException` is raised if the [varname]`clazz` parameter is null.#
* the object type when invoked on [classname]`BeanDescriptor`,
[[constraintmetadata-beandescriptor]]
=== BeanDescriptor
The [classname]`BeanDescriptor` interface describes a constrained Java Bean. This interface is returned by [methodname]`Validator.getConstraintsForClass(Class<?>)`.
.`BeanDescriptor` interface
include::{validation-api-source-dir}jakarta/validation/metadata/BeanDescriptor.java[lines=7..8;12..-1]
[tck-testable]#[methodname]`isBeanConstrained()` returns `true` if the given class (and superclasses and interfaces) has at least one class-level or property-level constraint or validation cascade.# If the method returns false, the {spec-name-bv} engine can safely ignore the bean as it will not be impacted by validation.
[tck-testable]#[methodname]`getConstraintsForProperty()` returns a [classname]`PropertyDescriptor` object describing the property level constraints (See <<constraintdeclarationvalidationprocess-requirements-propertyvalidation>>). The property is uniquely identified by its name as per the JavaBeans convention: field level and getter level constraints of the given name are all returned.# [tck-testable]#An [classname]`IllegalArgumentException` is raised if the [varname]`propertyName` parameter is null.#
[tck-testable]#[methodname]`getConstrainedProperties()` returns the [classname]``PropertyDescriptor``s of the bean properties having at least one constraint or being cascaded ([classname]`@Valid` annotation).#
The [classname]`PropertyDescriptor` interface describes a constrained property of a Java Bean.
This interface is returned by [methodname]`BeanDescriptor.getConstraintsForProperty(String)` or [methodname]`BeanDescriptor.getConstrainedProperties()`. Constraints declared on the attribute and the getter of the same name according to the JavaBeans rules are returned by this descriptor.
[classname]`MethodDescriptor` objects are returned by [methodname]`BeanDescriptor.getConstraintsForMethod(String, Class<?>...)` and [methodname]`BeanDescriptor.getConstrainedMethods(MethodType, MethodType...)`, while [classname]`ConstructorDescriptor` objects are returned by [methodname]`BeanDescriptor.getConstraintsForConstructor(Class<?>...)` and [methodname]`BeanDescriptor.getConstrainedConstructors()`.
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintmetadata/ValidInterval.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintmetadata/ValidAddress.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintmetadata/Author.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintmetadata/Book.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintmetadata/Account.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintmetadata/Address.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintmetadata/Roles.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintmetadata/LegalEntity.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintmetadata/Person.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintmetadata/Employee.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintmetadata/EmployeeImpl.java[tags=include]
include::{spec-examples-source-dir}org/beanvalidation/specexamples/constraintmetadata/MetaDataApiTest.java[tags=include]
./sources/constraint-metadata.asciidoc
// Jakarta Bean Validation
./sources/appendix-module-name.asciidoc
// Jakarta Bean Validation
./sources/license-evaluation.asciidoc
// Jakarta Bean Validation
Copyright © 2019 Eclipse Foundation. This software or document includes material copied from or derived from Jakarta Bean Validation https://projects.eclipse.org/projects/ee4j.bean-validation
./sources/license-final.asciidoc
// Jakarta Bean Validation
:spec-name-bv: Jakarta Bean Validation
:spec-name-enterprisebeans: Jakarta Enterprise Beans
./sources/index.asciidoc
// Jakarta Bean Validation
* [tck-testable]#`javafx.beans.observable.ObservableValue`; `value()` must be invoked with the observable value, passing `null` as node name; the extractor must be marked with `@UnwrapByDefault`#
* [tck-testable]#`javafx.beans.property.ReadOnlyListProperty` and `javafx.beans.property.ListProperty`; `indexedValue()` must be invoked for each contained element, passing the string literal `<list element>` as node name#
* [tck-testable]#`javafx.beans.property.ReadOnlySetProperty` and `javafx.beans.property.SetProperty`; `iterableValue()` must be invoked for each contained element, passing the string literal `<iterable element>` as node name#
* [tck-testable]#`javafx.beans.property.ReadOnlyMapProperty` and `javafx.beans.property.MapProperty`; both map keys and map values are to be supported;
./sources/value-extractor-definition.asciidoc
// Jakarta Bean Validation
The only changes in Bean Validation 3.0 are changes to support the Jarkarta EE javax to jakarta package namespace change.
* The namespace for Bean Validation XML descriptors has been changed to `https://jakarta.ee/xml/ns/validation/configuration` for `META-INF/validation.xml` and `https://jakarta.ee/xml/ns/validation/mapping` for constraint mapping files (see <<validationapi-bootstrapping-xmlconfiguration>>)
The main contribution of Bean Validation 2.0 is leveraging the new language features and API additions of Java 8 for the purposes of validation.
Java 8 or later is required to use Bean Validation 2.0.
* The namespace for Bean Validation XML descriptors has been changed to `http://xmlns.jcp.org/xml/ns/validation/configuration` for `META-INF/validation.xml` and `http://xmlns.jcp.org/xml/ns/validation/mapping` for constraint mapping files (see <<validationapi-bootstrapping-xmlconfiguration>>)
Bean Validation 1.1 improves and builds upon Bean Validation 1.0. The expert group and the community have been working on a few specific areas.
All of Bean Validation 1.1 work has been done in the open and in an open source way. Source code for the API, reference implementation, test compatibility kit as well as the specification and the website sources are available in the open. All discussions are done in the open in the publicly available development mailing list. Road map and proposals are also published on the website.
You can find all the details (mailing lists, source repositories etc.) at http://beanvalidation.org.
Bean Validation uses a few components [classname]`MessageInterpolator`, [classname]`TraversableResolver`, [classname]`ParameterNameProvider`, [classname]`ConstraintValidatorFactory` and [classname]`ConstraintValidator`. Bean Validation 1.1 standardizes how these objects are managed by a container and how these objects can benefit from container services. In particular, CDI support within Java EE is being defined.
Bean Validation 1.1 allows to put constraints to the parameters and return values of arbitrary methods and constructors. That way the Bean Validation API can be used to describe and validate the contract applying to a given method or constructor, that is:
./sources/whatsnew.asciidoc
// Jakarta Bean Validation
* [tck-testable]#configure [classname]`ValidatorFactory` with a custom [classname]`ConstraintValidatorFactory` instance that returns managed [classname]`ConstraintValidator` instances, unless a custom [classname]`ConstraintValidatorFactory` is requested by the user. The scope of [classname]`ConstraintValidator` instances is still fully controlled by the {spec-name-bv} provider as described in <<constraintsdefinitionimplementation-constraintfactory>>, but as managed beans they can receive expected services like injection of other objects.#
[tck-testable]#Similar to the {spec-name-eeplatform} integration via [classname]`@Resource` (see <<integration-jakartaee>>), a {spec-name-di} container must support injection of built-in default [classname]`ValidatorFactory` and [classname]`Validator` beans via [classname]`@Inject`. These default beans are injectable via the [classname]`@Default` qualifier.#
Optionally, the {spec-name-di} container can support injection of provider specific - as defined by [code]`Validation.byProvider()` - [classname]`ValidatorFactory` and [classname]`Validator` beans via [classname]`@Inject`. These beans must be registered with a custom qualifier, for example [classname]`@ACME`. Using the product name or brand for the qualifier is considered good practice.
Registration of the built-in default beans and the provider specific beans may be achieved using the {spec-name-di} portable extension SPI or a vendor specific SPI.
[tck-testable]#If custom [classname]`ConstraintValidatorFactory`, [classname]`MessageInterpolator`, [classname]`ParameterNameProvider`, [classname]`ClockProvider`, [classname]`TraversableResolver` or `ValueExtractor` classes are defined in the XML deployment descriptor (see <<validationapi-bootstrapping-xmlconfiguration>>), the [classname]`ValidatorFactory` must be configured with {spec-name-di} managed beans representing the requested classes. Services like dependency injection, interception and decoration must thus be made available to these instances by the container.#
If no custom [classname]`ConstraintValidatorFactory` is requested by the user, the [classname]`ValidatorFactory` must be configured with a custom [classname]`ConstraintValidatorFactory` instance that returns {spec-name-di} managed beans representing the requested [classname]`ConstraintValidator` types. The factory
[tck-testable]#{spec-name-bv} requires that {spec-name-di} beans support constructor and method validation as defined in <<integration-general-executable>>. Validation must happen at the equivalent time an interceptor occurs when having priority `Interceptor.Priority.PLATFORM_AFTER+800`, in other words priority of `4800`.#
[tck-not-testable]#For maximum portability, it is recommended to mark {spec-name-di} bean interfaces and classes involved in executable validation with [classname]`@ValidateOnExecution` (defaults to `IMPLICIT`). This helps some implementations to bind the method validation interceptor. Most {spec-name-di} - {spec-name-bv} integration implementations do not need such marker. In particular this marker should not be needed on validated beans annotated with constraint annotations, [classname]`@Valid` or [classname]`@ValidateOnExecution` anywhere in the class. Such limitation will be removed in a future version of this specification.#
./sources/integration.asciidoc
// Jakarta Bean Validation
./sources/appendix-persistence.asciidoc
/beanvalidation-release-scripts
/beanvalidation.org
./.gitignore
# Jakarta Bean Validation specification
This repository contains the Jakarta Bean Validation specification.
For more information on Jakarta Bean Validation and the work in progress,
go to <https://beanvalidation.org>.
The [Jakarta Bean Validation TCK](https://github.com/eclipse-ee4j/beanvalidation-tck) is a suite of unit
tests for validating the compliance of Jakarta Bean Validation implementations with the specification.
[TCK project](https://github.com/eclipse-ee4j/beanvalidation-tck/blob/master/tests/src/main/resources/tck-audit.xml).
More on contribution at <http://beanvalidation.org/contribute/>
./README.md
rsync --delete -avh target/html/ ci.hibernate.org:/var/www/staging-beanvalidation.org/latest-draft/spec/
./_scripts/publish-to-staging.sh
if [ ! -d "beanvalidation.github.io" ];
  git clone --depth 1 git@github.com:beanvalidation/beanvalidation.github.io.git
    echo "ERROR: beanvalidation/beanvalidation.github.io cannot be cloned!"
cd beanvalidation.github.io
if git commit -m "Publish latest-draft of beanvalidation-spec" ;
./_scripts/publish-to-github.sh
  ~ Jakarta Bean Validation: constrain once, validate everywhere.
    Jakarta Bean Validation TCK
            xsi:schemaLocation="http://jboss.com/products/weld/tck/audit" name="Jakarta Bean Validation 3.0"
            version="3.0.0" id="beanvalidation" generateSectionIds="true">
./tck-audit.xsl
  ~ Jakarta Bean Validation: constrain once, validate everywhere.
./tck-sectionid-renaming.xsl
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintdeclarationvalidation.resolution;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintdeclarationvalidation/resolution/NonEmpty.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.validationapi;
./spec-examples/src/test/java/org/beanvalidation/specexamples/validationapi/Book.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.validationapi;
./spec-examples/src/test/java/org/beanvalidation/specexamples/validationapi/NonEmpty.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.validationapi;
./spec-examples/src/test/java/org/beanvalidation/specexamples/validationapi/Author.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.validationapi;
./spec-examples/src/test/java/org/beanvalidation/specexamples/validationapi/FirstLevelCheck.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.validationapi;
				assert book == constraintViolation.getRootBean();
				assert book == constraintViolation.getLeafBean();
				assert book == constraintViolation.getRootBean();
				assert author == constraintViolation.getLeafBean();
				assert book == constraintViolation.getRootBean();
				assert book == constraintViolation.getLeafBean();
./spec-examples/src/test/java/org/beanvalidation/specexamples/validationapi/ValidationApiTest.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintmetadata;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintmetadata/Book.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintmetadata;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintmetadata/Person.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintmetadata;
import org.beanvalidation.specexamples.constraintmetadata.ValidInterval.List;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintmetadata/ValidInterval.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintmetadata;
import org.beanvalidation.specexamples.constraintmetadata.ValidAddress.List;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintmetadata/ValidAddress.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintmetadata;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintmetadata/LegalEntity.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintmetadata;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintmetadata/EmployeeImpl.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintmetadata;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintmetadata/Author.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintmetadata;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintmetadata/Employee.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintmetadata;
import jakarta.validation.metadata.BeanDescriptor;
import org.beanvalidation.specexamples.constraintmetadata.Book.SecondLevelCheck;
		BeanDescriptor bookDescriptor = validator.getConstraintsForClass(Book.class);
		assert bookDescriptor.isBeanConstrained();
		assert bookDescriptor.getConstraintDescriptors().size() == 0; //no bean-level constraint
		BeanDescriptor employeeImplDescriptor = validator.getConstraintsForClass( Employee.class );
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintmetadata/MetaDataApiTest.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintmetadata;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintmetadata/Account.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintmetadata;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintmetadata/Address.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintmetadata;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintmetadata/Roles.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintdefinition.annotation;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintdefinition/annotation/OrderNumber.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintdefinition.annotation;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintdefinition/annotation/Acceptable.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintdefinition.annotation;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintdefinition/annotation/ELAssertValidator.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintdefinition.annotation;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintdefinition/annotation/DateParametersConsistentValidator.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintdefinition.annotation;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintdefinition/annotation/OrderNumberValidator.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintdefinition.annotation;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintdefinition/annotation/Audible.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintdefinition.annotation;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintdefinition/annotation/DateParametersConsistent.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintdefinition.annotation;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintdefinition/annotation/ELAssert.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintdefinition.annotation;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintdefinition/annotation/DiscreteListOfIntegerValidator.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintdefinition.annotation;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintdefinition/annotation/AudibleValidator.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintdefinition.validator;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintdefinition/validator/SerialNumberValidator.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintdefinition.validator;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintdefinition/validator/BeginsWithValidator.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintdefinition.validator;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintdefinition/validator/SerialNumber.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintdefinition.validator;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintdefinition/validator/BeginsWith.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintdefinition.validator;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintdefinition/validator/DateParametersConsistentValidator.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintdefinition.validator;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintdefinition/validator/DateParametersConsistent.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintdefinition.multivaluedconstraint;
import org.beanvalidation.specexamples.constraintdefinition.multivaluedconstraint.ZipCode.List;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintdefinition/multivaluedconstraint/ZipCode.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintdefinition.multivaluedconstraint;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintdefinition/multivaluedconstraint/ZipCodeValidator.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintdefinition.multivaluedconstraint;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintdefinition/multivaluedconstraint/SuperUser.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintdefinition.multivaluedconstraint;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintdefinition/multivaluedconstraint/Address.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintdefinition.multivaluedconstraint.explicitlist;
import org.beanvalidation.specexamples.constraintdefinition.multivaluedconstraint.SuperUser;
import org.beanvalidation.specexamples.constraintdefinition.multivaluedconstraint.ZipCode;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintdefinition/multivaluedconstraint/explicitlist/Address.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintdefinition.constraintcomposition.single;
import org.beanvalidation.specexamples.constraintdefinition.constraintcomposition.FrenchZipCodeValidator;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintdefinition/constraintcomposition/single/FrenchZipCode.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintdefinition.constraintcomposition;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintdefinition/constraintcomposition/FrenchZipCodeValidator.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintdefinition.constraintcomposition.overriding.constraintindex;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintdefinition/constraintcomposition/overriding/constraintindex/EmmanuelsEmail.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintdefinition.constraintcomposition.overriding.interpreted;
import org.beanvalidation.specexamples.constraintdefinition.constraintcomposition.FrenchZipCodeValidator;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintdefinition/constraintcomposition/overriding/interpreted/FrenchZipCode.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintdefinition.constraintcomposition.overriding;
import org.beanvalidation.specexamples.constraintdefinition.constraintcomposition.FrenchZipCodeValidator;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintdefinition/constraintcomposition/overriding/FrenchZipCode.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintdefinition.constraintcomposition;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintdefinition/constraintcomposition/FrenchZipCode.java
 * Jakarta Bean Validation: constrain once, validate everywhere.
package org.beanvalidation.specexamples.constraintdefinition.temporal;
./spec-examples/src/test/java/org/beanvalidation/specexamples/constraintdefinition/temporal/PastValidatorForZonedDateTime.java
Jakarta Bean Validation: constrain once, validate everywhere.
./spec-examples/src/main/resources/license.header
  ~ Jakarta Bean Validation: constrain once, validate everywhere.
./spec-examples/src/main/resources/java-header-style.xml
  ~ Jakarta Bean Validation: constrain once, validate everywhere.
./spec-examples/src/main/resources/xml-header-style.xml
  ~ Jakarta Bean Validation: constrain once, validate everywhere.
    <groupId>org.beanvalidation</groupId>
./spec-examples/pom.xml
# Notices for Eclipse Jakarta Bean Validation
This content is produced and maintained by the Eclipse Jakarta Bean Validation
* Project home: https://projects.eclipse.org/projects/ee4j.bean-validation
 Jakarta Bean Validation is a trademark of the Eclipse Foundation.
 * [The specification repository](https://github.com/eclipse-ee4j/beanvalidation-spec)
 * [The API repository](https://github.com/eclipse-ee4j/beanvalidation-api)
 * [The TCK repository](https://github.com/eclipse-ee4j/beanvalidation-tck)
./NOTICE.md
# Contributing to Eclipse Jakarta Bean Validation
Bean Validation defines a metadata model and API for JavaBean and method validation.
* https://beanvalidation.org/
* https://projects.eclipse.org/projects/ee4j.bean-validation
Contributions from the community are essential in keeping Jakarta Bean Validation strong and successful.
Please see the following pages to learn more about contributing to the Jakarta Bean Validation spec, its API, TCK and website:
* [General contribution guide](https://beanvalidation.org/contribute/)
* [Contributing to the specification](https://beanvalidation.org/contribute/specification/)
* [Contributing to the API and the TCK](https://beanvalidation.org/contribute/coding)
* [Contributing to the website](https://beanvalidation.org/contribute/site)
e.g. by sending a mail to the [bean-validation-dev](https://accounts.eclipse.org/mailing-list/bean-validation-dev) mailing list.
 * [The specification repository](https://github.com/eclipse-ee4j/beanvalidation-spec)
 * [The API repository](https://github.com/eclipse-ee4j/beanvalidation-api)
 * [The TCK repository](https://github.com/eclipse-ee4j/beanvalidation-tck)
* https://accounts.eclipse.org/mailing-list/bean-validation-dev
./CONTRIBUTING.md

See

https://github.com/jakartaee/validation-tck/issues/191
https://github.com/jakartaee/validation-spec/issues/271

Hello @starksm64 , can you please change the title of this issue to reflect we have your consent on this?
I suggest "Perform steps to rename Jakarta Bean Validation to Jakarta Validation".