// phase 1: get file Models from the reactor.
            List<InterimResult> interimResults = build(projectIndex, pomFiles, new LinkedHashSet<>(), true, recursive);

            ClassLoader oldContextClassLoader = Thread.currentThread().getContextClassLoader();

            try {
                // Phase 2: get effective models from the reactor

 *
 * @since 4.0.0
 */
@Experimental
@Immutable
public interface ModelBuilderRequest {

    /**
     * Denotes minimal validation of POMs. This validation level is meant for processing of POMs from repositories
     * during metadata retrieval.
     */
    int VALIDATION_LEVEL_MINIMAL = 0;

    /**
     * Denotes validation as performed by Maven 2.0. This validation level is meant as a compatibility mode to allow

     * @param plugin The plugin for which to resolve the dependencies, must not be {@code null}.
     * @param pluginArtifact The plugin's main artifact, may be {@code null}.
     * @param dependencyFilter A filter to exclude artifacts from resolution (but not collection), may be {@code null}.
     * @param repositories The plugin repositories to use for resolving the plugin artifacts, must not be {@code null}.

        // The root artifact may, or may not be resolved so we need to check before we attempt to resolve.
        // This is often an artifact like a POM that is taken from disk and we already have hold of the
        // file reference. But this may be a Maven Plugin that we need to resolve from a remote repository
        // as well as its dependencies.

        if (request.isResolveRoot() /* && rootArtifact.getFile() == null */) {
            try {

                versionParser);
        ModelBuilderRequest.ModelBuilderRequestBuilder request = ModelBuilderRequest.builder();
        request.projectBuild(true);
        request.session(InternalSession.from(session));
        request.source(ModelSource.fromPath(src));
        request.validationLevel(ModelBuilderRequest.VALIDATION_LEVEL_MINIMAL);
        request.locationTracking(false);

  <url>http://maven.apache.org/maven2/</url>
  <issueManagement>

 * memorized and kept as long as supplier instance is kept open.
 * <p>
 * This class is not thread safe and must be used from one thread only, while the constructed {@link RepositorySystem}
 * is thread safe.
 * <p>
 * Important: Given the instance of supplier memorizes the supplier {@link RepositorySystem} instance it supplies,

            Session session,
            List<RemoteRepository> dominant,
            List<RemoteRepository> recessive,
            boolean processRecessive) {
        InternalSession internalSession = InternalSession.from(nonNull(session, "session"));
        List<org.eclipse.aether.repository.RemoteRepository> repos = remoteRepositoryManager.aggregateRepositories(
                internalSession.getSession(),

import org.apache.maven.plugin.MojoExecution;

/**
 * A stub implementation that assumes an empty lifecycle to bypass interaction with the plugin manager and to avoid
 * plugin artifact resolution from repositories.
 *
 */
@Deprecated
public class EmptyLifecycleExecutor implements LifecycleExecutor {

    public MavenExecutionPlan calculateExecutionPlan(MavenSession session, String... tasks) {

 *
 */
@Deprecated
class ProjectInheritanceTest extends AbstractProjectInheritanceTestCase {
    // ----------------------------------------------------------------------
    //
    // p1 inherits from p0
    // p0 inherits from super model
    //
    // or we can show it graphically as:
    //
    // p1 ---> p0 --> super model
    //
    // ----------------------------------------------------------------------

    /**