return buildFromRepository(artifact, remoteRepositories, configuration, allowStubModel);
    }

    @Override
    public MavenProject buildFromRepository(
            Artifact artifact, List<ArtifactRepository> remoteRepositories, ArtifactRepository localRepository)
            throws ProjectBuildingException {
        return buildFromRepository(artifact, remoteRepositories, localRepository, true);
    }

    /**

    ResolutionGroup retrieve(
            Artifact artifact, ArtifactRepository localRepository, List<ArtifactRepository> remoteRepositories)
            throws ArtifactMetadataRetrievalException;

    /**
     * Get a list of available versions for an artifact in the remote repository
     *

            throws InvalidRepositoryException {

        List<ArtifactRepository> remoteRepositories = new ArrayList<>();

        for (Repository r : repositories) {
            remoteRepositories.add(buildArtifactRepository(r, artifactRepositoryFactory, c));
        }

        return remoteRepositories;
    }

    public static ArtifactRepository buildDeploymentArtifactRepository(

            RepositoryMetadata metadata,
            List<ArtifactRepository> remoteRepositories,
            ArtifactRepository localRepository)
            throws RepositoryMetadataResolutionException {
        RepositoryRequest request = new DefaultRepositoryRequest();
        request.setLocalRepository(localRepository);
        request.setRemoteRepositories(remoteRepositories);
        resolve(metadata, request);
    }

    @Override

        super(msg, artifact);
    }

    public OverConstrainedVersionException(String msg, Artifact artifact, List<ArtifactRepository> remoteRepositories) {
        super(msg, artifact, remoteRepositories);
    }

        this.localRepository = localRepository;
    }

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

    public void setRemoteRepositories(List<ArtifactRepository> remoteRepositories) {
        this.remoteRepositories = remoteRepositories;
    }
    // --------------------------------------------------------------------

            }
        }

        return new ResolutionGroup(artifact, dependencies, remoteRepositories);
    }

    @Override
    public List<ArtifactVersion> retrieveAvailableVersions(
            Artifact artifact, ArtifactRepository localRepository, List<ArtifactRepository> remoteRepositories)
            throws ArtifactMetadataRetrievalException {

    private final ResolutionNode parent;

    private final List<ArtifactRepository> remoteRepositories;

    private boolean active = true;

    private List<Artifact> trail;

    public ResolutionNode(Artifact artifact, List<ArtifactRepository> remoteRepositories) {
        this.artifact = artifact;
        this.remoteRepositories = remoteRepositories;
        depth = 0;
        parents = Collections.emptyList();
        parent = null;

    private List<ArtifactRepository> remoteRepositories;

    public UnresolvedArtifacts(
            Artifact originatingArtifact, List<Artifact> artifacts, List<ArtifactRepository> remoteRepositories) {
        this.originatingArtifact = originatingArtifact;

        this.artifacts = artifacts;

        this.remoteRepositories = remoteRepositories;
    }

    public Artifact getOriginatingArtifact() {

            ArtifactRepository localRepository,
            List<ArtifactRepository> remoteRepositories);

    void put(
            Artifact artifact,
            boolean resolveManagedVersions,
            ArtifactRepository localRepository,
            List<ArtifactRepository> remoteRepositories,
            ResolutionGroup result);

    void flush();