@Target(ElementType.TYPE)
@Inherited
public @interface Execute {
    /**
     * Lifecycle phase to fork. Note that specifying a phase overrides specifying a goal.
     * @return the phase
     */
    @Nonnull
    String phase() default "";

    /**
     * Goal to fork. Note that specifying a phase overrides specifying a goal. The specified <code>goal</code> must be
     * another goal of the same plugin.
     * @return the goal
     */

 * under the License.
 */
package org.apache.maven.eventspy;

import java.util.Map;

/**
 * A core extension to monitor Maven's execution. Typically, such an extension gets loaded into Maven by specifying the
 * property {@code maven.ext.class.path} on the command line. As soon as dependency injection is set up, Maven
 * looks up all implementers of this interface and calls their {@link #init(Context)} method. Note:

     * configurations, as in the case where you want to use the artifact's final name as a parameter. In this case, you
     * want the user to modify <code>&lt;build&gt;&lt;finalName/&gt;&lt;/build&gt;</code> rather than specifying a value
     * for finalName directly in the plugin configuration section. It is also useful to ensure that - for example - a
     * List-typed parameter which expects items of type Artifact doesn't get a List full of Strings.

Quick Build
-------
If you want to bootstrap Maven, you'll need:
- Java 17+
- Maven 3.6.3 or later
- Run Maven, specifying a location into which the completed Maven distro should be installed:
    ```
    mvn -DdistributionTargetDir="$HOME/app/maven/apache-maven-4.0.x-SNAPSHOT" clean package
    ```


[home]: https://maven.apache.org/

     */
    @Nonnull
    String getExtension();

    /**
     * Get the default classifier associated to the dependency type.
     * The default classifier can be overridden when specifying
     * the {@link Dependency#getClassifier()}.
     *
     * @return the default classifier, or {@code null}.
     */
    @Nullable
    String getClassifier();

    /**

        boolean matched = false;
        for (Iterator<String> i = patterns.iterator(); i.hasNext() & !matched; ) {
            // TODO what about wildcards? Just specifying groups? versions?
            if (id.equals(i.next())) {
                matched = true;
            }
        }
        return matched;
    }

    public List<String> getPatterns() {

            this case, you want the user to modify {@code <build><finalName/></build>} rather
            than specifying a value for finalName directly in the plugin configuration section. It is also useful to
            ensure that - for example - a List-typed parameter which expects items of type Artifact doesn't get a List

            might come in handy for anyone working from a notebook or other
            mobile platform, to enable easy switching of entire proxy
            configurations by simply specifying the profile id, again either from
            the command line or from the defaults section below.
          </description>
          <association>
            <type>Proxy</type>

      ]]></description>
      <fields>
        <field>
          <name>activeByDefault</name>
          <version>1.0.0</version>
          <type>boolean</type>
          <description>Flag specifying whether this profile is active as a default.</description>
        </field>
        <field>
          <name>jdk</name>
          <version>1.0.0</version>
          <type>String</type>

          <description><![CDATA[
            For a plugin project (packaging is {@code maven-plugin}), the minimum version of
            Maven required to use the resulting plugin.<br>
            In Maven 2, this was also specifying the minimum version of Maven required to build a
            project, but this usage is <b>deprecated</b> in Maven 3 and not checked any more: use