final ModelRuleDescriptor descriptor = this.descriptor.append("create()");

        NodeInitializer nodeInitializer = creatorStrategy.initializer(elementType, Specs.<ModelType<?>>satisfyAll());
        ModelRegistration registration = ModelRegistrations.of(childPath, nodeInitializer)
            .descriptor(descriptor)

package org.gradle.model.internal.manage.schema.extract;

import org.gradle.model.internal.core.NodeInitializer;
import org.gradle.model.internal.core.NodeInitializerContext;
import org.gradle.model.internal.manage.schema.ModelSchema;
import org.gradle.model.internal.type.ModelType;

public interface NodeInitializerExtractionStrategy {
    <T> NodeInitializer extractNodeInitializer(ModelSchema<T> schema, NodeInitializerContext<T> context);

        ModelType<T> modelType = ModelType.of(type);
        NodeInitializer nodeInitializer = nodeInitializerRegistry.getNodeInitializer(forType(modelType));
        modelRegistry.register(
            ModelRegistrations.of(modelPath, nodeInitializer)
                .descriptor(descriptor)

            NodeInitializer nodeInitializer = nodeInitializerRegistry.getNodeInitializer(forType(modelType));
            modelRegistry.register(ModelRegistrations.of(modelPath, nodeInitializer).descriptor(descriptor).build());
        } catch (ModelTypeInitializationException e) {

 */

package org.gradle.model.internal.inspect;

import org.gradle.api.specs.Spec;
import org.gradle.model.internal.core.ChildNodeInitializerStrategy;
import org.gradle.model.internal.core.NodeInitializer;
import org.gradle.model.internal.core.NodeInitializerRegistry;
import org.gradle.model.internal.type.ModelType;

import static org.gradle.model.internal.core.NodeInitializerContext.forType;

    private static final ModelType<ModelSet<?>> MODEL_SET_MODEL_TYPE = new ModelType<ModelSet<?>>() {
    };

    @Override
    protected <T, E> NodeInitializer extractNodeInitializer(CollectionSchema<T, E> schema, NodeInitializerContext<T> context) {
        if (MODEL_SET_MODEL_TYPE.isAssignableFrom(schema.getType())) {
            return new ModelSetNodeInitializer<T, E>(schema);

        assert collectionSchema instanceof ManagedImplSchema
        def nodeInitializer = nodeInitializerRegistry.getNodeInitializer(forType(collectionSchema.getType()))
        reference = ModelReference.of(collectionPath, collectionType)
        registry.register(
            ModelRegistrations.of(collectionPath, nodeInitializer)
                .descriptor("define collection")
                .build()
        )
    }

    private static final ModelType<ModelMap<?>> MODEL_MAP_MODEL_TYPE = new ModelType<ModelMap<?>>() {
    };

    @Override
    protected <T, E> NodeInitializer extractNodeInitializer(CollectionSchema<T, E> schema, NodeInitializerContext<T> context) {
        if (MODEL_MAP_MODEL_TYPE.isAssignableFrom(schema.getType())) {
            return new ModelMapNodeInitializer<T, E>(schema);

import com.google.common.collect.Multimap;
import org.gradle.model.internal.core.*;
import org.gradle.model.internal.core.rule.describe.ModelRuleDescriptor;

public class ProjectionOnlyNodeInitializer implements NodeInitializer {
    private final ModelProjection[] projections;

    public ProjectionOnlyNodeInitializer(ModelProjection... projections) {
        this.projections = projections;
    }

    @Override

import org.gradle.api.specs.Spec;
import org.gradle.model.internal.type.ModelType;

public interface ChildNodeInitializerStrategy<T> {

    // Node must project item as S
    <S extends T> NodeInitializer initializer(ModelType<S> type, Spec<ModelType<?>> constraints);