*/
public interface ProjectBuildingRequest {

    ProjectBuildingRequest setLocalRepository(ArtifactRepository localRepository);

    ArtifactRepository getLocalRepository();

    ProjectBuildingRequest setRemoteRepositories(List<ArtifactRepository> remoteRepositories);

    List<ArtifactRepository> getRemoteRepositories();

    ProjectBuildingRequest setPluginArtifactRepositories(List<ArtifactRepository> pluginArtifactRepositories);

     */
    public DefaultRepositoryRequest(RepositoryRequest repositoryRequest) {
        setLocalRepository(repositoryRequest.getLocalRepository());
        setRemoteRepositories(repositoryRequest.getRemoteRepositories());
        setOffline(repositoryRequest.isOffline());
        setForceUpdate(repositoryRequest.isForceUpdate());
    }

                request.setUserProperties(session.getUserProperties());
            }

            MavenExecutionRequest req = session.getRequest();
            if (req != null) {
                request.setRemoteRepositories(req.getRemoteRepositories());
            }
        } else {
            Properties props = new Properties();
            EnvironmentUtils.addEnvVars(props);
            props.putAll(System.getProperties());

    }

    /**
     * @deprecated instead use {@link #setRemoteRepositories(List)}
     */
    @Deprecated
    public MetadataResolutionRequest setRemoteRepostories(List<ArtifactRepository> remoteRepositories) {
        this.remoteRepositories = remoteRepositories;

        return this;
    }

    public MetadataResolutionRequest setRemoteRepositories(List<ArtifactRepository> remoteRepositories) {

    protected MavenProject getProjectWithDependencies(File pom) throws Exception {
        ProjectBuildingRequest configuration = newBuildingRequest();
        configuration.setRemoteRepositories(Arrays.asList(new ArtifactRepository[] {}));
        configuration.setProcessPlugins(false);
        configuration.setResolveDependencies(true);

        try {

    public List<ArtifactRepository> getRemoteRepositories() {
        return repositoryRequest.getRemoteRepositories();
    }

    public DefaultMetadataResolutionRequest setRemoteRepositories(List<ArtifactRepository> remoteRepositories) {
        repositoryRequest.setRemoteRepositories(remoteRepositories);

        return this;
    }

    public boolean isResolveManagedVersions() {
        return resolveManagedVersions;
    }

        copy.setLoggingLevel(original.getLoggingLevel());
        copy.setGlobalChecksumPolicy(original.getGlobalChecksumPolicy());
        copy.setUpdateSnapshots(original.isUpdateSnapshots());
        copy.setRemoteRepositories(original.getRemoteRepositories());
        copy.setPluginArtifactRepositories(original.getPluginArtifactRepositories());
        copy.setRepositoryCache(original.getRepositoryCache());

            throws ArtifactResolutionException, ArtifactNotFoundException {
        RepositoryRequest request = new DefaultRepositoryRequest();
        request.setLocalRepository(localRepository);
        request.setRemoteRepositories(remoteRepositories);
        transformForResolve(artifact, request);
    }

    protected String resolveVersion(

    /**
     * Sets the remote repositories to use.
     *
     * @param remoteRepositories The remote repositories to use.
     * @return This request, never {@code null}.
     */
    RepositoryRequest setRemoteRepositories(List<ArtifactRepository> remoteRepositories);

        RepositoryRequest repositoryRequest = new DefaultRepositoryRequest();
        repositoryRequest.setLocalRepository(getLocalRepository());
        repositoryRequest.setRemoteRepositories(getPluginArtifactRepositories());

        PluginDescriptor pluginDescriptor = pluginManager.loadPlugin(
                plugin, session.getCurrentProject().getRemotePluginRepositories(), session.getRepositorySession());