}

            dependencies {
                api "org.test:dep1:1.0"
            }

            configurations.api.withDependencies { deps ->
                deps.add project.dependencies.create("org.test:dep2:1.1")
            }
            configurations.api.withDependencies { deps ->
                deps.each { dep ->
                    dep.version { require 'X' }
                }
            }
"""

	}
	return b
}

// WithDependencies sets the Dependencies field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the Dependencies field is set to the value of the last call.

     * </ul>
     *
     * This method is useful for mutating the dependencies for a configuration:
     * <pre class='autoTested'>
     * configurations { conf }
     * configurations['conf'].withDependencies { dependencies -&gt;
     *      dependencies.each { dependency -&gt;
     *          if (dependency.version == null) {
     *              dependency.version { require '1.0' }
     *          }
     *      }

=====

For the following use cases, consider these alternatives when replacing a `beforeResolve` hook:

* **Adding dependencies**: Use link:{javadocPath}/org/gradle/api/artifacts/Configuration.html#withDependencies-org.gradle.api.Action-[`withDependencies`].
* **Changing dependency versions**: Use <<using_preferred_versions,preferred version constraints>>.

                importMgmts.add(importMgmt);
            }
        }

        importIds.remove(importing);

        model = model.withDependencyManagement(model.getDependencyManagement().withDependencies(deps));

        return dependencyManagementImporter.importManagement(model, importMgmts, request, problems);
    }

    private DependencyManagement loadDependencyManagement(
            Model model,

- The <<declaring_dependencies.adoc#declaring-dependencies,dependencies>> of the variant, including <<rich_versions.adoc#rich-version-constraints,rich versions>> — `withDependencies {}` block

                    .map(candidate -> addExclusions(candidate, exclusions))
                    .collect(Collectors.toList());
            importMgmt = importMgmt.withDependencies(dependencies);
        }

        return importMgmt != null ? new DependencyManagement(importMgmt) : null;
    }

    private static org.apache.maven.api.model.Dependency addExclusions(

            if (dependencies.isEmpty()) {
                action.execute(dependencies);
            }
        });
        return this;
    }

    @Override
    public Configuration withDependencies(final Action<? super DependencySet> action) {
        validateMutation(MutationType.DEPENDENCIES);
        withDependencyActions = withDependencyActions.add(action);
        return this;
    }

    @Override

* NamedDomainObjectProvider<Configuration>.setTransitive
* NamedDomainObjectProvider<Configuration>.singleFile
* NamedDomainObjectProvider<Configuration>.state
* NamedDomainObjectProvider<Configuration>.withDependencies

You should prefer to directly reference the methods from `Configuration`.

=== Potential breaking changes

==== `JavaForkOptions` `getJvmArgs()` and `getAllJvmArgs()` return immutable lists