* limitations under the License.
 */
package org.gradle.plugin.use;

import org.gradle.api.artifacts.VersionConstraint;

/**
 * A plugin dependency.
 *
 * @since 7.2
 */
public interface PluginDependency {
    String getPluginId();

    VersionConstraint getVersion();

import org.gradle.plugin.use.PluginDependency;

public abstract class PluginDependencyValueSource implements ValueSource<PluginDependency, PluginDependencyValueSource.Params> {

    interface Params extends ValueSourceParameters {
        Property<String> getPluginName();

        Property<DefaultVersionCatalog> getConfig();
    }

    @Override
    public PluginDependency obtain() {

                }

                override fun alias(notation: Provider<PluginDependency>): PluginDependencySpec {
                    pluginManager.apply(notation.get().pluginId)
                    return NullPluginDependencySpec
                }

                override fun alias(notation: ProviderConvertible<PluginDependency>): PluginDependencySpec {
                    return alias(notation.asProvider())

     */
    default PluginDependencySpec alias(Provider<PluginDependency> notation) {
        PluginDependency pluginDependency = notation.get();
        if (pluginDependency.getVersion().getRequiredVersion().isEmpty()) {
            return id(pluginDependency.getPluginId());
        } else {
            return id(pluginDependency.getPluginId()).version(pluginDependency.getVersion().getRequiredVersion());
        }
    }

) : PluginDependenciesSpec {

    override fun id(id: String): PluginDependencySpec =
        plugins.id(id)

    override fun alias(notation: Provider<PluginDependency>) =
        plugins.alias(notation)

    override fun alias(notation: ProviderConvertible<PluginDependency>) =
        plugins.alias(notation)
}


/**
 * Specify the version of the plugin to depend on.
 *
 * Infix version of [PluginDependencySpec.version].

                }

                override fun alias(notation: Provider<PluginDependency>): PluginDependencySpec {
                    project.pluginManager.apply(notation.get().pluginId)
                    return NullPluginDependencySpec
                }

                override fun alias(notation: ProviderConvertible<PluginDependency>): PluginDependencySpec {
                    return alias(notation.asProvider())

import org.gradle.api.artifacts.MinimalExternalModuleDependency;
import org.gradle.api.provider.Provider;
import org.gradle.api.provider.ProviderConvertible;
import org.gradle.plugin.use.PluginDependency;

public interface ExternalModuleDependencyFactory {

    Provider<MinimalExternalModuleDependency> create(String alias);

 * limitations under the License.
 */
package org.gradle.api.artifacts;

import org.gradle.api.Named;
import org.gradle.api.NonNullApi;
import org.gradle.api.provider.Provider;
import org.gradle.plugin.use.PluginDependency;

import java.util.List;
import java.util.Optional;

/**
 * Provides access to a version catalog. Unlike generated extension
 * classes for catalogs, there is no guarantee that the requested

package org.gradle.api.internal.artifacts.dependencies;

import org.gradle.api.artifacts.MutableVersionConstraint;
import org.gradle.api.artifacts.VersionConstraint;
import org.gradle.plugin.use.PluginDependency;

public class DefaultPluginDependency implements PluginDependency {
    private final String pluginId;
    private final MutableVersionConstraint versionConstraint;

import org.gradle.api.model.ObjectFactory;
import org.gradle.api.provider.Provider;
import org.gradle.api.provider.ProviderFactory;
import org.gradle.plugin.use.PluginDependency;

import java.util.List;
import java.util.Optional;

import static org.gradle.api.internal.catalog.AliasNormalizer.normalize;

public class VersionCatalogView implements VersionCatalog {