* @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
     */

     */
    public final Provider<? extends MinimalExternalModuleDependency> modify(ProviderConvertible<? extends MinimalExternalModuleDependency> providerConvertibleToDependency) {
        return providerConvertibleToDependency.asProvider().map(this::modify);
    }

    /**

                                                                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) {

        }

        @Override
        protected ModuleVersionSelector parseType(ProviderConvertible<?> notation) {
            return providerConverter.parseType(notation.asProvider());
        }

    }

    static class ProviderConverter extends TypedNotationConverter<Provider<?>, ModuleVersionSelector> {

        private final String caller;

     *
     * @since 7.3
     */
    default PluginDependencySpec alias(ProviderConvertible<PluginDependency> notation) {
        return alias(notation.asProvider());
    }

.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 {