* compatible type of `this`.
 *
 * @param T the plugin type.
 * @see [PluginAware.apply]
 */
inline fun <reified T : Plugin<Settings>> Settings.apply() =
    (this as PluginAware).apply<T>()


/**
 * Locates a property on [Settings].
 */
operator fun Settings.provideDelegate(any: Any?, property: KProperty<*>): PropertyDelegate =

            }
        """
        file("included/src/main/kotlin/settings-plugin.settings.gradle.kts") << """
            extensions.create<SettingsExtension>("mySettingsExtension")
        """
        withSettings("""
            pluginManagement {
                includeBuild("included")
            }
            plugins {
                id("settings-plugin")
            }

            mySettingsExtension {

    }

    @Override
    public void applyFromProperty(Map<String, String> properties, T settings) {
        OptionValue<String> propertyValue = getFromProperties(properties);
        String value = propertyValue.getValue();
        if (value != null) {
            applyTo(value, settings, propertyValue.getOrigin());
        }
    }

    @Override
    public void configure(CommandLineParser parser) {

    attributes:
      label: "What did you expect to see?"
    validations:
      required: true
  - type: textarea
    id: editor-and-settings
    attributes:
      label: "Editor and settings"
      description: "Your editor and any settings you have configured (for example, your VSCode settings.json file)"
    validations:
      required: false
  - type: textarea
    id: logs
    attributes:
      label: "Logs"

        target.ensureProjectsLoaded()

        val schemaBuilder = GradleProcessInterpretationSchemaBuilder(softwareTypeRegistry)

        val settings = target.mutableModel.settings
        val settingsContext = LoadedSettingsScriptContext(settings, settings.classLoaderScope, settings.settingsScript)

        val settingsSequence = schemaBuilder.getEvaluationSchemaForScript(settingsContext)
            .sequenceOrError().analysisOnly()

                require(scriptContext is LoadedSettingsScriptContext) { "A ${LoadedSettingsScriptContext::class.simpleName} is needed to build the settings schema" }
                InterpretationSequenceAvailable(
                    settingsInterpretationSequence(scriptContext.settings, scriptContext.targetScope, scriptContext.scriptSource, softwareTypeRegistry)
                )
            }

            println("project_property_available in included root:           ${project.findProperty('project_property_available') ?: 'false'} ")
        '''
        file('includedBuild/settings.gradle') << '''
            println("system_property_available in included settings.gradle: ${System.getProperty('system_property_available', 'false')} ")
        '''
        file('includedBuild/buildSrc/build.gradle') << '''

 */

package org.gradle.plugin.software.internal;

import com.google.common.collect.ImmutableList;
import org.gradle.api.Plugin;
import org.gradle.api.Project;
import org.gradle.api.initialization.Settings;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

/**

                includeBuild 'build-logic'
            }
            plugins {
                id 'my-settings-plugin'
            }
        '''

        when:
        succeeds 'help'

        then:
        outputContains "before:plugin 'my-settings-plugin'"
        outputContains "after:plugin 'my-settings-plugin'"
    }

    def 'lifecycle actions can be registered in the context of the Gradle runtime'() {

        file('module-a').mkdir()
        file('module-b').mkdir()
        file('module-c').mkdir()
        file('module-a/settings.gradle') << """
            includeBuild('../module-b')
        """
        file('module-b/settings.gradle') << """
            includeBuild('../module-c')
        """
        file('module-c/settings.gradle') << """
            includeBuild('../module-a')
        """
    }