if (implementationRegistration == null) {
            return null;
        }
        return new ImplementationInfoImpl<S>(publicType, implementationRegistration, getInternalViews(publicType));
    }

    @Override
    public <S extends PUBLIC> ImplementationInfo getManagedSubtypeImplementationInfo(final ModelType<S> publicType) {
        if (!isManaged(publicType)) {

import org.gradle.platform.base.TypeBuilder;

import java.util.Set;

public interface TypeBuilderInternal<T> extends TypeBuilder<T> {
    Class<?> getDefaultImplementation();

    Set<Class<?>> getInternalViews();

         */
        ModelType<?> getDelegateType();

        /**
         * The internal views for the public type.
         */
        Set<ModelType<?>> getInternalViews();
    }

        }
        internalViews.add(internalView);
        return this;
    }

    @Override
    public Set<Class<?>> getInternalViews() {
        return internalViews;
    }

        }

        return ModelType.of(implementation);
    }

    private void validateInternalViewsAreInterfaces(TypeBuilderInternal<?> builder) {
        for (Class<?> internalView : builder.getInternalViews()) {
            if (!internalView.isInterface()) {
                throw new InvalidModelException(String.format("Internal view %s must be an interface.", internalView.getName()));
            }
        }
    }

        if (implementationInfo == null) {
            return null;
        }
        Set<ModelType<?>> internalViews = implementationInfo.getInternalViews();
        ModelType<?> delegateType = implementationInfo.getDelegateType();
        StructBindings<S> bindings = bindingsStore.getBindings(publicSchema.getType(), internalViews, delegateType);