if (Map.class.isAssignableFrom(propertyMetadata.getDeclaredType().getRawType())) {
            Class<?> keyType = JavaReflectionUtil.extractNestedType((TypeToken<Map<?, ?>>) propertyMetadata.getDeclaredType(), Map.class, 0).getRawType();
            NestedValidationUtil.validateKeyType(validationContext, propertyMetadata.getPropertyName(), keyType);
        }

        1 * propertyMetadata.getPropertyType() >> SoftwareType.class
        1 * propertyMetadata.getDeclaredType() >> TypeToken.of(TestModel.class)
        1 * propertyMetadata.getAnnotation(SoftwareType.class) >> Optional.of(softwareType)
        1 * duplicatePropertyMetadata.getPropertyType() >> SoftwareType.class
        1 * duplicatePropertyMetadata.getDeclaredType() >> TypeToken.of(TestModel.class)

        List<Class<?>> unpackedValueTypes = new ArrayList<>();
        Class<?> returnType = propertyMetadata.getDeclaredType().getRawType();
        if (Provider.class.isAssignableFrom(returnType)) {
            List<TypeOf<?>> typeArguments = TypeOf.typeOf(propertyMetadata.getDeclaredType().getType()).getActualTypeArguments();
            for (TypeOf<?> typeArgument : typeArguments) {

        propertyMetadata.getAnnotation(ServiceReference.class).ifPresent(annotation -> {
            String serviceName = annotation.value();
            TypeToken<?> declaredType = propertyMetadata.getDeclaredType();
            Class<?> serviceType = Cast.uncheckedCast(((ParameterizedType) declaredType.getType()).getActualTypeArguments()[0]);

    <T extends Annotation> Optional<T> getAnnotation(Class<T> annotationType);

    ImmutableMap<AnnotationCategory, Annotation> getAnnotations();

    TypeToken<?> getDeclaredType();

    @Nullable
    Object getPropertyValue(Object object);

    Optional<Annotation> getAnnotationForCategory(AnnotationCategory category);

    boolean hasAnnotationForCategory(AnnotationCategory category);

    Class<? extends Annotation> getPropertyType();

    TypeToken<?> getDeclaredType();

    @Nullable
    Object getPropertyValue(Object object);

     * Called when a service with the given annotation is registered.
     */
    void whenRegistered(Class<? extends Annotation> annotation, Registration registration);

    interface Registration {
        Class<?> getDeclaredType();

        /**
         * Returns the service instance, creating it if required.
         */
        Object getInstance();
    }

        @Override
        public Class<? extends Annotation> getPropertyType() {
            return propertyType;
        }

        @Override
        public TypeToken<?> getDeclaredType() {
            return annotationMetadata.getDeclaredType();
        }

        @Nullable
        @Override
        public Object getPropertyValue(Object object) {
            return annotationMetadata.getPropertyValue(object);

        propertyMetadata.getAnnotation(SoftwareType.class).ifPresent(softwareType -> {
            Class<?> publicType = softwareType.modelPublicType();
            Class<?> valueType = propertyMetadata.getDeclaredType().getRawType();
            if (publicType != Void.class && !publicType.isAssignableFrom(valueType)) {
                validationContext.visitPropertyProblem(problem ->
                    problem

                toType(object, IConventionAware.class).getConventionMapping()
            );
        }
        return conventionMapping;
    }

    public Class<?> getDeclaredType() {
        return getPublicType().getConcreteClass();
    }

    public TypeOf<Object> getPublicType() {
        if (object instanceof HasPublicType) {