protected AbstractTypeAnnotationHandler(Class<? extends Annotation> annotationType) {
        this.annotationType = annotationType;
    }

    private final Class<? extends Annotation> annotationType;

    @Override
    public Class<? extends Annotation> getAnnotationType() {
        return annotationType;
    }

    protected static void reportInvalidUseOfTypeAnnotation(

        @Override
        public boolean isAnnotationPresent(Class<? extends Annotation> annotationType) {
            return annotationMetadata.isAnnotationPresent(annotationType);
        }

        @Override
        public <T extends Annotation> Optional<T> getAnnotation(Class<T> annotationType) {
            return annotationMetadata.getAnnotation(annotationType);
        }

        @Override

        private final Class<? extends Annotation> annotationType;

        AnnotatedOrInPackageAnnotatedPredicate(Class<? extends Annotation> annotationType) {
            super("annotated (directly or via its package) with @" + annotationType.getName());
            this.annotationType = annotationType;
        }

        @Override
        public boolean test(JavaClass input) {

                Class<? extends Annotation> annotationType = a.annotationType();
                if ("org.eclipse.sisu.Typed".equals(annotationType.getName())
                        || "javax.enterprise.inject.Typed".equals(annotationType.getName())
                        || "jakarta.enterprise.inject.Typed".equals(annotationType.getName())) {
                    try {
                        Class<?>[] value =

        super(annotationType, Kind.INPUT, allowedModifiers);
    }

    protected static void validateUnsupportedInputPropertyValueTypes(
        PropertyMetadata propertyMetadata,
        TypeValidationContext validationContext,
        Class<? extends Annotation> annotationType
    ) {

        for (Annotation annotation : annotations) {
            Class<? extends Annotation> annotationType = annotation.annotationType();
            if (propertyAnnotationCategories.containsKey(annotationType)) {
                relevantAnnotations.put(annotationType, annotation);
            }
        }
        return relevantAnnotations.build();
    }

        this.properties = ImmutableSortedSet.copyOf(properties);
        this.validationProblems = validationProblems;
    }

    @Override
    public ImmutableSet<Annotation> getAnnotations() {
        return annotations.values();
    }

    @Override
    public boolean isAnnotationPresent(Class<? extends Annotation> annotationType) {

     */
    ImmutableSet<Annotation> getAnnotations();

    /**
     * Whether an annotation of the given type is present on the type itself.
     */
    boolean isAnnotationPresent(Class<? extends Annotation> annotationType);

    /**
     * Information about the type and annotations of each property of the type.
     */
    ImmutableSortedSet<PropertyAnnotationMetadata> getPropertiesAnnotationMetadata();

            Class<? extends Annotation> annotationType = handler.getAnnotationType();
            if (!enabledAnnotations.contains(annotationType)) {
                builder.add(annotationType);
            } else {
                InjectionPointQualifier injectionPointQualifier = annotationType.getAnnotation(InjectionPointQualifier.class);
                if (injectionPointQualifier != null) {

    private static class SimplePropertyAnnotationHandler extends AbstractPropertyAnnotationHandler {

        SimplePropertyAnnotationHandler(Class<? extends Annotation> annotationType, Kind kind, Collection<Class<? extends Annotation>> allowedModifiers) {
            super(annotationType, kind, ImmutableSet.copyOf(allowedModifiers))
        }

        @Override
        boolean isPropertyRelevant() {
            return true
        }