private DefaultExtensionsSchema(Iterable<ExtensionSchema> extensionSchemas) {
        this.extensionSchemas = extensionSchemas;
    }

    @Override
    public Iterator<ExtensionSchema> iterator() {
        return extensionSchemas.iterator();
    }

    @Override
    public Iterable<ExtensionSchema> getElements() {
        return this;
    }

 * @since 4.5
 */
public interface ExtensionsSchema extends NamedDomainObjectCollectionSchema, Iterable<ExtensionsSchema.ExtensionSchema> {

    /**
     * {@inheritDoc}
     */
    @Override
    Iterable<ExtensionSchema> getElements();

    /**
     * Schema of an extension.
     *
     * @since 4.5
     */
    interface ExtensionSchema extends NamedDomainObjectCollectionSchema.NamedDomainObjectSchema {

    internal
    open class KotlinJvmOptionsBase : KotlinJvmOptions

    interface KotlinJvmOptions

    private
    fun <T> extensionSchema(name: String, publicType: TypeOf<T>): ExtensionsSchema.ExtensionSchema = mock {
        on { getName() } doReturn name
        on { getPublicType() } doReturn publicType
    }

            val extensionsMock = run {
                val myExtensionMock = mock<MyExtension>()
                val extensionsSchemaMock = mock<ExtensionsSchema> {
                    on { elements }.thenReturn(listOf<ExtensionSchema>(object : ExtensionSchema {
                        override fun getName(): String = "myExtension"
                        override fun getPublicType(): TypeOf<*> = TypeOf.typeOf(MyExtension::class.java)

    }

    private static class ExtensionHolder<T> implements ExtensionsSchema.ExtensionSchema {
        private final String name;
        private final TypeOf<T> publicType;
        protected final T extension;

        private ExtensionHolder(String name, TypeOf<T> publicType, T extension) {

    def 'source set extension exposes its public type'() {
        when:
        project.pluginManager.apply(AntlrPlugin)

        then:
        def main = project.sourceSets.main
        main.extensions.extensionsSchema.find { it.name == 'antlr' }.publicType == typeOf(AntlrSourceDirectorySet)
    }

    fun generateVersionCatalogAccessors(
        rootProject: Project,
        buildSrcClassLoaderScope: ClassLoaderScope,
        classLoaderHash: HashCode,
    ): AccessorsClassPath =
        rootProject.extensions.extensionsSchema
            .filter { catalogExtensionBaseType.isAssignableFrom(it.publicType) }
            .takeIf { it.isNotEmpty() }
            ?.let { versionCatalogExtensionSchemas ->

}


private
fun getExtensionInfo(target: ExtensionAware): List<ExtensionInfo> {
    val annotationChecker = CachedHierarchyAnnotationChecker(Restricted::class)
    return target.extensions.extensionsSchema.elements.mapNotNull {
        val type = it.publicType.concreteClass.kotlin
        if (annotationChecker.isAnnotatedMaybeInSupertypes(type))

        assert convention.create("foo", FooExtension).class != FooExtension
        assert publicTypeOf("foo") == typeOf(FooExtension)
    }

    private TypeOf<?> publicTypeOf(String extension) {
        convention.extensionsSchema.find { it.name == extension }.publicType
    }

    interface PublicExtensionType {
    }

    static class ExtensionWithPublicType implements HasPublicType {
        @Override

        container.add "cat", new Thing("gizmo")
        container.add "meo", container.instanceGenerator.newInstance(Thing, "w")

        def schemaMap = container.extensionsSchema.collectEntries { [it.name, it.publicType] }
        expect:
        schemaMap == [ext: typeOf(ExtraPropertiesExtension),
                      foo: typeOf(Parent),
                      bar: typeOf(Capability),