public static ExtensionsSchema create(Iterable<? extends ExtensionSchema> schemas) {
        return new DefaultExtensionsSchema(Cast.<Iterable<ExtensionSchema>>uncheckedCast(schemas));
    }

    private final Iterable<ExtensionSchema> extensionSchemas;

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

    @Override

 */
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 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) {