private final Map<String, MavenArtifactRelocationSource> artifactRelocationSources;
    private final ArtifactDescriptorReaderDelegate delegate;
    private final Logger logger = LoggerFactory.getLogger(getClass());

    @Inject
    public DefaultArtifactDescriptorReader(
            RemoteRepositoryManager remoteRepositoryManager,
            VersionResolver versionResolver,

     */
    @Nonnull
    List<Node> getNodes();

    /**
     * Returns the file paths of all dependencies, regardless on which tool option those paths should be placed.
     * The returned list may contain a mix of Java class-path, Java module-path, and other types of path elements.
     * This collection has the same content than {@code getDependencies.values()} except that it does not contain
     * null elements.
     *

 * The cache is used for avoiding the need to reopen the same files many times when the
 * same dependency is used for different scope. For example a path used for compilation
 * is typically also used for tests.
 */
class PathModularizationCache {
    /**
     * Module information for each JAR file or output directories.
     * Cached when first requested to avoid decoding the module descriptors multiple times.
     *

import static org.apache.maven.internal.impl.Utils.cast;
import static org.apache.maven.internal.impl.Utils.map;
import static org.apache.maven.internal.impl.Utils.nonNull;

@Named
@Singleton
public class DefaultDependencyResolver implements DependencyResolver {

    @Nonnull
    @Override
    public DependencyResolverResult collect(@Nonnull DependencyResolverRequest request)

        injector.bindImplicit(MavenVersionScheme.class);
        injector.bindImplicit(BuildModelTransformer.class);
        injector.bindImplicit(DefaultDependencyManagementImporter.class);
        injector.bindImplicit(DefaultDependencyManagementInjector.class);
        injector.bindImplicit(DefaultModelBuilder.class);
        injector.bindImplicit(DefaultModelProcessor.class);
        injector.bindImplicit(DefaultModelValidator.class);

     * Shortcut for <code>getService(RepositoryFactory.class).createLocal(...)</code>
     *
     * @see RepositoryFactory#createLocal(Path)
     */
    @Override
    public LocalRepository createLocalRepository(Path path) {
        return getService(RepositoryFactory.class).createLocal(path);
    }

    /**
     * Shortcut for <code>getService(RepositoryFactory.class).createRemote(...)</code>
     *

    /**
     * Artifact type name for a JAR file that can be placed either on the class-path or on the module-path.
     * The path (classes or modules) is chosen by the plugin, possibly using heuristic rules.
     * This is the behavior of Maven 3.
     */
    String JAR = "jar";

    /**
     * Artifact type name for a fat-JAR file that can be only on the class-path.

import org.apache.maven.api.annotations.Nonnull;

/**
 * This annotation will mark your class as a Mojo, which is the implementation of a goal in a Maven plugin.
 * <p>
 * The mojo can be annotated with {@code org.apache.maven.api.di.*} annotations to
 * control the lifecycle of the mojo itself, and to inject other beans.
 * </p>
 * <p>
 * The mojo class can also be injected with an {@link Execute} annotation to specify a
 * forked lifecycle.

import org.apache.maven.api.services.ModelTransformerContext;

/**
 * ModelSourceTransformer for the build pom
 *
 * @since 4.0.0
 */
@Named
@Singleton
public class BuildModelTransformer implements ModelTransformer {

    @Override
    public Model transform(ModelTransformerContext context, Model model, Path path) {
        Model.Builder builder = Model.newBuilder(model);

import org.apache.maven.api.annotations.Experimental;
import org.apache.maven.api.services.MavenException;

/**
 * An exception occurring during the execution of a plugin.
 *
 * @since 4.0.0
 */
@Experimental
public class MojoException extends MavenException {

    protected Object source;

    protected String longMessage;

    /**
     * Constructs a new {@code MojoException} providing the source and a short and long message.