For example, the `org.apache.commons:commons-lang3:3.8` module has an implicit capability with group `org.apache.commons`, name `commons-lang3` and version `3.8`.
It is important to realize that capabilities are _versioned_.

[[sub:declaring-component-capabilities]]
== Declaring component capabilities

By default, Gradle will fail if two components in the dependency graph provide the same capability.

        ModelRuleDescriptor descriptor = modelAction.getDescriptor();
        ModelType<T> modelType = ModelType.of(type);
        try {
            NodeInitializerRegistry nodeInitializerRegistry = modelRegistry.realize(DEFAULT_REFERENCE.getPath(), DEFAULT_REFERENCE.getType());
            NodeInitializer nodeInitializer = nodeInitializerRegistry.getNodeInitializer(forType(modelType));

      TypeID::get<TF::ModOp>(),

      // MatrixDiagPartV3 should use the MLIR implementation due to performance.
      TypeID::get<TF::MatrixDiagPartV3Op>(),

      // Ops that are legalized in the old bridge using MlirXlaOpKernel
      TypeID::get<TF::AbsOp>(),
      TypeID::get<TF::AtanOp>(),
      TypeID::get<TF::AvgPool3DOp>(),
      TypeID::get<TF::BiasAddGradOp>(),
      TypeID::get<TF::CeilOp>(),

            for (PublishArtifact ownArtifact : ownArtifacts) {
                // The following line may realize tasks, so project lock must be held.
                result.add(new PublishArtifactLocalArtifactMetadata(componentId, ownArtifact));
            }

        new URLClassLoader(paths*.toURI()*.toURL() as URL[], ClassLoader.getSystemClassLoader().parent)
    }

    def "can attach export loader with no extra classpath before realize"() {
        when:
        def attachLoaderPath = file("attach")
        copyTo(TestClass1, attachLoaderPath)
        def attachLoader = isolatedLoader(attachLoaderPath)

        def node = ((DefaultModelRegistry) registry).node("item")

        when:
        def ruleSource = extractor.extract RuleSourceWithParameter
        ruleSource.apply(registry, node)
        def item = registry.realize("item", Bean)

        then:
        item.value == "input: 12"
    }

        return binder;
    }

    @Override
    public <T> T realize(String path, Class<T> type) {
        return realize(path, ModelType.of(type));
    }

    @Override
    public <T> T realize(String path, ModelType<T> type) {
        return realize(ModelPath.path(path), type);
    }

    @Override
    public <T> T realize(ModelPath path, ModelType<T> type) {

abstract class AbstractIterationOrderRetainingElementSourceTest extends ElementSourceSpec {
    @Override
    List<CharSequence> iterationOrder(CharSequence... values) {
        return values as List
    }

    def "can realize a filtered set of providers and order is correct"() {
        when:
        source.addPending(provider("foo"))
        source.addPending(provider(new StringBuffer("bar")))

    @Override
    protected boolean isDefaultConvention() {
        return getConventionSupplier() == NOT_DEFINED;
    }

    @Override
    protected String describeContents() {
        // NOTE: Do not realize the value of the Provider in toString().  The debugger will try to call this method and make debugging really frustrating.
        return String.format("property(%s, %s)", type.getName(), describeValue());
    }

                                ModelRegistry modelRegistry = projectModelResolver.resolveProjectModel(dependent.getId().getProjectPath());
                                ModelMap<NativeBinarySpecInternal> projectBinaries = modelRegistry.realize("binaries", ModelTypes.modelMap(NativeBinarySpecInternal.class));
                                NativeBinarySpecInternal dependentBinary = projectBinaries.get(dependent.getProjectScopedName());