import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * A type implemented by, or extended by maven plugins or extensions.
 * Maven plugins or extensions may provide implementations of those types which will be used by maven.
 * <p>
 * A type can be marked {@link Consumer} or {@link Provider} but not both. A type is assumed to be

        assertThat(set.contains(TestRunner.class.getName()), is(true));
        assertThat(set.contains("junit.textui.package-info"), is(false));
        assertThat(set.contains(junit.extensions.TestDecorator.class.getName()), is(not(true)));
    }

        if (lookup == null) {
            return customLifecycles != null ? customLifecycles : new HashMap<>();
        }

        // Lifecycles cannot be cached as extensions might add custom lifecycles later in the execution.
        try {
            Map<String, Lifecycle> lifecycles = new HashMap<>(lookup.lookupMap(Lifecycle.class));
            for (org.apache.maven.api.Lifecycle lf : registry) {

import org.apache.maven.execution.MojoExecutionEvent;
import org.apache.maven.plugin.MojoExecutionException;

/**
 * Extension point that allows build extensions observe and possibly veto mojo executions.
 * <p>
 * Unlike {@link org.apache.maven.execution.MojoExecutionListener}, this extension point does not
 * trigger instantiation of the component, hence "weak" class name prefix. Only applies to mojo execution
 * scoped components.

        PomTestWrapper pom = buildPom("build-extension-inheritance/sub");
        assertEquals(3, ((List<?>) pom.getValue("build/extensions")).size());
        assertEquals("b", pom.getValue("build/extensions[1]/artifactId"));
        assertEquals("a", pom.getValue("build/extensions[2]/artifactId"));
        assertEquals("0.2", pom.getValue("build/extensions[2]/version"));

package org.apache.maven.api.spi;

import org.apache.maven.api.annotations.Consumer;
import org.apache.maven.api.annotations.Experimental;

/**
 * Marker interface to indicate services that can be provided by plugins and extensions.
 */
@Experimental
@Consumer

    }

    private static String getKey(Plugin plugin, boolean extension) {
        String version = ArtifactUtils.toSnapshotVersion(plugin.getVersion());
        return (extension ? "extension>" : "plugin>") + plugin.getGroupId() + ":" + plugin.getArtifactId() + ":"
                + version;
    }

 */
public interface ModelBuildingListener {

    /**
     * Notifies the listener that the model has been constructed to the extent where build extensions can be processed.
     *
     * @param event The details about the event.
     */
    default void buildExtensionsAssembled(ModelBuildingEvent event) {}

        renameModule(project);
        wireInArtificialSourceSet(project, extension);
        setStyling(project, extension);
        overrideDokkaVersion(project, extension);
        setMemoryForWorkers(project);
    }

    private static void setMemoryForWorkers(Project project) {
        project.getTasks().withType(DokkatooGenerateTask.class).configureEach(task -> {

package org.apache.maven.api;

import org.apache.maven.api.annotations.Experimental;
import org.apache.maven.api.annotations.Nonnull;

/**
 * Interface that defines some kind of enums that can be extended by Maven plugins or extensions.
 *
 * Implementation must have {@code equals()} and {@code hashCode()} implemented, so implementations of this interface
 * can be used as keys.
 *
 * @since 4.0.0
 */
@Experimental