code: public static Map<Class<?>, LinkedHashMap<String, Type>> resolve(final Type type,
                                                                       final Class<?>... ignoreClasses) {
          return resolve(GenericsUtils.resolveClassIgnoringVariables(type),
                  resolveGenerics(type, IgnoreGenericsMap.getInstance()), ignoreClasses);
      }
docs: Resolve hierarchy of provided type. It makes sense only for {@link ParameterizedType} as only this type
  could hold class generics. Parameter preserved to be {@link Type} for more universal usage
  (to avoid instanceof checks), execution for simple {@link Class} is completely equal to
  {@link #resolve(Class, Class[])} method call (original method preserved for api compatibility).
  <p>
  When provided type is not {@link ParameterizedType}, root class generics will be resolved
  as upper bounds (the same as in {@link #resolve(Class, Class[])}).
  <p>
  IMPORTANT: If provided type contain variables ({@link TypeVariable}), they will be replaced by
  {@link Object} (not upper bound!). Perform variables processing manually before calling this method
  in order to get more precise results (e.g. with {@link TypeVariableUtils#resolveAllTypeVariables(Type)}).
  <p>
  You can also use {@link TypeLiteral} for dynamic type declarations (tracking cases):
  {@code GenericsResolutionUtils.resolve(new TypeLiteral<MyClass<String, Boolean>(){}.getType())}.
  
  @param type          type to resolve generics for
  @param ignoreClasses classes to ignore (if required)
  @return resolved generics for all types in class hierarchy
  @see #resolve(Class, LinkedHashMap, Class[]) if you have known root generics
  @see #resolve(Class, LinkedHashMap, Map, List) if you have known generics for middle types