@Override
        public ImmutableList<? extends Dependency> getDependencies() {
            return delegate.getDependencies();
        }

        @Override
        public ImmutableList<? extends DependencyConstraint> getDependencyConstraints() {
            return delegate.getDependencyConstraints();
        }

        @Override
        public ImmutableList<? extends File> getFiles() {

For example, a dependency constraint can narrow down the set of supported module versions.
Dependency constraints can be used to express such requirements for transitive dependencies.
For more information, see the sections on <<dependency_constraints.adoc#dependency-constraints,upgrading>> and <<dependency_downgrade_and_exclude.adoc#downgrading_versions_and_excluding_dependencies,downgrading>> transitive dependencies.

[[sub:terminology_feature_variant]]

import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.ImmutableList;
import org.gradle.api.GradleException;
import org.gradle.api.artifacts.Dependency;
import org.gradle.api.artifacts.DependencyConstraint;
import org.gradle.api.artifacts.ExcludeRule;
import org.gradle.api.artifacts.ExternalDependency;
import org.gradle.api.artifacts.ModuleDependency;
import org.gradle.api.artifacts.ProjectDependency;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.Sets;
import org.gradle.api.GradleException;
import org.gradle.api.artifacts.DependencyArtifact;
import org.gradle.api.artifacts.DependencyConstraint;
import org.gradle.api.artifacts.ExcludeRule;
import org.gradle.api.artifacts.ExternalDependency;
import org.gradle.api.artifacts.ModuleDependency;
import org.gradle.api.artifacts.ModuleVersionIdentifier;

* information about the project that created the dependency
* the authors of the dependency
* other dependencies required for a dependency to work properly, known as _transitive dependencies_

You can <<dependency_constraints.adoc#dependency-constraints,customize Gradle's handling of transitive dependencies>> based on the requirements of a project.

Projects with hundreds of declared dependencies can be difficult to debug.

        def bom = mavenRepo.module("org", "bom", "1.0")
        bom.hasPackaging('pom')
        bom.dependencyConstraint(root11)
        if (dependsOptional) {
            bom.dependencyConstraint(optional)
        }
        bom.publish()

        buildFile << """
apply plugin: 'java'

repositories {
    maven {
        name 'repo'

        given:
        def module = mavenRepo.module('test', 'dep', '1.0').publish()
        mavenRepo.module('test', 'bom', '1.0').hasPackaging('pom').dependencyConstraint(module).publish()

        pluginBuilder.addPlugin("println 'test-plugin applied'")
        def pluginModule = pluginBuilder.publishAs('test:plugin:1.0', mavenRepo, executer).pluginModule

include::rich_versions.adoc[leveloffset=+2]
include::dynamic_versions.adoc[leveloffset=+2]
include::dependency_locking.adoc[leveloffset=+2]

== CONTROLLING TRANSITIVES

include::dependency_constraints.adoc[leveloffset=+2]
include::dependency_downgrade_and_exclude.adoc[leveloffset=+2]
include::platforms.adoc[leveloffset=+2]
include::dependency_version_alignment.adoc[leveloffset=+2]

        def constrained = mavenRepo.module('org', 'constrained', '1.1').publish()
        def bom = mavenRepo.module('org', 'bom', '1.0').hasType('pom').dependencyConstraint(constrained).publish()
        def user = mavenRepo.module('org', 'user', '1.0').dependsOn(constrainedBase).publish()
        def higherUser = mavenRepo.module('org', 'user', '1.1').dependsOn(constrainedBase).publish()

[[sec:declaring_without_version]]
== Declaring a dependency without version

A recommended practice for larger projects is to declare dependencies without versions and use <<dependency_constraints.adoc#sec:adding-constraints-transitive-deps,dependency constraints>> for version declaration.
The advantage is that dependency constraints allow you to manage versions of all dependencies, including transitive ones, in one place.