import org.gradle.buildinit.plugins.internal.modifiers.BuildInitDsl;
import org.gradle.buildinit.plugins.internal.modifiers.BuildInitTestFramework;
import org.gradle.buildinit.plugins.internal.modifiers.ComponentType;
import org.gradle.buildinit.plugins.internal.modifiers.Language;
import org.gradle.buildinit.plugins.internal.modifiers.ModularizationOption;

import java.util.ArrayList;
import java.util.Arrays;

            <xs:element type="sha512Type" name="sha512"/>
        </xs:choice>
        <xs:attribute type="xs:string" name="name" use="required"/>
    </xs:complexType>
    <xs:complexType name="componentType">
        <xs:sequence>
            <xs:element type="artifactType" name="artifact" maxOccurs="unbounded" minOccurs="0"/>
        </xs:sequence>
        <xs:attribute type="xs:string" name="group" use="required"/>

 * class DefaultSampleBinary extends BaseBinarySpec implements SampleBinary {}
 *
 * apply plugin: MyCustomBinariesPlugin
 *
 * class MyCustomBinariesPlugin extends RuleSource {
 *     {@literal @}ComponentType
 *     void register(TypeBuilder<SampleBinary> builder) {
 *         builder.defaultImplementation(DefaultSampleBinary)
 *     }
 *
 *     {@literal @}ComponentBinaries

However, the general concepts apply for any software you are building with Gradle.
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.

== What you’ll build

You'll build a ${language.raw} ${componentType.raw} that consists of an _application_ and multiple _library_ projects.

 *      {@literal @}TaskAction void build() {
 *          //building the binary
 *      }
 * }
 *
 * class MyCustomBinariesPlugin extends RuleSource {
 *     {@literal @}ComponentType
 *     void register(TypeBuilder<SampleBinary> builder) {}
 *
 *     {@literal @}BinaryTasks
 *     void createBinaryTasks(ModelMap<Task> tasks, SampleBinary binary) {

import org.gradle.model.internal.type.ModelType;
import org.gradle.platform.base.BinarySpec;
import org.gradle.platform.base.ComponentSpec;
import org.gradle.platform.base.ComponentType;
import org.gradle.platform.base.InvalidModelException;
import org.gradle.platform.base.SourceComponentSpec;
import org.gradle.platform.base.TypeBuilder;
import org.gradle.platform.base.VariantComponentSpec;

        interface UnmanagedComponent extends ComponentSpec {}
        class DefaultUnmanagedComponent extends BaseComponentSpec implements UnmanagedComponent {}
        class MyRules extends RuleSource {
            @ComponentType
            public void register(TypeBuilder<UnmanagedComponent> builder) {
                builder.defaultImplementation(DefaultUnmanagedComponent)
            }
        }
        apply plugin: MyRules

        if (to instanceof WildcardType) {
          return; // Okay to say A[] is <?>
        }
        Type componentType = Types.getComponentType(to);
        checkArgument(componentType != null, "%s is not an array type.", to);
        populateTypeMappings(mappings, fromArrayType.getGenericComponentType(), componentType);
      }

      @Override
      void visitClass(Class<?> fromClass) {

        buildFile << """
        class MySamplePlugin implements Plugin<Project> {
            void apply(final Project project) {}

            static class Rules extends RuleSource {
                @ComponentType
                void register(TypeBuilder<SampleBinary> builder) {
                }

                @Mutate
                void createSampleBinary(BinaryContainer binaries) {

    }

    private static SourceSetInfo validate(SourceSetInfo info) {
        if (info == null) {
            throw new ModelInstantiationException("Direct instantiation of a BaseLanguageSourceSet is not permitted. Use a @ComponentType rule instead.");
        }
        return info;
    }

    private static class SourceSetInfo {
        private final ComponentSpecIdentifier identifier;