By default, `resolvableConfigurations` prints information about all purely resolvable configurations.
These are configurations that are marked resolvable but *not* marked consumable.
Though some resolvable configurations are also marked consumable, these are legacy configurations that should *not* have dependencies added in build scripts.

            taskDependencyFactory
        );
        instance.addMutationValidator(rootComponentMetadataBuilder.getValidator());
        return instance;
    }

    /**
     * Creates a new locked consumable configuration instance.
     */
    DefaultConsumableConfiguration createConsumable(
        String name,
        ConfigurationsProvider configurationsProvider,

            if (conf == null) {
                return null;
            }
            assert conf.getMetadata().isCanBeConsumed() : "External components' configurations are always consumable";
            return conf.asVariant();
        }
    }

        given:
        publishes(multiCoordinateComponent {
            compilation("first")
        })
        file("other/build.gradle") << """
            configurations {
                consumable("extraRuntimeElements") {
                    attributes {
                        attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage, "extra"))
                    }
                }
            }

    // Dependency scopes
    public static final String API_CONFIGURATION_NAME = "api";
    public static final String RUNTIME_CONFIGURATION_NAME = "runtime";

    // Consumable configurations
    public static final String API_ELEMENTS_CONFIGURATION_NAME = "apiElements";
    public static final String RUNTIME_ELEMENTS_CONFIGURATION_NAME = "runtimeElements";

First, a producer needs to declare a configuration which is going to be _exposed_ to consumers.
As explained in the <<declaring_dependencies.adoc#sec:resolvable-consumable-configs, configurations chapter>>, this corresponds to a _consumable configuration_.

Let's imagine that the consumer requires _instrumented classes_ from the producer, but that this artifact is _not_ the main one.

                constraint("org:bar:{strictly 1.0}", "org:bar:1.0")
            }
        }
    }

    // TODO: This is not desired behavior. We should deprecate and forbid this.
    def "can consume non-consumable project configuration when substituted as a transitive dependency"() {

        file("included/settings.gradle") << """
            rootProject.name = "transitive"
        """

The role of each configuration is described in the following tables:

.Java Library plugin - configurations used to declare dependencies
[%header%autowidth,compact]
|===
| Configuration name | Role | Consumable? | Resolvable? | Description

| `api`
| Declaring API dependencies
| no
| no
| This is where you declare dependencies which are transitively exported to consumers, for compile time and runtime.

        } else if (configuration.isCanBeResolved()) {
            type = ReportConfiguration.Type.RESOLVABLE;
        } else if (configuration.isCanBeConsumed()) {
            type = ReportConfiguration.Type.CONSUMABLE;
        } else {
            type = null;
        }

        return new ReportConfiguration(configuration.getName(), configuration.getDescription(), type, new ArrayList<>(lenientErrors),

                }
                onPlugins(failingPlugins) {
                    failsWith([
                        (missingAnnotationMessage { type('com.android.build.gradle.internal.TaskManager.ConfigAttrTask').property('consumable').missingInputOrOutput().includeLink() }): ERROR,