* annotation.  If a {@code META-INF/maven/lifecycle.xml} file is packaged
 * in the plugin, Maven will provide a default implementation that will parse
 * the file and return the contained lifecycle definitions.
 *
 * @since 4.0.0
 */
@Experimental
@Consumer
public interface LifecycleProvider {

    List<Lifecycle> getLifecycles();

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

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

/**
 * Specifies that the mojo should be run after the specific phase.
 *
 * @since 4.0.0
 */
@Experimental
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
public @interface After {

    /**
     * Type of pointer.

     * @param scope scope for which the graph should be resolved
     *
     * @return resulting "clean" graph for the specified scope
     *
     * @since 3.0
     */
    MetadataGraph resolveConflicts(MetadataGraph graph, ArtifactScopeEnum scope)
            throws GraphConflictResolutionException;

  /**
   * Asserts that a prior call that had caused this thread to block or wait has since returned
   * normally.
   */
  public void assertPriorCallReturns(@Nullable String methodName) throws Exception {
    assertEquals(null, getResponse(methodName).getResult());
  }

  /**
   * Asserts that a prior call that had caused this thread to block or wait has since returned the
   * expected boolean value.
   */

				if br, ok := p.readers[i].(io.Closer); ok {
					br.Close()
				}
				p.readers[i] = nil

				// Since ReadAt returned error, trigger another read.
				readTriggerCh <- true
				return
			}
			newBufLK.Lock()
			newBuf[bufIdx] = p.buf[bufIdx][:n]
			newBufLK.Unlock()
			// Since ReadAt returned success, there is no need to trigger another read.
			readTriggerCh <- false
		}(readerIndex)
		readerIndex++

import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * A {@code TearDownStack} contains a stack of {@link TearDown} instances.
 *
 * <p>This class is thread-safe.
 *
 * @author Kevin Bourrillion
 * @since 10.0
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public class TearDownStack implements TearDownAccepter {
  private static final Logger logger = Logger.getLogger(TearDownStack.class.getName());

 *     if any key is acceptable
 * @param <V> the most general type of values this listener can listen for; for example {@code
 *     Object} if any key is acceptable
 * @author Charles Fry
 * @since 10.0
 */
@GwtCompatible
@FunctionalInterface
@ElementTypesAreNonnullByDefault
public interface RemovalListener<K, V> {
  /**
   * Notifies the listener that a removal occurred at some point in the past.
   *

 * error. If your needs are more complex than {@code SettableFuture} supports, use {@link
 * AbstractFuture}, which offers an extensible version of the API.
 *
 * @author Sven Mawson
 * @since 9.0 (in 1.0 as {@code ValueFuture})
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public final class SettableFuture<V extends @Nullable Object>
    extends AbstractFuture.TrustedFuture<V> {
  /**

/**
 * Class to wrap request parameters to ModelProblemCollector.addProblem
 *
 * @deprecated use {@link org.apache.maven.api.services.ModelBuilder} instead
 */
@Deprecated(since = "4.0.0")
public final class ModelProblemCollectorRequest {

    private final ModelProblem.Severity severity;
    private final ModelProblem.Version version;
    private Exception exception;
    private String message;

/**
 * Provides information about artifacts (identified by groupId:artifactId string key) and classpath elements exported by
 * Maven core itself and loaded Maven core extensions.
 *
 * @since 3.3.0
 */
public class CoreExports {
    private final Set<String> artifacts;

    private final Map<String, ClassLoader> packages;

    public CoreExports(CoreExtensionEntry entry) {