PluginResolution resolved = resolvePluginRequest(pluginResolver, request);

            resolved.accept(pluginDependencies);

            if (request.isApply()) {
                pluginApplyActions.add(new ApplyAction(request, resolved));
            }

            String pluginVersion = resolved.getPluginVersion();
            if (pluginVersion != null) {

package org.gradle.api.artifacts;

import org.gradle.api.Action;

/**
 * Provides details about a dependency when it is resolved.
 * Provides means to manipulate dependency metadata when it is resolved.
 *
 * @since 1.4
 */
public interface DependencyResolveDetails {

    /**
     * The module, before it is resolved.
     * The requested module does not change even if there are multiple dependency resolve rules

 * in the resolved dependency graph, and the dependencies between them.
 */
@UsedByScanPlugin
@HasInternalProtocol
public interface ResolutionResult {

    /**
     * Gives access to the root of resolved dependency graph.
     * You can walk the graph recursively from the root to obtain information about resolved dependencies.

/**
 * The result of attempting to resolve a plugin to a classpath.
 */
public interface PluginResolution {

    /**
     * The ID of the resolved plugin.
     */
    PluginId getPluginId();

    /**
     * Accepts a visitor and visits the resolved plugin.
     */
    default void accept(PluginResolutionVisitor visitor) { }

    /**
     * Apply the plugin to the provided plugin manager.
     */

  - conditions:
    - lastTransitionTime: fake
      message: Route was valid
      reason: Accepted
      status: "True"
      type: Accepted
    - lastTransitionTime: fake
      message: All references resolved
      reason: ResolvedRefs
      status: "True"
      type: ResolvedRefs
    controllerName: istio.io/gateway-controller
    parentRef:
      group: ""
      kind: Service
      name: b-example

                    T componentState = componentForIdResolveResult(componentFactory, idResolveResult, selectorState);
                    if (resolved == null) {
                        resolved = new ArrayList<>();
                    }
                    resolved.add(componentState);
                } else {
                    if (failure == null) {
                        failure = idResolveResult.getFailure();

     * is of type {@link org.gradle.api.artifacts.ProjectDependency}. In this case, if transitive is <code>false</code>,
     * only the self resolving dependencies of the project configuration which are no project dependencies are resolved. If transitive
     * is set to true, other project dependencies belonging to the configuration of the resolved project dependency are
     * resolved recursively.

import org.gradle.internal.HasInternalProtocol;

/**
 * Allows modification of {@link PluginRequest}s before they are resolved.
 *
 * @since 3.5
 */
@HasInternalProtocol
public interface PluginResolutionStrategy {

    /**
     * Adds an action that is executed for each plugin that is resolved.
     * The {@link PluginResolveDetails} parameter contains information about

plugins {
    `ivy-publish`
}

group = "org.gradle.sample"
version = "1.0"

publishing {
// tag::customize-descriptor[]
// tag::versions-resolved[]
    publications {
        create<IvyPublication>("ivyCustom") {
            // end::versions-resolved[]
            descriptor {
                license {
                    name = "The Apache License, Version 2.0"
                    url = "http://www.apache.org/licenses/LICENSE-2.0.txt"

    /**
     * A {@link FileCollection} containing all resolved files. The returned collection
     * carries all task dependencies required to build the resolved files, and when used
     * as a task input the files will be built before the task executes.
     */
    FileCollection getFiles();

    /**
     * A set of resolved artifacts corresponding to the resolved files.
     */
    ArtifactCollection getArtifacts();