Here is how to setup the `minified` attribute so that the above works.
You need to register the new attribute in the schema, add it to all JAR artifacts and request it on all resolvable configurations.

.Artifact transform attribute setup
====
include::sample[dir="snippets/dependencyManagement/artifactTransforms-minify/kotlin",files="build.gradle.kts[tags=artifact-transform-attribute-setup]"]

env GO111MODULE=on

# Test that go mod edits and related mod flags work.
# Also test that they can use a dummy name that isn't resolvable. golang.org/issue/24100

# go mod init
! go mod init
stderr 'cannot determine module path'
! exists go.mod

go mod init x.x/y/z
stderr 'creating new go.mod: module x.x/y/z'
cmpenv go.mod $WORK/go.mod.init

! go mod init
cmpenv go.mod $WORK/go.mod.init

# go mod edits

        then:
        output.contains """
compile
+--- org.utils:api:1.3 -> 0.1
\\--- org.original:original:1.0 -> org.other:another:0.1
"""
    }

    void "doesn't fail if a configuration is not resolvable"() {
        mavenRepo.module("foo", "foo", '1.0').publish()
        mavenRepo.module("foo", "bar", '2.0').publish()

        file("build.gradle") << """
            repositories {

                        (missingAnnotationMessage { type('com.android.build.gradle.internal.TaskManager.ConfigAttrTask').property('resolvable').missingInputOrOutput().includeLink() }): ERROR,
                    ])
                }
            } else {
                alwaysPasses()
            }
        }
    }

// https://github.com/minio/minio/issues/5667
var errErasureV3ThisEmpty = fmt.Errorf("Erasure format version 3 has This field empty")

// isServerResolvable - checks if the endpoint is resolvable
// by sending a naked HTTP request with liveness checks.
func isServerResolvable(endpoint Endpoint, timeout time.Duration) error {
	serverURL := &url.URL{
		Scheme: endpoint.Scheme,
		Host:   endpoint.Host,

For more information, see the sections on <<declaring_dependencies.adoc#sec:what-are-dependency-configurations,dependency configurations>> as well as <<declaring_dependencies.adoc#sec:resolvable-consumable-configs,resolvable and consumable configurations>>.

NOTE: The word "configuration" is an overloaded term and has a different meaning outside of the context of dependency management.

[[sub:terminology_dependency]]
== Dependency

    }

    void "deprecations are passed to copies when corresponding role is #baseRole"() {
        ConfigurationRole role = new DefaultConfigurationRole("test", baseRole.consumable, baseRole.resolvable, baseRole.declarable, true, true, true)
        def configuration = prepareConfigurationForCopyTest(conf("conf", ":", ":", role))
        def resolutionStrategyCopy = Mock(ResolutionStrategyInternal)

     *     <li>Other configurations with names containing the 'test' substring (case ignored)</li>
     * </ul>
     * <p>
     * Note, that this property should contain resolvable configurations only.
     *
     * @since 7.5
     */
    @Incubating
    public SetProperty<Configuration> getTestConfigurations() {
        return testConfigurations;
    }

* The configurations in pink, also known as consumable denoted by \(C), are the ones used when a component runs against the library
* The configurations in blue, also known as resolvable denoted by \(R), are internal to the component, for its own use

The following configurations are used to declare dependencies:

`implementation`::

                    }
                }
            }
        """
        buildFile << """
            configurations {
                dependencyScope("deps")
                resolvable("res") {
                    extendsFrom(deps)
                    attributes {
                        attribute(CUSTOM_ATTRIBUTE, "foo")
                    }
                }
            }