return t();
    }

    @Override
    public T dependencyConstraint(Module module) {
        backingModule.dependencyConstraint(module);
        return t();
    }

    @Override
    public T dependencyConstraint(Map<String, ?> attributes, Module module) {
        backingModule.dependencyConstraint(attributes, module);
        return t();
    }

    @Override

     *
     * @return the added dependency constraint
     *
     * @see [DependencyConstraintHandler.add]
     */
    fun DependencyConstraintHandler.`api`(constraintNotation: Any, block: DependencyConstraint.() -> Unit): DependencyConstraint =
        add("api", constraintNotation, block)


    /**
     * Adds an artifact to the 'api' configuration.
     *

        private final String name;
        private final ImmutableAttributes attributes;
        private final ImmutableList<? extends Dependency> dependencies;
        private final ImmutableList<? extends DependencyConstraint> dependencyConstraints;
        private final ImmutableList<? extends File> files;
        private final ImmutableCapabilities capabilities;

                    ARETURN()
                }
            },
            metadata = {
                kmPackage.functions += newFunctionOf(
                    flags = functionFlags,
                    receiverType = GradleType.dependencyConstraintHandler,
                    returnType = GradleType.dependencyConstraint,
                    name = propertyName,

                }

                val k: DependencyConstraint = dependencies.constraints.api("direct:accessor:1.0")
                val l: DependencyConstraint = dependencies.constraints.api("direct:accessor-with-action") {
                    val constraint: DependencyConstraint = this
                }

                val projectDependency = dependencies.project(":core")

        private final String name;
        private final List<ComponentVariant.Dependency> dependencies = new ArrayList<>();
        private final List<ComponentVariant.DependencyConstraint> dependencyConstraints = new ArrayList<>();
        private final List<FileImpl> files = new ArrayList<>();
        private final Set<Capability> capabilities = new LinkedHashSet<>();

            .publish()

        bom.dependencyConstraint(moduleA, exclusions: [[group: 'group', module: 'moduleC']]).publish()

        def bom2 = mavenHttpRepo.module('group', 'bom2', '1.0').hasType("pom").allowAll()
        bom2.dependencyConstraint(moduleA, exclusions: [[group: 'group', module: 'moduleD']]).publish()


        buildFile << """

 * limitations under the License.
 */

package org.gradle.api.publish.internal.mapping;

import org.gradle.api.Action;
import org.gradle.api.artifacts.DependencyConstraint;
import org.gradle.api.artifacts.ExternalDependency;
import org.gradle.api.artifacts.ModuleIdentifier;
import org.gradle.api.artifacts.ModuleVersionIdentifier;
import org.gradle.api.artifacts.ProjectDependency;

    IvyModule dependsOn(Map<String, ?> attributes);

    IvyModule dependsOn(Module target);

    IvyModule dependsOn(Map<String, ?> attributes, Module target);

    IvyModule dependencyConstraint(Module module);

    IvyModule dependencyConstraint(Map<String, ?> attributes, Module module);

    /**
     * Responsible for exclusions at configuration level
     * @param group
     * @param module
     * @param configuration

import com.nhaarman.mockito_kotlin.mock
import com.nhaarman.mockito_kotlin.never
import com.nhaarman.mockito_kotlin.verify
import org.gradle.api.Action
import org.gradle.api.artifacts.DependencyConstraint
import org.gradle.api.artifacts.ExternalModuleDependency
import org.gradle.api.artifacts.MinimalExternalModuleDependency
import org.gradle.api.artifacts.dsl.DependencyConstraintHandler