*/
@HasInternalProtocol
public interface CapabilitiesResolution {
    /**
     * Configures the resolution strategy of capability conflicts for all capabilities.
     *
     * @param action the configuration action
     */
    void all(Action<? super CapabilityResolutionDetails> action);

    /**
     * Configures the resolution strategy of a specific capability. The capability version is <i>irrelevant</i>.
     *

    schema: AnalysisSchema,
    resolution: ResolutionResult,
    configureLambdas: ConfigureLambdaHandler,
    customAccessors: RuntimeCustomAccessors,
    createInstance: () -> T
): T {
    val trace = assignmentTrace(resolution)
    val context = ReflectionContext(SchemaTypeRefContext(schema), resolution, trace)
    val topLevel = reflect(resolution.topLevelReceiver, context)

    return createInstance().also {

     * Gets the filter used to exclude some dependencies from resolution.
     *
     * @return The filter to exclude dependencies from resolution or {@code null} to resolve all dependencies.
     */
    DependencyFilter getResolutionFilter();

    /**
     * Sets the filter used to exclude some dependencies from resolution. Note that this filter only controls the

        then:
        def e = thrown(InvalidUserDataException)
        e.message == "Cannot enable dependency mapping without configuring a resolution configuration."
    }

    def "returns resolution backed resolver if dependency mapping is enabled with configuration"() {
        given:
        def conf = conf()
        def variant = resolutionBacked(true, conf)

    ) = (node as? ElementNode)?.name == ConventionsTopLevelReceiver::conventions.name &&
        resolutionContainer.data(node).let { resolution ->
            resolution is ConfiguringElementResolved &&
                resolution.elementType.name.qualifiedName == ConventionsConfiguringBlock::class.qualifiedName
        }

        resolvers.forEach {
            val resolution = it.resolvePropertyRead(receiverClass, name)
            if (resolution !is UnresolvedRead)
                return resolution
        }
        return UnresolvedRead
    }

    override fun resolvePropertyWrite(receiverClass: KClass<*>, name: String): WriteResolution {
        resolvers.forEach {
            val resolution = it.resolvePropertyWrite(receiverClass, name)

     */
    boolean isForced();

    /**
     * Informs whether the component was selected by conflict resolution. For more information about Gradle's conflict resolution please refer to the user manual. {@link
     * org.gradle.api.artifacts.ResolutionStrategy} contains information about conflict resolution and includes means to configure it.
     */
    boolean isConflictResolution();

    /**

    private final List<String> resolutions;

    public PrecompiledScriptException(String message, String resolution) {
        super(message);
        this.resolutions = Collections.singletonList(resolution);
    }

    @Override
    public List<String> getResolutions() {
        return resolutions;
    }

= Understanding dependency resolution

This chapter covers the way dependency resolution works _inside_ Gradle.
After covering how you can declare <<declaring_repositories.adoc#declaring-repositories,repositories>> and <<declaring_dependencies.adoc#declaring-dependencies,dependencies>>, it makes sense to explain how these declarations come together during dependency resolution.

releaseNotes:
  - |
    **Improved** `ServiceEntry` with `resolution: NONE` to respect `targetPort`, if specified.
    This is particularly useful when doing TLS origination, allowing to set `port:80, targetPort: 443`.
    If undesired set `--compatibilityVersion=1.21` to revert to the old behavior, or remove the `targetPort` specification.
upgradeNotes:
  - title: "`ServiceEntry` with `resolution: NONE` now respects `targetPort`"
    content: |