@ThreadSafe
public class UnmanagedModelProjection<M> extends TypeCompatibilityModelProjectionSupport<M> {

    public static <M> ModelProjection of(ModelType<M> type) {
        return new UnmanagedModelProjection<M>(type);
    }

    public static <M> ModelProjection of(Class<M> type) {
        return of(ModelType.of(type));
    }

    public UnmanagedModelProjection(ModelType<M> type) {
        super(type);
    }

import org.gradle.model.internal.core.NodeInitializerContext;
import org.gradle.model.internal.core.NodeInitializerRegistry;
import org.gradle.model.internal.core.NodePredicate;
import org.gradle.model.internal.core.UnmanagedModelProjection;
import org.gradle.model.internal.core.rule.describe.SimpleModelRuleDescriptor;
import org.gradle.model.internal.registry.DefaultModelRegistry;
import org.gradle.model.internal.registry.ModelRegistry;

import org.gradle.model.internal.core.MutableModelNode
import org.gradle.model.internal.core.NoInputsModelAction
import org.gradle.model.internal.core.NodePredicate
import org.gradle.model.internal.core.UnmanagedModelProjection
import org.gradle.model.internal.core.rule.describe.ModelRuleDescriptor
import org.gradle.model.internal.core.rule.describe.SimpleModelRuleDescriptor
import org.gradle.model.internal.type.ModelType

package org.gradle.model.internal.core

import spock.lang.Specification

class UnmanagedModelProjectionTest extends Specification {
    def "describes available types"() {
        expect:
        def projection = UnmanagedModelProjection.of(type)
        projection.getTypeDescriptions(Stub(MutableModelNode)) as List == [description]

        where:
        type     | description

import org.gradle.model.internal.core.MutableModelNode;
import org.gradle.model.internal.core.NamedEntityInstantiator;
import org.gradle.model.internal.core.NodeBackedModelMap;
import org.gradle.model.internal.core.UnmanagedModelProjection;
import org.gradle.model.internal.core.rule.describe.SimpleModelRuleDescriptor;
import org.gradle.model.internal.registry.ModelRegistry;
import org.gradle.model.internal.type.ModelType;

import org.gradle.model.internal.core.ModelRegistrations;
import org.gradle.model.internal.core.MutableModelNode;
import org.gradle.model.internal.core.NamedEntityInstantiator;
import org.gradle.model.internal.core.UnmanagedModelProjection;
import org.gradle.model.internal.type.ModelType;
import org.gradle.platform.base.BinarySpec;
import org.gradle.platform.base.BinaryTasksCollection;
import org.gradle.platform.base.ComponentSpec;

                    context.contextualize(new UnmanagedElementCreationAction<R>(descriptor, subjectReference, inputs, modelType)));
            registration.withProjection(new UnmanagedModelProjection<R>(modelType));
            registration.withProjection(new ModelElementProjection(modelType));
        }
    }

            } else {
                registrationBuilder = ModelRegistrations.of(childPath);
            }
            registrationBuilder.withProjection(new UnmanagedModelProjection<P>(propertyType));
            registrationBuilder.withProjection(new ModelElementProjection(propertyType));
            addLink(modelNode, registrationBuilder, property.isInternal());
        }
    }

                    T t = factory.transform(modelNode);
                    modelNode.setPrivateData(modelReference.getType(), t);
                }
            })
            .withProjection(UnmanagedModelProjection.of(modelReference.getType()));
    }

    public static Builder of(ModelPath path) {
        return new Builder(path);
    }

    public static Builder of(ModelPath path, NodeInitializer initializer) {

                        return ImmutableSetMultimap.<ModelActionRole, ModelAction>builder()
                            .put(ModelActionRole.Discover, AddProjectionsAction.of(subject, descriptor,
                                UnmanagedModelProjection.of(type),
                                new ModelElementProjection(type)
                            ))