}
        };
        Class<T> superType = (Class<T>) key.getTypeLiteral().getRawType();
        Class<?>[] interfaces = getInterfaces(superType);
        return (T) java.lang.reflect.Proxy.newProxyInstance(superType.getClassLoader(), interfaces, dispatcher);
    }

    private Class<?>[] getInterfaces(Class<?> superType) {
        if (superType.isInterface()) {
            return new Class<?>[] {superType};

    subClass.superConeTypes.forEach { superType ->
        val superOfSub = superType.toRegularClassSymbol(useSiteSession) ?: return@forEach
        if (isSubClassOf(superOfSub.fir, superClass, useSiteSession, allowIndirectSubtyping = true)) return true
    }
    return false
}

/**
 * @see org.jetbrains.kotlin.analysis.api.types.KaType.abbreviatedType
 */

    }

    override fun isSubTypeOf(subType: KaType, superType: KaType, errorTypePolicy: KaSubtypingErrorTypePolicy): Boolean {
        require(subType is KaFe10Type)
        require(superType is KaFe10Type)
        return getTypeCheckerFor(errorTypePolicy).isSubtypeOf(subType.fe10Type, superType.fe10Type)
    }

        }
        if (contractType.getGenericInterfaces().length != 1) {
            return;
        }
        Type superType = contractType.getGenericInterfaces()[0];
        if (!(superType instanceof ParameterizedType)) {
            return;
        }
        ParameterizedType parameterizedSuperType = (ParameterizedType) superType;
        if (!parameterizedSuperType.getRawType().equals(ModelMap.class)) {
            return;
        }

        // Extract the type for common case that is quick to calculate
        for (Type superType : value.getClass().getGenericInterfaces()) {
            if (superType instanceof ParameterizedType) {
                ParameterizedType parameterizedSuperType = (ParameterizedType) superType;
                if (parameterizedSuperType.getRawType().equals(Callable.class)) {

        Map<String, PropertyDoc> props = new TreeMap<String, PropertyDoc>();
        List<ClassDoc> superTypes = classDoc.getSuperTypes();
        for (ClassDoc superType : superTypes) {
            LOG.info("Getting properties for {}", superType.getName());
            for (PropertyDoc propertyDoc : superType.getClassProperties()) {

            }

            Class<?> superclass = rawClass.getSuperclass();
            if (superclass != null) {
                ModelType<?> superType = ModelType.of(superclass);
                if (!seenTypes.contains(superType)) {
                    queue.add(superType);
                }
            }
            for (Class<?> iface : rawClass.getInterfaces()) {
                ModelType<?> ifaceType = ModelType.of(iface);

      <w>iterable</w>
      <w>nondeterministic</w>
      <w>nullable</w>
      <w>overridable</w>
      <w>pseudocode</w>
      <w>substitutor</w>
      <w>subtyping</w>
      <w>supertype</w>
      <w>supertypes</w>
      <w>tuple</w>
      <w>unary</w>
    </words>
  </dictionary>

    }

    public ClassNode readClassAsNode() {
        return classNode.get();
    }

    @Override
    public boolean isInstanceOf(@Nonnull String type, @Nonnull String superType) {
        return typeRegistry.getSuperTypes(type).contains(superType);
    }

                        .solution("Provide a public type for @SoftwareType that is the same type as or a supertype of the property type '" + ModelType.of(valueType).getDisplayName() + "'")
                );
            }
        });
    }