import javax.annotation.Nullable;

/**
 * Represents a constraints over all, including transitive, dependencies.
 *
 * @since 4.5
 */
public interface DependencyConstraint extends ModuleVersionSelector, HasConfigurableAttributes<DependencyConstraint> {

    /**
     * Configures the version constraint for this dependency constraint.
     *
     * @param configureAction the configuration action for the module version

    def "creates deep copy"() {
        when:
        def copy = dependencyConstraint.copy() as DependencyConstraint

        then:
        assertDeepCopy(dependencyConstraint, copy)
    }

    static void assertDeepCopy(DependencyConstraint dependencyConstraint, DependencyConstraint copiedDependencyConstraint) {
        assert copiedDependencyConstraint.group == dependencyConstraint.group

    }

    @Override
    public boolean add(final DependencyConstraint dependencyConstraint) {
        assertConfigurationIsDeclarable();
        clientConfiguration.maybeEmitDeclarationDeprecation();
        if (dependencyConstraint instanceof DependencyConstraintInternal) {
            ((DependencyConstraintInternal) dependencyConstraint).addMutationValidator(constraint ->

        injectServices(dependencyConstraint);
        return dependencyConstraint;
    }

    @Override
    public DependencyConstraint create(ProjectDependency project) {
        DependencyConstraint dependencyConstraint = dependencyConstraintNotationParser.getProjectDependencyNotationParser().parseNotation(project);
        injectServices(dependencyConstraint);
        return dependencyConstraint;
    }

    // endregion

        delegate.create(dependencyConstraintNotation)

    override fun create(dependencyConstraintNotation: Any, configureAction: Action<in DependencyConstraint>): DependencyConstraint =
        delegate.create(dependencyConstraintNotation, configureAction)

    override fun enforcedPlatform(notation: Any): DependencyConstraint =
        delegate.enforcedPlatform(notation)

        1 * dependencyConstraint.version(_ as Action<VersionConstraint>)
        1 * dependencyConstraintSet.add(dependencyConstraint)
    }

    void "creates a dependency constraint from some notation"() {
        def dependencyConstraint = Mock(DependencyConstraint)

        when:
        def result = dependencyConstraintHandler.create("someNotation")

        then:
        result == dependencyConstraint

        and:

     */
    DependencyConstraint create(@Nullable String group, String name, @Nullable String version);

    /**
     * Create a {@link DependencyConstraint} from a {@link MinimalExternalModuleDependency}.
     *
     * @param dependency the dependency
     * @return the new dependency constraint
     * @since 8.7
     */
    DependencyConstraint create(MinimalExternalModuleDependency dependency);

    /**

        DependencyConstraint dep = enforcedPlatform(notation);
        configureAction.execute(dep);
        return dep;
    }

    private DependencyConstraint doCreate(Object dependencyNotation, @Nullable Action<? super DependencyConstraint> configureAction) {
        DependencyConstraint dependencyConstraint = dependencyConstraintFactory.createDependencyConstraint(dependencyNotation);
        if (configureAction != null) {

        );
    }

    private ModuleMetadataSpec.DependencyConstraint dependencyConstraintFor(
        DependencyConstraint dependencyConstraint,
        ComponentDependencyResolver dependencyResolver,
        String variant
    ) {
        return new ModuleMetadataSpec.DependencyConstraint(
            dependencyConstraintCoordinatesFor(dependencyConstraint, dependencyResolver),

        doAddConstraintEager(dependencyConstraint, configuration);
    }

    @Override
    public void addConstraint(Provider<? extends DependencyConstraint> dependencyConstraint) {
        doAddConstraintLazy(dependencyConstraint, null);
    }

    @Override