code: private static List<Type> resolveLowerGenerics(final GenericsContext genericsContext,
                                                     final Type type,
                                                     final Class typeClass,
                                                     final boolean objectDeclared,
                                                     final Class lowerType) {
          final List<Type> res;
          if (!objectDeclared && !lowerType.equals(typeClass)) {
              // case: collection declared, but not interface.. going to lower type
              res = genericsContext.inlyingType(type).type(lowerType).genericTypes();
          } else {
              // normal case: type analyzed directly
              res = genericsContext.resolveTypeGenerics(objectDeclared ? lowerType : type);
          }
          return res;
      }
docs: Cases:
  <ul>
  <li>Type declared in class and used as is: resolve generics directly from type</li>
  <li>Type declared, but lower type used (e.g. collection impl declared): track lower type generics</li>
  <li>Type is Object: resolve generics from declaration (lower type available when value provided)</li>
  </ul>.
  
  @param genericsContext generics context
  @param type            declared property type
  @param typeClass       type's class
  @param objectDeclared  declared type is not Object
  @param lowerType       selected type from declaration (maybe lower then declared or comletely taken from value)
  @return lower type generics or empty list