* resolution as if they were defined by the endorsing module itself.
     *
     * @since 6.0
     */
    void endorseStrictVersions();

    /**
     * Resets the {@link #isEndorsingStrictVersions()} state of this dependency.
     *
     * @since 6.0
     */
    void doNotEndorseStrictVersions();

    /**

                    case "requestedCapabilities":
                        requestedCapabilities = consumeCapabilities(reader, false);
                        break;
                    case "endorseStrictVersions":
                        endorseStrictVersions = reader.nextBoolean();
                        break;
                    case "thirdPartyCompatibility":
                        reader.beginObject();

    public DirectDependencyMetadataAdapter(ImmutableAttributesFactory attributesFactory, ModuleDependencyMetadata metadata) {
        super(attributesFactory, metadata);
    }

    @Override
    public void endorseStrictVersions() {
        updateMetadata(getMetadata().withEndorseStrictVersions(true));
    }

    @Override
    public void doNotEndorseStrictVersions() {
        updateMetadata(getMetadata().withEndorseStrictVersions(false));

    def "add via string id with action is propagate to the underlying dependency list"() {
        when:
        adapter.add("org.gradle.test:module1") {
            it.version { it.require '1.0' }
            it.endorseStrictVersions()
        }

        then:
        dependenciesMetadata.size() == 1
        dependenciesMetadata[0].selector.group == "org.gradle.test"
        dependenciesMetadata[0].selector.module == "module1"

                    writeCapabilities("requestedCapabilities", moduleDependency.requestedCapabilities);
                    if (moduleDependency.endorseStrictVersions) {
                        write("endorseStrictVersions", true);
                    }
                    if (moduleDependency.reason != null) {
                        write("reason", moduleDependency.reason);
                    }

                    attributes: testAttributes))

            dependencies {
                implementation("org:platform:1.0") {
                    endorseStrictVersions()
                }
                implementation("org:foo") {
                    version {
                        strictly '1.0'
                    }
                }
                constraints {

         *
         * Selects the platform variant of the given dependency.
         */
        @Override
        protected void modifyImplementation(ModuleDependency dependency) {
            dependency.endorseStrictVersions();
            dependency.attributes(attributeContainer -> attributeContainer.attribute(Category.CATEGORY_ATTRIBUTE, getObjectFactory().named(Category.class, Category.REGULAR_PLATFORM)));
        }
    }

    /**

            // Changes here may require changes in DefaultExternalModuleDependencyVariantSpec
            ModuleDependency moduleDependency = (ModuleDependency) dependency;
            moduleDependency.endorseStrictVersions();
            platformSupport.addPlatformAttribute(moduleDependency, toCategory(Category.REGULAR_PLATFORM));
        } else if (dependency instanceof HasConfigurableAttributes) {

                    attributes: testAttributes))

            dependencies {
                implementation("org:platform:1.0") {
                    endorseStrictVersions()
                }
                implementation("org:foo") {
                    version {
                        strictly '1.0'
                    }
                }
                constraints {

        // Using a normal module as "platform" (i.e. endorsing it's strict constraints) also works
        MODULE             // constraints in module are published with strict constraints, consumer uses normal dependencies with 'endorseStrictVersions()'
    }

    String platformDependency(platformType, String dependency) {
        //noinspection GroovyFallthrough
        switch (platformType) {
            case PLATFORM:
            case LEGACY_PLATFORM: