@Override
        def void applyToLink(ModelActionRole type, ModelAction action) {

        }

        @Override
        void applyTo(NodePredicate predicate, ModelActionRole role, ModelAction action) {

        }

        @Override
        void applyTo(NodePredicate predicate, Class<? extends RuleSource> rules) {

        }

        @Override
        ModelNodeInternal getLink(String name) {

            def node = graph.projectNode(selectedProjectIdentityPath, selectedModuleVersionId)
            deps << new EdgeBuilder(this, requested, node)
            applyTo(node, cl)
            return node
        }

        private static void applyTo(NodeBuilder node, Closure cl) {
            cl.resolveStrategy = Closure.DELEGATE_ONLY
            cl.delegate = node
            cl.call()
        }

        /**

"configPatches"
"proxyVersion"
"metadata"
"service"
"vhost"
"gateway"
"filterChain"
"operation"
"value"
"filterClass"
"context"
"proxy"
"listener"
"routeConfiguration"
"cluster"
"applyTo"
"match"
"patch"
"transportProtocol"
"applicationProtocols"
"destinationPort"
"subFilter"
"bind"
"initialDelaySeconds"
"timeoutSeconds"
"periodSeconds"
"successThreshold"
"failureThreshold"

    static class MyEnumBuildOption extends EnumBuildOption<MyEnum, Dummy> {

        MyEnumBuildOption() {
            super("my option", MyEnum, MyEnum.values(), "test")
        }

        @Override
        void applyTo(MyEnum value, Dummy settings, Origin origin) {
            settings.accept(value)
        }
    }

    enum MyEnum {
        THOU,
        SHALT,
        NOT,
        PASS
    }

            this.request = request;
            this.resolved = resolved;
        }

        public void apply(PluginManagerInternal target) {
            try {
                try {
                    pluginApplicationListenerBroadcaster.pluginApplied(request);
                    resolved.applyTo(target);
                } catch (UnknownPluginException e) {
                    throw couldNotApply(request, request.getId(), e);

            metadataValueContainer.finalizeIfNotAlready();
            metadataValueContainer.get().applyTo(result);
        } catch (ExecutionException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

        }

        @Override
        public void applyTo(String value, LoggingConfiguration settings, Origin origin) {
            String consoleValue = TextUtil.capitalize(TextUtil.toLowerCaseLocaleSafe(value));
            try {

     */
    void attempted(ExternalResourceName location);

    /**
     * Copies the locations for this result to the given target.
     */
    void applyTo(ResourceAwareResolveResult target);

		{
			ApplyTo: networking.EnvoyFilter_LISTENER,
			Match: &networking.EnvoyFilter_EnvoyConfigObjectMatch{
				Context: networking.EnvoyFilter_SIDECAR_OUTBOUND,
			},
			Patch: &networking.EnvoyFilter_Patch{
				Operation: networking.EnvoyFilter_Patch_ADD,
				Value:     buildPatchStruct(`{"name":"new-outbound-listener"}`),
			},
		},
		{
			ApplyTo: networking.EnvoyFilter_LISTENER,

	ln, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		t.Fatalf("failed to listen on 127.0.0.1:0")
	}
	defer ln.Close()
	s.Listener = ln
	s.BindPort = ln.Addr().(*net.TCPAddr).Port

	if err := s.ApplyTo(&secureServingInfo, &loopbackClientConfig); err != nil {
		t.Errorf("unexpected error: %v", err)
	}
	if loopbackClientConfig == nil {
		t.Errorf("unexpected empty loopbackClientConfig")
	}