}

    @Override
    public void addRepository(@Nonnull Session session, Repository repository) {
        addRepository(session, repository, false);
    }

    @Override
    public void addRepository(Session session, Repository repository, boolean replace) {
        RepositorySystemSession rsession = InternalSession.from(session).getSession();
        if (rsession.isIgnoreArtifactDescriptorRepositories()) {

                .source(nonNull(source, "source cannot be null"))
                .build();
    }

    @Nonnull
    static ProjectBuilderRequest build(@Nonnull Session session, @Nonnull Path path) {
        return builder()
                .session(nonNull(session, "session cannot be null"))
                .path(nonNull(path, "path cannot be null"))
                .build();
    }

    static DependencyCoordinateFactoryRequest build(
            @Nonnull Session session,
            String groupId,
            String artifactId,
            String version,
            String classifier,
            String extension,
            String type) {
        return DependencyCoordinateFactoryRequest.builder()
                .session(nonNull(session, "session cannot be null"))
                .groupId(groupId)

import org.apache.maven.api.Session;
import org.apache.maven.api.services.LocalRepositoryManager;

@Named
@Singleton
public class DefaultLocalRepositoryManager implements LocalRepositoryManager {

    @Override
    public Path getPathForLocalArtifact(Session session, LocalRepository local, Artifact artifact) {
        InternalSession s = InternalSession.from(session);

                        org.apache.maven.api.plugin.Mojo.class, session, mojoExecution);
                mojo = new MojoWrapper(mojoV4);
            } else {
                mojo = mavenPluginManager.getConfiguredMojo(Mojo.class, session, mojoExecution);
            }

            legacySupport.setSession(session);

        return builder()
                .session(nonNull(session, "session cannot be null"))
                .coordinates(nonNull(coordinates, "coordinates cannot be null"))
                .build();
    }

    @NotThreadSafe
    class ArtifactResolverRequestBuilder {
        Session session;
        Collection<? extends ArtifactCoordinate> coordinates;

        ArtifactResolverRequestBuilder() {}

        @Nonnull

                .artifacts(nonNull(artifacts, "artifacts cannot be null"))
                .build();
    }

    @NotThreadSafe
    class ArtifactInstallerRequestBuilder {
        Session session;
        Collection<Artifact> artifacts = Collections.emptyList();

        ArtifactInstallerRequestBuilder() {}

        @Nonnull

            RepositorySystemSession session, ArtifactDescriptorRequest request) throws ArtifactDescriptorException {
        ArtifactDescriptorResult result = new ArtifactDescriptorResult(request);

        Model model = loadPom(session, request, result);
        if (model != null) {
            Map<String, Object> config = session.getConfigProperties();
            ArtifactDescriptorReaderDelegate delegate =

        MavenSession session = legacySupport.getSession();

        PluginDescriptor pluginDescriptor;
        try {
            pluginDescriptor = pluginManager.getPluginDescriptor(
                    plugin, session.getCurrentProject().getRemotePluginRepositories(), session.getRepositorySession());

            pluginManager.setupPluginRealm(pluginDescriptor, session, null, null, null);
        } catch (Exception e) {

                .root(nonNull(root, "root cannot be null"))
                .build();
    }

    @Nonnull
    static DependencyCollectorRequest build(@Nonnull Session session, @Nonnull Project project) {
        return builder()
                .session(nonNull(session, "session cannot be null"))
                .project(nonNull(project, "project cannot be null"))
                .build();