private
    val existingSource = """

        class ExistingClass {

            class ExistingNestedClass
        }

        val valTurnedIntoVar: String
            get() = ""

        typealias ExistingTypeAlias = String
    """

    private
    val internalSource = """

        $internalMembers

        class ExistingClass() {

            internal constructor(bar: String) : this()

        is KotlinClassMetadata.SyntheticClass -> false
        is KotlinClassMetadata.Unknown -> false
        else -> throw IllegalStateException("Unsupported Kotlin metadata type '${this::class}'")
    }


private
typealias FlagsPredicate = (Flags) -> Boolean


private
fun hasClassFlags(kmClassSupplier: Supplier<KmClass>, memberType: MemberType, jvmSignature: String, predicate: FlagsPredicate): Boolean {
    val kmClass = kmClassSupplier.get()

                }
            }
            writer.println("</body></html>")
        }
    }

    private
    fun String.escape() = replace("<", "&lt;").replace(">", "&gt;")
}

            platformClassLoader,
            classPath,
            classPathDependencies,
        ),
        parameterNamesSupplier
    )


private
typealias ApiTypeSupplier = () -> ApiType


typealias ParameterNamesSupplier = (String) -> List<String>?


private
fun ParameterNamesSupplier.parameterNamesFor(typeName: String, functionName: String, parameterTypeNames: List<String>): List<String>? =

import japicmp.model.JApiClass
import japicmp.model.JApiCompatibility
import japicmp.model.JApiConstructor
import japicmp.model.JApiField
import japicmp.model.JApiMethod


private
typealias PredicateVisitor = GenericVisitorAdapter<Boolean, Unit?>


internal
object JavaSourceQueries {

    fun isOverrideMethod(method: JApiMethod): JavaSourceQuery<Boolean> =
        JavaSourceQuery(
            false,

import java.util.zip.ZipOutputStream
import javax.inject.Inject
import kotlin.collections.component1
import kotlin.collections.component2
import kotlin.collections.set
import kotlin.streams.toList


typealias LeftoverFiles = Map<File, List<String>>


abstract class TestFilesCleanupService @Inject constructor(
    private val fileSystemOperations: FileSystemOperations

        is JApiMethod -> newMethod.get()
        else -> throw IllegalStateException("Unsupported japicmp member type '${this::class}'")
    }


/**
 * [CtClass] or [CtMember].
 */
private
typealias CtClassOrCtMember = Any


private
val CtClassOrCtMember.declaringClass: CtClass
    get() = when (this) {
        is CtClass -> declaringClass ?: this
        is CtMember -> declaringClass

 */

package org.gradle.kotlin.dsl.internal.sharedruntime.support

import java.io.Closeable
import java.io.File
import java.util.jar.JarFile


private
typealias ClassBytesSupplier = () -> ByteArray


private
typealias ClassBytesIndex = (String) -> ClassBytesSupplier?


/**
 * Repository providing access to class bytes by Kotlin source names.
 *

        return versions
    }


    private
    fun String.escape() = replace("<", "&lt;").replace(">", "&gt;")
}


private
typealias Version = String


private
typealias IncubatingDescription = String


private
typealias VersionsToIncubating = Map<Version, MutableSet<IncubatingDescription>>


private
interface VersionsToIncubatingCollector {

    listOf("7.0", "7.3"), // 7.0 <=version < 7.3
    listOf("7.3", "7.6"), // 7.3 <=version < 7.6
    listOf("7.6", "8.3"), // 7.6 <=version < 8.3
    listOf("8.3", "99.0") // 8.3 <=version < 99.0
)

typealias BuildProjectToSubprojectTestClassTimes = Map<String, Map<String, List<TestClassTime>>>

interface FunctionalTestBucketProvider {
    fun createFunctionalTestsFor(stage: Stage, testCoverage: TestCoverage): List<FunctionalTest>
}