diff --git a/annotationprocessor/src/main/java/io/toolisticon/annotationprocessortoolkit/tools/fluentfilter/FluentElementFilter.java b/annotationprocessor/src/main/java/io/toolisticon/annotationprocessortoolkit/tools/fluentfilter/FluentElementFilter.java
index a86ec247..a221aaef 100644
--- a/annotationprocessor/src/main/java/io/toolisticon/annotationprocessortoolkit/tools/fluentfilter/FluentElementFilter.java
+++ b/annotationprocessor/src/main/java/io/toolisticon/annotationprocessortoolkit/tools/fluentfilter/FluentElementFilter.java
@@ -160,7 +160,7 @@ public FluentElementFilter<ELEMENT> filterByAllOf(CHARACTERISTIC... criteria) {
      * @param coreMatcher the implicit core matcher to use
      * @return the FluentElementFilter instance
      */
-    public <TARGET_ELEMENT extends Element> FluentElementFilter<TARGET_ELEMENT> applyFilter(IsCoreMatcher<ELEMENT, TARGET_ELEMENT> coreMatcher) {
+    public <TARGET_ELEMENT extends Element> FluentElementFilter<TARGET_ELEMENT> is(IsCoreMatcher<ELEMENT, TARGET_ELEMENT> coreMatcher) {
 
         elements = coreMatcher.getFilter().filter(elements);
         return new FluentElementFilter<TARGET_ELEMENT>((List<TARGET_ELEMENT>) elements);
@@ -173,7 +173,7 @@ public <TARGET_ELEMENT extends Element> FluentElementFilter<TARGET_ELEMENT> appl
      * @param coreMatcher the implicit core matcher to use
      * @return the FluentElementFilter instance
      */
-    public <TARGET_ELEMENT extends Element> FluentElementFilter<ELEMENT> applyInvertedFilter(IsCoreMatcher<ELEMENT, TARGET_ELEMENT> coreMatcher) {
+    public <TARGET_ELEMENT extends Element> FluentElementFilter<ELEMENT> isNot(IsCoreMatcher<ELEMENT, TARGET_ELEMENT> coreMatcher) {
 
         elements = coreMatcher.getFilter().filter(elements, true);
         return FluentElementFilter.this;
@@ -187,7 +187,7 @@ public <TARGET_ELEMENT extends Element> FluentElementFilter<ELEMENT> applyInvert
      * @param coreMatcher the implicit core matcher to use
      * @return the FluentElementFilter instance
      */
-    public <TARGET_ELEMENT extends Element> FluentElementFilter<TARGET_ELEMENT> applyFilter(IsElementBasedCoreMatcher<TARGET_ELEMENT> coreMatcher) {
+    public <TARGET_ELEMENT extends Element> FluentElementFilter<TARGET_ELEMENT> is(IsElementBasedCoreMatcher<TARGET_ELEMENT> coreMatcher) {
 
         elements = (List<ELEMENT>) coreMatcher.getFilter().filter((List<Element>) elements);
         return new FluentElementFilter<TARGET_ELEMENT>((List<TARGET_ELEMENT>) elements);
@@ -200,7 +200,7 @@ public <TARGET_ELEMENT extends Element> FluentElementFilter<TARGET_ELEMENT> appl
      * @param coreMatcher the implicit core matcher to use
      * @return the FluentElementFilter instance
      */
-    public <TARGET_ELEMENT extends Element> FluentElementFilter<ELEMENT> applyInvertedFilter(IsElementBasedCoreMatcher<TARGET_ELEMENT> coreMatcher) {
+    public <TARGET_ELEMENT extends Element> FluentElementFilter<ELEMENT> isNot(IsElementBasedCoreMatcher<TARGET_ELEMENT> coreMatcher) {
 
         elements = (List<ELEMENT>) coreMatcher.getFilter().filter((List<Element>) elements, true);
         return FluentElementFilter.this;
diff --git a/annotationprocessor/src/main/java/io/toolisticon/annotationprocessortoolkit/tools/fluentvalidator/FluentElementValidator.java b/annotationprocessor/src/main/java/io/toolisticon/annotationprocessortoolkit/tools/fluentvalidator/FluentElementValidator.java
index e67affe0..cda6a126 100644
--- a/annotationprocessor/src/main/java/io/toolisticon/annotationprocessortoolkit/tools/fluentvalidator/FluentElementValidator.java
+++ b/annotationprocessor/src/main/java/io/toolisticon/annotationprocessortoolkit/tools/fluentvalidator/FluentElementValidator.java
@@ -1,6 +1,7 @@
 package io.toolisticon.annotationprocessortoolkit.tools.fluentvalidator;
 
 import io.toolisticon.annotationprocessortoolkit.tools.MessagerUtils;
+import io.toolisticon.annotationprocessortoolkit.tools.corematcher.CoreMatchers;
 import io.toolisticon.annotationprocessortoolkit.tools.corematcher.ExclusiveCriteriaCoreMatcher;
 import io.toolisticon.annotationprocessortoolkit.tools.corematcher.ExclusiveCriteriaElementBasedCoreMatcher;
 import io.toolisticon.annotationprocessortoolkit.tools.corematcher.ImplicitCoreMatcher;
@@ -17,6 +18,7 @@
 import io.toolisticon.annotationprocessortoolkit.tools.validator.InclusiveCriteriaElementValidator;
 
 import javax.lang.model.element.Element;
+import javax.lang.model.element.Modifier;
 import javax.tools.Diagnostic;
 
 /**
@@ -24,6 +26,252 @@
  */
 public class FluentElementValidator<ELEMENT extends Element> {
 
+    /**
+     * Apply validator interface.
+     */
+    public class PrepareApplyValidator<PREPARE_VALIDATOR_ELEMENT extends Element> {
+
+        /**
+         * Set warning scope for next validation.
+         *
+         * @return the fluent validator instance
+         */
+        public PrepareApplyValidator<PREPARE_VALIDATOR_ELEMENT> warning() {
+            return (PrepareApplyValidator<PREPARE_VALIDATOR_ELEMENT>) FluentElementValidator.this.warning();
+        }
+
+        /**
+         * Set note scope for next validation.
+         *
+         * @return the fluent validator instance
+         */
+        public PrepareApplyValidator<PREPARE_VALIDATOR_ELEMENT> note() {
+            return (PrepareApplyValidator<PREPARE_VALIDATOR_ELEMENT>) FluentElementValidator.this.note();
+        }
+
+        /**
+         * Set warning scope for next validation.
+         *
+         * @param customMessage the custom message to use.
+         * @return the fluent validator instance
+         */
+        public PrepareApplyValidator<PREPARE_VALIDATOR_ELEMENT> setCustomMessage(String customMessage) {
+            return (PrepareApplyValidator<PREPARE_VALIDATOR_ELEMENT>) FluentElementValidator.this.setCustomMessage(customMessage);
+        }
+
+
+        /**
+         * Applies is validator.
+         * Changes generic type of fluent validator.
+         *
+         * @param coreMatcher the implicit core matcher to use
+         * @return the FluentElementValidator instance
+         */
+        public <TARGET_ELEMENT extends Element> FluentElementValidator<TARGET_ELEMENT> is(IsCoreMatcher<ELEMENT, TARGET_ELEMENT> coreMatcher) {
+
+            return FluentElementValidator.this.is(coreMatcher);
+
+        }
+
+        /**
+         * Applies inverted is filter.
+         *
+         * @param coreMatcher the implicit core matcher to use
+         * @return the FluentElementValidator instance
+         */
+        public <TARGET_ELEMENT extends Element> FluentElementValidator<ELEMENT> isNot(IsCoreMatcher<ELEMENT, TARGET_ELEMENT> coreMatcher) {
+
+            return FluentElementValidator.this.isNot(coreMatcher);
+
+        }
+
+        /**
+         * Applies is element based filter.
+         * Changes generic type of fluent filter.
+         *
+         * @param coreMatcher the implicit core matcher to use
+         * @return the FluentElementValidator instance
+         */
+        public <TARGET_ELEMENT extends Element> FluentElementValidator<TARGET_ELEMENT> is(IsElementBasedCoreMatcher<TARGET_ELEMENT> coreMatcher) {
+
+            return FluentElementValidator.this.is(coreMatcher);
+
+
+        }
+
+        /**
+         * Applies inverted implicit element based filter.
+         *
+         * @param coreMatcher the implicit core matcher to use
+         * @return the FluentElementValidator instance
+         */
+        public <TARGET_ELEMENT extends Element> FluentElementValidator<ELEMENT> isNot(IsElementBasedCoreMatcher<TARGET_ELEMENT> coreMatcher) {
+
+            return FluentElementValidator.this.isNot(coreMatcher);
+
+        }
+
+        // -----------------------------------------------
+        // -- IMPLICIT FILTERS
+        // -----------------------------------------------
+
+        /**
+         * Applies implicit filter.
+         *
+         * @param coreMatcher the implicit core matcher to use
+         * @return the FluentElementValidator instance
+         */
+        public FluentElementValidator<ELEMENT> applyValidator(ImplicitCoreMatcher<ELEMENT> coreMatcher) {
+
+            return FluentElementValidator.this.applyValidator(coreMatcher);
+
+        }
+
+        /**
+         * Applies inverted implicit filter.
+         *
+         * @param coreMatcher the implicit core matcher to use
+         * @return the FluentElementValidator instance
+         */
+        public FluentElementValidator<ELEMENT> applyInvertedValidator(ImplicitCoreMatcher<ELEMENT> coreMatcher) {
+
+            return FluentElementValidator.this.applyInvertedValidator(coreMatcher);
+
+        }
+
+        /**
+         * Applies implicit element based filter.
+         *
+         * @param coreMatcher the implicit core matcher to use
+         * @return the FluentElementValidator instance
+         */
+        public FluentElementValidator<ELEMENT> applyValidator(ImplicitElementBasedCoreMatcher coreMatcher) {
+
+            return FluentElementValidator.this.applyValidator(coreMatcher);
+
+        }
+
+        /**
+         * Applies inverted implicit element based filter.
+         *
+         * @param coreMatcher the implicit core matcher to use
+         * @return the FluentElementValidator instance
+         */
+        public FluentElementValidator<ELEMENT> applyInvertedVaidator(ImplicitElementBasedCoreMatcher coreMatcher) {
+
+            return FluentElementValidator.this.applyInvertedValidator(coreMatcher);
+
+        }
+
+        // -----------------------------------------------
+        // -- INCLUSIVE CRITERIA FILTERS
+        // -----------------------------------------------
+
+        /**
+         * Applies inclusive criteria filter.
+         *
+         * @param coreMatcher the implicit core matcher to use
+         * @return the FluentElementValidator instance
+         */
+        public <CRITERIA> InclusiveCharacteristicFluentValidator<ELEMENT, CRITERIA> applyValidator(InclusiveCriteriaCoreMatcher<ELEMENT, CRITERIA> coreMatcher) {
+
+            return FluentElementValidator.this.applyValidator(coreMatcher);
+
+        }
+
+        /**
+         * Applies inverted inclusive criteria filter.
+         *
+         * @param coreMatcher the implicit core matcher to use
+         * @return the FluentElementValidator instance
+         */
+        public <CRITERIA> InclusiveCharacteristicFluentValidator<ELEMENT, CRITERIA> applyInvertedValidator(InclusiveCriteriaCoreMatcher<ELEMENT, CRITERIA> coreMatcher) {
+
+            return FluentElementValidator.this.applyInvertedValidator(coreMatcher);
+
+        }
+
+        /**
+         * Applies inclusive criteria element based filter.
+         *
+         * @param coreMatcher the implicit core matcher to use
+         * @return the FluentElementValidator instance
+         */
+        public <CRITERIA> InclusiveCharacteristicFluentValidator<Element, CRITERIA> applyValidator(InclusiveCharacteristicElementBasedCoreMatcher<CRITERIA> coreMatcher) {
+
+            return FluentElementValidator.this.applyValidator(coreMatcher);
+
+
+        }
+
+        /**
+         * Applies inverted inclusive element based criteria filter.
+         *
+         * @param coreMatcher the implicit core matcher to use
+         * @return the FluentElementValidator instance
+         */
+        public <CRITERIA> InclusiveCharacteristicFluentValidator<Element, CRITERIA> applyInvertedValidator(InclusiveCharacteristicElementBasedCoreMatcher<CRITERIA> coreMatcher) {
+
+            return FluentElementValidator.this.applyInvertedValidator(coreMatcher);
+
+        }
+
+        // -----------------------------------------------
+        // -- EXPLICIT FILTERS
+        // -----------------------------------------------
+
+        /**
+         * Applies exclusive criteria filter.
+         *
+         * @param coreMatcher the implicit core matcher to use
+         * @return the FluentElementValidator instance
+         */
+        public <CRITERIA> ExclusiveCharacteristicFluentValidator<ELEMENT, CRITERIA> applyValidator(ExclusiveCriteriaCoreMatcher<ELEMENT, CRITERIA> coreMatcher) {
+
+            return FluentElementValidator.this.applyValidator(coreMatcher);
+
+        }
+
+        /**
+         * Applies inverted exclusive criteria filter.
+         *
+         * @param coreMatcher the implicit core matcher to use
+         * @return the FluentElementValidator instance
+         */
+        public <CRITERIA> ExclusiveCharacteristicFluentValidator<ELEMENT, CRITERIA> applyInvertedValidator(ExclusiveCriteriaCoreMatcher<ELEMENT, CRITERIA> coreMatcher) {
+
+            return FluentElementValidator.this.applyInvertedValidator(coreMatcher);
+
+        }
+
+        /**
+         * Applies exclusive criteria element based filter.
+         *
+         * @param coreMatcher the implicit core matcher to use
+         * @return the FluentElementValidator instance
+         */
+        public <CRITERIA> ExclusiveCharacteristicFluentValidator<Element, CRITERIA> applyValidator(ExclusiveCriteriaElementBasedCoreMatcher<CRITERIA> coreMatcher) {
+
+            return FluentElementValidator.this.applyValidator(coreMatcher);
+
+
+        }
+
+
+        /**
+         * Applies inverted exclusive element based criteria filter.
+         *
+         * @param coreMatcher the implicit core matcher to use
+         * @return the FluentElementValidator instance
+         */
+        public <CRITERIA> ExclusiveCharacteristicFluentValidator<Element, CRITERIA> applyInvertedValidator(ExclusiveCriteriaElementBasedCoreMatcher<CRITERIA> coreMatcher) {
+
+            return FluentElementValidator.this.applyInvertedValidator(coreMatcher);
+
+        }
+
+    }
+
 
     /**
      * The element under validation.
@@ -36,50 +284,54 @@ public class FluentElementValidator<ELEMENT extends Element> {
      */
     private final FluentValidatorState fluentValidatorState;
 
-    /**
-     * The base class for all validators.
-     *
-     * @param <VALIDATOR_ELEMENT>
-     * @param <VALIDATOR>
-     */
-    public abstract class AbstractFluentValidatorBase<VALIDATOR_ELEMENT extends Element, VALIDATOR extends AbstractFluentValidatorBase<VALIDATOR_ELEMENT, VALIDATOR>> {
-
-        private Diagnostic.Kind messageScope = Diagnostic.Kind.ERROR;
-        private String message = null;
-        private boolean invert = false;
+    private NextValidationContext nextValidationContext = new NextValidationContext();
 
+    private class NextValidationContext {
 
-        public VALIDATOR not() {
+        private String customMessage;
+        private Diagnostic.Kind messageScope = Diagnostic.Kind.ERROR;
 
-            invert = true;
-            return self();
+        private void reset() {
+            customMessage = null;
+            messageScope = Diagnostic.Kind.ERROR;
+        }
 
+        public String getCustomMessage() {
+            return customMessage;
         }
 
-        public VALIDATOR warn() {
+        public void setCustomMessage(String customMessage) {
+            this.customMessage = customMessage;
+        }
 
-            messageScope = Diagnostic.Kind.MANDATORY_WARNING;
-            return self();
+        public Diagnostic.Kind getMessageScope() {
+            return messageScope;
+        }
 
+        public void setMessageScope(Diagnostic.Kind messageScope) {
+            this.messageScope = messageScope;
         }
+    }
 
-        public VALIDATOR message(String messsage) {
+    /**
+     * The base class for all validators.
+     *
+     * @param <VALIDATOR_ELEMENT>
+     * @param <VALIDATOR>
+     */
+    public abstract class AbstractFluentValidatorBase<VALIDATOR_ELEMENT extends Element, VALIDATOR extends AbstractFluentValidatorBase<VALIDATOR_ELEMENT, VALIDATOR>> {
 
-            this.message = messsage;
-            return self();
 
+        private boolean inverted = false;
+
+        public AbstractFluentValidatorBase(final boolean inverted) {
+            this.inverted = inverted;
         }
 
         protected abstract VALIDATOR self();
 
         protected boolean isInverted() {
-            return invert;
-        }
-
-        private String getMessage() {
-
-            return message;
-
+            return inverted;
         }
 
 
@@ -90,15 +342,18 @@ private String getMessage() {
          */
         protected void setValidationResult(boolean validationResult, String defaultMessage, Object... messsageParameter) {
 
-            if ((!validationResult && !invert) || (validationResult && invert)) {
+            if ((!validationResult && !inverted) || (validationResult && inverted)) {
                 fluentValidatorState.setAsFailedValidation();
 
-                if (message != null) {
-                    MessagerUtils.getMessagerUtils().printMessage(element, messageScope, message);
+                if (nextValidationContext.getCustomMessage() != null) {
+                    MessagerUtils.getMessagerUtils().printMessage(element, nextValidationContext.getMessageScope(), nextValidationContext.getCustomMessage());
                 } else {
-                    MessagerUtils.getMessagerUtils().printMessage(element, messageScope, defaultMessage, messsageParameter);
+                    MessagerUtils.getMessagerUtils().printMessage(element, nextValidationContext.getMessageScope(), defaultMessage, messsageParameter);
                 }
 
+                // rest validation context for next validation
+                nextValidationContext.reset();
+
             }
 
         }
@@ -116,7 +371,8 @@ public class ImplicitFluentValidator<VALIDATOR_ELEMENT extends Element> extends
 
         private final ImplicitValidator<VALIDATOR_ELEMENT, ImplicitMatcher<VALIDATOR_ELEMENT>> validator;
 
-        private ImplicitFluentValidator(ImplicitValidator<VALIDATOR_ELEMENT, ImplicitMatcher<VALIDATOR_ELEMENT>> validator) {
+        private ImplicitFluentValidator(ImplicitValidator<VALIDATOR_ELEMENT, ImplicitMatcher<VALIDATOR_ELEMENT>> validator, boolean inverted) {
+            super(inverted);
             this.validator = validator;
         }
 
@@ -144,7 +400,8 @@ public class IsFluentValidator<VALIDATOR_ELEMENT extends Element, TARGET_ELEMENT
 
         private final ImplicitValidator<VALIDATOR_ELEMENT, ImplicitMatcher<VALIDATOR_ELEMENT>> validator;
 
-        private IsFluentValidator(ImplicitValidator<VALIDATOR_ELEMENT, ImplicitMatcher<VALIDATOR_ELEMENT>> validator) {
+        private IsFluentValidator(ImplicitValidator<VALIDATOR_ELEMENT, ImplicitMatcher<VALIDATOR_ELEMENT>> validator, boolean inverted) {
+            super(inverted);
             this.validator = validator;
         }
 
@@ -169,6 +426,40 @@ protected IsFluentValidator<VALIDATOR_ELEMENT, TARGET_ELEMENT> self() {
         }
     }
 
+    /**
+     * Validator step for inverted is validators.
+     *
+     * @param <VALIDATOR_ELEMENT>
+     */
+    public class InvertedIsFluentValidator<VALIDATOR_ELEMENT extends Element, TARGET_ELEMENT extends Element> extends AbstractFluentValidatorBase<VALIDATOR_ELEMENT, InvertedIsFluentValidator<VALIDATOR_ELEMENT, TARGET_ELEMENT>> {
+
+        private final ImplicitValidator<VALIDATOR_ELEMENT, ImplicitMatcher<VALIDATOR_ELEMENT>> validator;
+
+        private InvertedIsFluentValidator(ImplicitValidator<VALIDATOR_ELEMENT, ImplicitMatcher<VALIDATOR_ELEMENT>> validator, boolean inverted) {
+            super(inverted);
+            this.validator = validator;
+        }
+
+        public FluentElementValidator<ELEMENT> apply() {
+
+
+            boolean validationResult = false;
+
+            // just validate if element != null
+            if (element != null) {
+                validationResult = validator.validate((VALIDATOR_ELEMENT) element);
+                setValidationResult(validationResult, validator.getMessage());
+            }
+
+            return FluentElementValidator.this;
+
+        }
+
+        @Override
+        protected InvertedIsFluentValidator<VALIDATOR_ELEMENT, TARGET_ELEMENT> self() {
+            return this;
+        }
+    }
 
     /**
      * Validator step for exlusive characteristics validators.
@@ -180,7 +471,8 @@ public class ExclusiveCharacteristicFluentValidator<VALIDATOR_ELEMENT extends El
 
         private final ExclusiveCriteriaElementValidator<VALIDATOR_ELEMENT, CHARACTERISTIC, CriteriaMatcher<VALIDATOR_ELEMENT, CHARACTERISTIC>> validator;
 
-        private ExclusiveCharacteristicFluentValidator(ExclusiveCriteriaElementValidator<VALIDATOR_ELEMENT, CHARACTERISTIC, CriteriaMatcher<VALIDATOR_ELEMENT, CHARACTERISTIC>> validator) {
+        private ExclusiveCharacteristicFluentValidator(ExclusiveCriteriaElementValidator<VALIDATOR_ELEMENT, CHARACTERISTIC, CriteriaMatcher<VALIDATOR_ELEMENT, CHARACTERISTIC>> validator, boolean inverted) {
+            super(inverted);
             this.validator = validator;
         }
 
@@ -216,7 +508,8 @@ public class InclusiveCharacteristicFluentValidator<VALIDATOR_ELEMENT extends El
 
         private final InclusiveCriteriaElementValidator<VALIDATOR_ELEMENT, CHARACTERISTIC, CriteriaMatcher<VALIDATOR_ELEMENT, CHARACTERISTIC>> validator;
 
-        private InclusiveCharacteristicFluentValidator(InclusiveCriteriaElementValidator<VALIDATOR_ELEMENT, CHARACTERISTIC, CriteriaMatcher<VALIDATOR_ELEMENT, CHARACTERISTIC>> validator) {
+        private InclusiveCharacteristicFluentValidator(InclusiveCriteriaElementValidator<VALIDATOR_ELEMENT, CHARACTERISTIC, CriteriaMatcher<VALIDATOR_ELEMENT, CHARACTERISTIC>> validator, boolean inverted) {
+            super(inverted);
             this.validator = validator;
         }
 
@@ -269,43 +562,238 @@ private FluentElementValidator(ELEMENT element, FluentValidatorState fluentValid
         this.fluentValidatorState = fluentValidatorState;
     }
 
+    // -----------------------------------------------
+    // -- IS VALIDATOR
+    // -----------------------------------------------
+
+    /**
+     * Applies is validator.
+     * Changes generic type of fluent validator.
+     *
+     * @param coreMatcher the implicit core matcher to use
+     * @return the FluentElementValidator instance
+     */
+    public <TARGET_ELEMENT extends Element> FluentElementValidator<TARGET_ELEMENT> is(IsCoreMatcher<ELEMENT, TARGET_ELEMENT> coreMatcher) {
+
+        return new IsFluentValidator<ELEMENT, TARGET_ELEMENT>(coreMatcher.getValidator(), false).apply();
 
-    // apply implicit validators
-    public ImplicitFluentValidator<ELEMENT> applyValidator(ImplicitCoreMatcher<ELEMENT> coreMatcher) {
-        return new ImplicitFluentValidator<ELEMENT>(coreMatcher.getValidator());
     }
 
-    public ImplicitFluentValidator<Element> applyValidator(ImplicitElementBasedCoreMatcher coreMatcher) {
-        return new ImplicitFluentValidator<Element>(coreMatcher.getValidator());
+    /**
+     * Applies inverted is filter.
+     *
+     * @param coreMatcher the implicit core matcher to use
+     * @return the FluentElementValidator instance
+     */
+    public <TARGET_ELEMENT extends Element> FluentElementValidator<ELEMENT> isNot(IsCoreMatcher<ELEMENT, TARGET_ELEMENT> coreMatcher) {
+
+        return new InvertedIsFluentValidator<ELEMENT, TARGET_ELEMENT>(coreMatcher.getValidator(), true).apply();
+
     }
 
-    // apply inclusive characteristics validators
-    public <CHARACTERISTIC> InclusiveCharacteristicFluentValidator<ELEMENT, CHARACTERISTIC> applyValidator(InclusiveCriteriaCoreMatcher<ELEMENT, CHARACTERISTIC> coreMatcher) {
-        return new InclusiveCharacteristicFluentValidator<ELEMENT, CHARACTERISTIC>(coreMatcher.getValidator());
+    /**
+     * Applies is element based filter.
+     * Changes generic type of fluent filter.
+     *
+     * @param coreMatcher the implicit core matcher to use
+     * @return the FluentElementValidator instance
+     */
+    public <TARGET_ELEMENT extends Element> FluentElementValidator<TARGET_ELEMENT> is(IsElementBasedCoreMatcher<TARGET_ELEMENT> coreMatcher) {
+
+        return new IsFluentValidator<Element, TARGET_ELEMENT>(coreMatcher.getValidator(), false).apply();
+
+
     }
 
-    public <CHARACTERISTIC> InclusiveCharacteristicFluentValidator<Element, CHARACTERISTIC> applyValidator(InclusiveCharacteristicElementBasedCoreMatcher<CHARACTERISTIC> coreMatcher) {
-        return new InclusiveCharacteristicFluentValidator<Element, CHARACTERISTIC>(coreMatcher.getValidator());
+    /**
+     * Applies inverted implicit element based filter.
+     *
+     * @param coreMatcher the implicit core matcher to use
+     * @return the FluentElementValidator instance
+     */
+    public <TARGET_ELEMENT extends Element> FluentElementValidator<ELEMENT> isNot(IsElementBasedCoreMatcher<TARGET_ELEMENT> coreMatcher) {
+
+        return new InvertedIsFluentValidator<Element, TARGET_ELEMENT>(coreMatcher.getValidator(), true).apply();
+
     }
 
-    // apply exclusive characteristics validators
-    public <CHARACTERISTIC> ExclusiveCharacteristicFluentValidator<ELEMENT, CHARACTERISTIC> applyValidator(ExclusiveCriteriaCoreMatcher<ELEMENT, CHARACTERISTIC> coreMatcher) {
-        return new ExclusiveCharacteristicFluentValidator<ELEMENT, CHARACTERISTIC>(coreMatcher.getValidator());
+    // -----------------------------------------------
+    // -- IMPLICIT FILTERS
+    // -----------------------------------------------
+
+    /**
+     * Applies implicit filter.
+     *
+     * @param coreMatcher the implicit core matcher to use
+     * @return the FluentElementValidator instance
+     */
+    public FluentElementValidator<ELEMENT> applyValidator(ImplicitCoreMatcher<ELEMENT> coreMatcher) {
+
+        return new ImplicitFluentValidator<ELEMENT>(coreMatcher.getValidator(), false).apply();
+
     }
 
-    public <CHARACTERISTIC> ExclusiveCharacteristicFluentValidator<Element, CHARACTERISTIC> applyValidator(ExclusiveCriteriaElementBasedCoreMatcher<CHARACTERISTIC> coreMatcher) {
-        return new ExclusiveCharacteristicFluentValidator<Element, CHARACTERISTIC>(coreMatcher.getValidator());
+    /**
+     * Applies inverted implicit filter.
+     *
+     * @param coreMatcher the implicit core matcher to use
+     * @return the FluentElementValidator instance
+     */
+    public FluentElementValidator<ELEMENT> applyInvertedValidator(ImplicitCoreMatcher<ELEMENT> coreMatcher) {
+
+        return new ImplicitFluentValidator<ELEMENT>(coreMatcher.getValidator(), true).apply();
+
     }
 
-    // apply is validators
-    public <TARGET_ELEMENT extends Element> FluentElementValidator<TARGET_ELEMENT> is(IsCoreMatcher<ELEMENT, TARGET_ELEMENT> coreMatcher) {
-        return new IsFluentValidator<ELEMENT, TARGET_ELEMENT>(coreMatcher.getValidator()).apply();
+    /**
+     * Applies implicit element based filter.
+     *
+     * @param coreMatcher the implicit core matcher to use
+     * @return the FluentElementValidator instance
+     */
+    public FluentElementValidator<ELEMENT> applyValidator(ImplicitElementBasedCoreMatcher coreMatcher) {
+
+        return new ImplicitFluentValidator<Element>(coreMatcher.getValidator(), true).apply();
+
     }
 
-    public <TARGET_ELEMENT extends Element> FluentElementValidator<TARGET_ELEMENT> is(IsElementBasedCoreMatcher<TARGET_ELEMENT> coreMatcher) {
-        return new IsFluentValidator<Element, TARGET_ELEMENT>(coreMatcher.getValidator()).apply();
+    /**
+     * Applies inverted implicit element based filter.
+     *
+     * @param coreMatcher the implicit core matcher to use
+     * @return the FluentElementValidator instance
+     */
+    public FluentElementValidator<ELEMENT> applyInvertedValidator(ImplicitElementBasedCoreMatcher coreMatcher) {
+
+        return new ImplicitFluentValidator<Element>(coreMatcher.getValidator(), true).apply();
+
     }
 
+    // -----------------------------------------------
+    // -- INCLUSIVE CRITERIA FILTERS
+    // -----------------------------------------------
+
+    /**
+     * Applies inclusive criteria filter.
+     *
+     * @param coreMatcher the implicit core matcher to use
+     * @return the FluentElementValidator instance
+     */
+    public <CRITERIA> InclusiveCharacteristicFluentValidator<ELEMENT, CRITERIA> applyValidator(InclusiveCriteriaCoreMatcher<ELEMENT, CRITERIA> coreMatcher) {
+
+        return new InclusiveCharacteristicFluentValidator<ELEMENT, CRITERIA>(coreMatcher.getValidator(), false);
+
+    }
+
+    /**
+     * Applies inverted inclusive criteria filter.
+     *
+     * @param coreMatcher the implicit core matcher to use
+     * @return the FluentElementValidator instance
+     */
+    public <CRITERIA> InclusiveCharacteristicFluentValidator<ELEMENT, CRITERIA> applyInvertedValidator(InclusiveCriteriaCoreMatcher<ELEMENT, CRITERIA> coreMatcher) {
+
+        return new InclusiveCharacteristicFluentValidator<ELEMENT, CRITERIA>(coreMatcher.getValidator(), true);
+
+    }
+
+    /**
+     * Applies inclusive criteria element based filter.
+     *
+     * @param coreMatcher the implicit core matcher to use
+     * @return the FluentElementValidator instance
+     */
+    public <CRITERIA> InclusiveCharacteristicFluentValidator<Element, CRITERIA> applyValidator(InclusiveCharacteristicElementBasedCoreMatcher<CRITERIA> coreMatcher) {
+
+        return new InclusiveCharacteristicFluentValidator<Element, CRITERIA>(coreMatcher.getValidator(), false);
+
+
+    }
+
+    /**
+     * Applies inverted inclusive element based criteria filter.
+     *
+     * @param coreMatcher the implicit core matcher to use
+     * @return the FluentElementValidator instance
+     */
+    public <CRITERIA> InclusiveCharacteristicFluentValidator<Element, CRITERIA> applyInvertedValidator(InclusiveCharacteristicElementBasedCoreMatcher<CRITERIA> coreMatcher) {
+
+        return new InclusiveCharacteristicFluentValidator<Element, CRITERIA>(coreMatcher.getValidator(), true);
+
+    }
+
+    // -----------------------------------------------
+    // -- EXPLICIT FILTERS
+    // -----------------------------------------------
+
+    /**
+     * Applies exclusive criteria filter.
+     *
+     * @param coreMatcher the implicit core matcher to use
+     * @return the FluentElementValidator instance
+     */
+    public <CRITERIA> ExclusiveCharacteristicFluentValidator<ELEMENT, CRITERIA> applyValidator(ExclusiveCriteriaCoreMatcher<ELEMENT, CRITERIA> coreMatcher) {
+
+        return new ExclusiveCharacteristicFluentValidator<ELEMENT, CRITERIA>(coreMatcher.getValidator(), false);
+
+    }
+
+    /**
+     * Applies inverted exclusive criteria filter.
+     *
+     * @param coreMatcher the implicit core matcher to use
+     * @return the FluentElementValidator instance
+     */
+    public <CRITERIA> ExclusiveCharacteristicFluentValidator<ELEMENT, CRITERIA> applyInvertedValidator(ExclusiveCriteriaCoreMatcher<ELEMENT, CRITERIA> coreMatcher) {
+
+        return new ExclusiveCharacteristicFluentValidator<ELEMENT, CRITERIA>(coreMatcher.getValidator(), true);
+
+    }
+
+    /**
+     * Applies exclusive criteria element based filter.
+     *
+     * @param coreMatcher the implicit core matcher to use
+     * @return the FluentElementValidator instance
+     */
+    public <CRITERIA> ExclusiveCharacteristicFluentValidator<Element, CRITERIA> applyValidator(ExclusiveCriteriaElementBasedCoreMatcher<CRITERIA> coreMatcher) {
+
+        return new ExclusiveCharacteristicFluentValidator<Element, CRITERIA>(coreMatcher.getValidator(), false);
+    }
+
+    /**
+     * Applies inverted exclusive element based criteria filter.
+     *
+     * @param coreMatcher the implicit core matcher to use
+     * @return the FluentElementValidator instance
+     */
+    public <CRITERIA> ExclusiveCharacteristicFluentValidator<Element, CRITERIA> applyInvertedValidator(ExclusiveCriteriaElementBasedCoreMatcher<CRITERIA> coreMatcher) {
+
+        return new ExclusiveCharacteristicFluentValidator<Element, CRITERIA>(coreMatcher.getValidator(), true);
+
+    }
+
+    // -------------------------------------------------------------
+    // -------------------------------------------------------------
+
+    public PrepareApplyValidator<ELEMENT> warning() {
+        this.nextValidationContext.setMessageScope(Diagnostic.Kind.WARNING);
+        return new PrepareApplyValidator<ELEMENT>();
+    }
+
+    public PrepareApplyValidator<ELEMENT> note() {
+        this.nextValidationContext.setMessageScope(Diagnostic.Kind.NOTE);
+        return new PrepareApplyValidator<ELEMENT>();
+    }
+
+    public PrepareApplyValidator<ELEMENT> setCustomMessage(String customMessage) {
+        this.nextValidationContext.setCustomMessage(customMessage);
+        return new PrepareApplyValidator<ELEMENT>();
+    }
+
+    // -------------------------------------------------------------
+    // -------------------------------------------------------------
+
 
     /**
      * Just return the validation result without issuing any messages.
@@ -336,4 +824,13 @@ public static <E extends Element> FluentElementValidator<E> createFluentElementV
     }
 
 
+    public static void main(String[] args) {
+        createFluentElementValidator(null)
+                .isNot(CoreMatchers.IS_EXECUTABLE_ELEMENT)
+                .is(CoreMatchers.IS_TYPE_ELEMENT)
+                .warning().setCustomMessage("").applyValidator(CoreMatchers.BY_MODIFIER).hasOneOf(Modifier.PUBLIC)
+                .validateAndIssueMessages();
+    }
+
+
 }
diff --git a/example/example-annotationprocessor/src/main/java/io/toolisticon/example/annotationprocessortoolkit/annotationprocessor/MethodWithOneStringParameterAndVoidReturnTypeAnnotationProcessor.java b/example/example-annotationprocessor/src/main/java/io/toolisticon/example/annotationprocessortoolkit/annotationprocessor/MethodWithOneStringParameterAndVoidReturnTypeAnnotationProcessor.java
index 2beb4414..abdf7148 100644
--- a/example/example-annotationprocessor/src/main/java/io/toolisticon/example/annotationprocessortoolkit/annotationprocessor/MethodWithOneStringParameterAndVoidReturnTypeAnnotationProcessor.java
+++ b/example/example-annotationprocessor/src/main/java/io/toolisticon/example/annotationprocessortoolkit/annotationprocessor/MethodWithOneStringParameterAndVoidReturnTypeAnnotationProcessor.java
@@ -43,7 +43,7 @@ public boolean processAnnotations(Set<? extends TypeElement> annotations, RoundE
 
             // validator already will print output so additional actions are not necessary
             FluentElementValidator.createFluentElementValidator(ElementUtils.CastElement.castMethod(element))
-                    .applyValidator(CoreMatchers.HAS_VOID_RETURN_TYPE).apply()
+                    .applyValidator(CoreMatchers.HAS_VOID_RETURN_TYPE)
                     .applyValidator(CoreMatchers.BY_PARAMETER_TYPE).hasOneOf(wrapToArray(String.class))
                     .validateAndIssueMessages();