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

/**
 *
 * @since 4.0.0
 */
@Experimental
public interface VersionResolverResult {

    @Nonnull
    List<Exception> getExceptions();

    @Nonnull
    Version getVersion();

    @Nonnull
    Optional<Repository> getRepository();

        return this;
    }

    public List<Throwable> getExceptions() {
        return exceptions;
    }

    public MavenExecutionResult addException(Throwable t) {
        exceptions.add(t);

        return this;
    }

    public boolean hasExceptions() {
        return !getExceptions().isEmpty();
    }

    public BuildSummary getBuildSummary(MavenProject project) {

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

/**
 *
 * @since 4.0.0
 */
@Experimental
public interface VersionRangeResolverResult {

    @Nonnull
    List<Exception> getExceptions();

    @Nonnull
    List<Version> getVersions();

    @Nonnull
    default Optional<Version> getLowerVersion() {
        return getVersions().isEmpty()
                ? Optional.empty()

    // for each exception
    // - knowing what artifacts are missing
    // - project building exception
    // - invalid project model exception: list of markers
    // - xmlpull parser exception
    List<Throwable> getExceptions();

    MavenExecutionResult addException(Throwable e);

    boolean hasExceptions();

    /**
     * Gets the build summary for the specified project.
     *

        if (result.hasExceptions()) {
            throw new ArtifactResolutionException(
                    "Unknown error during artifact resolution, " + request + ", " + result.getExceptions(),
                    request.getArtifact(),
                    request.getRemoteRepositories());
        }
    }

    private static <T> List<T> toList(Collection<T> items) {

    /**
     * Gets the exceptions that occurred while building the dependency graph.
     *
     * @return the exceptions that occurred, never {@code null}
     */
    @Nonnull
    List<Exception> getExceptions();

    /**
     * Gets the root node of the dependency graph.
     *
     * @return the root node of the dependency graph or {@code null} if none
     */
    @Nullable
    Node getRoot();

    /**

    // ------------------------------------------------------------------------

    public boolean hasExceptions() {
        return exceptions != null && !exceptions.isEmpty();
    }

    public List<Exception> getExceptions() {
        return exceptions == null ? Collections.emptyList() : Collections.unmodifiableList(exceptions);
    }

    // ------------------------------------------------------------------------

        return Optional.ofNullable(delegate.getMojoExecution()).map(me -> new DefaultMojoExecution(session, me));
    }

    @Override
    public Optional<Exception> getException() {
        return Optional.ofNullable(delegate.getException());
    }

        if (modelId == null) {
            modelId = getModelId();
            source = getSource();
        }

        if (line <= 0 && column <= 0 && req.getException() instanceof ModelParseException) {
            ModelParseException e = (ModelParseException) req.getException();
            line = e.getLineNumber();
            column = e.getColumnNumber();
        }

        ModelProblem problem = new DefaultModelProblem(

        logger.debug("Installing {} to {}", event.getMetadata(), event.getFile());
    }

    @Override
    public void metadataResolved(RepositoryEvent event) {
        Exception e = event.getException();
        if (e != null) {
            if (e instanceof MetadataNotFoundException) {
                logger.debug(e.getMessage());
            } else if (logger.isDebugEnabled()) {