return dependencyConstraints;
    }

    @Override
    public Set<? extends Capability> getCapabilities() {
        return capabilities;
    }

    @Override
    public Set<ExcludeRule> getGlobalExcludes() {
        return globalExcludes;
    }

    SetProperty<IvyConfiguration> getConfigurations();

    SetProperty<IvyArtifact> getArtifacts();

    SetProperty<IvyDependency> getDependencies();

    SetProperty<IvyExcludeRule> getGlobalExcludes();

    Action<XmlProvider> getXmlAction();

    List<IvyModuleDescriptorAuthor> getAuthors();

    List<IvyModuleDescriptorLicense> getLicenses();

    IvyModuleDescriptorDescription getDescription();

    Set<? extends ModuleDependency> getDependencies();
    Set<? extends DependencyConstraint> getDependencyConstraints();
    Set<? extends Capability> getCapabilities();
    Set<ExcludeRule> getGlobalExcludes();

                new HashSet<>(),
                new HashSet<>()));
        }
        return capabilities;
    }

    @Override
    public Set<ExcludeRule> getGlobalExcludes() {
        if (excludeRules == null) {
            this.excludeRules = ImmutableSet.copyOf(((ConfigurationInternal) configuration).getAllExcludeRules());
        }
        return excludeRules;
    }

    public abstract SetProperty<IvyArtifact> getArtifacts();

    @Override
    public abstract SetProperty<IvyDependency> getDependencies();

    @Override
    public abstract SetProperty<IvyExcludeRule> getGlobalExcludes();

    @Override
    public void license(Action<? super IvyModuleDescriptorLicense> action) {
        configureAndAdd(DefaultIvyModuleDescriptorLicense.class, action, licenses);
    }

    @Override

        model.licenses.addAll(descriptor.getLicenses());
        model.configurations.addAll(descriptor.getConfigurations().get());

        Set<IvyExcludeRule> globalExcludes = descriptor.getGlobalExcludes().getOrNull();
        if (globalExcludes != null) {
            model.globalExcludes.addAll(globalExcludes);
        }

        Set<IvyDependency> dependencies = descriptor.getDependencies().getOrNull();

            return emptyList();
        }
        ArrayList<ModuleMetadataSpec.Dependency> dependencies = new ArrayList<>();
        Set<ExcludeRule> additionalExcludes = variant.getGlobalExcludes();
        for (ModuleDependency moduleDependency : variant.getDependencies()) {
            if (moduleDependency.getArtifacts().isEmpty()) {
                dependencies.add(
                    dependencyFor(

        for (SoftwareComponentVariant variant : component.getUsages()) {
            String conf = mapVariantNameToIvyConfiguration(variant.getName());
            for (ExcludeRule excludeRule : variant.getGlobalExcludes()) {
                globalExcludes.add(new DefaultIvyExcludeRule(excludeRule, conf));
            }
        }

        return globalExcludes;
    }

        this.descriptor.setStatus(Module.DEFAULT_STATUS);
        this.descriptor.getWriteGradleMetadataMarker().set(providerFactory.provider(this::writeGradleMetadataMarker));
        this.descriptor.getGlobalExcludes().set(getComponent().map(ivyComponentParser::parseGlobalExcludes));
        this.descriptor.getConfigurations().set(this.configurations);
        this.descriptor.getArtifacts().set(providerFactory.provider(this::getArtifacts));

        String scope = scopeMapping.getScope();
        boolean optional = scopeMapping.isOptional();
        Set<ExcludeRule> globalExcludes = variant.getGlobalExcludes();

        MavenDependencyFactory dependencyFactory = new MavenDependencyFactory(
            warnings,
            resolvers.getVariantResolver(),
            resolvers.getComponentResolver(),