Iterable<? extends MutableModelNode> getLinks(ModelType<?> type);

    Iterable<? extends MutableModelNode> getLinks(Predicate<? super MutableModelNode> predicate);

    <T> void setPrivateData(Class<? super T> type, T object);

    <T> void setPrivateData(ModelType<? super T> type, T object);

    <T> T getPrivateData(Class<T> type);

    <T> T getPrivateData(ModelType<T> type);

    Object getPrivateData();

    /**

        ModelType<T> delegateType = Cast.uncheckedCast(implementationInfo.getDelegateType());
        T instance = Cast.uncheckedCast(implementationInfo.create(modelNode));
        modelNode.setPrivateData(delegateType, instance);
    }

                        ChildNodeInitializerStrategy<T> childFactory =
                            NodeBackedModelMap.createUsingRegistry(nodeInitializerRegistry);
                        node.setPrivateData(CHILD_NODE_INITIALIZER_STRATEGY_MODEL_TYPE, childFactory);
                    }
                })
                .descriptor(modelNode.getDescriptor())
                .withProjection(

            return false
        }

        @Override
        def <T> void setPrivateData(ModelType<? super T> type, T object) {

        }

        @Override
        def <T> void setPrivateData(Class<? super T> type, T object) {

        }

        @Override
        def <T> T getPrivateData(ModelType<T> type) {
            return null

                            ChildNodeInitializerStrategy<E> childStrategy = NodeBackedModelMap.createUsingRegistry(nodeInitializerRegistry);
                            modelNode.setPrivateData(ChildNodeInitializerStrategy.class, childStrategy);
                        }
                    }
                ))
                .build();
        }
    }

                            ChildNodeInitializerStrategy<T> childStrategy = new ManagedChildNodeCreatorStrategy<T>(nodeInitializerRegistry);
                            modelNode.setPrivateData(ChildNodeInitializerStrategy.class, childStrategy);
                        }
                    }
                ))
                .build();
        }
    }

        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void setPrivateData(Class<? super T> type, T object) {
        throw new UnsupportedOperationException();
    }

    @Override
    public <T> void setPrivateData(ModelType<? super T> type, T object) {
        throw new UnsupportedOperationException();
    }

    @Override

            if (instance == null) {
                throw new ModelRuleExecutionException(descriptor, "rule returned null");
            }
            T value = Cast.uncheckedCast(instance);
            modelNode.setPrivateData(type, value);
        }
    }

    private static class ExtractedUnmanagedCreationRule<R, S> extends ExtractedCreationRule<R, S> {

                        ChildNodeInitializerStrategy<E> childFactory = NodeBackedModelMap.createUsingRegistry(nodeInitializerRegistry);
                        modelNode.setPrivateData(ModelType.of(ChildNodeInitializerStrategy.class), childFactory);
                    }
                }
            ))
            .build();
    }

        def registration = ModelRegistrations.of(ModelPath.path(name))
            .action(ModelActionRole.Create) { MutableModelNode node ->
                def privateData = createUnmanagedInstance(node)
                node.setPrivateData(implType, privateData)
            }
            .withProjection(new ManagedModelProjection<T>(publicTypeSchema, bindings, ProjectRegistrySpec.MANAGED_PROXY_FACTORY, null))