protected void renderOutputs(T binary, TextReportBuilder builder) {
    }

    protected void renderVariants(T binary, TextReportBuilder builder) {
        ModelSchema<?> schema = schemaStore.getSchema(((BinarySpecInternal)binary).getPublicType());
        if (!(schema instanceof StructSchema)) {
            return;
        }
        Map<String, Object> variants = new TreeMap<>();

        }
    }

    private <T> ModelSchema<T> getModelSchema(ModelType<T> managedType, MethodRuleDefinition<?, ?> ruleDefinition) {
        try {
            return schemaStore.getSchema(managedType);
        } catch (InvalidManagedModelElementTypeException e) {
            throw new InvalidModelRuleDeclarationException(ruleDefinition.getDescriptor(), e);
        }
    }

            rawExtensions.put(entry.getKey(), entry.getValue().get());
        }
        return rawExtensions;
    }

    public ExtensionsSchema getSchema() {
        return DefaultExtensionsSchema.create(extensions.values());
    }

    public <T> T configureExtension(String name, Action<? super T> action) {

            finishVisitingMethod(methodVisitor);
            return;
        }
        if (!writable && property.getSchema() instanceof UnmanagedImplStructSchema) {
            UnmanagedImplStructSchema<?> structSchema = (UnmanagedImplStructSchema<?>) property.getSchema();
            if (!structSchema.isAnnotated()) {
                return;
            }

        then:
        result instanceof BrokenResolvedArtifactSet
        result.failure instanceof ArtifactVariantSelectionException

        1 * variantSet.getSchema() >> attributesSchema
        1 * variantSet.getOverriddenAttributes() >> ImmutableAttributes.EMPTY
        2 * attributeMatcher.matches(_, _, _) >> [variant, otherVariant]
        2 * attributeMatcher.isMatching(_, _, _) >> true

                s.append(String.format("Its property '%s %s' is not a valid managed collection%n", propertyType.getName(), propertyName));
                CollectionSchema<?, ?> schema = (CollectionSchema) schemaStore.getSchema(propertyType);
                s.append(String.format("A managed collection can not contain '%s's%n", schema.getElementType()));
                appendManagedCollections(s, 1, constructibleTypes);

                }

                private <T> Object doSet(String name, Object value, ModelProperty<T> property) {
                    ModelSchema<T> propertySchema = property.getSchema();

                    // TODO we are relying on the registration having established these links, we should be checking
                    MutableModelNode propertyNode = modelNode.getLink(name);

                                     NodeInitializerRegistry nodeInitializerRegistry
    ) {
        ModelType<P> propertyType = property.getType();
        ModelSchema<P> propertySchema = schemaStore.getSchema(propertyType);
        ModelType<T> publicType = bindings.getPublicSchema().getType();

        validateProperty(propertySchema, property, nodeInitializerRegistry);

            protected void execute(ModelRuleInvoker<?> invoker, ComponentSpecFactory registry, List<ModelView<?>> inputs) {
                try {
                    ModelSchema<? extends ComponentSpec> schema = schemaStore.getSchema(modelType);
                    TypeBuilderInternal<? extends ComponentSpec> builder = new DefaultTypeBuilder<ComponentSpec>(getAnnotationType(), schema);
                    invoker.invoke(builder);

        AttributeMatcher matcher = schema.withProducer(producer.getSchema());
        ImmutableAttributes componentRequested = attributesFactory.concat(requestAttributes, producer.getOverriddenAttributes());
        final List<ResolvedVariant> variants = ImmutableList.copyOf(producer.getVariants());