entry<TaskContainer, Delete>("delete")
                        ),
                        configurations = listOf(
                            ConfigurationEntry("api"),
                            ConfigurationEntry("compile", listOf("api", "implementation"))
                        ),
                        containerElements = listOf(
                            entry<SourceSetContainer, SourceSet>("main")

        ProjectSchemaEntry(f(target), name, f(type))
}


data class ConfigurationEntry<T>(
    val target: T,
    val dependencyDeclarationAlternatives: List<String> = listOf()
) : Serializable {

    fun hasDeclarationDeprecations() = dependencyDeclarationAlternatives.isNotEmpty()

    fun <U> map(f: (T) -> U) =
        ConfigurationEntry(f(target), dependencyDeclarationAlternatives)

                containerElements = listOf(),
                tasks = listOf(),
                configurations = listOf(
                    ConfigurationEntry("api"),
                    ConfigurationEntry("implementation"),
                    ConfigurationEntry("compile", listOf("api", "implementation"))
                )
            )

        val srcDir = newFolder("src")
        val binDir = newFolder("bin")

import org.gradle.internal.Factory
import org.gradle.internal.deprecation.DeprecatableConfiguration
import org.gradle.internal.deprecation.DeprecationLogger
import org.gradle.kotlin.dsl.accessors.ConfigurationEntry
import org.gradle.kotlin.dsl.accessors.ProjectSchema
import org.gradle.kotlin.dsl.accessors.ProjectSchemaEntry
import org.gradle.kotlin.dsl.accessors.ProjectSchemaProvider
import org.gradle.kotlin.dsl.accessors.SchemaType

) = TypedProjectSchema(
    extensions = extensions,
    conventions = conventions,
    tasks = tasks,
    containerElements = containerElements,
    configurations = configurations.map { ConfigurationEntry(it) }
)


internal
typealias TypedProjectSchemaEntryList = List<ProjectSchemaEntry<SchemaType>>


internal
fun ClassLoader.schemaTypeFor(typeString: String): SchemaType =

fun importsRequiredBy(vararg candidateTypes: TypeAccessibility): List<String> =
    importsRequiredBy(candidateTypes.asList())


internal
sealed class Accessor {

    data class ForConfiguration(val config: ConfigurationEntry<AccessorNameSpec>) : Accessor()

    data class ForExtension(val spec: TypedAccessorSpec) : Accessor()

    data class ForConvention(val spec: TypedAccessorSpec) : Accessor()

    "Accessors${hashOf(accessorSpec)}Kt"


internal
fun accessorDescriptorFor(receiverType: InternalName, returnType: InternalName) =
    "(L$receiverType;)L$returnType;"


private
fun ConfigurationEntry<AccessorNameSpec>.getDeclarationDeprecationMessage() = if (hasDeclarationDeprecations()) {
    val deprecationType = ConfigurationDeprecationType.DEPENDENCY_DECLARATION