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

        return repositoryRequest.getRemoteRepositories();
    }

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

        return this;
    }

    @Override
    public boolean isResolveManagedVersions() {
        return resolveManagedVersions;
    }

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

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

    }

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

        return this;
    }

    public MetadataResolutionRequest setRemoteRepositories(List<ArtifactRepository> remoteRepositories) {

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

    protected String resolveVersion(

    public ArtifactResolutionRequest() {
        // nothing here
    }

    public ArtifactResolutionRequest(RepositoryRequest request) {
        setLocalRepository(request.getLocalRepository());
        setRemoteRepositories(request.getRemoteRepositories());
        setOffline(request.isOffline());
        setForceUpdate(request.isForceUpdate());
    }

    public Artifact getArtifact() {
        return artifact;
    }

                .setShowErrors(true)
                .setPluginGroups(Arrays.asList("org.apache.maven.plugins"))
                .setLocalRepository(getLocalRepository())
                .setRemoteRepositories(getRemoteRepositories())
                .setPluginArtifactRepositories(getPluginArtifactRepositories())
                .setGoals(Arrays.asList("package"));

        if (pom != null) {

        injectSession(request);
        request.setArtifact(artifact);
        request.setLocalRepository(localRepository);
        request.setRemoteRepositories(remoteRepositories);
        request.setResolveManagedVersions(resolveManagedVersions);
        return retrieve(request);
    }

    @Override

                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());

        ProjectBuildingRequest configuration = new DefaultProjectBuildingRequest();
        configuration.setLocalRepository(getLocalRepository());
        configuration.setRemoteRepositories(Arrays.asList(new ArtifactRepository[] {}));
        configuration.setProcessPlugins(true);
        configuration.setResolveDependencies(true);
        initRepoSession(configuration);

        try {