import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

/**
 * Can be used on a static method to provide a bean.
 */
@Target(METHOD)
@Retention(RUNTIME)
@Documented

            }
        };
    }

    @Provides
    static RepositorySystemSupplier newRepositorySystemSupplier() {
        return new RepositorySystemSupplier();
    }

    @Provides
    static RepositorySystem newRepositorySystem(RepositorySystemSupplier repositorySystemSupplier) {
        return repositorySystemSupplier.getRepositorySystem();
    }

    @Provides

import org.apache.maven.api.di.Provides;
import org.apache.maven.api.di.Singleton;
import org.eclipse.aether.util.version.GenericVersionScheme;
import org.eclipse.aether.version.VersionScheme;

/**
 * Default version scheme provider: provides singleton {@link GenericVersionScheme} instance.
 */
@Singleton
@Named
public final class DefaultVersionSchemeProvider {

    @Provides
    static VersionScheme getVersionScheme() {

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

/**
 * Transporter provider is a service that provides somewhat trivial transport capabilities backed by Maven internals.
 * This API does not try to cover all the requirements out there, just the basic ones, and is intentionally simple.

import org.apache.maven.project.MavenProject;
import org.eclipse.aether.RepositorySystemSession;
import org.eclipse.aether.graph.DependencyFilter;
import org.eclipse.aether.repository.RemoteRepository;

/**
 * Provides basic services to manage Maven plugins and their mojos. This component is kept general in its design such
 * that the plugins/mojos can be used in arbitrary contexts. In particular, the mojos can be used for ordinary build

            super(providers, Language.NONE, Language.JAVA_FAMILY);
        }
    }

    static class DefaultExtensibleEnumRegistry<T extends ExtensibleEnum, P extends ExtensibleEnumProvider<T>>
            implements ExtensibleEnumRegistry<T> {

        private final Map<String, T> values;

        DefaultExtensibleEnumRegistry(List<P> providers, T... builtinValues) {

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.plugin;

import org.apache.maven.lifecycle.LifecycleExecutionException;

/**
 * Provides context for mojo execution. Invocation of {@link #run(MojoExecution)} will result in actual execution
 */
public interface MojoExecutionRunner {
    /**
     * Runs mojo execution
     *

    private final LegacyArtifactHandlerManager manager;

    @Inject
    public DefaultTypeRegistry(
            List<TypeProvider> providers, LanguageRegistry languageRegistry, LegacyArtifactHandlerManager manager) {
        this.types = nonNull(providers, "providers").stream()
                .flatMap(p -> p.provides().stream())
                .collect(Collectors.toMap(Type::id, identity()));

 * elements' text contents must not be HTML escaped</a>. As a result, it is impossible to escape an
 * HTML document correctly without domain-specific knowledge beyond what {@code HtmlEscapers}
 * provides. We strongly encourage the use of HTML templating systems.
 *
 * @author Sven Mawson
 * @author David Beaumont
 * @since 15.0
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public final class HtmlEscapers {

 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.execution;

/**
 * Provides a skeleton implementation for execution listeners. The methods of this class are empty.
 *
 */
public class AbstractExecutionListener implements ExecutionListener {