*
     * @see org.apache.maven.api.services.DependencyResolver#resolve(Session, List)
     */
    @Nonnull
    List<Path> resolveDependencies(@Nonnull List<DependencyCoordinate> dependencyCoordinates);

    /**
     * Shortcut for {@code getService(DependencyResolver.class).resolve(...).getPaths()}.
     *
     * @param project the project for which to get dependencies

            return new CumulativeScopeArtifactFilter(scopes);
        }
    }

    public List<MavenProject> executeForkedExecutions(MojoExecution mojoExecution, MavenSession session)
            throws LifecycleExecutionException {
        List<MavenProject> forkedProjects = Collections.emptyList();

        Map<String, List<MojoExecution>> forkedExecutions = mojoExecution.getForkedExecutions();

 */
package org.apache.maven.building;

import java.util.ArrayList;
import java.util.List;

/**
 * Collects problems that are encountered during settings building.
 *
 */
class DefaultProblemCollector implements ProblemCollector {

    private final List<Problem> problems;

    private String source;

    DefaultProblemCollector(List<Problem> problems) {
        this.problems = (problems != null) ? problems : new ArrayList<>();

        try {
            Map<Artifact, Path> paths = new HashMap<>();
            ArtifactManager artifactManager = session.getService(ArtifactManager.class);
            List<RemoteRepository> repositories = session.toRepositories(session.getRemoteRepositories());
            List<ArtifactRequest> requests = new ArrayList<>();
            for (ArtifactCoordinate coord : request.getCoordinates()) {

                .plugins(List.of(Plugin.newBuilder()
                        .prefix(pluginInfo.goalPrefix)
                        .artifactId(pluginInfo.artifactId)
                        .name(pluginInfo.name)
                        .build()))
                .build();
    }

    @Override
    protected void merge(Metadata recessive) {
        List<Plugin> recessivePlugins = recessive.getPlugins();

    PluginDescriptor loadPlugin(Plugin plugin, List<RemoteRepository> repositories, RepositorySystemSession session)
            throws PluginNotFoundException, PluginResolutionException, PluginDescriptorParsingException,
                    InvalidPluginDescriptorException;

    // igorf: Way too many declared exceptions!
    MojoDescriptor getMojoDescriptor(

        INLINE, // inline, each "internal" problem one line next to mojo invocation
        SUMMARY, // at end, list of plugin GAVs along with ANY validation issues
        BRIEF, // each "internal" problem one line next to mojo invocation
        // and at end list of plugin GAVs along with "external" issues
        VERBOSE // at end, list of plugin GAVs along with detailed report of ANY validation issues
    }

import java.util.ArrayList;
import java.util.List;

/**
 * MetadataGraph node - as it's a directed graph - holds adjacency lists for incident and exident nodes
 *
 *
 */
@Deprecated
public class MetadataGraphNode {
    /** node payload */
    MavenArtifactMetadata metadata;

    /** nodes, incident to this (depend on me) */
    List<MetadataGraphNode> inNodes;

 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.lifecycle.internal;

import java.util.List;
import java.util.Set;

import org.apache.maven.execution.MavenSession;
import org.apache.maven.lifecycle.LifecycleNotFoundException;
import org.apache.maven.lifecycle.LifecyclePhaseNotFoundException;

        setFile(project.getFile());
        setResolved(true);
    }

    public MavenProject getProject() {
        return project;
    }

    public List<Dependency> getDependencies() {
        return project.getModel().getDependencies();
    }

    public List<Dependency> getManagedDependencies() {
        DependencyManagement depMngt = project.getModel().getDependencyManagement();