for (StructSchema<?> viewSchema : bindings.getDeclaredViewSchemas()) {
                            addProjection(modelNode, viewSchema, proxyFactory, typeConverter);
                        }
                        modelNode.addProjection(new ModelElementProjection(bindings.getPublicSchema().getType()));
                    }
                }
            ))

                        modelNode.addProjection(new SpecializedModelMapProjection<T, E>(schema.getType(), schema.getElementType(), implementationType, strategyAccessor));
                        modelNode.addProjection(ModelMapModelProjection.managed(schema.getType(), schema.getElementType(), strategyAccessor));
                    }
                }

    }

    @Override
    public void execute(MutableModelNode modelNode, List<ModelView<?>> inputs) {
        for (ModelProjection projection : projections) {
            modelNode.addProjection(projection);
        }
    }

        def links = []

        TestNode(String creationPath, Class<?> type) {
            super(null, ModelRegistrations.of(ModelPath.path(creationPath)).descriptor("test").build())
            addProjection(new UnmanagedModelProjection(ModelType.of(type)))
        }

        TestNode(ModelRegistration registration) {
            super(null, registration)
        }

        @Override

    boolean isAtLeast(ModelNode.State state);

    void setHidden(boolean hidden);

    boolean isMutable();

    MutableModelNode getParent();

    void addProjection(ModelProjection projection);

        }
        return toProjection();
    }

    public ModelProjection getProjection() {
        return toProjection();
    }

    @Override
    public void addProjection(ModelProjection projection) {
        if (isAtLeast(Discovered)) {
            throw new IllegalStateException(String.format("Cannot add projections to '%s' as it is already in state %s.", getPath(), state));
        }

        addUntypedNode(node)
        addProjections(node, projections)
    }

    private void addUntypedNode(TestNode node) {
        bindings.nodeCreated(node)
    }

    private void addProjections(TestNode node, ModelProjection... projections) {
        projections.each { node.addProjection it }
        node.setState(ModelNode.State.Discovered)

    }

    def "node can be viewed via projection registered via projector"() {
        registry.configure(ModelActionRole.Discover) { it.path "foo" descriptor "project" node { node ->
            node.addProjection UnmanagedModelProjection.of(BeanInternal)
        } }
        registry
            .register("foo") { it.unmanaged(Bean, new AdvancedBean(name: "foo")) }
            .mutate (BeanInternal) { bean ->