diff --git a/pom.xml b/pom.xml
index 4926b6c..24ed3b1 100644
--- a/pom.xml
+++ b/pom.xml
@@ -25,7 +25,7 @@
   <parent>
     <artifactId>maven-plugins</artifactId>
     <groupId>org.apache.maven.plugins</groupId>
-    <version>34</version>
+    <version>35-SNAPSHOT</version>
     <relativePath />
   </parent>
 
@@ -95,7 +95,7 @@
     <invoker.install.skip>${invoker.skip}</invoker.install.skip>
     <invoker.it.skip>${invoker.skip}</invoker.it.skip>
     <invoker.cloneClean>true</invoker.cloneClean>
-    <mavenPluginToolsVersion>3.6.0</mavenPluginToolsVersion><!-- required for Java 11 generated Mojo -->
+    <mavenPluginToolsVersion>3.6.5-SNAPSHOT</mavenPluginToolsVersion><!-- required for Java 11 generated Mojo -->
     <checkstyle.violation.ignore>ParameterNumber,MethodLength</checkstyle.violation.ignore>
     <project.build.outputTimestamp>2020-12-30T10:47:20Z</project.build.outputTimestamp>
   </properties>
diff --git a/src/main/java/org/apache/maven/plugins/ear/AbstractEarModule.java b/src/main/java/org/apache/maven/plugins/ear/AbstractEarModule.java
index 05026b0..7573d0e 100644
--- a/src/main/java/org/apache/maven/plugins/ear/AbstractEarModule.java
+++ b/src/main/java/org/apache/maven/plugins/ear/AbstractEarModule.java
@@ -22,7 +22,6 @@
 import java.util.Set;
 
 import org.apache.maven.artifact.Artifact;
-import org.apache.maven.plugin.MojoFailureException;
 import org.apache.maven.plugins.ear.util.ArtifactRepository;
 import org.apache.maven.shared.mapping.MappingUtils;
 import org.codehaus.plexus.interpolation.InterpolationException;
diff --git a/src/main/java/org/apache/maven/plugins/ear/AbstractEarMojo.java b/src/main/java/org/apache/maven/plugins/ear/AbstractEarMojo.java
index d3caef5..ea5ffff 100644
--- a/src/main/java/org/apache/maven/plugins/ear/AbstractEarMojo.java
+++ b/src/main/java/org/apache/maven/plugins/ear/AbstractEarMojo.java
@@ -28,7 +28,6 @@
 import org.apache.maven.artifact.resolver.filter.ScopeArtifactFilter;
 import org.apache.maven.plugin.AbstractMojo;
 import org.apache.maven.plugin.MojoExecutionException;
-import org.apache.maven.plugin.MojoFailureException;
 import org.apache.maven.plugins.annotations.Parameter;
 import org.apache.maven.plugins.ear.util.ArtifactTypeMappingService;
 import org.apache.maven.plugins.ear.util.JavaEEVersion;
@@ -174,7 +173,7 @@
 
     /** {@inheritDoc} */
     public void execute()
-        throws MojoExecutionException, MojoFailureException
+        throws MojoExecutionException
     {
         if ( fileNameMapping != null )
         {
diff --git a/src/main/java/org/apache/maven/plugins/ear/EarModule.java b/src/main/java/org/apache/maven/plugins/ear/EarModule.java
index 80b4f56..d58d442 100644
--- a/src/main/java/org/apache/maven/plugins/ear/EarModule.java
+++ b/src/main/java/org/apache/maven/plugins/ear/EarModule.java
@@ -20,7 +20,6 @@
  */
 
 import org.apache.maven.artifact.Artifact;
-import org.apache.maven.plugin.MojoFailureException;
 import org.codehaus.plexus.util.xml.XMLWriter;
 
 import java.util.Set;
diff --git a/src/main/java/org/apache/maven/plugins/ear/EarMojo.java b/src/main/java/org/apache/maven/plugins/ear/EarMojo.java
index 8ce8277..3911166 100644
--- a/src/main/java/org/apache/maven/plugins/ear/EarMojo.java
+++ b/src/main/java/org/apache/maven/plugins/ear/EarMojo.java
@@ -46,7 +46,6 @@
 import org.apache.maven.artifact.DependencyResolutionRequiredException;
 import org.apache.maven.execution.MavenSession;
 import org.apache.maven.plugin.MojoExecutionException;
-import org.apache.maven.plugin.MojoFailureException;
 import org.apache.maven.plugins.annotations.Component;
 import org.apache.maven.plugins.annotations.LifecyclePhase;
 import org.apache.maven.plugins.annotations.Mojo;
@@ -313,7 +312,7 @@
 
     /** {@inheritDoc} */
     public void execute()
-        throws MojoExecutionException, MojoFailureException
+        throws MojoExecutionException
     {
         // Initializes ear modules
         super.execute();
@@ -435,7 +434,7 @@
     private void copyModules( final JavaEEVersion javaEEVersion, 
                               List<String> unpackTypesList, 
                               Collection<String> outdatedResources )
-        throws MojoExecutionException, MojoFailureException
+        throws MojoExecutionException
     {
         final Path workingDir = getWorkDirectory().toPath();
 
diff --git a/src/main/java/org/apache/maven/plugins/ear/GenerateApplicationXmlMojo.java b/src/main/java/org/apache/maven/plugins/ear/GenerateApplicationXmlMojo.java
index 8ec99a0..64c6d0b 100644
--- a/src/main/java/org/apache/maven/plugins/ear/GenerateApplicationXmlMojo.java
+++ b/src/main/java/org/apache/maven/plugins/ear/GenerateApplicationXmlMojo.java
@@ -26,7 +26,6 @@
 import java.util.List;
 
 import org.apache.maven.plugin.MojoExecutionException;
-import org.apache.maven.plugin.MojoFailureException;
 import org.apache.maven.plugins.annotations.LifecyclePhase;
 import org.apache.maven.plugins.annotations.Mojo;
 import org.apache.maven.plugins.annotations.Parameter;
@@ -161,7 +160,7 @@
      * {@inheritDoc}
      */
     public void execute()
-        throws MojoExecutionException, MojoFailureException
+        throws MojoExecutionException
     {
         // Initializes ear modules
         super.execute();
diff --git a/src/main/java/org/apache/maven/plugins/ear/JarModule.java b/src/main/java/org/apache/maven/plugins/ear/JarModule.java
index 0a925c8..0cb7b80 100644
--- a/src/main/java/org/apache/maven/plugins/ear/JarModule.java
+++ b/src/main/java/org/apache/maven/plugins/ear/JarModule.java
@@ -20,7 +20,6 @@
  */
 
 import org.apache.maven.artifact.Artifact;
-import org.apache.maven.plugin.MojoFailureException;
 import org.codehaus.plexus.util.xml.XMLWriter;
 
 import java.util.Set;
diff --git a/src/main/java/org/apache/maven/plugins/ear/WebModule.java b/src/main/java/org/apache/maven/plugins/ear/WebModule.java
index 9a0796b..160af73 100644
--- a/src/main/java/org/apache/maven/plugins/ear/WebModule.java
+++ b/src/main/java/org/apache/maven/plugins/ear/WebModule.java
@@ -20,7 +20,6 @@
  */
 
 import org.apache.maven.artifact.Artifact;
-import org.apache.maven.plugin.MojoFailureException;
 import org.codehaus.plexus.util.xml.XMLWriter;
 
 import java.util.Set;
