- `dependencies`: optional. When missing the variant is assumed to have no dependencies. Must not be present when `available-at` is present.
- `dependencyConstraints`: optional. When missing the variant is assumed to have no dependency constraints. Must not be present when `available-at` is present.

        );
    }

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

            })
        );
    }

    private void writeDependencyConstraints(List<ModuleMetadataSpec.DependencyConstraint> constraints) throws IOException {
        if (constraints.isEmpty()) {
            return;
        }
        writeArray("dependencyConstraints", () -> {
            for (ModuleMetadataSpec.DependencyConstraint constraint : constraints) {
                writeObject(() -> {

        'dependency constraint group'  | '/variants[0]/dependencyConstraints[0]'                                 | 'group'   | '"name": "v", "dependencyConstraints": [{ "module": "c" }]'
        'dependency constraint module' | '/variants[0]/dependencyConstraints[0]'                                 | 'module'  | '"name": "v", "dependencyConstraints": [{ "group": "g" }]'

- `capabilities`: optional. When missing, the variant is assumed to declare no specific capability.

### `attributes` value

This value, nested in `variants` or elements of `dependencies` or `dependencyConstraints` nodes, must contain an object with a value for each attribute.
The attribute value must be a string or boolean.

### `capabilities` value

                    module.dependencyConstraint(repository.module(*args))
                } else if (it instanceof Map) {
                    def other = repository.module(it.group, it.artifact, it.version)
                    module.dependencyConstraint(it, other)
                } else {
                    module.dependencyConstraint(it)
                }
            }
        }

            }

            class TestUsage implements UsageContext {
                String name
                Usage usage
                Set dependencies = []
                Set dependencyConstraints = []
                Set artifacts = []
                Set capabilities = []
                Set globalExcludes = []
                AttributeContainer attributes = ImmutableAttributes.EMPTY
            }

/**
 * See [Configuration.getDependencyConstraints].
 */
@Deprecated(deprecationMessage, replaceWith = ReplaceWith("get().dependencyConstraints"), level = DeprecationLevel.HIDDEN)
val <T : Configuration> NamedDomainObjectProvider<T>.dependencyConstraints
    get() = get().dependencyConstraints


/**
 * See [Configuration.getAllDependencyConstraints].
 */

                    Set<PublishArtifact> artifacts = [ publishedArtifact ]
                    Set<ModuleDependency> dependencies = [ publishedDependency ]
                    Set<DependencyConstraint> dependencyConstraints = []
                    Set<ExcludeRule> globalExcludes = []
                    Set<Capability> capabilities = []
                }
            }

        def v1 = Stub(UsageContext)
        v1.name >> "v1"
        v1.attributes >> attributes(usage: "compile")
        v1.dependencyConstraints >> [dc1]
        def v2 = Stub(UsageContext)
        v2.name >> "v2"
        v2.attributes >> attributes(usage: "runtime")
        v2.dependencyConstraints >> [dc2, dc3, dc4]

        component.usages >> [v1, v2]

        when:
        writeTo(writer, publication, [publication])