writeLn(" * <p>");
            writeLn(" * This version was declared in " + sanitizeUnicodeEscapes(context));
        }
        writeLn(" */");
        String methodName = asProvider ? "asProvider" : "get" + toJavaName(leafNodeForAlias(versionAlias));
        writeLn("public Provider<String> " + methodName + "() { return getVersion(\"" + versionAlias + "\"); }");
        writeLn();
    }

        doAddLazy(externalModule.asProvider(), null);
    }

    @Override
    public void add(ProviderConvertible<? extends MinimalExternalModuleDependency> externalModule, Action<? super ExternalModuleDependency> configuration) {
        doAddLazy(externalModule.asProvider(), configuration);
    }

    @Override
    public void add(Dependency dependency) {

        if(dependencyNotation instanceof ProviderConvertible<?>) {
            return doAddProvider(configuration, ((ProviderConvertible<?>) dependencyNotation).asProvider(), configureAction);
        }
        if (dependencyNotation instanceof Provider<?>) {
            return doAddProvider(configuration, (Provider<?>) dependencyNotation, configureAction);
        }

     * @since 8.7
     */
    default Provider<? extends DependencyConstraint> constraint(ProviderConvertible<? extends MinimalExternalModuleDependency> dependencyConstraint) {
        return constraint(dependencyConstraint.asProvider());
    }

    /**
     * Create a {@link DependencyConstraint} from a project.
     *
     * @param project the project
     * @return the new dependency constraint
     * @since 8.7
     */

                                                                Action<? super ExternalModuleDependencyVariantSpec> variantSpec) {
        return variantOf(dependencyProviderConvertible.asProvider(), variantSpec);
    }

    /**
     * Configures this dependency provider to select the platform variant of the target component
     * @param dependencyProvider the dependency provider

        addProvider(configurationName, dependencyNotation.asProvider(), configuration);
    }

    @Override
    public <T> void addProviderConvertible(String configurationName, ProviderConvertible<T> dependencyNotation) {

.Using a version from a version catalog when there are more specific aliases
====
include::sample[dir="snippets/dependencyManagement/catalogs-asprovider/kotlin",files="build.gradle.kts[tags=use_version_asprovider]"]
include::sample[dir="snippets/dependencyManagement/catalogs-asprovider/groovy",files="build.gradle[tags=use_version_asprovider]"]

                implementation "org.gradle.test:lib-core:1.+" // intentional!
                implementation "org.gradle.test:lib-ext" // intentional!
                constraints {
                    implementation libs.myLib //.asProvider() as a workaround
                    implementation libs.myLib.ext
                }
            }
        """

        when:
        run ':checkDeps'

        then:

    }

    @Override
    public ServiceProvider asProvider() {
        return thisAsServiceProvider;
    }

    private static ServiceProvider toParentServices(ServiceRegistry serviceRegistry) {
        if (serviceRegistry instanceof ContainsServices) {
            return new ParentServices(((ContainsServices) serviceRegistry).asProvider());
        }

        MockServiceRegistry(ParentServices parentServices) {
            this.parentServices = parentServices
        }

        @Override
        ServiceProvider asProvider() {
            return new MockServiceProvider(parentServices)
        }

        @Override
        def <T> T get(Class<T> serviceType) throws UnknownServiceException, ServiceLookupException {