kmpConfiguration {
    configure {
        jvm {
            target {
                
            }
            sourceSetMain {
                dependencies {
                    // Jvm only dependencies
                }
            }
            sourceSetTest {
                // ...
            }

            // Will automatically set
            // KotlinJvmCompilation.kotlinOptions.jvmTarget
            kotlinJvmTarget = JavaVersion.VERSION_1_8
            
            // If you aren't using android and have elected for `withJava()` 
            // in the `target` block above setting this will automatically
            // configure for you:
            //
            // JavaPluginExtension.sourceCompatibility
            // JavaPluginExtension.targetCompatibility
            compileSourceCompatibility = JavaVersion.VERSION_1_8
            compileTargetCompatibility = JavaVersion.VERSION_1_8
        }

        // Android.
        // Note that only 1 android example below will be utilized b/c
        // you can only have 1 android target in a multiplatform module.

        // The `com.android.application` plugin will be applied automatically 
        // if this target is enabled.
        androidApp {
            // Plugins to be applied if this target is being configured. In other
            // words, these plugins will not be applied in the event KMP_TARGETS
            // is passed via command line and does not contain ANDROID
            //
            // `pluginIds` are available for all targets for selectively applying
            // them based on needs
            pluginIds("org.jetbrains.kotlin.kapt", "androidx.navigation.safeargs")

            target {
                // ..
            }
            android {
                // configure BaseAppModuleExtension
            }

            // See jvm lambda above for explanation, works the same
            kotlinJvmTarget = JavaVersion.VERSION_1_8
            compileSourceCompatibility = JavaVersion.VERSION_1_8
            compileTargetCompatibility = JavaVersion.VERSION_1_8
        }

        // Will automatically apply the `com.android.library` plugin
        // if this target is enabled.
        androidLibrary {
            target {
                publishLibraryVariant("release")
            }
            android {
                // configure LibraryExtension
            }
            
            // Additional sourceSet lambda for androidLibrary and androidApp
            sourceSetTestInstrumented {
                // ...
            }
        }

        // The `*All` shortcuts enable all targets for that platform type.
        //
        // NOTE: If more targets become available in future Kotlin
        // releases, this will automatically add them. If that behavior
        // is undesired, consider not utilizing the `*All` shortcuts.
        iosAll()
        macosAll()
        tvosAll()
        watchosAll()

        options {
            // Will create additional source sets for `iOS`, `tvOS`, and
            // `watchOS` simulator targets to inherit from
            //
            // e.g. iosSimulator{Main/Test}
            useSimulatorSourceSets = true
            
            // Will create additional source sets for `iOS`, `tvOS`, and
            // `watchOS` NON-simulator targets to inherit from
            //
            // e.g. iosNonSimulator{Main/Test}
            useNonSimulatorSourceSets = true
        }

        androidNativeAll()
        linuxAll()

        // All androidNative targets are enabled from above, but say you only
        // need to configure the X64 variant. This will return the same lazy
        // container that was created in `androidNativeAll` above so you can
        // do that.
        androidNativeX64 {
            target {
                // ...
            }
        }
        
        // Add another with a non-default name
        androidNativeX64("androidNativeX64Awesome") {
            // ...
        }

        js()
        wasmJs {
            // ...
        }
        wasmWasi {
            // ..
        }
        
        // The `common` block is for configuring common source sets.
        // This will only be invoked if there is at least 1 target
        // being configured.
        common {
            pluginIds("kotlinx-atomicfu")

            sourceSetMain {
                dependencies {
                    // ...
                }
            }
            sourceSetTest {
                dependencies {
                    implementation(kotlin("test"))
                }
            }
        }

        // This will only be invoked if there is at least 1 target
        // being configured.
        kotlin {
            // Additional configuration via the KotlinMultiplatformExtension
            
            with(sourcSets) {
                // Want to use `findByName` in the event KMP_TARGETS is
                // set and does not include ANDROID or JVM, which means
                // the `jvmAndroid` intermediate source set will not be
                // created.
                val jvmAndroidMain: KotlinSourceSet? = findByName("jvmAndroidMain")?.apply {

                }

                // More intermediate source sets, as depicted above in
                // section `Hierarchical Source Set Structure`
                val nativeMain: KotlinSourceSet? = findByName("nativeMain")?.apply {

                }
                val darwinMain: KotlinSourceSet? = findByName("darwinMain")?.apply {

                }
                val iosMain: KotlinSourceSet? = findByName("iosMain")?.apply {

                }

                // setup additional source set configurations
                val linuxMain = findByName("linuxMain")
                val androidNativeMain = findByName("androidNativeMain")

                if (linuxMain != null || androidNativeMain != null) {
                    val linuxAndroidMain = maybeCreate("linuxAndroidMain").apply {
                        // `linux` and `androidNative` intermediate source sets
                        // inherit from unix, so it will always be available
                        // if either of them are configured. So, we can use
                        // `getByName` safely.
                        dependsOn(getByName("unixMain"))
                    }
                    val linuxAndroidTest = maybeCreate("linuxAndroidTest").apply {
                        dependsOn(getByName("unixTest"))
                    }

                    linuxMain?.apply { dependsOn(linuxAndroidMain) }
                    findByName("linuxTest")?.apply { dependsOn(linuxAndroidTest) }

                    androidNativeMain?.apply { dependsOn(linuxAndroidMain) }
                    findByName("androidNativeTest")?.apply { dependsOn(linuxAndroidTest) }
                }
            }
        }
    }
}