/**
 * Declares a custom {@link org.gradle.platform.base.ComponentSpec} type.
 *
 * The following example demonstrates how to register a custom component type using a plugin with a
 * {@link ComponentType} annotation.
 * Furthermore the plugin creates an instance of SampleComponent named 'sampleComponent'.
 *
 * <pre class='autoTested'>
 * interface SampleComponent extends ComponentSpec {}

import java.util.List;

public enum ComponentType {
    // These are in display order
    APPLICATION("Application", "app", "list", "utilities"),
    LIBRARY("Library", "lib"),
    GRADLE_PLUGIN("Gradle plugin", "plugin"),
    BASIC("Basic (build structure only)");

    private final String displayName;
    private final List<String> defaultProjectNames;

    ComponentType(String displayName, String... defaultProjectNames) {

        @ComponentType
        static void extendsType(TypeBuilder<? extends BinarySpec> builder) {
        }

        @ComponentType
        static void superType(TypeBuilder<? super BinarySpec> builder) {
        }

        @ComponentType
        static void notBinarySpec(TypeBuilder<NotBinarySpec> builder) {
        }

        @ComponentType

    public ComponentTypeRegistration maybeRegisterComponentType(Class<? extends Component> componentType) {
        ComponentTypeRegistration registration = componentRegistrations.get(componentType);
        if (registration == null) {
            registration = new DefaultComponentTypeRegistration(componentType);
            componentRegistrations.put(componentType, registration);
        }
        return registration;
    }

    @Override

        private final ModelType<C> componentType;
        private final ModelType<S> binaryType;

        public ExtractedComponentBinariesRule(ModelType<C> componentType, ModelType<S> binaryType, MethodRuleDefinition<?, ?> ruleDefinition) {
            super(ruleDefinition);
            this.componentType = componentType;
            this.binaryType = binaryType;
        }

        @Override

    }

    static class Rules {

        @ComponentType
        String returnValue(TypeBuilder<CustomLanguageSourceSet> languageBuilder) {
            return null
        }

        @ComponentType
        void noParams() {
        }

        @ComponentType
        void wrongSubject(LanguageSourceSet sourcet) {
        }

        @ComponentType
        void rawLanguageTypeBuilder(TypeBuilder builder) {

     * Returns the component types, in display order.
     */
    public List<ComponentType> getComponentTypes() {
        return Arrays.asList(ComponentType.values());
    }

    /**
     * Returns the default component type to use for interactive initialization.
     */
    public ComponentType getDefaultComponentType() {
        return ComponentType.APPLICATION;
    }

    // This should turn into a set of converters at some point

// end::text-tasks-generation[]
    @ComponentType
    void registerComponent(TypeBuilder<DocumentationComponent> builder) {}
// end::component-registration[]

// tag::binary-registration[]
    @ComponentType
    void registerBinary(TypeBuilder<DocumentationBinary> builder) {}
// end::binary-registration[]

// tag::text-lang-registration[]
    @ComponentType
    void registerText(TypeBuilder<TextSourceSet> builder) {}

import org.gradle.platform.base.BinaryTasks
import org.gradle.platform.base.ComponentType
import org.gradle.platform.base.TypeBuilder
import sample.documentation.DocumentationBinary

// tag::markdown-lang-registration[]
// tag::markdown-tasks-generation[]
class MarkdownPlugin extends RuleSource {
// end::markdown-tasks-generation[]
    @ComponentType
    void registerMarkdownLanguage(TypeBuilder<MarkdownSourceSet> builder) {}

This guide demonstrates how to create a ${language.raw} ${componentType.raw} with Gradle using `gradle init`.
You can follow the guide step-by-step to create a new project from scratch or download the complete sample project using the links above.

${configurationCacheCompatibility.raw}

== What you’ll build

You'll generate a ${language.raw} ${componentType.raw} that follows Gradle's conventions.

== What you’ll need