diff --git a/ArchUnitNET/Fluent/ArchRuleCreator.cs b/ArchUnitNET/Fluent/ArchRuleCreator.cs
index c3d0d733f..68eae4f84 100644
--- a/ArchUnitNET/Fluent/ArchRuleCreator.cs
+++ b/ArchUnitNET/Fluent/ArchRuleCreator.cs
@@ -43,7 +43,7 @@ public void AddPredicateConjunction(LogicalConjunction logicalConjunction)
             _predicateManager.SetNextLogicalConjunction(logicalConjunction);
         }
 
-        public void AddCondition(ICondition<TRuleType> condition)
+        public void AddCondition(IOrderedCondition<TRuleType> condition)
         {
             _conditionManager.AddCondition(condition);
         }
diff --git a/ArchUnitNET/Fluent/CombinedArchRuleCreator.cs b/ArchUnitNET/Fluent/CombinedArchRuleCreator.cs
index ac9847b49..7dfedc516 100644
--- a/ArchUnitNET/Fluent/CombinedArchRuleCreator.cs
+++ b/ArchUnitNET/Fluent/CombinedArchRuleCreator.cs
@@ -59,7 +59,7 @@ public void AddPredicateConjunction(LogicalConjunction logicalConjunction)
             _currentArchRuleCreator.AddPredicateConjunction(logicalConjunction);
         }
 
-        public void AddCondition(ICondition<TRuleType> condition)
+        public void AddCondition(IOrderedCondition<TRuleType> condition)
         {
             _currentArchRuleCreator.AddCondition(condition);
         }
diff --git a/ArchUnitNET/Fluent/ConditionManager.cs b/ArchUnitNET/Fluent/ConditionManager.cs
index fa8b70996..4acf30bbe 100644
--- a/ArchUnitNET/Fluent/ConditionManager.cs
+++ b/ArchUnitNET/Fluent/ConditionManager.cs
@@ -66,7 +66,7 @@ public void ContinueComplexCondition<TRelatedType>(IPredicate<TRelatedType> filt
             }
         }
 
-        public void AddCondition(ICondition<T> condition)
+        public void AddCondition(IOrderedCondition<T> condition)
         {
             _conditionElements.Last().SetCondition(condition);
         }
@@ -119,58 +119,19 @@ ICanBeEvaluated archRuleCreator
                 };
             }
 
-            if (_conditionElements.All(e => e.IsOrdered()))
-            {
-                var conditionResults = _conditionElements
-                    .Select(conditionElement =>
-                        conditionElement.Check(filteredObjectsList, architecture).ToList()
-                    )
-                    .ToList();
-                return filteredObjectsList.Select(
-                    (t, i) =>
-                        CreateEvaluationResult(
-                            conditionResults.Select(results => results[i]),
-                            architecture,
-                            archRuleCreator
-                        )
-                );
-            }
-
-            //rough heuristic - if we have small number of comparisons, we are fine with sequential search
-            //but in large cases its quadratic behavior becomes too slow and building of a dictionary is justified
-            if (filteredObjectsList.Count * _conditionElements.Count > 256)
-            {
-                var conditionResults = _conditionElements
-                    .Select(conditionElement =>
-                        conditionElement
-                            .Check(filteredObjectsList, architecture)
-                            .ToDictionary(x => x.ConditionResult.AnalyzedObject)
-                    )
-                    .ToList();
-
-                return filteredObjectsList.Select(t =>
-                    CreateEvaluationResult(
-                        FindResultsForObject(conditionResults, t),
-                        architecture,
-                        archRuleCreator
-                    )
-                );
-            }
-            else
-            {
-                var conditionResults = _conditionElements
-                    .Select(conditionElement =>
-                        conditionElement.Check(filteredObjectsList, architecture).ToList()
-                    )
-                    .ToList();
-                return filteredObjectsList.Select(t =>
+            var conditionResults = _conditionElements
+                .Select(conditionElement =>
+                    conditionElement.Check(filteredObjectsList, architecture).ToList()
+                )
+                .ToList();
+            return filteredObjectsList.Select(
+                (t, i) =>
                     CreateEvaluationResult(
-                        FindResultsForObject(conditionResults, t),
+                        conditionResults.Select(results => results[i]),
                         architecture,
                         archRuleCreator
                     )
-                );
-            }
+            );
         }
 
         private IEnumerable<ConditionElementResult> FindResultsForObject(
@@ -291,7 +252,7 @@ private class ConditionElement<T> : IHasDescription
             where T : ICanBeAnalyzed
         {
             private readonly LogicalConjunction _logicalConjunction;
-            private ICondition<T> _condition;
+            private IOrderedCondition<T> _condition;
 
             [CanBeNull]
             private string _customDescription;
@@ -338,7 +299,7 @@ public void AddReason(string reason)
                 _reason = "because " + reason;
             }
 
-            public void SetCondition(ICondition<T> condition)
+            public void SetCondition(IOrderedCondition<T> condition)
             {
                 _condition = condition;
             }
@@ -365,11 +326,6 @@ Architecture architecture
                     .Select(result => new ConditionElementResult(result, _logicalConjunction));
             }
 
-            public bool IsOrdered()
-            {
-                return _condition is IOrderedCondition<T>;
-            }
-
             public bool CheckEmpty(bool currentResult)
             {
                 if (_condition == null)
diff --git a/ArchUnitNET/Fluent/Conditions/ComplexCondition.cs b/ArchUnitNET/Fluent/Conditions/ComplexCondition.cs
index aba631d55..b070c1bc4 100644
--- a/ArchUnitNET/Fluent/Conditions/ComplexCondition.cs
+++ b/ArchUnitNET/Fluent/Conditions/ComplexCondition.cs
@@ -4,7 +4,7 @@
 
 namespace ArchUnitNET.Fluent.Conditions
 {
-    public class ComplexCondition<TRuleType, TRelatedType> : ICondition<TRuleType>
+    public class ComplexCondition<TRuleType, TRelatedType> : IOrderedCondition<TRuleType>
         where TRuleType : ICanBeAnalyzed
         where TRelatedType : ICanBeAnalyzed
     {
diff --git a/ArchUnitNET/Fluent/Conditions/ConditionExtensions.cs b/ArchUnitNET/Fluent/Conditions/ConditionExtensions.cs
new file mode 100644
index 000000000..4c3f28274
--- /dev/null
+++ b/ArchUnitNET/Fluent/Conditions/ConditionExtensions.cs
@@ -0,0 +1,72 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using ArchUnitNET.Domain;
+
+namespace ArchUnitNET.Fluent.Conditions
+{
+    public static class ConditionExtensions
+    {
+        private sealed class OrderedConditionWrapper<TRuleType> : IOrderedCondition<TRuleType>
+            where TRuleType : ICanBeAnalyzed
+        {
+            private readonly ICondition<TRuleType> _condition;
+
+            public OrderedConditionWrapper(ICondition<TRuleType> condition)
+            {
+                _condition = condition;
+            }
+
+            public string Description => _condition.Description;
+
+            public IEnumerable<ConditionResult> Check(
+                IEnumerable<TRuleType> objects,
+                Architecture architecture
+            )
+            {
+                var objectCollection = objects as ICollection<TRuleType> ?? objects.ToList();
+                var results = Check(architecture, objectCollection, _condition);
+                return objectCollection.Select(ruleType => results(ruleType));
+            }
+
+            public bool CheckEmpty() => _condition.CheckEmpty();
+
+            private static Func<TRuleType, ConditionResult> Check(
+                Architecture architecture,
+                ICollection<TRuleType> objects,
+                ICondition<TRuleType> condition
+            )
+            {
+                var conditionResults = condition.Check(objects, architecture);
+                if (objects.Count > 256)
+                {
+                    var resultDictionary = conditionResults.ToDictionary(result =>
+                        result.AnalyzedObject
+                    );
+                    return obj => resultDictionary[obj];
+                }
+                var resultList = conditionResults.ToList();
+                return obj => resultList.First(result => result.AnalyzedObject.Equals(obj));
+            }
+        }
+
+        /// <summary>
+        /// Wraps an ICondition as an IOrderedCondition if it is not already one, ensuring that the order of results
+        /// corresponds to the order of input objects.
+        /// </summary>
+        /// <param name="condition">Condition to be wrapped.</param>
+        /// <typeparam name="TRuleType">Type of objects the condition applies to.</typeparam>
+        /// <returns>An IOrderedCondition that maintains the order of input objects.</returns>
+        public static IOrderedCondition<TRuleType> AsOrderedCondition<TRuleType>(
+            this ICondition<TRuleType> condition
+        )
+            where TRuleType : ICanBeAnalyzed
+        {
+            if (condition is IOrderedCondition<TRuleType> orderedCondition)
+            {
+                return orderedCondition;
+            }
+            return new OrderedConditionWrapper<TRuleType>(condition);
+        }
+    }
+}
diff --git a/ArchUnitNET/Fluent/Conditions/ICondition.cs b/ArchUnitNET/Fluent/Conditions/ICondition.cs
index fc568729e..78cbdab4d 100644
--- a/ArchUnitNET/Fluent/Conditions/ICondition.cs
+++ b/ArchUnitNET/Fluent/Conditions/ICondition.cs
@@ -3,13 +3,24 @@
 
 namespace ArchUnitNET.Fluent.Conditions
 {
+    /// <summary>
+    /// A condition that can be checked against objects of type TRuleType.
+    /// </summary>
+    /// <typeparam name="TRuleType">Type of objects the condition can be checked against.</typeparam>
     public interface ICondition<in TRuleType> : IHasDescription
         where TRuleType : ICanBeAnalyzed
     {
+        /// <summary>
+        /// Checks the condition against the provided objects within the given architecture.
+        /// </summary>
+        /// <param name="objects">Objects to check the condition against.</param>
+        /// <param name="architecture">The architecture context for the check.</param>
+        /// <returns>A collection of ConditionResults indicating the outcome for each object.</returns>
         IEnumerable<ConditionResult> Check(
             IEnumerable<TRuleType> objects,
             Architecture architecture
         );
+
         bool CheckEmpty();
     }
 }
diff --git a/ArchUnitNET/Fluent/Conditions/IOrderedCondition.cs b/ArchUnitNET/Fluent/Conditions/IOrderedCondition.cs
index f2e6b17b0..62d9640fd 100644
--- a/ArchUnitNET/Fluent/Conditions/IOrderedCondition.cs
+++ b/ArchUnitNET/Fluent/Conditions/IOrderedCondition.cs
@@ -2,6 +2,11 @@
 
 namespace ArchUnitNET.Fluent.Conditions
 {
+    /// <summary>
+    /// An IOrderedCondition is a Condition that has the semantic requirement that the order of the results
+    /// corresponds to the order of the input objects.
+    /// </summary>
+    /// <typeparam name="TRuleType">Type of objects the condition can be checked against.</typeparam>
     public interface IOrderedCondition<in TRuleType> : ICondition<TRuleType>
         where TRuleType : ICanBeAnalyzed { }
 }
diff --git a/ArchUnitNET/Fluent/Conditions/RelationCondition.cs b/ArchUnitNET/Fluent/Conditions/RelationCondition.cs
index afce69393..29ef4ef63 100644
--- a/ArchUnitNET/Fluent/Conditions/RelationCondition.cs
+++ b/ArchUnitNET/Fluent/Conditions/RelationCondition.cs
@@ -9,10 +9,13 @@ public class RelationCondition<TRuleType, TRelatedType> : IHasDescription
         where TRuleType : ICanBeAnalyzed
         where TRelatedType : ICanBeAnalyzed
     {
-        private readonly Func<IObjectProvider<TRelatedType>, ICondition<TRuleType>> _relation;
+        private readonly Func<
+            IObjectProvider<TRelatedType>,
+            IOrderedCondition<TRuleType>
+        > _relation;
 
         public RelationCondition(
-            Func<IObjectProvider<TRelatedType>, ICondition<TRuleType>> relation,
+            Func<IObjectProvider<TRelatedType>, IOrderedCondition<TRuleType>> relation,
             string description,
             string failDescription
         )
@@ -26,7 +29,7 @@ string failDescription
 
         public string Description { get; }
 
-        public ICondition<TRuleType> GetCondition(IEnumerable<TRelatedType> objects)
+        public IOrderedCondition<TRuleType> GetCondition(IEnumerable<TRelatedType> objects)
         {
             return _relation(new ObjectProvider<TRelatedType>(objects.ToList()));
         }
diff --git a/ArchUnitNET/Fluent/IArchRuleCreator.cs b/ArchUnitNET/Fluent/IArchRuleCreator.cs
index 24d03757e..e0109b139 100644
--- a/ArchUnitNET/Fluent/IArchRuleCreator.cs
+++ b/ArchUnitNET/Fluent/IArchRuleCreator.cs
@@ -10,7 +10,7 @@ public interface IArchRuleCreator<TRuleType> : ICanBeEvaluated
     {
         void AddPredicate(IPredicate<TRuleType> predicate);
         void AddPredicateConjunction(LogicalConjunction logicalConjunction);
-        void AddCondition(ICondition<TRuleType> condition);
+        void AddCondition(IOrderedCondition<TRuleType> condition);
         void AddConditionConjunction(LogicalConjunction logicalConjunction);
         void AddConditionReason(string reason);
         void AddPredicateReason(string reason);
diff --git a/ArchUnitNET/Fluent/Syntax/Elements/Members/MemberConditionsDefinition.cs b/ArchUnitNET/Fluent/Syntax/Elements/Members/MemberConditionsDefinition.cs
index c27397554..5e6037aa2 100644
--- a/ArchUnitNET/Fluent/Syntax/Elements/Members/MemberConditionsDefinition.cs
+++ b/ArchUnitNET/Fluent/Syntax/Elements/Members/MemberConditionsDefinition.cs
@@ -11,21 +11,29 @@ namespace ArchUnitNET.Fluent.Syntax.Elements.Members
     public static class MemberConditionsDefinition<TRuleType>
         where TRuleType : IMember
     {
-        public static ICondition<TRuleType> BeDeclaredIn(IType firstType, params IType[] moreTypes)
+        public static IOrderedCondition<TRuleType> BeDeclaredIn(
+            IType firstType,
+            params IType[] moreTypes
+        )
         {
             var types = new List<IType> { firstType };
             types.AddRange(moreTypes);
             return BeDeclaredIn(types);
         }
 
-        public static ICondition<TRuleType> BeDeclaredIn(Type firstType, params Type[] moreTypes)
+        public static IOrderedCondition<TRuleType> BeDeclaredIn(
+            Type firstType,
+            params Type[] moreTypes
+        )
         {
             var types = new List<Type> { firstType };
             types.AddRange(moreTypes);
             return BeDeclaredIn(types);
         }
 
-        public static ICondition<TRuleType> BeDeclaredIn(IObjectProvider<IType> objectProvider)
+        public static IOrderedCondition<TRuleType> BeDeclaredIn(
+            IObjectProvider<IType> objectProvider
+        )
         {
             IEnumerable<ConditionResult> Condition(
                 IEnumerable<TRuleType> methods,
@@ -50,10 +58,13 @@ Architecture architecture
             }
 
             var description = "be declared in " + objectProvider.Description;
-            return new ArchitectureCondition<TRuleType>(Condition, description);
+            return new ArchitectureCondition<TRuleType>(
+                Condition,
+                description
+            ).AsOrderedCondition();
         }
 
-        public static ICondition<TRuleType> BeDeclaredIn(IEnumerable<IType> types)
+        public static IOrderedCondition<TRuleType> BeDeclaredIn(IEnumerable<IType> types)
         {
             var typeList = types.ToList();
 
@@ -92,10 +103,10 @@ IEnumerable<ConditionResult> Condition(IEnumerable<TRuleType> methods)
                     );
             }
 
-            return new EnumerableCondition<TRuleType>(Condition, description);
+            return new EnumerableCondition<TRuleType>(Condition, description).AsOrderedCondition();
         }
 
-        public static ICondition<TRuleType> BeDeclaredIn(IEnumerable<Type> types)
+        public static IOrderedCondition<TRuleType> BeDeclaredIn(IEnumerable<Type> types)
         {
             var typeList = types.ToList();
 
@@ -151,10 +162,13 @@ Architecture architecture
                     );
             }
 
-            return new ArchitectureCondition<TRuleType>(Condition, description);
+            return new ArchitectureCondition<TRuleType>(
+                Condition,
+                description
+            ).AsOrderedCondition();
         }
 
-        public static ICondition<TRuleType> BeStatic()
+        public static IOrderedCondition<TRuleType> BeStatic()
         {
             return new SimpleCondition<TRuleType>(
                 member => !member.IsStatic.HasValue || member.IsStatic.Value,
@@ -163,7 +177,7 @@ public static ICondition<TRuleType> BeStatic()
             );
         }
 
-        public static ICondition<TRuleType> BeReadOnly()
+        public static IOrderedCondition<TRuleType> BeReadOnly()
         {
             return new SimpleCondition<TRuleType>(
                 member => member.Writability == Writability.ReadOnly,
@@ -172,7 +186,7 @@ public static ICondition<TRuleType> BeReadOnly()
             );
         }
 
-        public static ICondition<TRuleType> BeImmutable()
+        public static IOrderedCondition<TRuleType> BeImmutable()
         {
             return new SimpleCondition<TRuleType>(
                 member => member.Writability.IsImmutable(),
@@ -194,7 +208,7 @@ public static RelationCondition<TRuleType, IType> BeDeclaredInTypesThat()
 
         //Negations
 
-        public static ICondition<TRuleType> NotBeDeclaredIn(
+        public static IOrderedCondition<TRuleType> NotBeDeclaredIn(
             IType firstType,
             params IType[] moreTypes
         )
@@ -204,14 +218,19 @@ params IType[] moreTypes
             return NotBeDeclaredIn(types);
         }
 
-        public static ICondition<TRuleType> NotBeDeclaredIn(Type firstType, params Type[] moreTypes)
+        public static IOrderedCondition<TRuleType> NotBeDeclaredIn(
+            Type firstType,
+            params Type[] moreTypes
+        )
         {
             var types = new List<Type> { firstType };
             types.AddRange(moreTypes);
             return NotBeDeclaredIn(types);
         }
 
-        public static ICondition<TRuleType> NotBeDeclaredIn(IObjectProvider<IType> objectProvider)
+        public static IOrderedCondition<TRuleType> NotBeDeclaredIn(
+            IObjectProvider<IType> objectProvider
+        )
         {
             IEnumerable<ConditionResult> Condition(
                 IEnumerable<TRuleType> methods,
@@ -236,10 +255,13 @@ Architecture architecture
             }
 
             var description = "not be declared in " + objectProvider.Description;
-            return new ArchitectureCondition<TRuleType>(Condition, description);
+            return new ArchitectureCondition<TRuleType>(
+                Condition,
+                description
+            ).AsOrderedCondition();
         }
 
-        public static ICondition<TRuleType> NotBeDeclaredIn(IEnumerable<IType> types)
+        public static IOrderedCondition<TRuleType> NotBeDeclaredIn(IEnumerable<IType> types)
         {
             var typeList = types.ToList();
 
@@ -278,10 +300,10 @@ IEnumerable<ConditionResult> Condition(IEnumerable<TRuleType> methods)
                     );
             }
 
-            return new EnumerableCondition<TRuleType>(Condition, description);
+            return new EnumerableCondition<TRuleType>(Condition, description).AsOrderedCondition();
         }
 
-        public static ICondition<TRuleType> NotBeDeclaredIn(IEnumerable<Type> types)
+        public static IOrderedCondition<TRuleType> NotBeDeclaredIn(IEnumerable<Type> types)
         {
             var typeList = types.ToList();
 
@@ -337,10 +359,13 @@ Architecture architecture
                     );
             }
 
-            return new ArchitectureCondition<TRuleType>(Condition, description);
+            return new ArchitectureCondition<TRuleType>(
+                Condition,
+                description
+            ).AsOrderedCondition();
         }
 
-        public static ICondition<TRuleType> NotBeStatic()
+        public static IOrderedCondition<TRuleType> NotBeStatic()
         {
             return new SimpleCondition<TRuleType>(
                 member => !member.IsStatic.HasValue || !member.IsStatic.Value,
@@ -349,7 +374,7 @@ public static ICondition<TRuleType> NotBeStatic()
             );
         }
 
-        public static ICondition<TRuleType> NotBeReadOnly()
+        public static IOrderedCondition<TRuleType> NotBeReadOnly()
         {
             return new SimpleCondition<TRuleType>(
                 member => member.Writability != Writability.ReadOnly,
@@ -358,7 +383,7 @@ public static ICondition<TRuleType> NotBeReadOnly()
             );
         }
 
-        public static ICondition<TRuleType> NotBeImmutable()
+        public static IOrderedCondition<TRuleType> NotBeImmutable()
         {
             return new SimpleCondition<TRuleType>(
                 member => !member.Writability.IsImmutable(),
diff --git a/ArchUnitNET/Fluent/Syntax/Elements/Members/MethodMembers/MethodMemberConditionsDefinition.cs b/ArchUnitNET/Fluent/Syntax/Elements/Members/MethodMembers/MethodMemberConditionsDefinition.cs
index 096b92a7a..b2739b35c 100644
--- a/ArchUnitNET/Fluent/Syntax/Elements/Members/MethodMembers/MethodMemberConditionsDefinition.cs
+++ b/ArchUnitNET/Fluent/Syntax/Elements/Members/MethodMembers/MethodMemberConditionsDefinition.cs
@@ -19,7 +19,7 @@ public static RelationCondition<MethodMember, MethodMember> BeMethodMembersThat(
             );
         }
 
-        public static ICondition<MethodMember> BeConstructor()
+        public static IOrderedCondition<MethodMember> BeConstructor()
         {
             return new SimpleCondition<MethodMember>(
                 member => member.IsConstructor(),
@@ -28,7 +28,7 @@ public static ICondition<MethodMember> BeConstructor()
             );
         }
 
-        public static ICondition<MethodMember> BeVirtual()
+        public static IOrderedCondition<MethodMember> BeVirtual()
         {
             return new SimpleCondition<MethodMember>(
                 member => member.IsVirtual,
@@ -37,21 +37,29 @@ public static ICondition<MethodMember> BeVirtual()
             );
         }
 
-        public static ICondition<MethodMember> BeCalledBy(IType firstType, params IType[] moreTypes)
+        public static IOrderedCondition<MethodMember> BeCalledBy(
+            IType firstType,
+            params IType[] moreTypes
+        )
         {
             var types = new List<IType> { firstType };
             types.AddRange(moreTypes);
             return BeCalledBy(types);
         }
 
-        public static ICondition<MethodMember> BeCalledBy(Type firstType, params Type[] moreTypes)
+        public static IOrderedCondition<MethodMember> BeCalledBy(
+            Type firstType,
+            params Type[] moreTypes
+        )
         {
             var types = new List<Type> { firstType };
             types.AddRange(moreTypes);
             return BeCalledBy(types);
         }
 
-        public static ICondition<MethodMember> BeCalledBy(IObjectProvider<IType> objectProvider)
+        public static IOrderedCondition<MethodMember> BeCalledBy(
+            IObjectProvider<IType> objectProvider
+        )
         {
             IEnumerable<ConditionResult> Condition(
                 IEnumerable<MethodMember> methodMembers,
@@ -76,10 +84,13 @@ Architecture architecture
             }
 
             var description = "be called by " + objectProvider.Description;
-            return new ArchitectureCondition<MethodMember>(Condition, description);
+            return new ArchitectureCondition<MethodMember>(
+                Condition,
+                description
+            ).AsOrderedCondition();
         }
 
-        public static ICondition<MethodMember> BeCalledBy(IEnumerable<IType> types)
+        public static IOrderedCondition<MethodMember> BeCalledBy(IEnumerable<IType> types)
         {
             var typeList = types.ToList();
             var firstType = typeList.First();
@@ -133,10 +144,13 @@ IEnumerable<ConditionResult> Condition(IEnumerable<MethodMember> methodMembers)
                     );
             }
 
-            return new EnumerableCondition<MethodMember>(Condition, description);
+            return new EnumerableCondition<MethodMember>(
+                Condition,
+                description
+            ).AsOrderedCondition();
         }
 
-        public static ICondition<MethodMember> BeCalledBy(IEnumerable<Type> types)
+        public static IOrderedCondition<MethodMember> BeCalledBy(IEnumerable<Type> types)
         {
             var typeList = types.ToList();
             var firstType = typeList.First();
@@ -208,10 +222,13 @@ Architecture architecture
                     );
             }
 
-            return new ArchitectureCondition<MethodMember>(Condition, description);
+            return new ArchitectureCondition<MethodMember>(
+                Condition,
+                description
+            ).AsOrderedCondition();
         }
 
-        public static ICondition<MethodMember> HaveDependencyInMethodBodyTo(
+        public static IOrderedCondition<MethodMember> HaveDependencyInMethodBodyTo(
             IType firstType,
             params IType[] moreTypes
         )
@@ -221,7 +238,7 @@ params IType[] moreTypes
             return HaveDependencyInMethodBodyTo(types);
         }
 
-        public static ICondition<MethodMember> HaveDependencyInMethodBodyTo(
+        public static IOrderedCondition<MethodMember> HaveDependencyInMethodBodyTo(
             Type firstType,
             params Type[] moreTypes
         )
@@ -231,7 +248,7 @@ params Type[] moreTypes
             return HaveDependencyInMethodBodyTo(types);
         }
 
-        public static ICondition<MethodMember> HaveDependencyInMethodBodyTo(
+        public static IOrderedCondition<MethodMember> HaveDependencyInMethodBodyTo(
             IObjectProvider<IType> objectProvider
         )
         {
@@ -265,10 +282,13 @@ Architecture architecture
             }
 
             var description = "have dependencies in method body to " + objectProvider.Description;
-            return new ArchitectureCondition<MethodMember>(Condition, description);
+            return new ArchitectureCondition<MethodMember>(
+                Condition,
+                description
+            ).AsOrderedCondition();
         }
 
-        public static ICondition<MethodMember> HaveDependencyInMethodBodyTo(
+        public static IOrderedCondition<MethodMember> HaveDependencyInMethodBodyTo(
             IEnumerable<IType> types
         )
         {
@@ -333,10 +353,15 @@ IEnumerable<ConditionResult> Condition(IEnumerable<MethodMember> methodMembers)
                     );
             }
 
-            return new EnumerableCondition<MethodMember>(Condition, description);
+            return new EnumerableCondition<MethodMember>(
+                Condition,
+                description
+            ).AsOrderedCondition();
         }
 
-        public static ICondition<MethodMember> HaveDependencyInMethodBodyTo(IEnumerable<Type> types)
+        public static IOrderedCondition<MethodMember> HaveDependencyInMethodBodyTo(
+            IEnumerable<Type> types
+        )
         {
             var typeList = types.ToList();
             var firstType = typeList.First();
@@ -415,10 +440,13 @@ Architecture architecture
                     );
             }
 
-            return new ArchitectureCondition<MethodMember>(Condition, description);
+            return new ArchitectureCondition<MethodMember>(
+                Condition,
+                description
+            ).AsOrderedCondition();
         }
 
-        public static ICondition<MethodMember> HaveReturnType(
+        public static IOrderedCondition<MethodMember> HaveReturnType(
             IType firstType,
             params IType[] moreTypes
         )
@@ -428,7 +456,7 @@ params IType[] moreTypes
             return HaveReturnType(types);
         }
 
-        public static ICondition<MethodMember> HaveReturnType(IEnumerable<IType> types)
+        public static IOrderedCondition<MethodMember> HaveReturnType(IEnumerable<IType> types)
         {
             var typeList = types.ToList();
             var typeStringList = typeList.Select(type => type.FullName).ToList();
@@ -447,7 +475,7 @@ bool Condition(MethodMember member)
             );
         }
 
-        public static ICondition<MethodMember> HaveReturnType(IObjectProvider<IType> types)
+        public static IOrderedCondition<MethodMember> HaveReturnType(IObjectProvider<IType> types)
         {
             IEnumerable<ConditionResult> Condition(
                 IEnumerable<MethodMember> methodMembers,
@@ -477,10 +505,13 @@ Architecture architecture
             }
 
             var description = "have return type " + types.Description;
-            return new ArchitectureCondition<MethodMember>(Condition, description);
+            return new ArchitectureCondition<MethodMember>(
+                Condition,
+                description
+            ).AsOrderedCondition();
         }
 
-        public static ICondition<MethodMember> HaveReturnType(
+        public static IOrderedCondition<MethodMember> HaveReturnType(
             Type firstType,
             params Type[] moreTypes
         )
@@ -490,7 +521,7 @@ params Type[] moreTypes
             return HaveReturnType(types);
         }
 
-        public static ICondition<MethodMember> HaveReturnType(IEnumerable<Type> types)
+        public static IOrderedCondition<MethodMember> HaveReturnType(IEnumerable<Type> types)
         {
             var typeList = types.ToList();
             var typeStringList = typeList.Select(type => type.ToString()).ToList();
@@ -511,7 +542,7 @@ bool Condition(MethodMember member)
 
         //Negations
 
-        public static ICondition<MethodMember> BeNoConstructor()
+        public static IOrderedCondition<MethodMember> BeNoConstructor()
         {
             return new SimpleCondition<MethodMember>(
                 member => !member.IsConstructor(),
@@ -520,7 +551,7 @@ public static ICondition<MethodMember> BeNoConstructor()
             );
         }
 
-        public static ICondition<MethodMember> NotBeVirtual()
+        public static IOrderedCondition<MethodMember> NotBeVirtual()
         {
             return new SimpleCondition<MethodMember>(
                 member => !member.IsVirtual,
@@ -529,7 +560,7 @@ public static ICondition<MethodMember> NotBeVirtual()
             );
         }
 
-        public static ICondition<MethodMember> NotBeCalledBy(
+        public static IOrderedCondition<MethodMember> NotBeCalledBy(
             IType firstType,
             params IType[] moreTypes
         )
@@ -539,7 +570,7 @@ params IType[] moreTypes
             return NotBeCalledBy(types);
         }
 
-        public static ICondition<MethodMember> NotBeCalledBy(
+        public static IOrderedCondition<MethodMember> NotBeCalledBy(
             Type firstType,
             params Type[] moreTypes
         )
@@ -549,7 +580,9 @@ params Type[] moreTypes
             return NotBeCalledBy(types);
         }
 
-        public static ICondition<MethodMember> NotBeCalledBy(IObjectProvider<IType> objectProvider)
+        public static IOrderedCondition<MethodMember> NotBeCalledBy(
+            IObjectProvider<IType> objectProvider
+        )
         {
             IEnumerable<ConditionResult> Condition(
                 IEnumerable<MethodMember> methodMembers,
@@ -574,10 +607,13 @@ Architecture architecture
             }
 
             var description = "not be called by " + objectProvider.Description;
-            return new ArchitectureCondition<MethodMember>(Condition, description);
+            return new ArchitectureCondition<MethodMember>(
+                Condition,
+                description
+            ).AsOrderedCondition();
         }
 
-        public static ICondition<MethodMember> NotBeCalledBy(IEnumerable<IType> types)
+        public static IOrderedCondition<MethodMember> NotBeCalledBy(IEnumerable<IType> types)
         {
             var typeList = types.ToList();
             var firstType = typeList.First();
@@ -631,10 +667,13 @@ IEnumerable<ConditionResult> Condition(IEnumerable<MethodMember> methodMembers)
                     );
             }
 
-            return new EnumerableCondition<MethodMember>(Condition, description);
+            return new EnumerableCondition<MethodMember>(
+                Condition,
+                description
+            ).AsOrderedCondition();
         }
 
-        public static ICondition<MethodMember> NotBeCalledBy(IEnumerable<Type> types)
+        public static IOrderedCondition<MethodMember> NotBeCalledBy(IEnumerable<Type> types)
         {
             var typeList = types.ToList();
             var firstType = typeList.First();
@@ -706,10 +745,13 @@ Architecture architecture
                     );
             }
 
-            return new ArchitectureCondition<MethodMember>(Condition, description);
+            return new ArchitectureCondition<MethodMember>(
+                Condition,
+                description
+            ).AsOrderedCondition();
         }
 
-        public static ICondition<MethodMember> NotHaveDependencyInMethodBodyTo(
+        public static IOrderedCondition<MethodMember> NotHaveDependencyInMethodBodyTo(
             IType firstType,
             params IType[] moreTypes
         )
@@ -719,7 +761,7 @@ params IType[] moreTypes
             return NotHaveDependencyInMethodBodyTo(types);
         }
 
-        public static ICondition<MethodMember> NotHaveDependencyInMethodBodyTo(
+        public static IOrderedCondition<MethodMember> NotHaveDependencyInMethodBodyTo(
             Type firstType,
             params Type[] moreTypes
         )
@@ -729,7 +771,7 @@ params Type[] moreTypes
             return NotHaveDependencyInMethodBodyTo(types);
         }
 
-        public static ICondition<MethodMember> NotHaveDependencyInMethodBodyTo(
+        public static IOrderedCondition<MethodMember> NotHaveDependencyInMethodBodyTo(
             IObjectProvider<IType> objectProvider
         )
         {
@@ -764,10 +806,13 @@ Architecture architecture
 
             var description =
                 "not have dependencies in method body to " + objectProvider.Description;
-            return new ArchitectureCondition<MethodMember>(Condition, description);
+            return new ArchitectureCondition<MethodMember>(
+                Condition,
+                description
+            ).AsOrderedCondition();
         }
 
-        public static ICondition<MethodMember> NotHaveDependencyInMethodBodyTo(
+        public static IOrderedCondition<MethodMember> NotHaveDependencyInMethodBodyTo(
             IEnumerable<IType> types
         )
         {
@@ -833,10 +878,13 @@ IEnumerable<ConditionResult> Condition(IEnumerable<MethodMember> methodMembers)
                     );
             }
 
-            return new EnumerableCondition<MethodMember>(Condition, description);
+            return new EnumerableCondition<MethodMember>(
+                Condition,
+                description
+            ).AsOrderedCondition();
         }
 
-        public static ICondition<MethodMember> NotHaveDependencyInMethodBodyTo(
+        public static IOrderedCondition<MethodMember> NotHaveDependencyInMethodBodyTo(
             IEnumerable<Type> types
         )
         {
@@ -918,10 +966,13 @@ Architecture architecture
                     );
             }
 
-            return new ArchitectureCondition<MethodMember>(Condition, description);
+            return new ArchitectureCondition<MethodMember>(
+                Condition,
+                description
+            ).AsOrderedCondition();
         }
 
-        public static ICondition<MethodMember> NotHaveReturnType(
+        public static IOrderedCondition<MethodMember> NotHaveReturnType(
             IType firstType,
             params IType[] moreTypes
         )
@@ -931,7 +982,7 @@ params IType[] moreTypes
             return NotHaveReturnType(types);
         }
 
-        public static ICondition<MethodMember> NotHaveReturnType(IEnumerable<IType> types)
+        public static IOrderedCondition<MethodMember> NotHaveReturnType(IEnumerable<IType> types)
         {
             var typeList = types.ToList();
             var typeStringList = typeList.Select(type => type.FullName).ToList();
@@ -950,7 +1001,9 @@ bool Condition(MethodMember member)
             );
         }
 
-        public static ICondition<MethodMember> NotHaveReturnType(IObjectProvider<IType> types)
+        public static IOrderedCondition<MethodMember> NotHaveReturnType(
+            IObjectProvider<IType> types
+        )
         {
             IEnumerable<ConditionResult> Condition(
                 IEnumerable<MethodMember> methodMembers,
@@ -980,10 +1033,13 @@ Architecture architecture
             }
 
             var description = "not have return type " + types.Description;
-            return new ArchitectureCondition<MethodMember>(Condition, description);
+            return new ArchitectureCondition<MethodMember>(
+                Condition,
+                description
+            ).AsOrderedCondition();
         }
 
-        public static ICondition<MethodMember> NotHaveReturnType(
+        public static IOrderedCondition<MethodMember> NotHaveReturnType(
             Type firstType,
             params Type[] moreTypes
         )
@@ -993,7 +1049,7 @@ params Type[] moreTypes
             return NotHaveReturnType(types);
         }
 
-        public static ICondition<MethodMember> NotHaveReturnType(IEnumerable<Type> types)
+        public static IOrderedCondition<MethodMember> NotHaveReturnType(IEnumerable<Type> types)
         {
             var typeList = types.ToList();
             var typeStringList = typeList.Select(type => type.ToString()).ToList();
diff --git a/ArchUnitNET/Fluent/Syntax/Elements/Members/PropertyMembers/PropertyMemberConditionsDefinition.cs b/ArchUnitNET/Fluent/Syntax/Elements/Members/PropertyMembers/PropertyMemberConditionsDefinition.cs
index 23dbd6014..c56b78386 100644
--- a/ArchUnitNET/Fluent/Syntax/Elements/Members/PropertyMembers/PropertyMemberConditionsDefinition.cs
+++ b/ArchUnitNET/Fluent/Syntax/Elements/Members/PropertyMembers/PropertyMemberConditionsDefinition.cs
@@ -6,7 +6,7 @@ namespace ArchUnitNET.Fluent.Syntax.Elements.Members.PropertyMembers
 {
     public static class PropertyMemberConditionsDefinition
     {
-        public static ICondition<PropertyMember> HaveGetter()
+        public static IOrderedCondition<PropertyMember> HaveGetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.GetterVisibility != NotAccessible,
@@ -15,7 +15,7 @@ public static ICondition<PropertyMember> HaveGetter()
             );
         }
 
-        public static ICondition<PropertyMember> HavePrivateGetter()
+        public static IOrderedCondition<PropertyMember> HavePrivateGetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.GetterVisibility == Private,
@@ -27,7 +27,7 @@ public static ICondition<PropertyMember> HavePrivateGetter()
             );
         }
 
-        public static ICondition<PropertyMember> HavePublicGetter()
+        public static IOrderedCondition<PropertyMember> HavePublicGetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.GetterVisibility == Public,
@@ -39,7 +39,7 @@ public static ICondition<PropertyMember> HavePublicGetter()
             );
         }
 
-        public static ICondition<PropertyMember> HaveProtectedGetter()
+        public static IOrderedCondition<PropertyMember> HaveProtectedGetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.GetterVisibility == Protected,
@@ -51,7 +51,7 @@ public static ICondition<PropertyMember> HaveProtectedGetter()
             );
         }
 
-        public static ICondition<PropertyMember> HaveInternalGetter()
+        public static IOrderedCondition<PropertyMember> HaveInternalGetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.GetterVisibility == Internal,
@@ -63,7 +63,7 @@ public static ICondition<PropertyMember> HaveInternalGetter()
             );
         }
 
-        public static ICondition<PropertyMember> HaveProtectedInternalGetter()
+        public static IOrderedCondition<PropertyMember> HaveProtectedInternalGetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.GetterVisibility == ProtectedInternal,
@@ -75,7 +75,7 @@ public static ICondition<PropertyMember> HaveProtectedInternalGetter()
             );
         }
 
-        public static ICondition<PropertyMember> HavePrivateProtectedGetter()
+        public static IOrderedCondition<PropertyMember> HavePrivateProtectedGetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.GetterVisibility == PrivateProtected,
@@ -85,7 +85,7 @@ public static ICondition<PropertyMember> HavePrivateProtectedGetter()
             );
         }
 
-        public static ICondition<PropertyMember> HaveSetter()
+        public static IOrderedCondition<PropertyMember> HaveSetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.SetterVisibility != NotAccessible,
@@ -94,7 +94,7 @@ public static ICondition<PropertyMember> HaveSetter()
             );
         }
 
-        public static ICondition<PropertyMember> HavePrivateSetter()
+        public static IOrderedCondition<PropertyMember> HavePrivateSetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.SetterVisibility == Private,
@@ -106,7 +106,7 @@ public static ICondition<PropertyMember> HavePrivateSetter()
             );
         }
 
-        public static ICondition<PropertyMember> HavePublicSetter()
+        public static IOrderedCondition<PropertyMember> HavePublicSetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.SetterVisibility == Public,
@@ -118,7 +118,7 @@ public static ICondition<PropertyMember> HavePublicSetter()
             );
         }
 
-        public static ICondition<PropertyMember> HaveProtectedSetter()
+        public static IOrderedCondition<PropertyMember> HaveProtectedSetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.SetterVisibility == Protected,
@@ -130,7 +130,7 @@ public static ICondition<PropertyMember> HaveProtectedSetter()
             );
         }
 
-        public static ICondition<PropertyMember> HaveInternalSetter()
+        public static IOrderedCondition<PropertyMember> HaveInternalSetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.SetterVisibility == Internal,
@@ -142,7 +142,7 @@ public static ICondition<PropertyMember> HaveInternalSetter()
             );
         }
 
-        public static ICondition<PropertyMember> HaveProtectedInternalSetter()
+        public static IOrderedCondition<PropertyMember> HaveProtectedInternalSetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.SetterVisibility == ProtectedInternal,
@@ -154,7 +154,7 @@ public static ICondition<PropertyMember> HaveProtectedInternalSetter()
             );
         }
 
-        public static ICondition<PropertyMember> HavePrivateProtectedSetter()
+        public static IOrderedCondition<PropertyMember> HavePrivateProtectedSetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.SetterVisibility == PrivateProtected,
@@ -164,7 +164,7 @@ public static ICondition<PropertyMember> HavePrivateProtectedSetter()
             );
         }
 
-        public static ICondition<PropertyMember> HaveInitSetter()
+        public static IOrderedCondition<PropertyMember> HaveInitSetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.Writability == Writability.InitOnly,
@@ -173,7 +173,7 @@ public static ICondition<PropertyMember> HaveInitSetter()
             );
         }
 
-        public static ICondition<PropertyMember> BeVirtual()
+        public static IOrderedCondition<PropertyMember> BeVirtual()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.IsVirtual,
@@ -184,7 +184,7 @@ public static ICondition<PropertyMember> BeVirtual()
 
         //Negations
 
-        public static ICondition<PropertyMember> NotHaveGetter()
+        public static IOrderedCondition<PropertyMember> NotHaveGetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.GetterVisibility == NotAccessible,
@@ -193,7 +193,7 @@ public static ICondition<PropertyMember> NotHaveGetter()
             );
         }
 
-        public static ICondition<PropertyMember> NotHavePrivateGetter()
+        public static IOrderedCondition<PropertyMember> NotHavePrivateGetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.GetterVisibility != Private,
@@ -202,7 +202,7 @@ public static ICondition<PropertyMember> NotHavePrivateGetter()
             );
         }
 
-        public static ICondition<PropertyMember> NotHavePublicGetter()
+        public static IOrderedCondition<PropertyMember> NotHavePublicGetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.GetterVisibility != Public,
@@ -211,7 +211,7 @@ public static ICondition<PropertyMember> NotHavePublicGetter()
             );
         }
 
-        public static ICondition<PropertyMember> NotHaveProtectedGetter()
+        public static IOrderedCondition<PropertyMember> NotHaveProtectedGetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.GetterVisibility != Protected,
@@ -220,7 +220,7 @@ public static ICondition<PropertyMember> NotHaveProtectedGetter()
             );
         }
 
-        public static ICondition<PropertyMember> NotHaveInternalGetter()
+        public static IOrderedCondition<PropertyMember> NotHaveInternalGetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.GetterVisibility != Internal,
@@ -229,7 +229,7 @@ public static ICondition<PropertyMember> NotHaveInternalGetter()
             );
         }
 
-        public static ICondition<PropertyMember> NotHaveProtectedInternalGetter()
+        public static IOrderedCondition<PropertyMember> NotHaveProtectedInternalGetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.GetterVisibility != ProtectedInternal,
@@ -238,7 +238,7 @@ public static ICondition<PropertyMember> NotHaveProtectedInternalGetter()
             );
         }
 
-        public static ICondition<PropertyMember> NotHavePrivateProtectedGetter()
+        public static IOrderedCondition<PropertyMember> NotHavePrivateProtectedGetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.GetterVisibility != PrivateProtected,
@@ -247,7 +247,7 @@ public static ICondition<PropertyMember> NotHavePrivateProtectedGetter()
             );
         }
 
-        public static ICondition<PropertyMember> NotHaveSetter()
+        public static IOrderedCondition<PropertyMember> NotHaveSetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.SetterVisibility == NotAccessible,
@@ -256,7 +256,7 @@ public static ICondition<PropertyMember> NotHaveSetter()
             );
         }
 
-        public static ICondition<PropertyMember> NotHavePrivateSetter()
+        public static IOrderedCondition<PropertyMember> NotHavePrivateSetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.SetterVisibility != Private,
@@ -265,7 +265,7 @@ public static ICondition<PropertyMember> NotHavePrivateSetter()
             );
         }
 
-        public static ICondition<PropertyMember> NotHavePublicSetter()
+        public static IOrderedCondition<PropertyMember> NotHavePublicSetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.SetterVisibility != Public,
@@ -274,7 +274,7 @@ public static ICondition<PropertyMember> NotHavePublicSetter()
             );
         }
 
-        public static ICondition<PropertyMember> NotHaveProtectedSetter()
+        public static IOrderedCondition<PropertyMember> NotHaveProtectedSetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.SetterVisibility != Protected,
@@ -283,7 +283,7 @@ public static ICondition<PropertyMember> NotHaveProtectedSetter()
             );
         }
 
-        public static ICondition<PropertyMember> NotHaveInternalSetter()
+        public static IOrderedCondition<PropertyMember> NotHaveInternalSetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.SetterVisibility != Internal,
@@ -292,7 +292,7 @@ public static ICondition<PropertyMember> NotHaveInternalSetter()
             );
         }
 
-        public static ICondition<PropertyMember> NotHaveProtectedInternalSetter()
+        public static IOrderedCondition<PropertyMember> NotHaveProtectedInternalSetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.SetterVisibility != ProtectedInternal,
@@ -301,7 +301,7 @@ public static ICondition<PropertyMember> NotHaveProtectedInternalSetter()
             );
         }
 
-        public static ICondition<PropertyMember> NotHavePrivateProtectedSetter()
+        public static IOrderedCondition<PropertyMember> NotHavePrivateProtectedSetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.SetterVisibility != PrivateProtected,
@@ -310,7 +310,7 @@ public static ICondition<PropertyMember> NotHavePrivateProtectedSetter()
             );
         }
 
-        public static ICondition<PropertyMember> NotHaveInitSetter()
+        public static IOrderedCondition<PropertyMember> NotHaveInitSetter()
         {
             return new SimpleCondition<PropertyMember>(
                 member => member.Writability != Writability.InitOnly,
@@ -319,7 +319,7 @@ public static ICondition<PropertyMember> NotHaveInitSetter()
             );
         }
 
-        public static ICondition<PropertyMember> NotBeVirtual()
+        public static IOrderedCondition<PropertyMember> NotBeVirtual()
         {
             return new SimpleCondition<PropertyMember>(
                 member => !member.IsVirtual,
diff --git a/ArchUnitNET/Fluent/Syntax/Elements/ObjectConditionsDefinition.cs b/ArchUnitNET/Fluent/Syntax/Elements/ObjectConditionsDefinition.cs
index b4e7f928b..d84f03042 100644
--- a/ArchUnitNET/Fluent/Syntax/Elements/ObjectConditionsDefinition.cs
+++ b/ArchUnitNET/Fluent/Syntax/Elements/ObjectConditionsDefinition.cs
@@ -14,12 +14,14 @@ namespace ArchUnitNET.Fluent.Syntax.Elements
     internal static class ObjectConditionsDefinition<TRuleType>
         where TRuleType : ICanBeAnalyzed
     {
-        public static ICondition<TRuleType> Exist()
+        public static IOrderedCondition<TRuleType> Exist()
         {
             return new ExistsCondition<TRuleType>(true);
         }
 
-        public static ICondition<TRuleType> Be(IObjectProvider<ICanBeAnalyzed> objectProvider)
+        public static IOrderedCondition<TRuleType> Be(
+            IObjectProvider<ICanBeAnalyzed> objectProvider
+        )
         {
             var sizedObjectProvider = objectProvider as ISizedObjectProvider<ICanBeAnalyzed>;
             IEnumerable<ConditionResult> Condition(
@@ -52,7 +54,9 @@ Architecture architecture
             return new OrderedArchitectureCondition<TRuleType>(Condition, description);
         }
 
-        public static ICondition<TRuleType> CallAny(IObjectProvider<MethodMember> objectProvider)
+        public static IOrderedCondition<TRuleType> CallAny(
+            IObjectProvider<MethodMember> objectProvider
+        )
         {
             IEnumerable<ConditionResult> Condition(
                 IEnumerable<TRuleType> ruleTypes,
@@ -91,7 +95,9 @@ Architecture architecture
             return new OrderedArchitectureCondition<TRuleType>(Condition, description);
         }
 
-        public static ICondition<TRuleType> DependOnAny(IObjectProvider<IType> objectProvider)
+        public static IOrderedCondition<TRuleType> DependOnAny(
+            IObjectProvider<IType> objectProvider
+        )
         {
             IEnumerable<ConditionResult> Condition(
                 IEnumerable<TRuleType> ruleTypes,
@@ -130,7 +136,7 @@ Architecture architecture
             return new OrderedArchitectureCondition<TRuleType>(Condition, description);
         }
 
-        public static ICondition<TRuleType> FollowCustomCondition(
+        public static IOrderedCondition<TRuleType> FollowCustomCondition(
             Func<TRuleType, ConditionResult> condition,
             string description
         )
@@ -138,7 +144,7 @@ string description
             return new SimpleCondition<TRuleType>(condition, description);
         }
 
-        public static ICondition<TRuleType> FollowCustomCondition(
+        public static IOrderedCondition<TRuleType> FollowCustomCondition(
             Func<TRuleType, bool> condition,
             string description,
             string failDescription
@@ -147,7 +153,9 @@ string failDescription
             return new SimpleCondition<TRuleType>(condition, description, failDescription);
         }
 
-        public static ICondition<TRuleType> OnlyDependOn(IObjectProvider<IType> objectProvider)
+        public static IOrderedCondition<TRuleType> OnlyDependOn(
+            IObjectProvider<IType> objectProvider
+        )
         {
             IEnumerable<ConditionResult> Condition(
                 IEnumerable<TRuleType> ruleTypes,
@@ -187,7 +195,7 @@ Architecture architecture
             return new OrderedArchitectureCondition<TRuleType>(Condition, description);
         }
 
-        public static ICondition<TRuleType> HaveAnyAttributes(
+        public static IOrderedCondition<TRuleType> HaveAnyAttributes(
             IObjectProvider<Attribute> objectProvider
         )
         {
@@ -228,7 +236,7 @@ Architecture architecture
             return new OrderedArchitectureCondition<TRuleType>(Condition, description);
         }
 
-        public static ICondition<TRuleType> OnlyHaveAttributes(
+        public static IOrderedCondition<TRuleType> OnlyHaveAttributes(
             IObjectProvider<Attribute> objectProvider
         )
         {
@@ -268,7 +276,7 @@ Architecture architecture
             return new OrderedArchitectureCondition<TRuleType>(Condition, description);
         }
 
-        public static ICondition<TRuleType> HaveAnyAttributesWithArguments(
+        public static IOrderedCondition<TRuleType> HaveAnyAttributesWithArguments(
             IEnumerable<object> argumentValues
         )
         {
@@ -326,7 +334,7 @@ Architecture architecture
             return new OrderedArchitectureCondition<TRuleType>(Condition, description);
         }
 
-        public static ICondition<TRuleType> HaveAttributeWithArguments(
+        public static IOrderedCondition<TRuleType> HaveAttributeWithArguments(
             string attributeFullName,
             [NotNull] Func<Architecture, Attribute> getAttribute,
             [NotNull] IEnumerable<object> argumentValues
@@ -390,7 +398,7 @@ Architecture architecture
             return new OrderedArchitectureCondition<TRuleType>(Condition, description);
         }
 
-        public static ICondition<TRuleType> HaveAnyAttributesWithNamedArguments(
+        public static IOrderedCondition<TRuleType> HaveAnyAttributesWithNamedArguments(
             IEnumerable<(string, object)> namedArguments
         )
         {
@@ -451,7 +459,7 @@ Architecture architecture
             return new OrderedArchitectureCondition<TRuleType>(Condition, description);
         }
 
-        public static ICondition<TRuleType> HaveAttributeWithNamedArguments(
+        public static IOrderedCondition<TRuleType> HaveAttributeWithNamedArguments(
             string attributeFullName,
             [NotNull] Func<Architecture, Attribute> getAttribute,
             IEnumerable<(string, object)> namedArguments
@@ -518,7 +526,7 @@ Architecture architecture
             return new OrderedArchitectureCondition<TRuleType>(Condition, description);
         }
 
-        public static ICondition<TRuleType> HaveName(string name)
+        public static IOrderedCondition<TRuleType> HaveName(string name)
         {
             return new SimpleCondition<TRuleType>(
                 obj => obj.NameEquals(name),
@@ -527,7 +535,7 @@ public static ICondition<TRuleType> HaveName(string name)
             );
         }
 
-        public static ICondition<TRuleType> HaveNameMatching(string pattern)
+        public static IOrderedCondition<TRuleType> HaveNameMatching(string pattern)
         {
             return new SimpleCondition<TRuleType>(
                 obj => obj.NameMatches(pattern),
@@ -536,7 +544,7 @@ public static ICondition<TRuleType> HaveNameMatching(string pattern)
             );
         }
 
-        public static ICondition<TRuleType> HaveNameStartingWith(string pattern)
+        public static IOrderedCondition<TRuleType> HaveNameStartingWith(string pattern)
         {
             return new SimpleCondition<TRuleType>(
                 obj => obj.NameStartsWith(pattern),
@@ -545,7 +553,7 @@ public static ICondition<TRuleType> HaveNameStartingWith(string pattern)
             );
         }
 
-        public static ICondition<TRuleType> HaveNameEndingWith(string pattern)
+        public static IOrderedCondition<TRuleType> HaveNameEndingWith(string pattern)
         {
             return new SimpleCondition<TRuleType>(
                 obj => obj.NameEndsWith(pattern),
@@ -554,7 +562,7 @@ public static ICondition<TRuleType> HaveNameEndingWith(string pattern)
             );
         }
 
-        public static ICondition<TRuleType> HaveNameContaining(string pattern)
+        public static IOrderedCondition<TRuleType> HaveNameContaining(string pattern)
         {
             return new SimpleCondition<TRuleType>(
                 obj => obj.NameContains(pattern),
@@ -563,7 +571,7 @@ public static ICondition<TRuleType> HaveNameContaining(string pattern)
             );
         }
 
-        public static ICondition<TRuleType> HaveFullName(string name)
+        public static IOrderedCondition<TRuleType> HaveFullName(string name)
         {
             return new SimpleCondition<TRuleType>(
                 obj => obj.FullNameEquals(name),
@@ -572,7 +580,7 @@ public static ICondition<TRuleType> HaveFullName(string name)
             );
         }
 
-        public static ICondition<TRuleType> HaveFullNameMatching(string pattern)
+        public static IOrderedCondition<TRuleType> HaveFullNameMatching(string pattern)
         {
             return new SimpleCondition<TRuleType>(
                 obj => obj.FullNameMatches(pattern),
@@ -581,7 +589,7 @@ public static ICondition<TRuleType> HaveFullNameMatching(string pattern)
             );
         }
 
-        public static ICondition<TRuleType> HaveFullNameStartingWith(string pattern)
+        public static IOrderedCondition<TRuleType> HaveFullNameStartingWith(string pattern)
         {
             return new SimpleCondition<TRuleType>(
                 obj => obj.FullNameStartsWith(pattern),
@@ -590,7 +598,7 @@ public static ICondition<TRuleType> HaveFullNameStartingWith(string pattern)
             );
         }
 
-        public static ICondition<TRuleType> HaveFullNameEndingWith(string pattern)
+        public static IOrderedCondition<TRuleType> HaveFullNameEndingWith(string pattern)
         {
             return new SimpleCondition<TRuleType>(
                 obj => obj.FullNameEndsWith(pattern),
@@ -599,7 +607,7 @@ public static ICondition<TRuleType> HaveFullNameEndingWith(string pattern)
             );
         }
 
-        public static ICondition<TRuleType> HaveFullNameContaining(string pattern)
+        public static IOrderedCondition<TRuleType> HaveFullNameContaining(string pattern)
         {
             return new SimpleCondition<TRuleType>(
                 obj => obj.FullNameContains(pattern),
@@ -608,7 +616,9 @@ public static ICondition<TRuleType> HaveFullNameContaining(string pattern)
             );
         }
 
-        public static ICondition<TRuleType> HaveAssemblyQualifiedName(string assemblyQualifiedName)
+        public static IOrderedCondition<TRuleType> HaveAssemblyQualifiedName(
+            string assemblyQualifiedName
+        )
         {
             return new SimpleCondition<TRuleType>(
                 obj => obj.AssemblyQualifiedNameEquals(assemblyQualifiedName),
@@ -617,7 +627,7 @@ public static ICondition<TRuleType> HaveAssemblyQualifiedName(string assemblyQua
             );
         }
 
-        public static ICondition<TRuleType> HaveAssemblyQualifiedNameMatching(string pattern)
+        public static IOrderedCondition<TRuleType> HaveAssemblyQualifiedNameMatching(string pattern)
         {
             return new SimpleCondition<TRuleType>(
                 obj => obj.AssemblyQualifiedNameMatches(pattern),
@@ -626,7 +636,9 @@ public static ICondition<TRuleType> HaveAssemblyQualifiedNameMatching(string pat
             );
         }
 
-        public static ICondition<TRuleType> HaveAssemblyQualifiedNameStartingWith(string pattern)
+        public static IOrderedCondition<TRuleType> HaveAssemblyQualifiedNameStartingWith(
+            string pattern
+        )
         {
             return new SimpleCondition<TRuleType>(
                 obj => obj.AssemblyQualifiedNameStartsWith(pattern),
@@ -635,7 +647,9 @@ public static ICondition<TRuleType> HaveAssemblyQualifiedNameStartingWith(string
             );
         }
 
-        public static ICondition<TRuleType> HaveAssemblyQualifiedNameEndingWith(string pattern)
+        public static IOrderedCondition<TRuleType> HaveAssemblyQualifiedNameEndingWith(
+            string pattern
+        )
         {
             return new SimpleCondition<TRuleType>(
                 obj => obj.AssemblyQualifiedNameEndsWith(pattern),
@@ -644,7 +658,9 @@ public static ICondition<TRuleType> HaveAssemblyQualifiedNameEndingWith(string p
             );
         }
 
-        public static ICondition<TRuleType> HaveAssemblyQualifiedNameContaining(string pattern)
+        public static IOrderedCondition<TRuleType> HaveAssemblyQualifiedNameContaining(
+            string pattern
+        )
         {
             return new SimpleCondition<TRuleType>(
                 obj => obj.AssemblyQualifiedNameContains(pattern),
@@ -653,7 +669,7 @@ public static ICondition<TRuleType> HaveAssemblyQualifiedNameContaining(string p
             );
         }
 
-        public static ICondition<TRuleType> BePrivate()
+        public static IOrderedCondition<TRuleType> BePrivate()
         {
             return new SimpleCondition<TRuleType>(
                 obj => obj.Visibility == Private,
@@ -662,7 +678,7 @@ public static ICondition<TRuleType> BePrivate()
             );
         }
 
-        public static ICondition<TRuleType> BePublic()
+        public static IOrderedCondition<TRuleType> BePublic()
         {
             return new SimpleCondition<TRuleType>(
                 obj => obj.Visibility == Public,
@@ -671,7 +687,7 @@ public static ICondition<TRuleType> BePublic()
             );
         }
 
-        public static ICondition<TRuleType> BeProtected()
+        public static IOrderedCondition<TRuleType> BeProtected()
         {
             return new SimpleCondition<TRuleType>(
                 obj => obj.Visibility == Protected,
@@ -680,7 +696,7 @@ public static ICondition<TRuleType> BeProtected()
             );
         }
 
-        public static ICondition<TRuleType> BeInternal()
+        public static IOrderedCondition<TRuleType> BeInternal()
         {
             return new SimpleCondition<TRuleType>(
                 obj => obj.Visibility == Internal,
@@ -689,7 +705,7 @@ public static ICondition<TRuleType> BeInternal()
             );
         }
 
-        public static ICondition<TRuleType> BeProtectedInternal()
+        public static IOrderedCondition<TRuleType> BeProtectedInternal()
         {
             return new SimpleCondition<TRuleType>(
                 obj => obj.Visibility == ProtectedInternal,
@@ -698,7 +714,7 @@ public static ICondition<TRuleType> BeProtectedInternal()
             );
         }
 
-        public static ICondition<TRuleType> BePrivateProtected()
+        public static IOrderedCondition<TRuleType> BePrivateProtected()
         {
             return new SimpleCondition<TRuleType>(
                 obj => obj.Visibility == PrivateProtected,
@@ -747,12 +763,14 @@ public static RelationCondition<TRuleType, Attribute> OnlyHaveAttributesThat()
 
         //Negations
 
-        public static ICondition<TRuleType> NotExist()
+        public static IOrderedCondition<TRuleType> NotExist()
         {
             return new ExistsCondition<TRuleType>(false);
         }
 
-        public static ICondition<TRuleType> NotBe(IObjectProvider<ICanBeAnalyzed> objectProvider)
+        public static IOrderedCondition<TRuleType> NotBe(
+            IObjectProvider<ICanBeAnalyzed> objectProvider
+        )
         {
             IEnumerable<ConditionResult> Condition(
                 IEnumerable<TRuleType> ruleTypes,
@@ -785,7 +803,9 @@ Architecture architecture
             return new OrderedArchitectureCondition<TRuleType>(Condition, description);
         }
 
-        public static ICondition<TRuleType> NotCallAny(IObjectProvider<MethodMember> objectProvider)
+        public static IOrderedCondition<TRuleType> NotCallAny(
+            IObjectProvider<MethodMember> objectProvider
+        )
         {
             IEnumerable<ConditionResult> Condition(
                 IEnumerable<TRuleType> ruleTypes,
@@ -821,7 +841,9 @@ Architecture architecture
             return new OrderedArchitectureCondition<TRuleType>(Condition, description);
         }
 
-        public static ICondition<TRuleType> NotDependOnAny(IObjectProvider<IType> objectProvider)
+        public static IOrderedCondition<TRuleType> NotDependOnAny(
+            IObjectProvider<IType> objectProvider
+        )
         {
             IEnumerable<ConditionResult> Condition(
                 IEnumerable<TRuleType> ruleTypes,
@@ -858,7 +880,7 @@ Architecture architecture
             return new OrderedArchitectureCondition<TRuleType>(Condition, description);
         }
 
-        public static ICondition<TRuleType> NotHaveAnyAttributes(
+        public static IOrderedCondition<TRuleType> NotHaveAnyAttributes(
             IObjectProvider<Attribute> objectProvider
         )
         {
@@ -897,7 +919,7 @@ Architecture architecture
             return new OrderedArchitectureCondition<TRuleType>(Condition, description);
         }
 
-        public static ICondition<TRuleType> NotHaveAnyAttributesWithArguments(
+        public static IOrderedCondition<TRuleType> NotHaveAnyAttributesWithArguments(
             IEnumerable<object> argumentValues
         )
         {
@@ -956,7 +978,7 @@ Architecture architecture
             return new OrderedArchitectureCondition<TRuleType>(Condition, description);
         }
 
-        public static ICondition<TRuleType> NotHaveAttributeWithArguments(
+        public static IOrderedCondition<TRuleType> NotHaveAttributeWithArguments(
             string attributeFullName,
             [NotNull] Func<Architecture, Attribute> getAttribute,
             IEnumerable<object> argumentValues
@@ -1004,7 +1026,7 @@ Architecture architecture
             return new OrderedArchitectureCondition<TRuleType>(Condition, description);
         }
 
-        public static ICondition<TRuleType> NotHaveAnyAttributesWithNamedArguments(
+        public static IOrderedCondition<TRuleType> NotHaveAnyAttributesWithNamedArguments(
             IEnumerable<(string, object)> namedArguments
         )
         {
@@ -1066,7 +1088,7 @@ Architecture architecture
             return new OrderedArchitectureCondition<TRuleType>(Condition, description);
         }
 
-        public static ICondition<TRuleType> NotHaveAttributeWithNamedArguments(
+        public static IOrderedCondition<TRuleType> NotHaveAttributeWithNamedArguments(
             string attributeFullName,
             [NotNull] Func<Architecture, Attribute> getAttribute,
             IEnumerable<(string, object)> namedArguments
@@ -1120,7 +1142,7 @@ Architecture architecture
             return new OrderedArchitectureCondition<TRuleType>(Condition, description);
         }
 
-        public static ICondition<TRuleType> NotHaveName(string name)
+        public static IOrderedCondition<TRuleType> NotHaveName(string name)
         {
             return new SimpleCondition<TRuleType>(
                 obj => !obj.NameEquals(name),
@@ -1129,7 +1151,7 @@ public static ICondition<TRuleType> NotHaveName(string name)
             );
         }
 
-        public static ICondition<TRuleType> NotHaveNameMatching(string pattern)
+        public static IOrderedCondition<TRuleType> NotHaveNameMatching(string pattern)
         {
             return new SimpleCondition<TRuleType>(
                 obj => !obj.NameMatches(pattern),
@@ -1138,7 +1160,7 @@ public static ICondition<TRuleType> NotHaveNameMatching(string pattern)
             );
         }
 
-        public static ICondition<TRuleType> NotHaveNameStartingWith(string pattern)
+        public static IOrderedCondition<TRuleType> NotHaveNameStartingWith(string pattern)
         {
             return new SimpleCondition<TRuleType>(
                 obj => !obj.NameStartsWith(pattern),
@@ -1147,7 +1169,7 @@ public static ICondition<TRuleType> NotHaveNameStartingWith(string pattern)
             );
         }
 
-        public static ICondition<TRuleType> NotHaveNameEndingWith(string pattern)
+        public static IOrderedCondition<TRuleType> NotHaveNameEndingWith(string pattern)
         {
             return new SimpleCondition<TRuleType>(
                 obj => !obj.NameEndsWith(pattern),
@@ -1156,7 +1178,7 @@ public static ICondition<TRuleType> NotHaveNameEndingWith(string pattern)
             );
         }
 
-        public static ICondition<TRuleType> NotHaveNameContaining(string pattern)
+        public static IOrderedCondition<TRuleType> NotHaveNameContaining(string pattern)
         {
             return new SimpleCondition<TRuleType>(
                 obj => !obj.NameContains(pattern),
@@ -1165,7 +1187,7 @@ public static ICondition<TRuleType> NotHaveNameContaining(string pattern)
             );
         }
 
-        public static ICondition<TRuleType> NotHaveFullName(string fullName)
+        public static IOrderedCondition<TRuleType> NotHaveFullName(string fullName)
         {
             return new SimpleCondition<TRuleType>(
                 obj => !obj.FullNameEquals(fullName),
@@ -1174,7 +1196,7 @@ public static ICondition<TRuleType> NotHaveFullName(string fullName)
             );
         }
 
-        public static ICondition<TRuleType> NotHaveFullNameMatching(string pattern)
+        public static IOrderedCondition<TRuleType> NotHaveFullNameMatching(string pattern)
         {
             return new SimpleCondition<TRuleType>(
                 obj => !obj.FullNameMatches(pattern),
@@ -1183,7 +1205,7 @@ public static ICondition<TRuleType> NotHaveFullNameMatching(string pattern)
             );
         }
 
-        public static ICondition<TRuleType> NotHaveFullNameStartingWith(string pattern)
+        public static IOrderedCondition<TRuleType> NotHaveFullNameStartingWith(string pattern)
         {
             return new SimpleCondition<TRuleType>(
                 obj => !obj.FullNameStartsWith(pattern),
@@ -1192,7 +1214,7 @@ public static ICondition<TRuleType> NotHaveFullNameStartingWith(string pattern)
             );
         }
 
-        public static ICondition<TRuleType> NotHaveFullNameEndingWith(string pattern)
+        public static IOrderedCondition<TRuleType> NotHaveFullNameEndingWith(string pattern)
         {
             return new SimpleCondition<TRuleType>(
                 obj => !obj.FullNameEndsWith(pattern),
@@ -1201,7 +1223,7 @@ public static ICondition<TRuleType> NotHaveFullNameEndingWith(string pattern)
             );
         }
 
-        public static ICondition<TRuleType> NotHaveFullNameContaining(string pattern)
+        public static IOrderedCondition<TRuleType> NotHaveFullNameContaining(string pattern)
         {
             return new SimpleCondition<TRuleType>(
                 obj => !obj.FullNameContains(pattern),
@@ -1210,7 +1232,7 @@ public static ICondition<TRuleType> NotHaveFullNameContaining(string pattern)
             );
         }
 
-        public static ICondition<TRuleType> NotHaveAssemblyQualifiedName(
+        public static IOrderedCondition<TRuleType> NotHaveAssemblyQualifiedName(
             string assemblyQualifiedName
         )
         {
@@ -1221,7 +1243,9 @@ string assemblyQualifiedName
             );
         }
 
-        public static ICondition<TRuleType> NotHaveAssemblyQualifiedNameMatching(string pattern)
+        public static IOrderedCondition<TRuleType> NotHaveAssemblyQualifiedNameMatching(
+            string pattern
+        )
         {
             return new SimpleCondition<TRuleType>(
                 obj => !obj.AssemblyQualifiedNameMatches(pattern),
@@ -1230,7 +1254,9 @@ public static ICondition<TRuleType> NotHaveAssemblyQualifiedNameMatching(string
             );
         }
 
-        public static ICondition<TRuleType> NotHaveAssemblyQualifiedNameStartingWith(string pattern)
+        public static IOrderedCondition<TRuleType> NotHaveAssemblyQualifiedNameStartingWith(
+            string pattern
+        )
         {
             return new SimpleCondition<TRuleType>(
                 obj => !obj.AssemblyQualifiedNameStartsWith(pattern),
@@ -1239,7 +1265,9 @@ public static ICondition<TRuleType> NotHaveAssemblyQualifiedNameStartingWith(str
             );
         }
 
-        public static ICondition<TRuleType> NotHaveAssemblyQualifiedNameEndingWith(string pattern)
+        public static IOrderedCondition<TRuleType> NotHaveAssemblyQualifiedNameEndingWith(
+            string pattern
+        )
         {
             return new SimpleCondition<TRuleType>(
                 obj => !obj.AssemblyQualifiedNameEndsWith(pattern),
@@ -1248,7 +1276,9 @@ public static ICondition<TRuleType> NotHaveAssemblyQualifiedNameEndingWith(strin
             );
         }
 
-        public static ICondition<TRuleType> NotHaveAssemblyQualifiedNameContaining(string pattern)
+        public static IOrderedCondition<TRuleType> NotHaveAssemblyQualifiedNameContaining(
+            string pattern
+        )
         {
             return new SimpleCondition<TRuleType>(
                 obj => !obj.AssemblyQualifiedNameContains(pattern),
@@ -1257,7 +1287,7 @@ public static ICondition<TRuleType> NotHaveAssemblyQualifiedNameContaining(strin
             );
         }
 
-        public static ICondition<TRuleType> NotBePrivate()
+        public static IOrderedCondition<TRuleType> NotBePrivate()
         {
             return new SimpleCondition<TRuleType>(
                 obj => obj.Visibility != Private,
@@ -1266,7 +1296,7 @@ public static ICondition<TRuleType> NotBePrivate()
             );
         }
 
-        public static ICondition<TRuleType> NotBePublic()
+        public static IOrderedCondition<TRuleType> NotBePublic()
         {
             return new SimpleCondition<TRuleType>(
                 obj => obj.Visibility != Public,
@@ -1275,7 +1305,7 @@ public static ICondition<TRuleType> NotBePublic()
             );
         }
 
-        public static ICondition<TRuleType> NotBeProtected()
+        public static IOrderedCondition<TRuleType> NotBeProtected()
         {
             return new SimpleCondition<TRuleType>(
                 obj => obj.Visibility != Protected,
@@ -1284,7 +1314,7 @@ public static ICondition<TRuleType> NotBeProtected()
             );
         }
 
-        public static ICondition<TRuleType> NotBeInternal()
+        public static IOrderedCondition<TRuleType> NotBeInternal()
         {
             return new SimpleCondition<TRuleType>(
                 obj => obj.Visibility != Internal,
@@ -1293,7 +1323,7 @@ public static ICondition<TRuleType> NotBeInternal()
             );
         }
 
-        public static ICondition<TRuleType> NotBeProtectedInternal()
+        public static IOrderedCondition<TRuleType> NotBeProtectedInternal()
         {
             return new SimpleCondition<TRuleType>(
                 obj => obj.Visibility != ProtectedInternal,
@@ -1302,7 +1332,7 @@ public static ICondition<TRuleType> NotBeProtectedInternal()
             );
         }
 
-        public static ICondition<TRuleType> NotBePrivateProtected()
+        public static IOrderedCondition<TRuleType> NotBePrivateProtected()
         {
             return new SimpleCondition<TRuleType>(
                 obj => obj.Visibility != PrivateProtected,
diff --git a/ArchUnitNET/Fluent/Syntax/Elements/ObjectsShould.cs b/ArchUnitNET/Fluent/Syntax/Elements/ObjectsShould.cs
index adc5365b3..036fa7642 100644
--- a/ArchUnitNET/Fluent/Syntax/Elements/ObjectsShould.cs
+++ b/ArchUnitNET/Fluent/Syntax/Elements/ObjectsShould.cs
@@ -43,7 +43,7 @@ public TRuleTypeShouldConjunction Exist()
         public TRuleTypeShouldConjunction DependOnAny(IEnumerable<IType> types) => DependOnAny(new ObjectProvider<IType>(types));
         public TRuleTypeShouldConjunction DependOnAny(IEnumerable<Type> types) => DependOnAny(new SystemTypeObjectProvider<IType>(types));
 
-        public TRuleTypeShouldConjunction FollowCustomCondition(ICondition<TRuleType> condition) => AddCondition(condition);
+        public TRuleTypeShouldConjunction FollowCustomCondition(ICondition<TRuleType> condition) => AddCondition(condition.AsOrderedCondition());
         public TRuleTypeShouldConjunction FollowCustomCondition(Func<TRuleType, ConditionResult> condition, string description) => AddCondition(ObjectConditionsDefinition<TRuleType>.FollowCustomCondition(condition, description));
         public TRuleTypeShouldConjunction FollowCustomCondition(Func<TRuleType, bool> condition, string description, string failDescription) => AddCondition(ObjectConditionsDefinition<TRuleType>.FollowCustomCondition(condition, description, failDescription));
 
@@ -189,7 +189,7 @@ public TRuleTypeShouldConjunction NotExist()
         public ShouldRelateToAttributesThat<TRuleTypeShouldConjunction, TRuleType> NotHaveAnyAttributesThat() => BeginComplexAttributeCondition(ObjectConditionsDefinition<TRuleType>.NotHaveAnyAttributesThat());
         // csharpier-ignore-end
 
-        private TRuleTypeShouldConjunction AddCondition(ICondition<TRuleType> condition)
+        private TRuleTypeShouldConjunction AddCondition(IOrderedCondition<TRuleType> condition)
         {
             _ruleCreator.AddCondition(condition);
             return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);
diff --git a/ArchUnitNET/Fluent/Syntax/Elements/Types/Attributes/AttributeConditionsDefinition.cs b/ArchUnitNET/Fluent/Syntax/Elements/Types/Attributes/AttributeConditionsDefinition.cs
index f7678268e..854eec9bb 100644
--- a/ArchUnitNET/Fluent/Syntax/Elements/Types/Attributes/AttributeConditionsDefinition.cs
+++ b/ArchUnitNET/Fluent/Syntax/Elements/Types/Attributes/AttributeConditionsDefinition.cs
@@ -5,7 +5,7 @@ namespace ArchUnitNET.Fluent.Syntax.Elements.Types.Attributes
 {
     public static class AttributeConditionsDefinition
     {
-        public static ICondition<Attribute> BeAbstract()
+        public static IOrderedCondition<Attribute> BeAbstract()
         {
             return new SimpleCondition<Attribute>(
                 attribute => !attribute.IsAbstract.HasValue || attribute.IsAbstract.Value,
@@ -14,7 +14,7 @@ public static ICondition<Attribute> BeAbstract()
             );
         }
 
-        public static ICondition<Attribute> BeSealed()
+        public static IOrderedCondition<Attribute> BeSealed()
         {
             return new SimpleCondition<Attribute>(
                 attribute => !attribute.IsSealed.HasValue || attribute.IsSealed.Value,
@@ -25,7 +25,7 @@ public static ICondition<Attribute> BeSealed()
 
         //Negations
 
-        public static ICondition<Attribute> NotBeAbstract()
+        public static IOrderedCondition<Attribute> NotBeAbstract()
         {
             return new SimpleCondition<Attribute>(
                 attribute => !attribute.IsAbstract.HasValue || !attribute.IsAbstract.Value,
@@ -34,7 +34,7 @@ public static ICondition<Attribute> NotBeAbstract()
             );
         }
 
-        public static ICondition<Attribute> NotBeSealed()
+        public static IOrderedCondition<Attribute> NotBeSealed()
         {
             return new SimpleCondition<Attribute>(
                 attribute => !attribute.IsSealed.HasValue || !attribute.IsSealed.Value,
diff --git a/ArchUnitNET/Fluent/Syntax/Elements/Types/Classes/ClassConditionsDefinition.cs b/ArchUnitNET/Fluent/Syntax/Elements/Types/Classes/ClassConditionsDefinition.cs
index 5fd8b88ed..3bc186b6c 100644
--- a/ArchUnitNET/Fluent/Syntax/Elements/Types/Classes/ClassConditionsDefinition.cs
+++ b/ArchUnitNET/Fluent/Syntax/Elements/Types/Classes/ClassConditionsDefinition.cs
@@ -6,7 +6,7 @@ namespace ArchUnitNET.Fluent.Syntax.Elements.Types.Classes
 {
     public static class ClassConditionsDefinition
     {
-        public static ICondition<Class> BeAbstract()
+        public static IOrderedCondition<Class> BeAbstract()
         {
             return new SimpleCondition<Class>(
                 cls => !cls.IsAbstract.HasValue || cls.IsAbstract.Value,
@@ -15,7 +15,7 @@ public static ICondition<Class> BeAbstract()
             );
         }
 
-        public static ICondition<Class> BeSealed()
+        public static IOrderedCondition<Class> BeSealed()
         {
             return new SimpleCondition<Class>(
                 cls => !cls.IsSealed.HasValue || cls.IsSealed.Value,
@@ -24,7 +24,7 @@ public static ICondition<Class> BeSealed()
             );
         }
 
-        public static ICondition<Class> BeRecord()
+        public static IOrderedCondition<Class> BeRecord()
         {
             return new SimpleCondition<Class>(
                 cls => !cls.IsRecord.HasValue || cls.IsRecord.Value,
@@ -33,7 +33,7 @@ public static ICondition<Class> BeRecord()
             );
         }
 
-        public static ICondition<Class> BeImmutable()
+        public static IOrderedCondition<Class> BeImmutable()
         {
             return new SimpleCondition<Class>(
                 cls =>
@@ -46,7 +46,7 @@ public static ICondition<Class> BeImmutable()
 
         //Negations
 
-        public static ICondition<Class> NotBeAbstract()
+        public static IOrderedCondition<Class> NotBeAbstract()
         {
             return new SimpleCondition<Class>(
                 cls => !cls.IsAbstract.HasValue || !cls.IsAbstract.Value,
@@ -55,7 +55,7 @@ public static ICondition<Class> NotBeAbstract()
             );
         }
 
-        public static ICondition<Class> NotBeSealed()
+        public static IOrderedCondition<Class> NotBeSealed()
         {
             return new SimpleCondition<Class>(
                 cls => !cls.IsSealed.HasValue || !cls.IsSealed.Value,
@@ -64,7 +64,7 @@ public static ICondition<Class> NotBeSealed()
             );
         }
 
-        public static ICondition<Class> NotBeRecord()
+        public static IOrderedCondition<Class> NotBeRecord()
         {
             return new SimpleCondition<Class>(
                 cls => !cls.IsRecord.HasValue || !cls.IsRecord.Value,
@@ -73,7 +73,7 @@ public static ICondition<Class> NotBeRecord()
             );
         }
 
-        public static ICondition<Class> NotBeImmutable()
+        public static IOrderedCondition<Class> NotBeImmutable()
         {
             return new SimpleCondition<Class>(
                 cls => cls.Members.Any(m => m.IsStatic == false && !m.Writability.IsImmutable()),
diff --git a/ArchUnitNET/Fluent/Syntax/Elements/Types/TypeConditionsDefinition.cs b/ArchUnitNET/Fluent/Syntax/Elements/Types/TypeConditionsDefinition.cs
index bfe0a5f6f..bb1d5d595 100644
--- a/ArchUnitNET/Fluent/Syntax/Elements/Types/TypeConditionsDefinition.cs
+++ b/ArchUnitNET/Fluent/Syntax/Elements/Types/TypeConditionsDefinition.cs
@@ -14,14 +14,14 @@ namespace ArchUnitNET.Fluent.Syntax.Elements.Types
     public static class TypeConditionsDefinition<TRuleType>
         where TRuleType : IType
     {
-        public static ICondition<TRuleType> Be(Type firstType, params Type[] moreTypes)
+        public static IOrderedCondition<TRuleType> Be(Type firstType, params Type[] moreTypes)
         {
             var types = new List<Type> { firstType };
             types.AddRange(moreTypes);
             return Be(types);
         }
 
-        public static ICondition<TRuleType> Be(IEnumerable<Type> types)
+        public static IOrderedCondition<TRuleType> Be(IEnumerable<Type> types)
         {
             var typeList = types.ToList();
 
@@ -81,7 +81,10 @@ Architecture architecture
                     );
             }
 
-            return new ArchitectureCondition<TRuleType>(Condition, description);
+            return new ArchitectureCondition<TRuleType>(
+                Condition,
+                description
+            ).AsOrderedCondition();
         }
 
         public static RelationCondition<TRuleType, IType> BeTypesThat()
@@ -93,7 +96,7 @@ public static RelationCondition<TRuleType, IType> BeTypesThat()
             );
         }
 
-        public static ICondition<TRuleType> BeAssignableTo(
+        public static IOrderedCondition<TRuleType> BeAssignableTo(
             IType firstType,
             params IType[] moreTypes
         )
@@ -103,14 +106,19 @@ params IType[] moreTypes
             return BeAssignableTo(types);
         }
 
-        public static ICondition<TRuleType> BeAssignableTo(Type firstType, params Type[] moreTypes)
+        public static IOrderedCondition<TRuleType> BeAssignableTo(
+            Type firstType,
+            params Type[] moreTypes
+        )
         {
             var types = new List<Type> { firstType };
             types.AddRange(moreTypes);
             return BeAssignableTo(types);
         }
 
-        public static ICondition<TRuleType> BeAssignableTo(IObjectProvider<IType> objectProvider)
+        public static IOrderedCondition<TRuleType> BeAssignableTo(
+            IObjectProvider<IType> objectProvider
+        )
         {
             IEnumerable<ConditionResult> Condition(
                 IEnumerable<TRuleType> ruleTypes,
@@ -135,10 +143,13 @@ Architecture architecture
             }
 
             var description = "be assignable to " + objectProvider.Description;
-            return new ArchitectureCondition<TRuleType>(Condition, description);
+            return new ArchitectureCondition<TRuleType>(
+                Condition,
+                description
+            ).AsOrderedCondition();
         }
 
-        public static ICondition<TRuleType> BeAssignableTo(IEnumerable<IType> types)
+        public static IOrderedCondition<TRuleType> BeAssignableTo(IEnumerable<IType> types)
         {
             var typeList = types.ToList();
             var firstType = typeList.First();
@@ -192,10 +203,10 @@ IEnumerable<ConditionResult> Condition(IEnumerable<TRuleType> ruleTypes)
                     );
             }
 
-            return new EnumerableCondition<TRuleType>(Condition, description);
+            return new EnumerableCondition<TRuleType>(Condition, description).AsOrderedCondition();
         }
 
-        public static ICondition<TRuleType> BeAssignableTo(IEnumerable<Type> types)
+        public static IOrderedCondition<TRuleType> BeAssignableTo(IEnumerable<Type> types)
         {
             var typeList = types.ToList();
             var firstType = typeList.First();
@@ -266,24 +277,33 @@ Architecture architecture
                     );
             }
 
-            return new ArchitectureCondition<TRuleType>(Condition, description);
+            return new ArchitectureCondition<TRuleType>(
+                Condition,
+                description
+            ).AsOrderedCondition();
         }
 
-        public static ICondition<TRuleType> BeNestedIn(IType firstType, params IType[] moreTypes)
+        public static IOrderedCondition<TRuleType> BeNestedIn(
+            IType firstType,
+            params IType[] moreTypes
+        )
         {
             var types = new List<IType> { firstType };
             types.AddRange(moreTypes);
             return BeNestedIn(types);
         }
 
-        public static ICondition<TRuleType> BeNestedIn(Type firstType, params Type[] moreTypes)
+        public static IOrderedCondition<TRuleType> BeNestedIn(
+            Type firstType,
+            params Type[] moreTypes
+        )
         {
             var types = new List<Type> { firstType };
             types.AddRange(moreTypes);
             return BeNestedIn(types);
         }
 
-        public static ICondition<TRuleType> BeNestedIn(IObjectProvider<IType> objectProvider)
+        public static IOrderedCondition<TRuleType> BeNestedIn(IObjectProvider<IType> objectProvider)
         {
             IEnumerable<ConditionResult> Condition(
                 IEnumerable<TRuleType> ruleTypes,
@@ -312,10 +332,13 @@ Architecture architecture
             }
 
             var description = "be nested in " + objectProvider.Description;
-            return new ArchitectureCondition<TRuleType>(Condition, description);
+            return new ArchitectureCondition<TRuleType>(
+                Condition,
+                description
+            ).AsOrderedCondition();
         }
 
-        public static ICondition<TRuleType> BeNestedIn(IEnumerable<IType> types)
+        public static IOrderedCondition<TRuleType> BeNestedIn(IEnumerable<IType> types)
         {
             var typeList = types.ToList();
             var firstType = typeList.First();
@@ -373,10 +396,10 @@ IEnumerable<ConditionResult> Condition(IEnumerable<TRuleType> ruleTypes)
                     );
             }
 
-            return new EnumerableCondition<TRuleType>(Condition, description);
+            return new EnumerableCondition<TRuleType>(Condition, description).AsOrderedCondition();
         }
 
-        public static ICondition<TRuleType> BeNestedIn(IEnumerable<Type> types)
+        public static IOrderedCondition<TRuleType> BeNestedIn(IEnumerable<Type> types)
         {
             var typeList = types.ToList();
             var firstType = typeList.First();
@@ -437,10 +460,13 @@ Architecture architecture
                     );
             }
 
-            return new ArchitectureCondition<TRuleType>(Condition, description);
+            return new ArchitectureCondition<TRuleType>(
+                Condition,
+                description
+            ).AsOrderedCondition();
         }
 
-        public static ICondition<TRuleType> BeValueTypes()
+        public static IOrderedCondition<TRuleType> BeValueTypes()
         {
             return new SimpleCondition<TRuleType>(
                 type => type is Enum || type is Struct,
@@ -449,12 +475,12 @@ public static ICondition<TRuleType> BeValueTypes()
             );
         }
 
-        public static ICondition<TRuleType> BeEnums()
+        public static IOrderedCondition<TRuleType> BeEnums()
         {
             return new SimpleCondition<TRuleType>(type => type is Enum, "be enums", "is no enum");
         }
 
-        public static ICondition<TRuleType> BeStructs()
+        public static IOrderedCondition<TRuleType> BeStructs()
         {
             return new SimpleCondition<TRuleType>(
                 type => type is Struct,
@@ -463,7 +489,7 @@ public static ICondition<TRuleType> BeStructs()
             );
         }
 
-        public static ICondition<TRuleType> ImplementInterface(Interface intf)
+        public static IOrderedCondition<TRuleType> ImplementInterface(Interface intf)
         {
             return new SimpleCondition<TRuleType>(
                 type => type.ImplementsInterface(intf),
@@ -472,7 +498,7 @@ public static ICondition<TRuleType> ImplementInterface(Interface intf)
             );
         }
 
-        public static ICondition<TRuleType> ImplementInterface(Type intf)
+        public static IOrderedCondition<TRuleType> ImplementInterface(Type intf)
         {
             IEnumerable<ConditionResult> Condition(
                 IEnumerable<TRuleType> ruleTypes,
@@ -528,10 +554,12 @@ Architecture architecture
             return new ArchitectureCondition<TRuleType>(
                 Condition,
                 "implement interface \"" + intf.FullName + "\""
-            );
+            ).AsOrderedCondition();
         }
 
-        public static ICondition<TRuleType> ImplementAny(IObjectProvider<Interface> interfaces)
+        public static IOrderedCondition<TRuleType> ImplementAny(
+            IObjectProvider<Interface> interfaces
+        )
         {
             IEnumerable<ConditionResult> Condition(
                 IEnumerable<TRuleType> ruleTypes,
@@ -568,10 +596,13 @@ Architecture architecture
                 "implement",
                 "implement any"
             );
-            return new ArchitectureCondition<TRuleType>(Condition, description);
+            return new ArchitectureCondition<TRuleType>(
+                Condition,
+                description
+            ).AsOrderedCondition();
         }
 
-        public static ICondition<TRuleType> ResideInNamespace(string fullName)
+        public static IOrderedCondition<TRuleType> ResideInNamespace(string fullName)
         {
             return new SimpleCondition<TRuleType>(
                 type => type.ResidesInNamespace(fullName),
@@ -580,7 +611,7 @@ public static ICondition<TRuleType> ResideInNamespace(string fullName)
             );
         }
 
-        public static ICondition<TRuleType> ResideInNamespaceMatching(string pattern)
+        public static IOrderedCondition<TRuleType> ResideInNamespaceMatching(string pattern)
         {
             return new SimpleCondition<TRuleType>(
                 type => type.ResidesInNamespaceMatching(pattern),
@@ -589,7 +620,7 @@ public static ICondition<TRuleType> ResideInNamespaceMatching(string pattern)
             );
         }
 
-        public static ICondition<TRuleType> ResideInAssembly(string fullName)
+        public static IOrderedCondition<TRuleType> ResideInAssembly(string fullName)
         {
             return new SimpleCondition<TRuleType>(
                 type => type.ResidesInAssembly(fullName),
@@ -598,7 +629,7 @@ public static ICondition<TRuleType> ResideInAssembly(string fullName)
             );
         }
 
-        public static ICondition<TRuleType> ResideInAssemblyMatching(string pattern)
+        public static IOrderedCondition<TRuleType> ResideInAssemblyMatching(string pattern)
         {
             return new SimpleCondition<TRuleType>(
                 type => type.ResidesInAssemblyMatching(pattern),
@@ -607,7 +638,7 @@ public static ICondition<TRuleType> ResideInAssemblyMatching(string pattern)
             );
         }
 
-        public static ICondition<TRuleType> ResideInAssembly(
+        public static IOrderedCondition<TRuleType> ResideInAssembly(
             System.Reflection.Assembly assembly,
             params System.Reflection.Assembly[] moreAssemblies
         )
@@ -632,7 +663,7 @@ bool Condition(TRuleType ruleType, Architecture architecture)
             );
         }
 
-        public static ICondition<TRuleType> ResideInAssembly(
+        public static IOrderedCondition<TRuleType> ResideInAssembly(
             Assembly assembly,
             Assembly[] moreAssemblies
         )
@@ -655,7 +686,7 @@ bool Condition(TRuleType ruleType)
             );
         }
 
-        public static ICondition<TRuleType> HavePropertyMemberWithName(string name)
+        public static IOrderedCondition<TRuleType> HavePropertyMemberWithName(string name)
         {
             return new SimpleCondition<TRuleType>(
                 type => type.HasPropertyMemberWithName(name),
@@ -664,19 +695,21 @@ public static ICondition<TRuleType> HavePropertyMemberWithName(string name)
             );
         }
 
-        public static ICondition<TRuleType> AdhereToPlantUmlDiagram(Stream stream)
+        public static IOrderedCondition<TRuleType> AdhereToPlantUmlDiagram(Stream stream)
         {
             PlantUmlParsedDiagram diagram = new PlantUmlParser().Parse(stream);
             return createPlantUmlCondition(diagram);
         }
 
-        public static ICondition<TRuleType> AdhereToPlantUmlDiagram(string file)
+        public static IOrderedCondition<TRuleType> AdhereToPlantUmlDiagram(string file)
         {
             PlantUmlParsedDiagram diagram = new PlantUmlParser().Parse(file);
             return createPlantUmlCondition(diagram);
         }
 
-        private static ICondition<TRuleType> createPlantUmlCondition(PlantUmlParsedDiagram diagram)
+        private static IOrderedCondition<TRuleType> createPlantUmlCondition(
+            PlantUmlParsedDiagram diagram
+        )
         {
             ClassDiagramAssociation classDiagramAssociation = new ClassDiagramAssociation(diagram);
 
@@ -725,7 +758,7 @@ ConditionResult Condition(TRuleType ruleType)
             return new SimpleCondition<TRuleType>(Condition, "adhere to PlantUML diagram.");
         }
 
-        public static ICondition<TRuleType> HaveFieldMemberWithName(string name)
+        public static IOrderedCondition<TRuleType> HaveFieldMemberWithName(string name)
         {
             return new SimpleCondition<TRuleType>(
                 type => type.HasFieldMemberWithName(name),
@@ -734,7 +767,7 @@ public static ICondition<TRuleType> HaveFieldMemberWithName(string name)
             );
         }
 
-        public static ICondition<TRuleType> HaveMethodMemberWithName(string name)
+        public static IOrderedCondition<TRuleType> HaveMethodMemberWithName(string name)
         {
             return new SimpleCondition<TRuleType>(
                 type => type.HasMethodMemberWithName(name),
@@ -743,7 +776,7 @@ public static ICondition<TRuleType> HaveMethodMemberWithName(string name)
             );
         }
 
-        public static ICondition<TRuleType> HaveMemberWithName(string name)
+        public static IOrderedCondition<TRuleType> HaveMemberWithName(string name)
         {
             return new SimpleCondition<TRuleType>(
                 type => type.HasMemberWithName(name),
@@ -752,7 +785,7 @@ public static ICondition<TRuleType> HaveMemberWithName(string name)
             );
         }
 
-        public static ICondition<TRuleType> BeNested()
+        public static IOrderedCondition<TRuleType> BeNested()
         {
             return new SimpleCondition<TRuleType>(
                 type => type.IsNested,
@@ -783,14 +816,14 @@ public static RelationCondition<TRuleType, Interface> ImplementAnyInterfacesThat
 
         //Negations
 
-        public static ICondition<TRuleType> NotBe(Type firstType, params Type[] moreTypes)
+        public static IOrderedCondition<TRuleType> NotBe(Type firstType, params Type[] moreTypes)
         {
             var types = new List<Type> { firstType };
             types.AddRange(moreTypes);
             return NotBe(types);
         }
 
-        public static ICondition<TRuleType> NotBe(IEnumerable<Type> types)
+        public static IOrderedCondition<TRuleType> NotBe(IEnumerable<Type> types)
         {
             var typeList = types.ToList();
 
@@ -850,10 +883,13 @@ Architecture architecture
                     );
             }
 
-            return new ArchitectureCondition<TRuleType>(Condition, description);
+            return new ArchitectureCondition<TRuleType>(
+                Condition,
+                description
+            ).AsOrderedCondition();
         }
 
-        public static ICondition<TRuleType> NotBeAssignableTo(
+        public static IOrderedCondition<TRuleType> NotBeAssignableTo(
             IType firstType,
             params IType[] moreTypes
         )
@@ -863,7 +899,7 @@ params IType[] moreTypes
             return NotBeAssignableTo(types);
         }
 
-        public static ICondition<TRuleType> NotBeAssignableTo(
+        public static IOrderedCondition<TRuleType> NotBeAssignableTo(
             Type firstType,
             params Type[] moreTypes
         )
@@ -873,7 +909,9 @@ params Type[] moreTypes
             return NotBeAssignableTo(types);
         }
 
-        public static ICondition<TRuleType> NotBeAssignableTo(IObjectProvider<IType> objectProvider)
+        public static IOrderedCondition<TRuleType> NotBeAssignableTo(
+            IObjectProvider<IType> objectProvider
+        )
         {
             IEnumerable<ConditionResult> Condition(
                 IEnumerable<TRuleType> ruleTypes,
@@ -898,10 +936,13 @@ Architecture architecture
             }
 
             var description = "not be assignable to " + objectProvider.Description;
-            return new ArchitectureCondition<TRuleType>(Condition, description);
+            return new ArchitectureCondition<TRuleType>(
+                Condition,
+                description
+            ).AsOrderedCondition();
         }
 
-        public static ICondition<TRuleType> NotBeAssignableTo(IEnumerable<IType> types)
+        public static IOrderedCondition<TRuleType> NotBeAssignableTo(IEnumerable<IType> types)
         {
             var typeList = types.ToList();
             var firstType = typeList.First();
@@ -969,10 +1010,10 @@ IEnumerable<ConditionResult> Condition(IEnumerable<TRuleType> ruleTypes)
                     );
             }
 
-            return new EnumerableCondition<TRuleType>(Condition, description);
+            return new EnumerableCondition<TRuleType>(Condition, description).AsOrderedCondition();
         }
 
-        public static ICondition<TRuleType> NotBeAssignableTo(IEnumerable<Type> types)
+        public static IOrderedCondition<TRuleType> NotBeAssignableTo(IEnumerable<Type> types)
         {
             var typeList = types.ToList();
             var firstType = typeList.First();
@@ -1061,10 +1102,13 @@ var type in failedObject
                     );
             }
 
-            return new ArchitectureCondition<TRuleType>(Condition, description);
+            return new ArchitectureCondition<TRuleType>(
+                Condition,
+                description
+            ).AsOrderedCondition();
         }
 
-        public static ICondition<TRuleType> NotBeValueTypes()
+        public static IOrderedCondition<TRuleType> NotBeValueTypes()
         {
             return new SimpleCondition<TRuleType>(
                 type => !(type is Enum) && !(type is Struct),
@@ -1073,7 +1117,7 @@ public static ICondition<TRuleType> NotBeValueTypes()
             );
         }
 
-        public static ICondition<TRuleType> NotBeEnums()
+        public static IOrderedCondition<TRuleType> NotBeEnums()
         {
             return new SimpleCondition<TRuleType>(
                 type => !(type is Enum),
@@ -1082,7 +1126,7 @@ public static ICondition<TRuleType> NotBeEnums()
             );
         }
 
-        public static ICondition<TRuleType> NotBeStructs()
+        public static IOrderedCondition<TRuleType> NotBeStructs()
         {
             return new SimpleCondition<TRuleType>(
                 type => !(type is Struct),
@@ -1091,7 +1135,7 @@ public static ICondition<TRuleType> NotBeStructs()
             );
         }
 
-        public static ICondition<TRuleType> NotImplementInterface(Interface intf)
+        public static IOrderedCondition<TRuleType> NotImplementInterface(Interface intf)
         {
             return new SimpleCondition<TRuleType>(
                 type => !type.ImplementsInterface(intf),
@@ -1100,7 +1144,7 @@ public static ICondition<TRuleType> NotImplementInterface(Interface intf)
             );
         }
 
-        public static ICondition<TRuleType> NotImplementInterface(Type intf)
+        public static IOrderedCondition<TRuleType> NotImplementInterface(Type intf)
         {
             IEnumerable<ConditionResult> Condition(
                 IEnumerable<TRuleType> ruleTypes,
@@ -1152,10 +1196,12 @@ Architecture architecture
             return new ArchitectureCondition<TRuleType>(
                 Condition,
                 "not implement interface \"" + intf.FullName + "\""
-            );
+            ).AsOrderedCondition();
         }
 
-        public static ICondition<TRuleType> NotImplementAny(IObjectProvider<Interface> interfaces)
+        public static IOrderedCondition<TRuleType> NotImplementAny(
+            IObjectProvider<Interface> interfaces
+        )
         {
             IEnumerable<ConditionResult> Condition(
                 IEnumerable<TRuleType> ruleTypes,
@@ -1190,10 +1236,13 @@ Architecture architecture
                 "not implement",
                 "not implement any"
             );
-            return new ArchitectureCondition<TRuleType>(Condition, description);
+            return new ArchitectureCondition<TRuleType>(
+                Condition,
+                description
+            ).AsOrderedCondition();
         }
 
-        public static ICondition<TRuleType> NotResideInNamespace(string fullName)
+        public static IOrderedCondition<TRuleType> NotResideInNamespace(string fullName)
         {
             return new SimpleCondition<TRuleType>(
                 type => !type.ResidesInNamespace(fullName),
@@ -1202,7 +1251,7 @@ public static ICondition<TRuleType> NotResideInNamespace(string fullName)
             );
         }
 
-        public static ICondition<TRuleType> NotResideInNamespaceMatching(string pattern)
+        public static IOrderedCondition<TRuleType> NotResideInNamespaceMatching(string pattern)
         {
             return new SimpleCondition<TRuleType>(
                 type => !type.ResidesInNamespaceMatching(pattern),
@@ -1211,7 +1260,7 @@ public static ICondition<TRuleType> NotResideInNamespaceMatching(string pattern)
             );
         }
 
-        public static ICondition<TRuleType> NotResideInAssembly(string fullName)
+        public static IOrderedCondition<TRuleType> NotResideInAssembly(string fullName)
         {
             return new SimpleCondition<TRuleType>(
                 type => !type.ResidesInAssembly(fullName),
@@ -1220,7 +1269,7 @@ public static ICondition<TRuleType> NotResideInAssembly(string fullName)
             );
         }
 
-        public static ICondition<TRuleType> NotResideInAssemblyMatching(string pattern)
+        public static IOrderedCondition<TRuleType> NotResideInAssemblyMatching(string pattern)
         {
             return new SimpleCondition<TRuleType>(
                 type => !type.ResidesInAssemblyMatching(pattern),
@@ -1229,7 +1278,7 @@ public static ICondition<TRuleType> NotResideInAssemblyMatching(string pattern)
             );
         }
 
-        public static ICondition<TRuleType> NotResideInAssembly(
+        public static IOrderedCondition<TRuleType> NotResideInAssembly(
             System.Reflection.Assembly assembly,
             params System.Reflection.Assembly[] moreAssemblies
         )
@@ -1254,7 +1303,7 @@ bool Condition(TRuleType ruleType, Architecture architecture)
             );
         }
 
-        public static ICondition<TRuleType> NotResideInAssembly(
+        public static IOrderedCondition<TRuleType> NotResideInAssembly(
             Assembly assembly,
             params Assembly[] moreAssemblies
         )
@@ -1277,7 +1326,7 @@ bool Condition(TRuleType ruleType)
             );
         }
 
-        public static ICondition<TRuleType> NotHavePropertyMemberWithName(string name)
+        public static IOrderedCondition<TRuleType> NotHavePropertyMemberWithName(string name)
         {
             return new SimpleCondition<TRuleType>(
                 type => !type.HasPropertyMemberWithName(name),
@@ -1286,7 +1335,7 @@ public static ICondition<TRuleType> NotHavePropertyMemberWithName(string name)
             );
         }
 
-        public static ICondition<TRuleType> NotHaveFieldMemberWithName(string name)
+        public static IOrderedCondition<TRuleType> NotHaveFieldMemberWithName(string name)
         {
             return new SimpleCondition<TRuleType>(
                 type => !type.HasFieldMemberWithName(name),
@@ -1295,7 +1344,7 @@ public static ICondition<TRuleType> NotHaveFieldMemberWithName(string name)
             );
         }
 
-        public static ICondition<TRuleType> NotHaveMethodMemberWithName(string name)
+        public static IOrderedCondition<TRuleType> NotHaveMethodMemberWithName(string name)
         {
             return new SimpleCondition<TRuleType>(
                 type => !type.HasMethodMemberWithName(name),
@@ -1304,7 +1353,7 @@ public static ICondition<TRuleType> NotHaveMethodMemberWithName(string name)
             );
         }
 
-        public static ICondition<TRuleType> NotHaveMemberWithName(string name)
+        public static IOrderedCondition<TRuleType> NotHaveMemberWithName(string name)
         {
             return new SimpleCondition<TRuleType>(
                 type => !type.HasMemberWithName(name),
@@ -1313,7 +1362,7 @@ public static ICondition<TRuleType> NotHaveMemberWithName(string name)
             );
         }
 
-        public static ICondition<TRuleType> NotBeNested()
+        public static IOrderedCondition<TRuleType> NotBeNested()
         {
             return new SimpleCondition<TRuleType>(
                 type => !type.IsNested,
diff --git a/ArchUnitNET/Fluent/Syntax/Elements/Types/TypesShould.cs b/ArchUnitNET/Fluent/Syntax/Elements/Types/TypesShould.cs
index c730f3917..f4fd44317 100644
--- a/ArchUnitNET/Fluent/Syntax/Elements/Types/TypesShould.cs
+++ b/ArchUnitNET/Fluent/Syntax/Elements/Types/TypesShould.cs
@@ -505,7 +505,7 @@ public ShouldRelateToInterfacesThat<
             );
         }
 
-        private TRuleTypeShouldConjunction Handle(ICondition<TRuleType> condition)
+        private TRuleTypeShouldConjunction Handle(IOrderedCondition<TRuleType> condition)
         {
             _ruleCreator.AddCondition(condition);
             return Create<TRuleTypeShouldConjunction, TRuleType>(_ruleCreator);