@Override
    public Model importManagement(
            Model target,
            List<? extends DependencyManagement> sources,
            ModelBuilderRequest request,
            ModelProblemCollector problems) {
        if (sources != null && !sources.isEmpty()) {
            Map<String, Dependency> dependencies = new LinkedHashMap<>();

     * Imports the specified dependency management sections into the given target model.
     *
     * @param target The model into which to import the dependency management section, must not be <code>null</code>.
     * @param sources The dependency management sections to import, may be <code>null</code>.
     * @param request The model building request that holds further settings, must not be {@code null}.

                ModelSource source = getSource(groupId, artifactId);
                if (source == null) {
                    // we need to check the whole reactor in case it's a dependency
                    loadFullReactor();
                    source = getSource(groupId, artifactId);
                }
                if (source != null) {
                    if (!addEdge(from, source.getPath(), problems)) {

                new DefaultType(Type.JAVADOC, Language.JAVA_FAMILY, "jar", "javadoc", false, JavaPathType.CLASSES),
                new DefaultType(Type.JAVA_SOURCE, Language.JAVA_FAMILY, "jar", "sources", false),
                new DefaultType(
                        Type.TEST_JAR,
                        Language.JAVA_FAMILY,
                        "jar",
                        "tests",

     * Builds the effective settings of the specified settings sources.
     *
     * @return the result of the settings building, never {@code null}
     * @throws SettingsBuilderException if the effective settings could not be built
     */
    @Nonnull
    default SettingsBuilderResult build(
            @Nonnull Session session, @Nonnull Source globalSettingsSource, @Nonnull Source userSettingsSource) {

    }

    // These methods deal with construction intact Plugin object that look like they come from a standard
    // <plugin/> block in a Maven POM. We have to do some wiggling to pull the sources of information
    // together and this really shows the problem of constructing a sensible default configuration but
    // it's all encapsulated here so it appears normalized to the POM builder.

                    phase("generate-sources"),
                    phase("process-sources"),
                    phase("generate-resources"),
                    phase("process-resources"),
                    phase("compile"),
                    phase("process-classes"),
                    phase("generate-test-sources"),
                    phase("process-test-sources"),
                    phase("generate-test-resources"),

    /**
     * Builds the effective toolchains for the specified toolchains sources.
     *
     * @param session the {@link Session}, must not be {@code null}
     * @param globalToolchainsSource The {@link Source} pointing to the global toolchains, must not be {@code null}
     * @param userToolchainsSource The {@link Source} pointing to the user toolchains, must not be {@code null}

     * This type is new in Maven 4.
     */
    String MODULAR_JAR = "modular-jar";

    /**
     * Artifact type name for source code packaged in a JAR file.
     */
    String JAVA_SOURCE = "java-source";

    /**
     * Artifact type name for javadoc packaged in a JAR file.
     */
    String JAVADOC = "javadoc";

    /**
     * Artifact type name for a Maven plugin.

        task.sources(patternSet -> patternSet.include("userguide_single.adoc"));

        // TODO: This breaks the provider
        task.setSourceDir(extension.getUserManual().getStagedDocumentation().get().getAsFile());

        Map<String, Object> attributes = new HashMap<>();
        attributes.put("source-highlighter", "coderay");
        attributes.put("toc", "macro");