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

/**
 * Resolves artifact meta/pseudo versions.
 *
 * @since 4.0.0
 */
@Experimental
@Consumer
public interface VersionResolver extends Service {

    /**
     * Resolves an artifact's meta version (if any) to a concrete version. For example, resolves "1.0-SNAPSHOT"
     * to "1.0-20090208.132618-23" or "RELEASE"/"LATEST" to "2.0".
     *

import java.util.Collection;

public interface ResolverProviderFactory {
    /**
     * Create any applicable resolvers and add to the given collection.
     */
    void create(Collection<ComponentResolvers> resolvers, LocalComponentRegistry localComponentRegistry);

Artifacts
    - producer-other.txt''')
    }

    def 'consumer resolves jar variant of producer'() {
        file('consumer/build.gradle') << '''
            resolve {
                expectations = [ 'producer-jar.txt' ]
            }
        '''
        expect:
        succeeds(':consumer:resolve')
    }

    def 'consumer resolves javadoc variant of producer'() {
        file('consumer/build.gradle') << '''

        if (it.isLowerCase()) it.uppercaseChar() else it
    }
}


class CompositePropertyResolver(private val resolvers: List<RuntimePropertyResolver>) : RuntimePropertyResolver {
    override fun resolvePropertyRead(receiverClass: KClass<*>, name: String): ReadResolution {
        resolvers.forEach {
            val resolution = it.resolvePropertyRead(receiverClass, name)
            if (resolution !is UnresolvedRead)

 *             but should have been.
 *
 */
@Deprecated
public interface ProjectDependenciesResolver {

    /**
     * Resolves the transitive dependencies of the specified project.
     *
     * @param project         The project whose dependencies should be resolved, must not be {@code null}.

public interface VariantArtifactResolver {
    /**
     * Creates an adhoc resolved variant which resolves the provided artifacts of the component.
     */
    ResolvedVariant resolveAdhocVariant(ComponentArtifactResolveMetadata component, ImmutableList<? extends ComponentArtifactMetadata> artifacts);

    /**
     * Resolves the given variant metadata to its artifacts.
     */

import java.nio.file.Path;

import org.apache.maven.model.Model;
import org.apache.maven.model.building.ModelBuildingRequest;

/**
 * Resolves relative paths of a model against a specific base directory.
 *
 */
public interface ModelPathTranslator {

    /**
     * Resolves the well-known paths of the specified model against the given base directory. Paths within plugin
     * configuration are not processed.
     *

 * under the License.
 */
package org.apache.maven.model.path;

import java.io.File;
import java.nio.file.Path;

/**
 * Resolves relative paths against a specific base directory.
 *
 */
public interface PathTranslator {

    /**
     * Resolves the specified path against the given base directory. The resolved path will be absolute and uses the

    def patternSetFactory = Mock(Factory)
    def fileCollection = new ProviderBackedFileCollection(provider, resolver, taskDependencyFactory, patternSetFactory, ProviderResolutionStrategy.REQUIRE_PRESENT)

    def "resolves task dependencies for provider with known producer"() {
        def task = Stub(Task)

        when:
        def dependencies = fileCollection.buildDependencies

        then:
        0 * _

        when:

    private final List<Resolver> resolvers;
    private final Map<String, Set<NodeState>> capabilityWithoutVersionToNodes = new HashMap<>();
    private final Deque<CapabilityConflict> conflicts = new ArrayDeque<>();

    public DefaultCapabilitiesConflictHandler(List<Resolver> resolvers) {
        this.resolvers = resolvers;
    }

    @Override