Configuration (Gradle API 9.1.0)
Description: declaration: package: org.gradle.api.artifacts, interface: Configuration

Package org.gradle.api.artifacts

# Interface Configuration

All Superinterfaces:
  `AntBuilderAware`, `Buildable`, `FileCollection`, `HasAttributes`, `HasConfigurableAttributes<Configuration>`, `Iterable<File>`, `Named`

All Known Subinterfaces:
  `ConsumableConfiguration`, `DependencyScopeConfiguration`, `LegacyConfiguration`, `ResolvableConfiguration`

public interface Configuration extends FileCollection, HasConfigurableAttributes<Configuration>, Named
A `Configuration` represents a group of artifacts and their dependencies. Find more information about declaring dependencies to a configuration or about managing configurations in docs for `ConfigurationContainer`

Configuration is an instance of a `FileCollection` that contains all dependencies (see also `getAllDependencies()`) but not artifacts. If you want to refer to the artifacts declared in this configuration please use `getArtifacts()` or `getAllArtifacts()`. Read more about declaring artifacts in the configuration in docs for `ArtifactHandler` Please see the Declaring Dependencies User Manual chapter for more information.

- ## Nested Class Summary

  Nested Classes
  Modifier and Type
  Interface
  Description
  `static enum`
  `Configuration.State`
  The states a configuration can be into.

  ## Nested classes/interfaces inherited from interface org.gradle.api.file.FileCollection

  `FileCollection.AntType`

  ## Nested classes/interfaces inherited from interface org.gradle.api.Named

  `Named.Namer`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `Configuration`
  `copy()`
  Creates a copy of this configuration that only contains the dependencies directly in this configuration (without contributions from superconfigurations).
  `Configuration`
  `copy(Closure dependencySpec)`
  Takes a closure which gets coerced into a `Spec`.
  `Configuration`
  `copy(Spec<? super Dependency> dependencySpec)`
  Creates a copy of this configuration ignoring superconfigurations (see `copy()` but filtering the dependencies using the specified dependency spec.
  `Configuration`
  `copyRecursive()`
  Creates a copy of this configuration that contains the dependencies directly in this configuration and those derived from superconfigurations.
  `Configuration`
  `copyRecursive(Closure dependencySpec)`
  Takes a closure which gets coerced into a `Spec`.
  `Configuration`
  `copyRecursive(Spec<? super Dependency> dependencySpec)`
  Creates a copy of this configuration with dependencies from superconfigurations (see `copyRecursive()`) but filtering the dependencies using the dependencySpec.
  `Configuration`
  `defaultDependencies(Action<? super DependencySet> action)`
  Execute the given action if the configuration has no defined dependencies when it first participates in dependency resolution.
  `Configuration`
  `disableConsistentResolution()`
  Disables consistent resolution for this configuration.
  `Configuration`
  `exclude(Map<String,String> excludeProperties)`
  Adds an exclude rule to exclude transitive dependencies for all dependencies of this configuration.
  `Configuration`
  `extendsFrom(Configuration... superConfigs)`
  Adds the given configurations to the set of configuration which this configuration extends from.
  `default void`
  `fromDependencyCollector(DependencyCollector collector)`
  Use the given collector as a source for dependencies and dependency constraints.
  `PublishArtifactSet`
  `getAllArtifacts()`
  Returns the artifacts of this configuration including the artifacts of extended configurations.
  `DependencySet`
  `getAllDependencies()`
  Gets the complete set of declared dependencies including those contributed by superconfigurations.
  `DependencyConstraintSet`
  `getAllDependencyConstraints()`
  Gets the complete set of dependency constraints including those contributed by superconfigurations.
  `PublishArtifactSet`
  `getArtifacts()`
  Returns the artifacts of this configuration excluding the artifacts of extended configurations.
  `TaskDependency`
  `getBuildDependencies()`
  Returns a `TaskDependency` object containing all required dependencies to build the local dependencies (e.g.
  `DependencySet`
  `getDependencies()`
  Gets the set of declared dependencies directly contained in this configuration (ignoring superconfigurations).
  `DependencyConstraintSet`
  `getDependencyConstraints()`
  Gets the set of dependency constraints directly contained in this configuration (ignoring superconfigurations).
  `@Nullable String`
  `getDescription()`
  Returns the description for this configuration.
  `Set<ExcludeRule>`
  `getExcludeRules()`
  Returns the exclude rules applied for resolving any dependency of this configuration.
  `Set<Configuration>`
  `getExtendsFrom()`
  Returns the names of the configurations which this configuration extends from.
  `Set<Configuration>`
  `getHierarchy()`
  Gets an ordered set including this configuration and all superconfigurations recursively.
  `ResolvableDependencies`
  `getIncoming()`
  Returns a `ResolvableDependencies` instance, exposing the results of dependency resolution.
  `ConfigurationPublications`
  `getOutgoing()`
  Returns the outgoing `ConfigurationPublications` instance that advertises and allows configuring the artifacts and variants published by this configuration.
  `ResolutionStrategy`
  `getResolutionStrategy()`
  Returns the resolution strategy used by this configuration.
  `ResolvedConfiguration`
  `getResolvedConfiguration()`
  Returns a `ResolvedConfiguration`, a legacy view of the results of dependency resolution.
  `Configuration.State`
  `getState()`
  Returns the state of the configuration.
  `TaskDependency`
  `getTaskDependencyFromProjectDependency(boolean useDependedOn, String taskName)`
  Returns a TaskDependency object containing dependencies on all tasks with the specified name from project dependencies related to this configuration or one of its super configurations.
  `boolean`
  `isCanBeConsumed()`
  Returns true if this configuration can be consumed from another project, or published.
  `boolean`
  `isCanBeDeclared()`
  Returns true if it is allowed to declare dependencies upon this configuration.
  `boolean`
  `isCanBeResolved()`
  Returns true if it is allowed to query or resolve this configuration.
  `boolean`
  `isTransitive()`
  Returns the transitivity of this configuration.
  `boolean`
  `isVisible()`
  Deprecated.
  This property is deprecated and will be removed in Gradle 10.
  `void`
  `outgoing(Action<? super ConfigurationPublications> action)`
  Configures the outgoing `ConfigurationPublications` instance that advertises and allows configuring the artifacts and variants published by this configuration.
  `Configuration`
  `resolutionStrategy(Closure closure)`
  The resolution strategy provides extra details on how to resolve this configuration.
  `Configuration`
  `resolutionStrategy(Action<? super ResolutionStrategy> action)`
  The resolution strategy provides extra details on how to resolve this configuration.
  `Set<File>`
  `resolve()`
  Resolves this configuration.
  `void`
  `setCanBeConsumed(boolean allowed)`
  Configures if a configuration can be consumed.
  `void`
  `setCanBeDeclared(boolean allowed)`
  Configures if a configuration can have dependencies declared upon it.
  `void`
  `setCanBeResolved(boolean allowed)`
  Configures if a configuration can be resolved.
  `Configuration`
  `setDescription(@Nullable String description)`
  Sets the description for this configuration.
  `Configuration`
  `setExtendsFrom(Iterable<Configuration> superConfigs)`
  Sets the configurations which this configuration extends from.
  `Configuration`
  `setTransitive(boolean t)`
  Sets the transitivity of this configuration.
  `Configuration`
  `setVisible(boolean visible)`
  Deprecated.
  This property is deprecated and will be removed in Gradle 10.
  `Configuration`
  `shouldResolveConsistentlyWith(Configuration versionsSource)`
  Tells that this configuration, when resolved, should resolve versions consistently from the resolution result of another resolvable configuration.
  `Configuration`
  `withDependencies(Action<? super DependencySet> action)`
  Execute the given action before the configuration first participates in dependency resolution.

  ### Methods inherited from interface org.gradle.api.file.FileCollection

  `addToAntBuilder, addToAntBuilder, contains, filter, filter, getAsFileTree, getAsPath, getElements, getFiles, getSingleFile, isEmpty, minus, plus`

  ### Methods inherited from interface org.gradle.api.attributes.HasAttributes

  `getAttributes`

  ### Methods inherited from interface org.gradle.api.attributes.HasConfigurableAttributes

  `attributes`

  ### Methods inherited from interface java.lang.Iterable

  `forEach, iterator, spliterator`

  ### Methods inherited from interface org.gradle.api.Named

  `getName`

- ## Method Details

  - ### getResolutionStrategy

    ResolutionStrategy getResolutionStrategy()
    Returns the resolution strategy used by this configuration. The resolution strategy provides extra details on how to resolve this configuration. See docs for `ResolutionStrategy` for more info and examples.
    Returns:
      resolution strategy
    Since:
      1.0-milestone-6
    Implementation Requirements:
      Usage: This method should only be called on resolvable configurations, but will not warn if used otherwise.

  - ### resolutionStrategy

    Configuration resolutionStrategy(@DelegatesTo(value=ResolutionStrategy.class,strategy=1) Closure closure)
    The resolution strategy provides extra details on how to resolve this configuration. See docs for `ResolutionStrategy` for more info and examples.
    Parameters:
      `closure` - closure applied to the `ResolutionStrategy`
    Returns:
      this configuration instance
    Since:
      1.0-milestone-6
    Implementation Requirements:
      Usage: This method should only be called on resolvable configurations, but will not warn if used otherwise.

  - ### resolutionStrategy

    Configuration resolutionStrategy(Action<? super ResolutionStrategy> action)
    The resolution strategy provides extra details on how to resolve this configuration. See docs for `ResolutionStrategy` for more info and examples.
    Parameters:
      `action` - action applied to the `ResolutionStrategy`
    Returns:
      this configuration instance
    Since:
      3.1
    Implementation Requirements:
      Usage: This method should only be called on resolvable configurations, but will not warn if used otherwise.

  - ### getState

    Configuration.State getState()
    Returns the state of the configuration.
    Returns:
      The state of the configuration
    See Also:
      - `Configuration.State`
    Implementation Requirements:
      Usage: This method should only be called on resolvable configurations, but will not warn if used otherwise.

  - ### isVisible

    @Deprecated boolean isVisible()
    Deprecated.
    This property is deprecated and will be removed in Gradle 10.
    This is a legacy property and the value does not affect dependency resolution in any way. There is no need to read this property and this method will be deprecated in an upcoming Gradle version.

    The value of this property does not dictate in any way the "visibility" of a configuration, or if it is accessible between projects.

  - ### setVisible

    @Deprecated Configuration setVisible(boolean visible)
    Deprecated.
    This property is deprecated and will be removed in Gradle 10.
    Sets the value returned by `isVisible()`. There is no need to set this property and this method will be deprecated in an upcoming Gradle version.
    Parameters:
      `visible` - the value to set.

  - ### getExtendsFrom

    Set<Configuration> getExtendsFrom()
    Returns the names of the configurations which this configuration extends from. The artifacts of the super configurations are also available in this configuration.
    Returns:
      The super configurations. Returns an empty set when this configuration does not extend any others.

  - ### setExtendsFrom

    Configuration setExtendsFrom(Iterable<Configuration> superConfigs)
    Sets the configurations which this configuration extends from.

    Configurations are only allowed to extend from other configurations in the same project.

    Parameters:
      `superConfigs` - The super configuration. Should not be null.
    Returns:
      this configuration

  - ### extendsFrom

    Configuration extendsFrom(Configuration... superConfigs)
    Adds the given configurations to the set of configuration which this configuration extends from.

    Configurations are only allowed to extend from other configurations in the same project.

    Parameters:
      `superConfigs` - The super configurations.
    Returns:
      this configuration

  - ### isTransitive

    boolean isTransitive()
    Returns the transitivity of this configuration. A transitive configuration contains the transitive closure of its direct dependencies, and all their dependencies. An intransitive configuration contains only the direct dependencies. The default value is true.
    Returns:
      true if this is a transitive configuration, false otherwise.

  - ### setTransitive

    Configuration setTransitive(boolean t)
    Sets the transitivity of this configuration. When set to true, this configuration will contain the transitive closure of its dependencies and their dependencies. The default value is true.
    Parameters:
      `t` - true if this is a transitive configuration.
    Returns:
      this configuration

  - ### getDescription

    @Nullable String getDescription()
    Returns the description for this configuration.
    Returns:
      the description. May be null.

  - ### setDescription

    Configuration setDescription(@Nullable String description)
    Sets the description for this configuration.
    Parameters:
      `description` - the description. May be null
    Returns:
      this configuration

  - ### getHierarchy

    Set<Configuration> getHierarchy()
    Gets an ordered set including this configuration and all superconfigurations recursively.
    Returns:
      the set of all configurations

  - ### resolve

    Set<File> resolve()
    Resolves this configuration. This locates and downloads the files which make up this configuration, and returns the resulting set of files.
    Returns:
      The files of this configuration.
    Implementation Requirements:
      Usage: This method should only be called on resolvable configurations and will emit a deprecation warning if called on a configuration that does not permit this usage, or has allowed this usage but marked it as deprecated.

  - ### getResolvedConfiguration

    ResolvedConfiguration getResolvedConfiguration()
    Returns a `ResolvedConfiguration`, a legacy view of the results of dependency resolution. Avoid this method for new code. Prefer accessing resolution outputs via `getIncoming()`. This API will be deprecated and removed in future Gradle versions.

    See `ResolvedConfiguration` for details on why this API should not be used.

    Returns:
      The ResolvedConfiguration object
    Implementation Requirements:
      Usage: This method should only be called on resolvable configurations and should fail if called on a configuration that does not permit this usage. It should warn if called on a configuration that has allowed this usage but marked it as deprecated.

  - ### getBuildDependencies

    TaskDependency getBuildDependencies()
    Returns a `TaskDependency` object containing all required dependencies to build the local dependencies (e.g. project dependencies) belonging to this configuration or to one of its super configurations.
    Specified by:
      `getBuildDependencies` in interface `Buildable`
    Returns:
      a TaskDependency object
    Implementation Requirements:
      Usage: This method should only be called on resolvable configurations, but will not warn if used otherwise.

  - ### getTaskDependencyFromProjectDependency

    TaskDependency getTaskDependencyFromProjectDependency(boolean useDependedOn, String taskName)
    Returns a TaskDependency object containing dependencies on all tasks with the specified name from project dependencies related to this configuration or one of its super configurations. These other projects may be projects this configuration depends on or projects with a similarly named configuration that depend on this one based on the useDependOn argument.
    Parameters:
      `useDependedOn` - if true, add tasks from project dependencies in this configuration, otherwise use projects from configurations with the same name that depend on this one.
      `taskName` - name of task to depend on
    Returns:
      the populated TaskDependency object

  - ### getDependencies

    DependencySet getDependencies()
    Gets the set of declared dependencies directly contained in this configuration (ignoring superconfigurations).

    This method does not resolve the configuration. Therefore, the return value does not include transitive dependencies.

    Returns:
      the set of dependencies
    See Also:
      - `extendsFrom(Configuration...)`
    Implementation Requirements:
      Usage: This method should only be called on declarable configurations, but will not warn if used otherwise.

  - ### getAllDependencies

    DependencySet getAllDependencies()
    Gets the complete set of declared dependencies including those contributed by superconfigurations.

    This method does not resolve the configuration. Therefore, the return value does not include transitive dependencies.

    Returns:
      the (read-only) set of dependencies
    See Also:
      - `extendsFrom(Configuration...)`

  - ### getDependencyConstraints

    DependencyConstraintSet getDependencyConstraints()
    Gets the set of dependency constraints directly contained in this configuration (ignoring superconfigurations).
    Returns:
      the set of dependency constraints
    Since:
      4.6
    Implementation Requirements:
      Usage: This method should only be called on declarable configurations, but will not warn if used otherwise.

  - ### getAllDependencyConstraints

    DependencyConstraintSet getAllDependencyConstraints()

    Gets the complete set of dependency constraints including those contributed by superconfigurations.

    Returns:
      the (read-only) set of dependency constraints
    Since:
      4.6

  - ### fromDependencyCollector

    @Incubating default void fromDependencyCollector(DependencyCollector collector)
    Use the given collector as a source for dependencies and dependency constraints.
    Parameters:
      `collector` - the collector to use
    Since:
      8.7

  - ### getArtifacts

    PublishArtifactSet getArtifacts()
    Returns the artifacts of this configuration excluding the artifacts of extended configurations.
    Returns:
      The set.
    Implementation Requirements:
      Usage: This method should only be called on consumable configurations, but will not warn if used otherwise.

  - ### getAllArtifacts

    PublishArtifactSet getAllArtifacts()
    Returns the artifacts of this configuration including the artifacts of extended configurations.
    Returns:
      The (read-only) set.

  - ### getExcludeRules

    Set<ExcludeRule> getExcludeRules()
    Returns the exclude rules applied for resolving any dependency of this configuration.
    Returns:
      The exclude rules
    See Also:
      - `exclude(java.util.Map)`

  - ### exclude

    Configuration exclude(Map<String,String> excludeProperties)
    Adds an exclude rule to exclude transitive dependencies for all dependencies of this configuration. You can also add exclude rules per-dependency. See `ModuleDependency.exclude(java.util.Map)`.
    Parameters:
      `excludeProperties` - the properties to define the exclude rule.
    Returns:
      this

  - ### defaultDependencies

    Configuration defaultDependencies(Action<? super DependencySet> action)
    Execute the given action if the configuration has no defined dependencies when it first participates in dependency resolution. A `Configuration` will participate in dependency resolution when:
    - The `Configuration` itself is resolved
    - Another `Configuration` that extends this one is resolved
    - Another `Configuration` that references this one as a project dependency is resolved
    This method is useful for specifying default dependencies for a configuration:

         configurations { conf }
         configurations['conf'].defaultDependencies { dependencies ->
              dependencies.add(owner.project.dependencies.create("org.gradle:my-util:1.0"))
         }

    A `Configuration` is considered empty even if it extends another, non-empty `Configuration`.

    If multiple actions are supplied, each action will be executed until the set of dependencies is no longer empty. Remaining actions will be ignored.

    Parameters:
      `action` - the action to execute when the configuration has no defined dependencies.
    Returns:
      this
    Implementation Requirements:
      Usage: This method should only be called on declarable configurations and will emit a deprecation warning if called on a configuration that does not permit this usage, or has allowed this usage but marked it as deprecated.

  - ### withDependencies

    Configuration withDependencies(Action<? super DependencySet> action)
    Execute the given action before the configuration first participates in dependency resolution. Actions will be executed in the order provided. A configuration will participate in dependency resolution when:
    - The `Configuration` itself is resolved
    - The `Configuration` is published to a repository
    - The `Configuration` is consumed as a variant by another project
    - Another `Configuration` that extends this one is resolved, published, or consumed

    In general, this method should be avoided in favor of other lazy APIs. However, in some cases where lazy APIs are not yet available, this method can be used to perform actions before the configuration is used.

    Despite the method's name, callbacks registered on this method should not add dependencies to the configuration or mutate the dependencies already present on the configuration. Instead, use the `Provider`-accepting methods on `DependencySet` and `DependencyConstraintSet`.

    Consider the following example that lazily adds a dependency to a configuration:

         configurations { conf }
         configurations['conf'].dependencies.addLater(provider {
             project.dependencies.create("com:example:1.0")
         })

    Similarly, instead of mutating an existing dependency, use dependency constraints instead. Consider the following example that uses a dependency constraint to prefer a specific version of a dependency if the dependency has not declared a preferred version itself. If the dependency has declared a version, the preferred version constraint will be ignored:

         configurations { conf }
         dependencies {
             conf("com:example")

             constraints {
                 conf("com:example") {
                     version {
                         prefer("2.0")
                     }
                 }
             }
         }

    In some cases, using this method may still be necessary:
    - Adding excludes: This method may be used to lazily add excludes to a Configuration. Adding excludes to declared dependencies should be handled with `component metadata rules`
    - Mutating configuration hierarchy: Mutating a configuration's hierarchy (`extendsFrom(Configuration...)`) after declaration is highly discouraged. However, doing so is possible with this method.
    Parameters:
      `action` - a dependency action to execute before the configuration is used.
    Returns:
      this
    Since:
      4.4

  - ### getIncoming

    ResolvableDependencies getIncoming()
    Returns a `ResolvableDependencies` instance, exposing the results of dependency resolution. This method is the primary way to consume dependency resolution outputs.
    Returns:
      An object that exposes the results of dependency resolution.
    Implementation Requirements:
      Usage: This method should only be called on consumable and resolvable configurations, but will not warn if used otherwise.

  - ### getOutgoing

    ConfigurationPublications getOutgoing()
    Returns the outgoing `ConfigurationPublications` instance that advertises and allows configuring the artifacts and variants published by this configuration.

    This allows adding additional artifacts and accessing and configuring variants to publish.

    Returns:
      The outgoing publications object containing artifacts and variants published by this configuration.
    Since:
      3.4
    Implementation Requirements:
      Usage: This method should only be called on consumable configurations, but will not warn if used otherwise.

  - ### outgoing

    void outgoing(Action<? super ConfigurationPublications> action)
    Configures the outgoing `ConfigurationPublications` instance that advertises and allows configuring the artifacts and variants published by this configuration.
    Parameters:
      `action` - The action to perform the configuration.
    Since:
      3.4
    Implementation Requirements:
      Usage: This method should only be called on consumable configurations, but will not warn if used otherwise.

  - ### copy

    Configuration copy()
    Creates a copy of this configuration that only contains the dependencies directly in this configuration (without contributions from superconfigurations). The new configuration will be in the UNRESOLVED state, but will retain all other attributes of this configuration except superconfigurations. `getHierarchy()` for the copy will not include any superconfigurations.

    This method is only intended for use for specific situations involving resolvable configuration, it is NOT intended as a general-purpose copying mechanism.

    Returns:
      copy of this configuration
    Implementation Requirements:
      Usage: This method should only be called on resolvable configurations and will emit a deprecation warning if called on a configuration that does not permit this usage, or has allowed this usage but marked it as deprecated.

  - ### copyRecursive

    Configuration copyRecursive()
    Creates a copy of this configuration that contains the dependencies directly in this configuration and those derived from superconfigurations. The new configuration will be in the UNRESOLVED state, but will retain all other attributes of this configuration except superconfigurations. `getHierarchy()` for the copy will not include any superconfigurations.

    This method is only intended for use for specific situations involving resolvable configuration, it is NOT intended as a general-purpose copying mechanism.

    Returns:
      copy of this configuration
    Implementation Requirements:
      Usage: This method should only be called on resolvable configurations and will emit a deprecation warning if called on a configuration that does not permit this usage, or has allowed this usage but marked it as deprecated.

  - ### copy

    Configuration copy(Spec<? super Dependency> dependencySpec)
    Creates a copy of this configuration ignoring superconfigurations (see `copy()` but filtering the dependencies using the specified dependency spec.

    This method is only intended for use for specific situations involving resolvable configuration, it is NOT intended as a general-purpose copying mechanism.

    Parameters:
      `dependencySpec` - filtering requirements
    Returns:
      copy of this configuration
    Implementation Requirements:
      Usage: This method should only be called on resolvable configurations and will emit a deprecation warning if called on a configuration that does not permit this usage, or has allowed this usage but marked it as deprecated.

  - ### copyRecursive

    Configuration copyRecursive(Spec<? super Dependency> dependencySpec)
    Creates a copy of this configuration with dependencies from superconfigurations (see `copyRecursive()`) but filtering the dependencies using the dependencySpec.

    This method is only intended for use for specific situations involving resolvable configuration, it is NOT intended as a general-purpose copying mechanism.

    Parameters:
      `dependencySpec` - filtering requirements
    Returns:
      copy of this configuration
    Implementation Requirements:
      Usage: This method should only be called on resolvable configurations and will emit a deprecation warning if called on a configuration that does not permit this usage, or has allowed this usage but marked it as deprecated.

  - ### copy

    Configuration copy(Closure dependencySpec)
    Takes a closure which gets coerced into a `Spec`. Behaves otherwise in the same way as `copy(org.gradle.api.specs.Spec)`

    This method is only intended for use for specific situations involving resolvable configuration, it is NOT intended as a general-purpose copying mechanism.

    Parameters:
      `dependencySpec` - filtering requirements
    Returns:
      copy of this configuration
    Implementation Requirements:
      Usage: This method should only be called on resolvable configurations and will emit a deprecation warning if called on a configuration that does not permit this usage, or has allowed this usage but marked it as deprecated.

  - ### copyRecursive

    Configuration copyRecursive(Closure dependencySpec)
    Takes a closure which gets coerced into a `Spec`. Behaves otherwise in the same way as `copyRecursive(org.gradle.api.specs.Spec)`

    This method is only intended for use for specific situations involving resolvable configuration, it is NOT intended as a general-purpose copying mechanism.

    Parameters:
      `dependencySpec` - filtering requirements
    Returns:
      copy of this configuration
    Implementation Requirements:
      Usage: This method should only be called on resolvable configurations and will emit a deprecation warning if called on a configuration that does not permit this usage, or has allowed this usage but marked it as deprecated.

  - ### setCanBeConsumed

    void setCanBeConsumed(boolean allowed)
    Configures if a configuration can be consumed.
    Since:
      3.3

  - ### isCanBeConsumed

    boolean isCanBeConsumed()
    Returns true if this configuration can be consumed from another project, or published. Defaults to true.
    Returns:
      true if this configuration can be consumed or published.
    Since:
      3.3

  - ### setCanBeResolved

    void setCanBeResolved(boolean allowed)
    Configures if a configuration can be resolved.
    Since:
      3.3

  - ### isCanBeResolved

    boolean isCanBeResolved()
    Returns true if it is allowed to query or resolve this configuration. Defaults to true.
    Returns:
      true if this configuration can be queried or resolved.
    Since:
      3.3

  - ### setCanBeDeclared

    @Incubating void setCanBeDeclared(boolean allowed)
    Configures if a configuration can have dependencies declared upon it.
    Since:
      8.2

  - ### isCanBeDeclared

    @Incubating boolean isCanBeDeclared()
    Returns true if it is allowed to declare dependencies upon this configuration. Defaults to true.
    Returns:
      true if this configuration can have dependencies declared
    Since:
      8.2

  - ### shouldResolveConsistentlyWith

    @Incubating Configuration shouldResolveConsistentlyWith(Configuration versionsSource)
    Tells that this configuration, when resolved, should resolve versions consistently from the resolution result of another resolvable configuration. For example, it's expected that the versions of the runtime classpath are the same as the versions from the compile classpath.
    Parameters:
      `versionsSource` - another resolvable configuration to use as reference for versions
    Returns:
      this configuration
    Since:
      6.8
    Implementation Requirements:
      Usage: This method should only be called on resolvable configurations and will emit a deprecation warning if called on a configuration that does not permit this usage, or has had allowed this usage but marked it as deprecated.

  - ### disableConsistentResolution

    @Incubating Configuration disableConsistentResolution()
    Disables consistent resolution for this configuration.
    Since:
      6.8
    Implementation Requirements:
      Usage: This method should only be called on resolvable configurations and will emit a deprecation warning if called on a configuration that does not permit this usage, or has had allowed this usage but marked it as deprecated.