@SuppressWarnings("unchecked")
    private void innerExport() {
        typeMappings = codegenModule.get(TypeMappings.class);
        queryTypeFactory = codegenModule.get(QueryTypeFactory.class);
        typeFactory = new TypeFactory(Arrays.asList(entityAnnotation, supertypeAnnotation, embeddableAnnotation), codegenModule.get(Function.class, CodegenModule.VARIABLE_NAME_FUNCTION_CLASS));

        // copy annotations helpers to typeFactory
        for (AnnotationHelper helper : annotationHelpers) {
            typeFactory.addAnnotationHelper(helper);
        }

        // process supertypes
        for (Class<?> cl : superTypes.keySet()) {
            createEntityType(cl, superTypes);
        }

        // process embeddables
        for (Class<?> cl : embeddableTypes.keySet()) {
            createEntityType(cl, embeddableTypes);
        }

        // process entities
        for (Class<?> cl : entityTypes.keySet()) {
            createEntityType(cl, entityTypes);
        }

        // process projections
        for (Class<?> cl : projectionTypes.keySet()) {
            createEntityType(cl, projectionTypes);
        }

        // add constructors and properties
        for (Map<Class<?>, EntityType> entries : Arrays.asList(superTypes, embeddableTypes, entityTypes, projectionTypes)) {
            for (Map.Entry<Class<?>, EntityType> entry : new HashSet<>(entries.entrySet())) {
                addConstructors(entry.getKey(), entry.getValue());
                addProperties(entry.getKey(), entry.getValue());
            }
        }

        // merge supertype fields into subtypes
        Set<EntityType> handled = new HashSet<EntityType>();
        for (EntityType type : superTypes.values()) {
            addSupertypeFields(type, allTypes, handled);
        }
        for (EntityType type : entityTypes.values()) {
            addSupertypeFields(type, allTypes, handled);
        }
        for (EntityType type : embeddableTypes.values()) {
            addSupertypeFields(type, allTypes, handled);
        }

        // extend types
        typeFactory.extendTypes();

        try {
            Serializer supertypeSerializer, entitySerializer, embeddableSerializer, projectionSerializer;

            if (serializerClass != null) {
                Serializer serializer = codegenModule.get(serializerClass);
                supertypeSerializer = serializer;
                entitySerializer = serializer;
                embeddableSerializer = serializer;
                projectionSerializer = serializer;
            } else {
                supertypeSerializer = codegenModule.get(SupertypeSerializer.class);
                entitySerializer = codegenModule.get(EntitySerializer.class);
                embeddableSerializer = codegenModule.get(EmbeddableSerializer.class);
                projectionSerializer = codegenModule.get(ProjectionSerializer.class);
            }

            // serialize super types
            serialize(supertypeSerializer, superTypes);

            // serialize entity types
            serialize(entitySerializer, entityTypes);

            // serialize embeddable types
            serialize(embeddableSerializer, embeddableTypes);

            // serialize projection types
            serialize(projectionSerializer, projectionTypes);

        } catch (IOException e) {
            throw new QueryException(e);
        }

    }
Export the given classes

@param classes classes to be scanned
querydsl-codegen/src/main/java/com/querydsl/codegen/GenericExporter.java