diff --git a/src/Ardalis.Specification/Builder/CacheSpecificationBuilder.cs b/src/Ardalis.Specification/Builder/CacheSpecificationBuilder.cs
deleted file mode 100644
index c5691ecd..00000000
--- a/src/Ardalis.Specification/Builder/CacheSpecificationBuilder.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-namespace Ardalis.Specification;
-
-public class CacheSpecificationBuilder<T> : ICacheSpecificationBuilder<T> where T : class
-{
-    public Specification<T> Specification { get; }
-    public bool IsChainDiscarded { get; set; }
-
-    public CacheSpecificationBuilder(Specification<T> specification)
-        : this(specification, false)
-    {
-    }
-
-    public CacheSpecificationBuilder(Specification<T> specification, bool isChainDiscarded)
-    {
-        Specification = specification;
-        IsChainDiscarded = isChainDiscarded;
-    }
-}
diff --git a/src/Ardalis.Specification/Builder/ICacheSpecificationBuilder.cs b/src/Ardalis.Specification/Builder/ICacheSpecificationBuilder.cs
deleted file mode 100644
index 460deac7..00000000
--- a/src/Ardalis.Specification/Builder/ICacheSpecificationBuilder.cs
+++ /dev/null
@@ -1,6 +0,0 @@
-namespace Ardalis.Specification;
-
-public interface ICacheSpecificationBuilder<T> : ISpecificationBuilder<T> where T : class
-{
-    bool IsChainDiscarded { get; set; }
-}
diff --git a/src/Ardalis.Specification/Builder/IIncludableSpecificationBuilder.cs b/src/Ardalis.Specification/Builder/IIncludableSpecificationBuilder.cs
deleted file mode 100644
index 07857e19..00000000
--- a/src/Ardalis.Specification/Builder/IIncludableSpecificationBuilder.cs
+++ /dev/null
@@ -1,6 +0,0 @@
-namespace Ardalis.Specification;
-
-public interface IIncludableSpecificationBuilder<T, out TProperty> : ISpecificationBuilder<T> where T : class
-{
-    bool IsChainDiscarded { get; set; }
-}
diff --git a/src/Ardalis.Specification/Builder/IOrderedSpecificationBuilder.cs b/src/Ardalis.Specification/Builder/IOrderedSpecificationBuilder.cs
deleted file mode 100644
index 0039dd79..00000000
--- a/src/Ardalis.Specification/Builder/IOrderedSpecificationBuilder.cs
+++ /dev/null
@@ -1,6 +0,0 @@
-namespace Ardalis.Specification;
-
-public interface IOrderedSpecificationBuilder<T> : ISpecificationBuilder<T>
-{
-    bool IsChainDiscarded { get; set; }
-}
diff --git a/src/Ardalis.Specification/Builder/ISpecificationBuilder.cs b/src/Ardalis.Specification/Builder/ISpecificationBuilder.cs
deleted file mode 100644
index dfeba22c..00000000
--- a/src/Ardalis.Specification/Builder/ISpecificationBuilder.cs
+++ /dev/null
@@ -1,11 +0,0 @@
-namespace Ardalis.Specification;
-
-public interface ISpecificationBuilder<T, TResult> : ISpecificationBuilder<T>
-{
-    new Specification<T, TResult> Specification { get; }
-}
-
-public interface ISpecificationBuilder<T>
-{
-    Specification<T> Specification { get; }
-}
diff --git a/src/Ardalis.Specification/Builder/IncludableBuilderExtensions.cs b/src/Ardalis.Specification/Builder/IncludableBuilderExtensions.cs
deleted file mode 100644
index d9d80b8e..00000000
--- a/src/Ardalis.Specification/Builder/IncludableBuilderExtensions.cs
+++ /dev/null
@@ -1,50 +0,0 @@
-namespace Ardalis.Specification;
-
-public static class IncludableBuilderExtensions
-{
-    public static IIncludableSpecificationBuilder<TEntity, TProperty> ThenInclude<TEntity, TPreviousProperty, TProperty>(
-        this IIncludableSpecificationBuilder<TEntity, TPreviousProperty> previousBuilder,
-        Expression<Func<TPreviousProperty, TProperty>> thenIncludeExpression)
-        where TEntity : class
-        => ThenInclude(previousBuilder, thenIncludeExpression, true);
-
-    public static IIncludableSpecificationBuilder<TEntity, TProperty> ThenInclude<TEntity, TPreviousProperty, TProperty>(
-        this IIncludableSpecificationBuilder<TEntity, TPreviousProperty> previousBuilder,
-        Expression<Func<TPreviousProperty, TProperty>> thenIncludeExpression,
-        bool condition)
-        where TEntity : class
-    {
-        if (condition && !previousBuilder.IsChainDiscarded)
-        {
-            var expr = new IncludeExpressionInfo(thenIncludeExpression, typeof(TEntity), typeof(TProperty), typeof(TPreviousProperty));
-            previousBuilder.Specification.Add(expr);
-        }
-
-        var includeBuilder = new IncludableSpecificationBuilder<TEntity, TProperty>(previousBuilder.Specification, !condition || previousBuilder.IsChainDiscarded);
-
-        return includeBuilder;
-    }
-
-    public static IIncludableSpecificationBuilder<TEntity, TProperty> ThenInclude<TEntity, TPreviousProperty, TProperty>(
-        this IIncludableSpecificationBuilder<TEntity, IEnumerable<TPreviousProperty>> previousBuilder,
-        Expression<Func<TPreviousProperty, TProperty>> thenIncludeExpression)
-        where TEntity : class
-        => ThenInclude(previousBuilder, thenIncludeExpression, true);
-
-    public static IIncludableSpecificationBuilder<TEntity, TProperty> ThenInclude<TEntity, TPreviousProperty, TProperty>(
-        this IIncludableSpecificationBuilder<TEntity, IEnumerable<TPreviousProperty>> previousBuilder,
-        Expression<Func<TPreviousProperty, TProperty>> thenIncludeExpression,
-        bool condition)
-        where TEntity : class
-    {
-        if (condition && !previousBuilder.IsChainDiscarded)
-        {
-            var expr = new IncludeExpressionInfo(thenIncludeExpression, typeof(TEntity), typeof(TProperty), typeof(IEnumerable<TPreviousProperty>));
-            previousBuilder.Specification.Add(expr);
-        }
-
-        var includeBuilder = new IncludableSpecificationBuilder<TEntity, TProperty>(previousBuilder.Specification, !condition || previousBuilder.IsChainDiscarded);
-
-        return includeBuilder;
-    }
-}
diff --git a/src/Ardalis.Specification/Builder/IncludableSpecificationBuilder.cs b/src/Ardalis.Specification/Builder/IncludableSpecificationBuilder.cs
deleted file mode 100644
index f1686f50..00000000
--- a/src/Ardalis.Specification/Builder/IncludableSpecificationBuilder.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-namespace Ardalis.Specification;
-
-public class IncludableSpecificationBuilder<T, TProperty> : IIncludableSpecificationBuilder<T, TProperty> where T : class
-{
-    public Specification<T> Specification { get; }
-    public bool IsChainDiscarded { get; set; }
-
-    public IncludableSpecificationBuilder(Specification<T> specification)
-        : this(specification, false)
-    {
-    }
-
-    public IncludableSpecificationBuilder(Specification<T> specification, bool isChainDiscarded)
-    {
-        Specification = specification;
-        IsChainDiscarded = isChainDiscarded;
-    }
-}
diff --git a/src/Ardalis.Specification/Builder/OrderedBuilderExtensions.cs b/src/Ardalis.Specification/Builder/OrderedBuilderExtensions.cs
deleted file mode 100644
index 69c8073e..00000000
--- a/src/Ardalis.Specification/Builder/OrderedBuilderExtensions.cs
+++ /dev/null
@@ -1,50 +0,0 @@
-namespace Ardalis.Specification;
-
-public static class OrderedBuilderExtensions
-{
-    public static IOrderedSpecificationBuilder<T> ThenBy<T>(
-        this IOrderedSpecificationBuilder<T> orderedBuilder,
-        Expression<Func<T, object?>> orderExpression)
-        => ThenBy(orderedBuilder, orderExpression, true);
-
-    public static IOrderedSpecificationBuilder<T> ThenBy<T>(
-        this IOrderedSpecificationBuilder<T> orderedBuilder,
-        Expression<Func<T, object?>> orderExpression,
-        bool condition)
-    {
-        if (condition && !orderedBuilder.IsChainDiscarded)
-        {
-            var expr = new OrderExpressionInfo<T>(orderExpression, OrderTypeEnum.ThenBy);
-            orderedBuilder.Specification.Add(expr);
-        }
-        else
-        {
-            orderedBuilder.IsChainDiscarded = true;
-        }
-
-        return orderedBuilder;
-    }
-
-    public static IOrderedSpecificationBuilder<T> ThenByDescending<T>(
-        this IOrderedSpecificationBuilder<T> orderedBuilder,
-        Expression<Func<T, object?>> orderExpression)
-        => ThenByDescending(orderedBuilder, orderExpression, true);
-
-    public static IOrderedSpecificationBuilder<T> ThenByDescending<T>(
-        this IOrderedSpecificationBuilder<T> orderedBuilder,
-        Expression<Func<T, object?>> orderExpression,
-        bool condition)
-    {
-        if (condition && !orderedBuilder.IsChainDiscarded)
-        {
-            var expr = new OrderExpressionInfo<T>(orderExpression, OrderTypeEnum.ThenByDescending);
-            orderedBuilder.Specification.Add(expr);
-        }
-        else
-        {
-            orderedBuilder.IsChainDiscarded = true;
-        }
-
-        return orderedBuilder;
-    }
-}
diff --git a/src/Ardalis.Specification/Builder/OrderedSpecificationBuilder.cs b/src/Ardalis.Specification/Builder/OrderedSpecificationBuilder.cs
deleted file mode 100644
index 7a319030..00000000
--- a/src/Ardalis.Specification/Builder/OrderedSpecificationBuilder.cs
+++ /dev/null
@@ -1,18 +0,0 @@
-namespace Ardalis.Specification;
-
-public class OrderedSpecificationBuilder<T> : IOrderedSpecificationBuilder<T>
-{
-    public Specification<T> Specification { get; }
-    public bool IsChainDiscarded { get; set; }
-
-    public OrderedSpecificationBuilder(Specification<T> specification)
-        : this(specification, false)
-    {
-    }
-
-    public OrderedSpecificationBuilder(Specification<T> specification, bool isChainDiscarded)
-    {
-        Specification = specification;
-        IsChainDiscarded = isChainDiscarded;
-    }
-}
diff --git a/src/Ardalis.Specification/Builder/SpecificationBuilder.cs b/src/Ardalis.Specification/Builder/SpecificationBuilder.cs
deleted file mode 100644
index b23eed0b..00000000
--- a/src/Ardalis.Specification/Builder/SpecificationBuilder.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-namespace Ardalis.Specification;
-
-public class SpecificationBuilder<T, TResult> : SpecificationBuilder<T>, ISpecificationBuilder<T, TResult>
-{
-    public new Specification<T, TResult> Specification { get; }
-
-    public SpecificationBuilder(Specification<T, TResult> specification)
-        : base(specification)
-    {
-        Specification = specification;
-    }
-}
-
-public class SpecificationBuilder<T> : ISpecificationBuilder<T>
-{
-    public Specification<T> Specification { get; }
-
-    public SpecificationBuilder(Specification<T> specification)
-    {
-        Specification = specification;
-    }
-}
diff --git a/src/Ardalis.Specification/Builder/SpecificationBuilderExtensions.cs b/src/Ardalis.Specification/Builder/SpecificationBuilderExtensions.cs
deleted file mode 100644
index 21f59751..00000000
--- a/src/Ardalis.Specification/Builder/SpecificationBuilderExtensions.cs
+++ /dev/null
@@ -1,534 +0,0 @@
-namespace Ardalis.Specification;
-
-public static class SpecificationBuilderExtensions
-{
-    /// <summary>
-    /// Specify a predicate that will be applied to the query
-    /// </summary>
-    /// <typeparam name="T"></typeparam>
-    /// <param name="specificationBuilder"></param>
-    /// <param name="criteria"></param>
-    public static ISpecificationBuilder<T> Where<T>(
-        this ISpecificationBuilder<T> specificationBuilder,
-        Expression<Func<T, bool>> criteria)
-        => Where(specificationBuilder, criteria, true);
-
-    /// <summary>
-    /// Specify a predicate that will be applied to the query
-    /// </summary>
-    /// <typeparam name="T"></typeparam>
-    /// <param name="specificationBuilder"></param>
-    /// <param name="criteria"></param>
-    /// <param name="condition">If false, the criteria won't be added.</param>
-    public static ISpecificationBuilder<T> Where<T>(
-        this ISpecificationBuilder<T> specificationBuilder,
-        Expression<Func<T, bool>> criteria,
-        bool condition)
-    {
-        if (condition)
-        {
-            var expr = new WhereExpressionInfo<T>(criteria);
-            specificationBuilder.Specification.Add(expr);
-        }
-
-        return specificationBuilder;
-    }
-
-    /// <summary>
-    /// Specify the query result will be ordered by <paramref name="orderExpression"/> in an ascending order
-    /// </summary>
-    /// <typeparam name="T"></typeparam>
-    /// <param name="specificationBuilder"></param>
-    /// <param name="orderExpression"></param>
-    public static IOrderedSpecificationBuilder<T> OrderBy<T>(
-        this ISpecificationBuilder<T> specificationBuilder,
-        Expression<Func<T, object?>> orderExpression)
-        => OrderBy(specificationBuilder, orderExpression, true);
-
-    /// <summary>
-    /// Specify the query result will be ordered by <paramref name="orderExpression"/> in an ascending order
-    /// </summary>
-    /// <typeparam name="T"></typeparam>
-    /// <param name="specificationBuilder"></param>
-    /// <param name="orderExpression"></param>
-    /// <param name="condition">If false, the expression won't be added. The whole Order chain will be discarded.</param>
-    public static IOrderedSpecificationBuilder<T> OrderBy<T>(
-        this ISpecificationBuilder<T> specificationBuilder,
-        Expression<Func<T, object?>> orderExpression,
-        bool condition)
-    {
-        if (condition)
-        {
-            var expr = new OrderExpressionInfo<T>(orderExpression, OrderTypeEnum.OrderBy);
-            specificationBuilder.Specification.Add(expr);
-        }
-
-        var orderedSpecificationBuilder = new OrderedSpecificationBuilder<T>(specificationBuilder.Specification, !condition);
-
-        return orderedSpecificationBuilder;
-    }
-
-    /// <summary>
-    /// Specify the query result will be ordered by <paramref name="orderExpression"/> in a descending order
-    /// </summary>
-    /// <typeparam name="T"></typeparam>
-    /// <param name="specificationBuilder"></param>
-    /// <param name="orderExpression"></param>
-    public static IOrderedSpecificationBuilder<T> OrderByDescending<T>(
-        this ISpecificationBuilder<T> specificationBuilder,
-        Expression<Func<T, object?>> orderExpression)
-        => OrderByDescending(specificationBuilder, orderExpression, true);
-
-    /// <summary>
-    /// Specify the query result will be ordered by <paramref name="orderExpression"/> in a descending order
-    /// </summary>
-    /// <typeparam name="T"></typeparam>
-    /// <param name="specificationBuilder"></param>
-    /// <param name="orderExpression"></param>
-    /// <param name="condition">If false, the expression won't be added. The whole Order chain will be discarded.</param>
-    public static IOrderedSpecificationBuilder<T> OrderByDescending<T>(
-        this ISpecificationBuilder<T> specificationBuilder,
-        Expression<Func<T, object?>> orderExpression,
-        bool condition)
-    {
-        if (condition)
-        {
-            var expr = new OrderExpressionInfo<T>(orderExpression, OrderTypeEnum.OrderByDescending);
-            specificationBuilder.Specification.Add(expr);
-        }
-
-        var orderedSpecificationBuilder = new OrderedSpecificationBuilder<T>(specificationBuilder.Specification, !condition);
-
-        return orderedSpecificationBuilder;
-    }
-
-    /// <summary>
-    /// Specify an include expression.
-    /// This information is utilized to build Include function in the query, which ORM tools like Entity Framework use
-    /// to include related entities (via navigation properties) in the query result.
-    /// </summary>
-    /// <typeparam name="T"></typeparam>
-    /// <typeparam name="TProperty"></typeparam>
-    /// <param name="specificationBuilder"></param>
-    /// <param name="includeExpression"></param>
-    public static IIncludableSpecificationBuilder<T, TProperty> Include<T, TProperty>(
-        this ISpecificationBuilder<T> specificationBuilder,
-        Expression<Func<T, TProperty>> includeExpression) where T : class
-        => Include(specificationBuilder, includeExpression, true);
-
-    /// <summary>
-    /// Specify an include expression.
-    /// This information is utilized to build Include function in the query, which ORM tools like Entity Framework use
-    /// to include related entities (via navigation properties) in the query result.
-    /// </summary>
-    /// <typeparam name="T"></typeparam>
-    /// <typeparam name="TProperty"></typeparam>
-    /// <param name="specificationBuilder"></param>
-    /// <param name="includeExpression"></param>
-    /// <param name="condition">If false, the expression won't be added. The whole Include chain will be discarded.</param>
-    public static IIncludableSpecificationBuilder<T, TProperty> Include<T, TProperty>(
-        this ISpecificationBuilder<T> specificationBuilder,
-        Expression<Func<T, TProperty>> includeExpression,
-        bool condition) where T : class
-    {
-        if (condition)
-        {
-            var expr = new IncludeExpressionInfo(includeExpression, typeof(T), typeof(TProperty));
-            specificationBuilder.Specification.Add(expr);
-        }
-
-        var includeBuilder = new IncludableSpecificationBuilder<T, TProperty>(specificationBuilder.Specification, !condition);
-
-        return includeBuilder;
-    }
-
-    /// <summary>
-    /// Specify a collection of navigation properties, as strings, to include in the query.
-    /// </summary>
-    /// <typeparam name="T"></typeparam>
-    /// <param name="specificationBuilder"></param>
-    /// <param name="includeString"></param>
-    public static ISpecificationBuilder<T> Include<T>(
-        this ISpecificationBuilder<T> specificationBuilder,
-        string includeString) where T : class
-        => Include(specificationBuilder, includeString, true);
-
-    /// <summary>
-    /// Specify a collection of navigation properties, as strings, to include in the query.
-    /// </summary>
-    /// <typeparam name="T"></typeparam>
-    /// <param name="specificationBuilder"></param>
-    /// <param name="includeString"></param>
-    /// <param name="condition">If false, the include expression won't be added.</param>
-    public static ISpecificationBuilder<T> Include<T>(
-        this ISpecificationBuilder<T> specificationBuilder,
-        string includeString,
-        bool condition) where T : class
-    {
-        if (condition)
-        {
-            specificationBuilder.Specification.Add(includeString);
-        }
-
-        return specificationBuilder;
-    }
-
-    /// <summary>
-    /// Specify a 'SQL LIKE' operations for search purposes
-    /// </summary>
-    /// <typeparam name="T"></typeparam>
-    /// <param name="specificationBuilder"></param>
-    /// <param name="selector">the property to apply the SQL LIKE against</param>
-    /// <param name="searchTerm">the value to use for the SQL LIKE</param>
-    /// <param name="searchGroup">the index used to group sets of Selectors and SearchTerms together</param>
-    public static ISpecificationBuilder<T> Search<T>(
-        this ISpecificationBuilder<T> specificationBuilder,
-        Expression<Func<T, string>> selector,
-        string searchTerm,
-        int searchGroup = 1) where T : class
-        => Search(specificationBuilder, selector, searchTerm, true, searchGroup);
-
-    /// <summary>
-    /// Specify a 'SQL LIKE' operations for search purposes
-    /// </summary>
-    /// <typeparam name="T"></typeparam>
-    /// <param name="specificationBuilder"></param>
-    /// <param name="selector">the property to apply the SQL LIKE against</param>
-    /// <param name="searchTerm">the value to use for the SQL LIKE</param>
-    /// <param name="condition">If false, the expression won't be added.</param>
-    /// <param name="searchGroup">the index used to group sets of Selectors and SearchTerms together</param>
-    public static ISpecificationBuilder<T> Search<T>(
-        this ISpecificationBuilder<T> specificationBuilder,
-        Expression<Func<T, string>> selector,
-        string searchTerm,
-        bool condition,
-        int searchGroup = 1) where T : class
-    {
-        if (condition)
-        {
-            var expr = new SearchExpressionInfo<T>(selector, searchTerm, searchGroup);
-            specificationBuilder.Specification.Add(expr);
-        }
-
-        return specificationBuilder;
-    }
-
-    /// <summary>
-    /// Specify the number of elements to return.
-    /// </summary>
-    /// <param name="specificationBuilder"></param>
-    /// <param name="take">number of elements to take</param>
-    public static ISpecificationBuilder<T> Take<T>(
-        this ISpecificationBuilder<T> specificationBuilder,
-        int take)
-        => Take(specificationBuilder, take, true);
-
-    /// <summary>
-    /// Specify the number of elements to return.
-    /// </summary>
-    /// <param name="specificationBuilder"></param>
-    /// <param name="take">number of elements to take</param>
-    /// <param name="condition">If false, the value will be discarded.</param>
-    public static ISpecificationBuilder<T> Take<T>(
-        this ISpecificationBuilder<T> specificationBuilder,
-        int take,
-        bool condition)
-    {
-        if (condition)
-        {
-            if (specificationBuilder.Specification.Take != -1) throw new DuplicateTakeException();
-
-            specificationBuilder.Specification.Take = take;
-        }
-
-        return specificationBuilder;
-    }
-
-    /// <summary>
-    /// Specify the number of elements to skip before returning the remaining elements.
-    /// </summary>
-    /// <typeparam name="T"></typeparam>
-    /// <param name="specificationBuilder"></param>
-    /// <param name="skip">number of elements to skip</param>
-    public static ISpecificationBuilder<T> Skip<T>(
-        this ISpecificationBuilder<T> specificationBuilder,
-        int skip)
-        => Skip(specificationBuilder, skip, true);
-
-    /// <summary>
-    /// Specify the number of elements to skip before returning the remaining elements.
-    /// </summary>
-    /// <typeparam name="T"></typeparam>
-    /// <param name="specificationBuilder"></param>
-    /// <param name="skip">number of elements to skip</param>
-    /// <param name="condition">If false, the value will be discarded.</param>
-    public static ISpecificationBuilder<T> Skip<T>(
-        this ISpecificationBuilder<T> specificationBuilder,
-        int skip,
-        bool condition)
-    {
-        if (condition)
-        {
-            if (specificationBuilder.Specification.Skip != -1) throw new DuplicateSkipException();
-
-            specificationBuilder.Specification.Skip = skip;
-        }
-
-        return specificationBuilder;
-    }
-
-    /// <summary>
-    /// Specify a transform function to apply to the <typeparamref name="T"/> element 
-    /// to produce another <typeparamref name="TResult"/> element.
-    /// </summary>
-    public static ISpecificationBuilder<T, TResult> Select<T, TResult>(
-        this ISpecificationBuilder<T, TResult> specificationBuilder,
-        Expression<Func<T, TResult>> selector)
-    {
-        specificationBuilder.Specification.Selector = selector;
-
-        return specificationBuilder;
-    }
-
-    /// <summary>
-    /// Specify a transform function to apply to the <typeparamref name="T"/> element 
-    /// to produce a flattened sequence of <typeparamref name="TResult"/> elements.
-    /// </summary>
-    public static ISpecificationBuilder<T, TResult> SelectMany<T, TResult>(
-        this ISpecificationBuilder<T, TResult> specificationBuilder,
-        Expression<Func<T, IEnumerable<TResult>>> selector)
-    {
-        specificationBuilder.Specification.SelectorMany = selector;
-
-        return specificationBuilder;
-    }
-
-    /// <summary>
-    /// Specify a transform function to apply to the result of the query 
-    /// and returns the same <typeparamref name="T"/> type
-    /// </summary>
-    public static ISpecificationBuilder<T> PostProcessingAction<T>(
-        this ISpecificationBuilder<T> specificationBuilder,
-        Func<IEnumerable<T>, IEnumerable<T>> predicate)
-    {
-        specificationBuilder.Specification.PostProcessingAction = predicate;
-
-        return specificationBuilder;
-    }
-
-    /// <summary>
-    /// Specify a transform function to apply to the result of the query.
-    /// and returns another <typeparamref name="TResult"/> type
-    /// </summary>
-    public static ISpecificationBuilder<T, TResult> PostProcessingAction<T, TResult>(
-        this ISpecificationBuilder<T, TResult> specificationBuilder,
-        Func<IEnumerable<TResult>, IEnumerable<TResult>> predicate)
-    {
-        specificationBuilder.Specification.PostProcessingAction = predicate;
-
-        return specificationBuilder;
-    }
-
-    /// <summary>
-    /// Must be called after specifying criteria
-    /// </summary>
-    /// <param name="specificationName"></param>
-    /// <param name="args">Any arguments used in defining the specification</param>
-    public static ICacheSpecificationBuilder<T> EnableCache<T>(
-        this ISpecificationBuilder<T> specificationBuilder,
-        string specificationName,
-        params object[] args) where T : class
-        => EnableCache(specificationBuilder, specificationName, true, args);
-
-    /// <summary>
-    /// Must be called after specifying criteria
-    /// </summary>
-    /// <param name="specificationName"></param>
-    /// <param name="args">Any arguments used in defining the specification</param>
-    /// <param name="condition">If false, the caching won't be enabled.</param>
-    public static ICacheSpecificationBuilder<T> EnableCache<T>(
-        this ISpecificationBuilder<T> specificationBuilder,
-        string specificationName,
-        bool condition,
-        params object[] args) where T : class
-    {
-        if (condition)
-        {
-            if (string.IsNullOrEmpty(specificationName))
-            {
-                throw new ArgumentException($"Required input {specificationName} was null or empty.", specificationName);
-            }
-
-            specificationBuilder.Specification.CacheKey = $"{specificationName}-{string.Join("-", args)}";
-        }
-
-        var cacheBuilder = new CacheSpecificationBuilder<T>(specificationBuilder.Specification, !condition);
-
-        return cacheBuilder;
-    }
-
-    /// <summary>
-    /// If the entity instances are modified, this will be detected
-    /// by the change tracker.
-    /// </summary>
-    /// <param name="specificationBuilder"></param>
-    public static ISpecificationBuilder<T> AsTracking<T>(
-        this ISpecificationBuilder<T> specificationBuilder) where T : class
-        => AsTracking(specificationBuilder, true);
-
-    /// <summary>
-    /// If the entity instances are modified, this will be detected
-    /// by the change tracker.
-    /// </summary>
-    /// <param name="specificationBuilder"></param>
-    /// <param name="condition">If false, the setting will be discarded.</param>
-    public static ISpecificationBuilder<T> AsTracking<T>(
-        this ISpecificationBuilder<T> specificationBuilder,
-        bool condition) where T : class
-    {
-        if (condition)
-        {
-            specificationBuilder.Specification.AsNoTracking = false;
-            specificationBuilder.Specification.AsNoTrackingWithIdentityResolution = false;
-            specificationBuilder.Specification.AsTracking = true;
-        }
-
-        return specificationBuilder;
-    }
-
-    /// <summary>
-    /// If the entity instances are modified, this will not be detected
-    /// by the change tracker.
-    /// </summary>
-    /// <param name="specificationBuilder"></param>
-    public static ISpecificationBuilder<T> AsNoTracking<T>(
-        this ISpecificationBuilder<T> specificationBuilder) where T : class
-        => AsNoTracking(specificationBuilder, true);
-
-    /// <summary>
-    /// If the entity instances are modified, this will not be detected
-    /// by the change tracker.
-    /// </summary>
-    /// <param name="specificationBuilder"></param>
-    /// <param name="condition">If false, the setting will be discarded.</param>
-    public static ISpecificationBuilder<T> AsNoTracking<T>(
-        this ISpecificationBuilder<T> specificationBuilder,
-        bool condition) where T : class
-    {
-        if (condition)
-        {
-            specificationBuilder.Specification.AsTracking = false;
-            specificationBuilder.Specification.AsNoTrackingWithIdentityResolution = false;
-            specificationBuilder.Specification.AsNoTracking = true;
-        }
-
-        return specificationBuilder;
-    }
-
-    /// <summary>
-    /// The generated sql query will be split into multiple SQL queries
-    /// </summary>
-    /// <remarks>
-    /// This feature was introduced in EF Core 5.0. It only works when using Include
-    /// for more info: https://docs.microsoft.com/en-us/ef/core/querying/single-split-queries
-    /// </remarks>
-    /// <typeparam name="T"></typeparam>
-    /// <param name="specificationBuilder"></param>
-    public static ISpecificationBuilder<T> AsSplitQuery<T>(
-        this ISpecificationBuilder<T> specificationBuilder) where T : class
-        => AsSplitQuery(specificationBuilder, true);
-
-    /// <summary>
-    /// The generated sql query will be split into multiple SQL queries
-    /// </summary>
-    /// <remarks>
-    /// This feature was introduced in EF Core 5.0. It only works when using Include
-    /// for more info: https://docs.microsoft.com/en-us/ef/core/querying/single-split-queries
-    /// </remarks>
-    /// <typeparam name="T"></typeparam>
-    /// <param name="specificationBuilder"></param>
-    /// <param name="condition">If false, the setting will be discarded.</param>
-    public static ISpecificationBuilder<T> AsSplitQuery<T>(
-        this ISpecificationBuilder<T> specificationBuilder,
-        bool condition) where T : class
-    {
-        if (condition)
-        {
-            specificationBuilder.Specification.AsSplitQuery = true;
-        }
-
-        return specificationBuilder;
-    }
-
-    /// <summary>
-    /// The query will then keep track of returned instances 
-    /// (without tracking them in the normal way) 
-    /// and ensure no duplicates are created in the query results
-    /// </summary>
-    /// <remarks>
-    /// for more info: https://docs.microsoft.com/en-us/ef/core/change-tracking/identity-resolution#identity-resolution-and-queries
-    /// </remarks>
-    /// <typeparam name="T"></typeparam>
-    /// <param name="specificationBuilder"></param>
-    public static ISpecificationBuilder<T> AsNoTrackingWithIdentityResolution<T>(
-        this ISpecificationBuilder<T> specificationBuilder) where T : class
-        => AsNoTrackingWithIdentityResolution(specificationBuilder, true);
-
-    /// <summary>
-    /// The query will then keep track of returned instances 
-    /// (without tracking them in the normal way) 
-    /// and ensure no duplicates are created in the query results
-    /// </summary>
-    /// <remarks>
-    /// for more info: https://docs.microsoft.com/en-us/ef/core/change-tracking/identity-resolution#identity-resolution-and-queries
-    /// </remarks>
-    /// <typeparam name="T"></typeparam>
-    /// <param name="specificationBuilder"></param>
-    /// <param name="condition">If false, the setting will be discarded.</param>
-    public static ISpecificationBuilder<T> AsNoTrackingWithIdentityResolution<T>(
-        this ISpecificationBuilder<T> specificationBuilder,
-        bool condition) where T : class
-    {
-        if (condition)
-        {
-            specificationBuilder.Specification.AsTracking = false;
-            specificationBuilder.Specification.AsNoTracking = false;
-            specificationBuilder.Specification.AsNoTrackingWithIdentityResolution = true;
-        }
-
-        return specificationBuilder;
-    }
-
-    /// <summary>
-    /// The query will ignore the defined global query filters
-    /// </summary>
-    /// <remarks>
-    /// for more info: https://docs.microsoft.com/en-us/ef/core/querying/filters
-    /// </remarks>
-    /// <typeparam name="T"></typeparam>
-    /// <param name="specificationBuilder"></param>
-    public static ISpecificationBuilder<T> IgnoreQueryFilters<T>(
-        this ISpecificationBuilder<T> specificationBuilder) where T : class
-        => IgnoreQueryFilters(specificationBuilder, true);
-
-    /// <summary>
-    /// The query will ignore the defined global query filters
-    /// </summary>
-    /// <remarks>
-    /// for more info: https://docs.microsoft.com/en-us/ef/core/querying/filters
-    /// </remarks>
-    /// <typeparam name="T"></typeparam>
-    /// <param name="specificationBuilder"></param>
-    /// <param name="condition">If false, the setting will be discarded.</param>
-    public static ISpecificationBuilder<T> IgnoreQueryFilters<T>(
-        this ISpecificationBuilder<T> specificationBuilder,
-        bool condition) where T : class
-    {
-        if (condition)
-        {
-            specificationBuilder.Specification.IgnoreQueryFilters = true;
-        }
-
-        return specificationBuilder;
-    }
-}
diff --git a/src/Ardalis.Specification/Builders/Builder_Cache.cs b/src/Ardalis.Specification/Builders/Builder_Cache.cs
new file mode 100644
index 00000000..d1b098c8
--- /dev/null
+++ b/src/Ardalis.Specification/Builders/Builder_Cache.cs
@@ -0,0 +1,96 @@
+namespace Ardalis.Specification;
+
+public static partial class SpecificationBuilderExtensions
+{
+    /// <summary>
+    /// Set's the cache key for the specification.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="specificationName">Used as prefix for the cache key</param>
+    /// <param name="args">To be appended to the cache key, separated by dash.</param>
+    /// <returns>The updated ordered specification builder.</returns>
+    /// <exception cref="ArgumentException">If specificationName is null or empty.</exception>
+    public static ICacheSpecificationBuilder<T, TResult> EnableCache<T, TResult>(
+        this ISpecificationBuilder<T, TResult> builder,
+        string specificationName,
+        params object[] args) where T : class
+        => EnableCache(builder, specificationName, true, args);
+
+    /// <summary>
+    /// Set's the cache key for the specification.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="specificationName">Used as prefix for the cache key</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <param name="args">To be appended to the cache key, separated by dash.</param>
+    /// <returns>The updated ordered specification builder.</returns>
+    /// <exception cref="ArgumentException">If specificationName is null or empty.</exception>
+    public static ICacheSpecificationBuilder<T, TResult> EnableCache<T, TResult>(
+        this ISpecificationBuilder<T, TResult> builder,
+        string specificationName,
+        bool condition,
+        params object[] args) where T : class
+    {
+        if (condition)
+        {
+            if (string.IsNullOrEmpty(specificationName))
+            {
+                throw new ArgumentException($"Required input {specificationName} was null or empty.", specificationName);
+            }
+
+            builder.Specification.CacheKey = $"{specificationName}-{string.Join("-", args)}";
+        }
+
+        Specification<T, TResult>.IsChainDiscarded = !condition;
+        return (SpecificationBuilder<T, TResult>)builder;
+    }
+
+    /// <summary>
+    /// Set's the cache key for the specification.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="specificationName">Used as prefix for the cache key</param>
+    /// <param name="args">To be appended to the cache key, separated by dash.</param>
+    /// <returns>The updated ordered specification builder.</returns>
+    /// <exception cref="ArgumentException">If specificationName is null or empty.</exception>
+    public static ICacheSpecificationBuilder<T> EnableCache<T>(
+        this ISpecificationBuilder<T> builder,
+        string specificationName,
+        params object[] args) where T : class
+        => EnableCache(builder, specificationName, true, args);
+
+    /// <summary>
+    /// Set's the cache key for the specification.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="specificationName">Used as prefix for the cache key</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <param name="args">To be appended to the cache key, separated by dash.</param>
+    /// <returns>The updated ordered specification builder.</returns>
+    /// <exception cref="ArgumentException">If specificationName is null or empty.</exception>
+    public static ICacheSpecificationBuilder<T> EnableCache<T>(
+        this ISpecificationBuilder<T> builder,
+        string specificationName,
+        bool condition,
+        params object[] args) where T : class
+    {
+        if (condition)
+        {
+            if (string.IsNullOrEmpty(specificationName))
+            {
+                throw new ArgumentException($"Required input {specificationName} was null or empty.", specificationName);
+            }
+
+            builder.Specification.CacheKey = $"{specificationName}-{string.Join("-", args)}";
+        }
+
+        Specification<T>.IsChainDiscarded = !condition;
+        return (SpecificationBuilder<T>)builder;
+    }
+}
diff --git a/src/Ardalis.Specification/Builders/Builder_Flags.cs b/src/Ardalis.Specification/Builders/Builder_Flags.cs
new file mode 100644
index 00000000..62a84228
--- /dev/null
+++ b/src/Ardalis.Specification/Builders/Builder_Flags.cs
@@ -0,0 +1,328 @@
+namespace Ardalis.Specification;
+
+public static partial class SpecificationBuilderExtensions
+{
+    /// <summary>
+    /// Configures the specification to ignore query filters.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T, TResult> IgnoreQueryFilters<T, TResult>(
+        this ISpecificationBuilder<T, TResult> builder) where T : class
+        => IgnoreQueryFilters(builder, true);
+
+    /// <summary>
+    /// Configures the specification to ignore query filters if the condition is true.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T, TResult> IgnoreQueryFilters<T, TResult>(
+        this ISpecificationBuilder<T, TResult> builder,
+        bool condition) where T : class
+    {
+        if (condition)
+        {
+            builder.Specification.IgnoreQueryFilters = true;
+        }
+
+        return builder;
+    }
+
+    /// <summary>
+    /// Configures the specification to ignore query filters.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T> IgnoreQueryFilters<T>(
+        this ISpecificationBuilder<T> builder) where T : class
+        => IgnoreQueryFilters(builder, true);
+
+    /// <summary>
+    /// Configures the specification to ignore query filters if the condition is true.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T> IgnoreQueryFilters<T>(
+        this ISpecificationBuilder<T> builder,
+        bool condition) where T : class
+    {
+        if (condition)
+        {
+            builder.Specification.IgnoreQueryFilters = true;
+        }
+
+        return builder;
+    }
+
+    /// <summary>
+    /// Configures the specification to use split queries.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T, TResult> AsSplitQuery<T, TResult>(
+        this ISpecificationBuilder<T, TResult> builder) where T : class
+        => AsSplitQuery(builder, true);
+
+    /// <summary>
+    /// Configures the specification to use split queries if the condition is true.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T, TResult> AsSplitQuery<T, TResult>(
+        this ISpecificationBuilder<T, TResult> builder,
+        bool condition) where T : class
+    {
+        if (condition)
+        {
+            builder.Specification.AsSplitQuery = true;
+        }
+
+        return builder;
+    }
+
+    /// <summary>
+    /// Configures the specification to use split queries.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T> AsSplitQuery<T>(
+        this ISpecificationBuilder<T> builder) where T : class
+        => AsSplitQuery(builder, true);
+
+    /// <summary>
+    /// Configures the specification to use split queries if the condition is true.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T> AsSplitQuery<T>(
+        this ISpecificationBuilder<T> builder,
+        bool condition) where T : class
+    {
+        if (condition)
+        {
+            builder.Specification.AsSplitQuery = true;
+        }
+
+        return builder;
+    }
+
+    /// <summary>
+    /// Configures the specification to apply NoTracking behavior.
+    /// It will also disable AsNoTrackingWithIdentityResolution and AsTracking flags.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T, TResult> AsNoTracking<T, TResult>(
+        this ISpecificationBuilder<T, TResult> builder) where T : class
+        => AsNoTracking(builder, true);
+
+    /// <summary>
+    /// Configures the specification to apply NoTracking behavior if the condition is true.
+    /// It will also disable AsNoTrackingWithIdentityResolution and AsTracking flags.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T, TResult> AsNoTracking<T, TResult>(
+        this ISpecificationBuilder<T, TResult> builder,
+        bool condition) where T : class
+    {
+        if (condition)
+        {
+            builder.Specification.AsTracking = false;
+            builder.Specification.AsNoTrackingWithIdentityResolution = false;
+            builder.Specification.AsNoTracking = true;
+        }
+
+        return builder;
+    }
+
+    /// <summary>
+    /// Configures the specification to apply NoTracking behavior.
+    /// It will also disable AsNoTrackingWithIdentityResolution and AsTracking flags.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T> AsNoTracking<T>(
+        this ISpecificationBuilder<T> builder) where T : class
+        => AsNoTracking(builder, true);
+
+    /// <summary>
+    /// Configures the specification to apply NoTracking behavior if the condition is true.
+    /// It will also disable AsNoTrackingWithIdentityResolution and AsTracking flags.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T> AsNoTracking<T>(
+        this ISpecificationBuilder<T> builder,
+        bool condition) where T : class
+    {
+        if (condition)
+        {
+            builder.Specification.AsTracking = false;
+            builder.Specification.AsNoTrackingWithIdentityResolution = false;
+            builder.Specification.AsNoTracking = true;
+        }
+
+        return builder;
+    }
+
+    /// <summary>
+    /// Configures the specification to apply AsNoTrackingWithIdentityResolution behavior.
+    /// It will also disable AsNoTracking and AsTracking flags.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T, TResult> AsNoTrackingWithIdentityResolution<T, TResult>(
+        this ISpecificationBuilder<T, TResult> builder) where T : class
+        => AsNoTrackingWithIdentityResolution(builder, true);
+
+    /// <summary>
+    /// Configures the specification to apply AsNoTrackingWithIdentityResolution behavior if the condition is true.
+    /// It will also disable AsNoTracking and AsTracking flags.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T, TResult> AsNoTrackingWithIdentityResolution<T, TResult>(
+        this ISpecificationBuilder<T, TResult> builder,
+        bool condition) where T : class
+    {
+        if (condition)
+        {
+            builder.Specification.AsTracking = false;
+            builder.Specification.AsNoTracking = false;
+            builder.Specification.AsNoTrackingWithIdentityResolution = true;
+        }
+
+        return builder;
+    }
+
+    /// <summary>
+    /// Configures the specification to apply AsNoTrackingWithIdentityResolution behavior.
+    /// It will also disable AsNoTracking and AsTracking flags.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T> AsNoTrackingWithIdentityResolution<T>(
+        this ISpecificationBuilder<T> builder) where T : class
+        => AsNoTrackingWithIdentityResolution(builder, true);
+
+    /// <summary>
+    /// Configures the specification to apply AsNoTrackingWithIdentityResolution behavior if the condition is true.
+    /// It will also disable AsNoTracking and AsTracking flags.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T> AsNoTrackingWithIdentityResolution<T>(
+        this ISpecificationBuilder<T> builder,
+        bool condition) where T : class
+    {
+        if (condition)
+        {
+            builder.Specification.AsTracking = false;
+            builder.Specification.AsNoTracking = false;
+            builder.Specification.AsNoTrackingWithIdentityResolution = true;
+        }
+
+        return builder;
+    }
+
+    /// <summary>
+    /// Configures the specification to apply AsTracking behavior.
+    /// It will also disable AsNoTrackingWithIdentityResolution and AsNoTracking flags.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T, TResult> AsTracking<T, TResult>(
+        this ISpecificationBuilder<T, TResult> builder) where T : class
+        => AsTracking(builder, true);
+
+    /// <summary>
+    /// Configures the specification to apply AsTracking behavior if the condition is true.
+    /// It will also disable AsNoTrackingWithIdentityResolution and AsNoTracking flags.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T, TResult> AsTracking<T, TResult>(
+        this ISpecificationBuilder<T, TResult> builder,
+        bool condition) where T : class
+    {
+        if (condition)
+        {
+            builder.Specification.AsNoTracking = false;
+            builder.Specification.AsNoTrackingWithIdentityResolution = false;
+            builder.Specification.AsTracking = true;
+        }
+
+        return builder;
+    }
+
+    /// <summary>
+    /// Configures the specification to apply AsTracking behavior.
+    /// It will also disable AsNoTrackingWithIdentityResolution and AsNoTracking flags.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T> AsTracking<T>(
+        this ISpecificationBuilder<T> builder) where T : class
+        => AsTracking(builder, true);
+
+    /// <summary>
+    /// Configures the specification to apply AsTracking behavior if the condition is true.
+    /// It will also disable AsNoTrackingWithIdentityResolution and AsNoTracking flags.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T> AsTracking<T>(
+        this ISpecificationBuilder<T> builder,
+        bool condition) where T : class
+    {
+        if (condition)
+        {
+            builder.Specification.AsNoTracking = false;
+            builder.Specification.AsNoTrackingWithIdentityResolution = false;
+            builder.Specification.AsTracking = true;
+        }
+
+        return builder;
+    }
+}
diff --git a/src/Ardalis.Specification/Builders/Builder_Include.cs b/src/Ardalis.Specification/Builders/Builder_Include.cs
new file mode 100644
index 00000000..945d920f
--- /dev/null
+++ b/src/Ardalis.Specification/Builders/Builder_Include.cs
@@ -0,0 +1,334 @@
+namespace Ardalis.Specification;
+
+public static partial class SpecificationBuilderExtensions
+{
+    /// <summary>
+    /// Adds an Include clause to the specification.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="includeString">The include string.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T, TResult> Include<T, TResult>(
+        this ISpecificationBuilder<T, TResult> builder,
+        string includeString) where T : class
+        => Include(builder, includeString, true);
+
+    /// <summary>
+    /// Adds an Include clause to the specification if the condition is true.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="includeString">The include string.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T, TResult> Include<T, TResult>(
+        this ISpecificationBuilder<T, TResult> builder,
+        string includeString,
+        bool condition) where T : class
+    {
+        if (condition)
+        {
+            builder.Specification.Add(includeString);
+        }
+
+        return builder;
+    }
+
+    /// <summary>
+    /// Adds an Include clause to the specification.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="includeString">The include string.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T> Include<T>(
+        this ISpecificationBuilder<T> builder,
+        string includeString) where T : class
+        => Include(builder, includeString, true);
+
+    /// <summary>
+    /// Adds an Include clause to the specification if the condition is true.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="includeString">The include string.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T> Include<T>(
+        this ISpecificationBuilder<T> builder,
+        string includeString,
+        bool condition) where T : class
+    {
+        if (condition)
+        {
+            builder.Specification.Add(includeString);
+        }
+
+        return builder;
+    }
+
+    /// <summary>
+    /// Adds an Include clause to the specification.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <typeparam name="TProperty">The type of the property.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="navigationSelector">The include expression.</param>
+    /// <returns>The updated includable specification builder.</returns>
+    public static IIncludableSpecificationBuilder<T, TResult, TProperty> Include<T, TResult, TProperty>(
+        this ISpecificationBuilder<T, TResult> builder,
+        Expression<Func<T, TProperty>> navigationSelector) where T : class
+        => Include(builder, navigationSelector, true);
+
+    /// <summary>
+    /// Adds an Include clause to the specification if the condition is true.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <typeparam name="TProperty">The type of the property.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="navigationSelector">The include expression.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated includable specification builder.</returns>
+    public static IIncludableSpecificationBuilder<T, TResult, TProperty> Include<T, TResult, TProperty>(
+        this ISpecificationBuilder<T, TResult> builder,
+        Expression<Func<T, TProperty>> navigationSelector,
+        bool condition) where T : class
+    {
+        if (condition)
+        {
+            var expr = new IncludeExpressionInfo(navigationSelector, typeof(T), typeof(TProperty));
+            builder.Specification.Add(expr);
+        }
+
+        Specification<T, TResult>.IsChainDiscarded = !condition;
+        var includeBuilder = new IncludableSpecificationBuilder<T, TResult, TProperty>(builder.Specification);
+        return includeBuilder;
+    }
+
+    /// <summary>
+    /// Adds an Include clause to the specification.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TProperty">The type of the property.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="navigationSelector">The include expression.</param>
+    /// <returns>The updated includable specification builder.</returns>
+    public static IIncludableSpecificationBuilder<T, TProperty> Include<T, TProperty>(
+        this ISpecificationBuilder<T> builder,
+        Expression<Func<T, TProperty>> navigationSelector) where T : class
+        => Include(builder, navigationSelector, true);
+
+    /// <summary>
+    /// Adds an Include clause to the specification if the condition is true.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TProperty">The type of the property.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="navigationSelector">The include expression.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated includable specification builder.</returns>
+    public static IIncludableSpecificationBuilder<T, TProperty> Include<T, TProperty>(
+        this ISpecificationBuilder<T> builder,
+        Expression<Func<T, TProperty>> navigationSelector,
+        bool condition) where T : class
+    {
+        if (condition)
+        {
+            var expr = new IncludeExpressionInfo(navigationSelector, typeof(T), typeof(TProperty));
+            builder.Specification.Add(expr);
+        }
+
+        Specification<T>.IsChainDiscarded = !condition;
+        var includeBuilder = new IncludableSpecificationBuilder<T, TProperty>(builder.Specification);
+        return includeBuilder;
+    }
+
+    /// <summary>
+    /// Adds a ThenInclude clause to the specification.
+    /// </summary>
+    /// <typeparam name="TEntity">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <typeparam name="TPreviousProperty">The type of the previous property.</typeparam>
+    /// <typeparam name="TProperty">The type of the property.</typeparam>
+    /// <param name="builder">The previous includable specification builder.</param>
+    /// <param name="navigationSelector">The include expression.</param>
+    /// <returns>The updated includable specification builder.</returns>
+    public static IIncludableSpecificationBuilder<TEntity, TResult, TProperty> ThenInclude<TEntity, TResult, TPreviousProperty, TProperty>(
+        this IIncludableSpecificationBuilder<TEntity, TResult, TPreviousProperty> builder,
+        Expression<Func<TPreviousProperty, TProperty>> navigationSelector)
+        where TEntity : class
+        => ThenInclude(builder, navigationSelector, true);
+
+    /// <summary>
+    /// Adds a ThenInclude clause to the specification if the condition is true.
+    /// </summary>
+    /// <typeparam name="TEntity">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <typeparam name="TPreviousProperty">The type of the previous property.</typeparam>
+    /// <typeparam name="TProperty">The type of the property.</typeparam>
+    /// <param name="builder">The previous includable specification builder.</param>
+    /// <param name="navigationSelector">The include expression.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated includable specification builder.</returns>
+    public static IIncludableSpecificationBuilder<TEntity, TResult, TProperty> ThenInclude<TEntity, TResult, TPreviousProperty, TProperty>(
+        this IIncludableSpecificationBuilder<TEntity, TResult, TPreviousProperty> builder,
+        Expression<Func<TPreviousProperty, TProperty>> navigationSelector,
+        bool condition)
+        where TEntity : class
+    {
+        if (condition && !Specification<TEntity, TResult>.IsChainDiscarded)
+        {
+            var expr = new IncludeExpressionInfo(navigationSelector, typeof(TEntity), typeof(TProperty), typeof(TPreviousProperty));
+            builder.Specification.Add(expr);
+        }
+        else
+        {
+            Specification<TEntity, TResult>.IsChainDiscarded = true;
+        }
+
+        var includeBuilder = new IncludableSpecificationBuilder<TEntity, TResult, TProperty>(builder.Specification);
+        return includeBuilder;
+    }
+
+    /// <summary>
+    /// Adds a ThenInclude clause to the specification.
+    /// </summary>
+    /// <typeparam name="TEntity">The type of the entity.</typeparam>
+    /// <typeparam name="TPreviousProperty">The type of the previous property.</typeparam>
+    /// <typeparam name="TProperty">The type of the property.</typeparam>
+    /// <param name="builder">The previous includable specification builder.</param>
+    /// <param name="navigationSelector">The include expression.</param>
+    /// <returns>The updated includable specification builder.</returns>
+    public static IIncludableSpecificationBuilder<TEntity, TProperty> ThenInclude<TEntity, TPreviousProperty, TProperty>(
+        this IIncludableSpecificationBuilder<TEntity, TPreviousProperty> builder,
+        Expression<Func<TPreviousProperty, TProperty>> navigationSelector)
+        where TEntity : class
+        => ThenInclude(builder, navigationSelector, true);
+
+    /// <summary>
+    /// Adds a ThenInclude clause to the specification if the condition is true.
+    /// </summary>
+    /// <typeparam name="TEntity">The type of the entity.</typeparam>
+    /// <typeparam name="TPreviousProperty">The type of the previous property.</typeparam>
+    /// <typeparam name="TProperty">The type of the property.</typeparam>
+    /// <param name="builder">The previous includable specification builder.</param>
+    /// <param name="navigationSelector">The include expression.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated includable specification builder.</returns>
+    public static IIncludableSpecificationBuilder<TEntity, TProperty> ThenInclude<TEntity, TPreviousProperty, TProperty>(
+        this IIncludableSpecificationBuilder<TEntity, TPreviousProperty> builder,
+        Expression<Func<TPreviousProperty, TProperty>> navigationSelector,
+        bool condition)
+        where TEntity : class
+    {
+        if (condition && !Specification<TEntity>.IsChainDiscarded)
+        {
+            var expr = new IncludeExpressionInfo(navigationSelector, typeof(TEntity), typeof(TProperty), typeof(TPreviousProperty));
+            builder.Specification.Add(expr);
+        }
+        else
+        {
+            Specification<TEntity>.IsChainDiscarded = true;
+        }
+
+        var includeBuilder = new IncludableSpecificationBuilder<TEntity, TProperty>(builder.Specification);
+        return includeBuilder;
+    }
+
+    /// <summary>
+    /// Adds a ThenInclude clause to the specification.
+    /// </summary>
+    /// <typeparam name="TEntity">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <typeparam name="TPreviousProperty">The type of the previous property.</typeparam>
+    /// <typeparam name="TProperty">The type of the property.</typeparam>
+    /// <param name="builder">The previous includable specification builder.</param>
+    /// <param name="navigationSelector">The include expression.</param>
+    /// <returns>The updated includable specification builder.</returns>
+    public static IIncludableSpecificationBuilder<TEntity, TResult, TProperty> ThenInclude<TEntity, TResult, TPreviousProperty, TProperty>(
+        this IIncludableSpecificationBuilder<TEntity, TResult, IEnumerable<TPreviousProperty>> builder,
+        Expression<Func<TPreviousProperty, TProperty>> navigationSelector)
+        where TEntity : class
+        => ThenInclude(builder, navigationSelector, true);
+
+    /// <summary>
+    /// Adds a ThenInclude clause to the specification if the condition is true.
+    /// </summary>
+    /// <typeparam name="TEntity">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <typeparam name="TPreviousProperty">The type of the previous property.</typeparam>
+    /// <typeparam name="TProperty">The type of the property.</typeparam>
+    /// <param name="builder">The previous includable specification builder.</param>
+    /// <param name="navigationSelector">The include expression.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated includable specification builder.</returns>
+    public static IIncludableSpecificationBuilder<TEntity, TResult, TProperty> ThenInclude<TEntity, TResult, TPreviousProperty, TProperty>(
+        this IIncludableSpecificationBuilder<TEntity, TResult, IEnumerable<TPreviousProperty>> builder,
+        Expression<Func<TPreviousProperty, TProperty>> navigationSelector,
+        bool condition)
+        where TEntity : class
+    {
+        if (condition && !Specification<TEntity, TResult>.IsChainDiscarded)
+        {
+            var expr = new IncludeExpressionInfo(navigationSelector, typeof(TEntity), typeof(TProperty), typeof(IEnumerable<TPreviousProperty>));
+            builder.Specification.Add(expr);
+        }
+        else
+        {
+            Specification<TEntity, TResult>.IsChainDiscarded = true;
+        }
+
+        var includeBuilder = new IncludableSpecificationBuilder<TEntity, TResult, TProperty>(builder.Specification);
+        return includeBuilder;
+    }
+
+    /// <summary>
+    /// Adds a ThenInclude clause to the specification.
+    /// </summary>
+    /// <typeparam name="TEntity">The type of the entity.</typeparam>
+    /// <typeparam name="TPreviousProperty">The type of the previous property.</typeparam>
+    /// <typeparam name="TProperty">The type of the property.</typeparam>
+    /// <param name="builder">The previous includable specification builder.</param>
+    /// <param name="navigationSelector">The include expression.</param>
+    /// <returns>The updated includable specification builder.</returns>
+    public static IIncludableSpecificationBuilder<TEntity, TProperty> ThenInclude<TEntity, TPreviousProperty, TProperty>(
+        this IIncludableSpecificationBuilder<TEntity, IEnumerable<TPreviousProperty>> builder,
+        Expression<Func<TPreviousProperty, TProperty>> navigationSelector)
+        where TEntity : class
+        => ThenInclude(builder, navigationSelector, true);
+
+    /// <summary>
+    /// Adds a ThenInclude clause to the specification if the condition is true.
+    /// </summary>
+    /// <typeparam name="TEntity">The type of the entity.</typeparam>
+    /// <typeparam name="TPreviousProperty">The type of the previous property.</typeparam>
+    /// <typeparam name="TProperty">The type of the property.</typeparam>
+    /// <param name="builder">The previous includable specification builder.</param>
+    /// <param name="navigationSelector">The include expression.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated includable specification builder.</returns>
+    public static IIncludableSpecificationBuilder<TEntity, TProperty> ThenInclude<TEntity, TPreviousProperty, TProperty>(
+        this IIncludableSpecificationBuilder<TEntity, IEnumerable<TPreviousProperty>> builder,
+        Expression<Func<TPreviousProperty, TProperty>> navigationSelector,
+        bool condition)
+        where TEntity : class
+    {
+        if (condition && !Specification<TEntity>.IsChainDiscarded)
+        {
+            var expr = new IncludeExpressionInfo(navigationSelector, typeof(TEntity), typeof(TProperty), typeof(IEnumerable<TPreviousProperty>));
+            builder.Specification.Add(expr);
+        }
+        else
+        {
+            Specification<TEntity>.IsChainDiscarded = true;
+        }
+
+        var includeBuilder = new IncludableSpecificationBuilder<TEntity, TProperty>(builder.Specification);
+        return includeBuilder;
+    }
+}
diff --git a/src/Ardalis.Specification/Builders/Builder_Order.cs b/src/Ardalis.Specification/Builders/Builder_Order.cs
new file mode 100644
index 00000000..20714370
--- /dev/null
+++ b/src/Ardalis.Specification/Builders/Builder_Order.cs
@@ -0,0 +1,304 @@
+namespace Ardalis.Specification;
+
+public static partial class SpecificationBuilderExtensions
+{
+    /// <summary>
+    /// Adds an OrderBy clause to the specification.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="keySelector">The key selector expression.</param>
+    /// <returns>The updated ordered specification builder.</returns>
+    public static IOrderedSpecificationBuilder<T, TResult> OrderBy<T, TResult>(
+        this ISpecificationBuilder<T, TResult> builder,
+        Expression<Func<T, object?>> keySelector)
+        => OrderBy(builder, keySelector, true);
+
+    /// <summary>
+    /// Adds an OrderBy clause to the specification if the condition is true.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="keySelector">The key selector expression.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated ordered specification builder.</returns>
+    public static IOrderedSpecificationBuilder<T, TResult> OrderBy<T, TResult>(
+        this ISpecificationBuilder<T, TResult> builder,
+        Expression<Func<T, object?>> keySelector,
+        bool condition)
+    {
+        if (condition)
+        {
+            var expr = new OrderExpressionInfo<T>(keySelector, OrderTypeEnum.OrderBy);
+            builder.Specification.Add(expr);
+        }
+
+        Specification<T, TResult>.IsChainDiscarded = !condition;
+        return (SpecificationBuilder<T, TResult>)builder;
+    }
+
+    /// <summary>
+    /// Adds an OrderBy clause to the specification.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="keySelector">The key selector expression.</param>
+    /// <returns>The updated ordered specification builder.</returns>
+    public static IOrderedSpecificationBuilder<T> OrderBy<T>(
+        this ISpecificationBuilder<T> builder,
+        Expression<Func<T, object?>> keySelector)
+        => OrderBy(builder, keySelector, true);
+
+    /// <summary>
+    /// Adds an OrderBy clause to the specification if the condition is true.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="keySelector">The key selector expression.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated ordered specification builder.</returns>
+    public static IOrderedSpecificationBuilder<T> OrderBy<T>(
+        this ISpecificationBuilder<T> builder,
+        Expression<Func<T, object?>> keySelector,
+        bool condition)
+    {
+        if (condition)
+        {
+            var expr = new OrderExpressionInfo<T>(keySelector, OrderTypeEnum.OrderBy);
+            builder.Specification.Add(expr);
+        }
+
+        Specification<T>.IsChainDiscarded = !condition;
+        return (SpecificationBuilder<T>)builder;
+    }
+
+    /// <summary>
+    /// Adds an OrderBy descending clause to the specification.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="keySelector">The key selector expression.</param>
+    /// <returns>The updated ordered specification builder.</returns>
+    public static IOrderedSpecificationBuilder<T, TResult> OrderByDescending<T, TResult>(
+        this ISpecificationBuilder<T, TResult> builder,
+        Expression<Func<T, object?>> keySelector)
+        => OrderByDescending(builder, keySelector, true);
+
+    /// <summary>
+    /// Adds an OrderByDescending clause to the specification if the condition is true.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="keySelector">The key selector expression.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated ordered specification builder.</returns>
+    public static IOrderedSpecificationBuilder<T, TResult> OrderByDescending<T, TResult>(
+        this ISpecificationBuilder<T, TResult> builder,
+        Expression<Func<T, object?>> keySelector,
+        bool condition)
+    {
+        if (condition)
+        {
+            var expr = new OrderExpressionInfo<T>(keySelector, OrderTypeEnum.OrderByDescending);
+            builder.Specification.Add(expr);
+        }
+
+        Specification<T, TResult>.IsChainDiscarded = !condition;
+        return (SpecificationBuilder<T, TResult>)builder;
+    }
+
+    /// <summary>
+    /// Adds an OrderByDescending clause to the specification.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="keySelector">The key selector expression.</param>
+    /// <returns>The updated ordered specification builder.</returns>
+    public static IOrderedSpecificationBuilder<T> OrderByDescending<T>(
+        this ISpecificationBuilder<T> builder,
+        Expression<Func<T, object?>> keySelector)
+        => OrderByDescending(builder, keySelector, true);
+
+    /// <summary>
+    /// Adds an OrderByDescending clause to the specification if the condition is true.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="keySelector">The key selector expression.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated ordered specification builder.</returns>
+    public static IOrderedSpecificationBuilder<T> OrderByDescending<T>(
+        this ISpecificationBuilder<T> builder,
+        Expression<Func<T, object?>> keySelector,
+        bool condition)
+    {
+        if (condition)
+        {
+            var expr = new OrderExpressionInfo<T>(keySelector, OrderTypeEnum.OrderByDescending);
+            builder.Specification.Add(expr);
+        }
+
+        Specification<T>.IsChainDiscarded = !condition;
+        return (SpecificationBuilder<T>)builder;
+    }
+
+    /// <summary>
+    /// Adds a ThenBy clause to the specification.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The ordered specification builder.</param>
+    /// <param name="keySelector">The key selector expression.</param>
+    /// <returns>The updated ordered specification builder.</returns>
+    public static IOrderedSpecificationBuilder<T, TResult> ThenBy<T, TResult>(
+        this IOrderedSpecificationBuilder<T, TResult> builder,
+        Expression<Func<T, object?>> keySelector)
+        => ThenBy(builder, keySelector, true);
+
+    /// <summary>
+    /// Adds a ThenBy clause to the specification if the condition is true.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The ordered specification builder.</param>
+    /// <param name="keySelector">The key selector expression.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated ordered specification builder.</returns>
+    public static IOrderedSpecificationBuilder<T, TResult> ThenBy<T, TResult>(
+        this IOrderedSpecificationBuilder<T, TResult> builder,
+        Expression<Func<T, object?>> keySelector,
+        bool condition)
+    {
+        if (condition && !Specification<T, TResult>.IsChainDiscarded)
+        {
+            var expr = new OrderExpressionInfo<T>(keySelector, OrderTypeEnum.ThenBy);
+            builder.Specification.Add(expr);
+        }
+        else
+        {
+            Specification<T, TResult>.IsChainDiscarded = true;
+        }
+
+        return builder;
+    }
+
+    /// <summary>
+    /// Adds a ThenBy clause to the specification.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The ordered specification builder.</param>
+    /// <param name="keySelector">The key selector expression.</param>
+    /// <returns>The updated ordered specification builder.</returns>
+    public static IOrderedSpecificationBuilder<T> ThenBy<T>(
+        this IOrderedSpecificationBuilder<T> builder,
+        Expression<Func<T, object?>> keySelector)
+        => ThenBy(builder, keySelector, true);
+
+    /// <summary>
+    /// Adds a ThenBy clause to the specification if the condition is true.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The ordered specification builder.</param>
+    /// <param name="keySelector">The key selector expression.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated ordered specification builder.</returns>
+    public static IOrderedSpecificationBuilder<T> ThenBy<T>(
+        this IOrderedSpecificationBuilder<T> builder,
+        Expression<Func<T, object?>> keySelector,
+        bool condition)
+    {
+        if (condition && !Specification<T>.IsChainDiscarded)
+        {
+            var expr = new OrderExpressionInfo<T>(keySelector, OrderTypeEnum.ThenBy);
+            builder.Specification.Add(expr);
+        }
+        else
+        {
+            Specification<T>.IsChainDiscarded = true;
+        }
+
+        return builder;
+    }
+
+    /// <summary>
+    /// Adds a ThenByDescending clause to the specification.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The ordered specification builder.</param>
+    /// <param name="keySelector">The key selector expression.</param>
+    /// <returns>The updated ordered specification builder.</returns>
+    public static IOrderedSpecificationBuilder<T, TResult> ThenByDescending<T, TResult>(
+        this IOrderedSpecificationBuilder<T, TResult> builder,
+        Expression<Func<T, object?>> keySelector)
+        => ThenByDescending(builder, keySelector, true);
+
+    /// <summary>
+    /// Adds a ThenByDescending clause to the specification if the condition is true.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The ordered specification builder.</param>
+    /// <param name="keySelector">The key selector expression.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated ordered specification builder.</returns>
+    public static IOrderedSpecificationBuilder<T, TResult> ThenByDescending<T, TResult>(
+        this IOrderedSpecificationBuilder<T, TResult> builder,
+        Expression<Func<T, object?>> keySelector,
+        bool condition)
+    {
+        if (condition && !Specification<T, TResult>.IsChainDiscarded)
+        {
+            var expr = new OrderExpressionInfo<T>(keySelector, OrderTypeEnum.ThenByDescending);
+            builder.Specification.Add(expr);
+        }
+        else
+        {
+            Specification<T, TResult>.IsChainDiscarded = true;
+        }
+
+        return builder;
+    }
+
+    /// <summary>
+    /// Adds a ThenByDescending clause to the specification.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The ordered specification builder.</param>
+    /// <param name="keySelector">The key selector expression.</param>
+    /// <returns>The updated ordered specification builder.</returns>
+    public static IOrderedSpecificationBuilder<T> ThenByDescending<T>(
+        this IOrderedSpecificationBuilder<T> builder,
+        Expression<Func<T, object?>> keySelector)
+        => ThenByDescending(builder, keySelector, true);
+
+    /// <summary>
+    /// Adds a ThenByDescending clause to the specification if the condition is true.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The ordered specification builder.</param>
+    /// <param name="keySelector">The key selector expression.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated ordered specification builder.</returns>
+    public static IOrderedSpecificationBuilder<T> ThenByDescending<T>(
+        this IOrderedSpecificationBuilder<T> builder,
+        Expression<Func<T, object?>> keySelector,
+        bool condition)
+    {
+        if (condition && !Specification<T>.IsChainDiscarded)
+        {
+            var expr = new OrderExpressionInfo<T>(keySelector, OrderTypeEnum.ThenByDescending);
+            builder.Specification.Add(expr);
+        }
+        else
+        {
+            Specification<T>.IsChainDiscarded = true;
+        }
+
+        return builder;
+    }
+}
diff --git a/src/Ardalis.Specification/Builders/Builder_Paging.cs b/src/Ardalis.Specification/Builders/Builder_Paging.cs
new file mode 100644
index 00000000..8a3b431a
--- /dev/null
+++ b/src/Ardalis.Specification/Builders/Builder_Paging.cs
@@ -0,0 +1,152 @@
+namespace Ardalis.Specification;
+
+public static partial class SpecificationBuilderExtensions
+{
+    /// <summary>
+    /// Sets the number of items to take in the specification.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="take">The number of items to take.</param>
+    /// <returns>The updated specification builder.</returns>
+    /// <exception cref="DuplicateTakeException">If take value is already set.</exception>
+    public static ISpecificationBuilder<T, TResult> Take<T, TResult>(
+        this ISpecificationBuilder<T, TResult> builder,
+        int take)
+        => Take(builder, take, true);
+
+    /// <summary>
+    /// Sets the number of items to take in the specification if the condition is true.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="take">The number of items to take.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated specification builder.</returns>
+    /// <exception cref="DuplicateTakeException">If take value is already set.</exception>
+    public static ISpecificationBuilder<T, TResult> Take<T, TResult>(
+        this ISpecificationBuilder<T, TResult> builder,
+        int take,
+        bool condition)
+    {
+        if (condition)
+        {
+            if (builder.Specification.Take != -1) throw new DuplicateTakeException();
+            builder.Specification.Take = take;
+        }
+
+        return builder;
+    }
+
+    /// <summary>
+    /// Sets the number of items to take in the specification.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="take">The number of items to take.</param>
+    /// <returns>The updated specification builder.</returns>
+    /// <exception cref="DuplicateTakeException">If take value is already set.</exception>
+    public static ISpecificationBuilder<T> Take<T>(
+        this ISpecificationBuilder<T> builder,
+        int take)
+        => Take(builder, take, true);
+
+    /// <summary>
+    /// Sets the number of items to take in the specification if the condition is true.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="take">The number of items to take.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated specification builder.</returns>
+    /// <exception cref="DuplicateTakeException">If take value is already set.</exception>
+    public static ISpecificationBuilder<T> Take<T>(
+        this ISpecificationBuilder<T> builder,
+        int take,
+        bool condition)
+    {
+        if (condition)
+        {
+            if (builder.Specification.Take != -1) throw new DuplicateTakeException();
+            builder.Specification.Take = take;
+        }
+
+        return builder;
+    }
+
+    /// <summary>
+    /// Sets the number of items to skip in the specification.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="skip">The number of items to skip.</param>
+    /// <returns>The updated specification builder.</returns>
+    /// <exception cref="DuplicateSkipException">If the skip value is already set.</exception>
+    public static ISpecificationBuilder<T, TResult> Skip<T, TResult>(
+        this ISpecificationBuilder<T, TResult> builder,
+        int skip)
+        => Skip(builder, skip, true);
+
+    /// <summary>
+    /// Sets the number of items to skip in the specification if the condition is true.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="skip">The number of items to skip.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated specification builder.</returns>
+    /// <exception cref="DuplicateSkipException">If the skip value is already set.</exception>
+    public static ISpecificationBuilder<T, TResult> Skip<T, TResult>(
+        this ISpecificationBuilder<T, TResult> builder,
+        int skip,
+        bool condition)
+    {
+        if (condition)
+        {
+            if (builder.Specification.Skip != -1) throw new DuplicateSkipException();
+            builder.Specification.Skip = skip;
+        }
+
+        return builder;
+    }
+
+    /// <summary>
+    /// Sets the number of items to skip in the specification.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="skip">The number of items to skip.</param>
+    /// <returns>The updated specification builder.</returns>
+    /// <exception cref="DuplicateSkipException">If the skip value is already set.</exception>
+    public static ISpecificationBuilder<T> Skip<T>(
+        this ISpecificationBuilder<T> builder,
+        int skip)
+        => Skip(builder, skip, true);
+
+    /// <summary>
+    /// Sets the number of items to skip in the specification if the condition is true.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="skip">The number of items to skip.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated specification builder.</returns>
+    /// <exception cref="DuplicateSkipException">If the skip value is already set.</exception>
+    public static ISpecificationBuilder<T> Skip<T>(
+        this ISpecificationBuilder<T> builder,
+        int skip,
+        bool condition)
+    {
+        if (condition)
+        {
+            if (builder.Specification.Skip != -1) throw new DuplicateSkipException();
+            builder.Specification.Skip = skip;
+        }
+
+        return builder;
+    }
+}
diff --git a/src/Ardalis.Specification/Builders/Builder_PostProcessing.cs b/src/Ardalis.Specification/Builders/Builder_PostProcessing.cs
new file mode 100644
index 00000000..df4fcad8
--- /dev/null
+++ b/src/Ardalis.Specification/Builders/Builder_PostProcessing.cs
@@ -0,0 +1,39 @@
+namespace Ardalis.Specification;
+
+public static partial class SpecificationBuilderExtensions
+{
+
+    /// <summary>
+    /// Specify a function to apply to the result of the query. It's an in-memory operation.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="filter">The filter function.</param>
+    /// <returns>Filtered results</returns>
+    public static ISpecificationBuilder<T, TResult> PostProcessingAction<T, TResult>(
+        this ISpecificationBuilder<T, TResult> builder,
+        Func<IEnumerable<TResult>, IEnumerable<TResult>> filter)
+    {
+        builder.Specification.PostProcessingAction = filter;
+
+        return builder;
+    }
+
+
+    /// <summary>
+    /// Specify a function to apply to the result of the query. It's an in-memory operation.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="filter">The filter function.</param>
+    /// <returns>Filtered results</returns>
+    public static ISpecificationBuilder<T> PostProcessingAction<T>(
+        this ISpecificationBuilder<T> builder,
+        Func<IEnumerable<T>, IEnumerable<T>> filter)
+    {
+        builder.Specification.PostProcessingAction = filter;
+
+        return builder;
+    }
+}
diff --git a/src/Ardalis.Specification/Builders/Builder_Search.cs b/src/Ardalis.Specification/Builders/Builder_Search.cs
new file mode 100644
index 00000000..67e4bb1a
--- /dev/null
+++ b/src/Ardalis.Specification/Builders/Builder_Search.cs
@@ -0,0 +1,92 @@
+namespace Ardalis.Specification;
+
+public static partial class SpecificationBuilderExtensions
+{
+    // TODO: Improve the nullability for the key selector. Update everything to work with Func<T, string?>. [Fati Iseni, 27/02/2025]
+
+    /// <summary>
+    /// Adds a Like clause to the specification.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="keySelector">The key selector expression.</param>
+    /// <param name="pattern">The pattern to match.</param>
+    /// <param name="group">The group number. Like clauses within the same group are evaluated using OR logic.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T, TResult> Search<T, TResult>(
+        this ISpecificationBuilder<T, TResult> builder,
+        Expression<Func<T, string>> keySelector,
+        string pattern,
+        int group = 1) where T : class
+        => Search(builder, keySelector, pattern, true, group);
+
+    /// <summary>
+    /// Adds a Like clause to the specification if the condition is true.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="keySelector">The key selector expression.</param>
+    /// <param name="pattern">The pattern to match.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <param name="group">The group number. Like clauses within the same group are evaluated using OR logic.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T, TResult> Search<T, TResult>(
+        this ISpecificationBuilder<T, TResult> builder,
+        Expression<Func<T, string>> keySelector,
+        string pattern,
+        bool condition,
+        int group = 1) where T : class
+    {
+        if (condition)
+        {
+            var expr = new SearchExpressionInfo<T>(keySelector, pattern, group);
+            builder.Specification.Add(expr);
+        }
+
+        return builder;
+    }
+
+    /// <summary>
+    /// Adds a Like clause to the specification.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="keySelector">The key selector expression.</param>
+    /// <param name="pattern">The pattern to match.</param>
+    /// <param name="group">The group number. Like clauses within the same group are evaluated using OR logic.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T> Search<T>(
+        this ISpecificationBuilder<T> builder,
+        Expression<Func<T, string>> keySelector,
+        string pattern,
+        int group = 1) where T : class
+        => Search(builder, keySelector, pattern, true, group);
+
+    /// <summary>
+    /// Adds a Like clause to the specification if the condition is true.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="keySelector">The key selector expression.</param>
+    /// <param name="pattern">The pattern to match.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <param name="group">The group number. Like clauses within the same group are evaluated using OR logic.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T> Search<T>(
+        this ISpecificationBuilder<T> builder,
+        Expression<Func<T, string>> keySelector,
+        string pattern,
+        bool condition,
+        int group = 1) where T : class
+    {
+        if (condition)
+        {
+            var expr = new SearchExpressionInfo<T>(keySelector, pattern, group);
+            builder.Specification.Add(expr);
+        }
+
+        return builder;
+    }
+}
diff --git a/src/Ardalis.Specification/Builders/Builder_Select.cs b/src/Ardalis.Specification/Builders/Builder_Select.cs
new file mode 100644
index 00000000..8f291479
--- /dev/null
+++ b/src/Ardalis.Specification/Builders/Builder_Select.cs
@@ -0,0 +1,32 @@
+namespace Ardalis.Specification;
+
+public static partial class SpecificationBuilderExtensions
+{
+    /// <summary>
+    /// Adds a Select clause to the specification.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="selector">The selector expression.</param>
+    public static void Select<T, TResult>(
+        this ISpecificationBuilder<T, TResult> builder,
+        Expression<Func<T, TResult>> selector)
+    {
+        builder.Specification.Selector = selector;
+    }
+
+    /// <summary>
+    /// Adds a SelectMany clause to the specification.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="selector">The selector expression.</param>
+    public static void SelectMany<T, TResult>(
+        this ISpecificationBuilder<T, TResult> builder,
+        Expression<Func<T, IEnumerable<TResult>>> selector)
+    {
+        builder.Specification.SelectorMany = selector;
+    }
+}
diff --git a/src/Ardalis.Specification/Builders/Builder_Where.cs b/src/Ardalis.Specification/Builders/Builder_Where.cs
new file mode 100644
index 00000000..49800b86
--- /dev/null
+++ b/src/Ardalis.Specification/Builders/Builder_Where.cs
@@ -0,0 +1,74 @@
+namespace Ardalis.Specification;
+
+public static partial class SpecificationBuilderExtensions
+{
+    /// <summary>
+    /// Adds a Where clause to the specification.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="predicate">The predicate expression.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T, TResult> Where<T, TResult>(
+        this ISpecificationBuilder<T, TResult> builder,
+        Expression<Func<T, bool>> predicate)
+        => Where(builder, predicate, true);
+
+    /// <summary>
+    /// Adds a Where clause to the specification if the condition is true.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <typeparam name="TResult">The type of the result.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="predicate">The predicate expression.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T, TResult> Where<T, TResult>(
+        this ISpecificationBuilder<T, TResult> builder,
+        Expression<Func<T, bool>> predicate,
+        bool condition)
+    {
+        if (condition)
+        {
+            var expr = new WhereExpressionInfo<T>(predicate);
+            builder.Specification.Add(expr);
+        }
+
+        return builder;
+    }
+
+    /// <summary>
+    /// Adds a Where clause to the specification.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="predicate">The predicate expression.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T> Where<T>(
+        this ISpecificationBuilder<T> builder,
+        Expression<Func<T, bool>> predicate)
+        => Where(builder, predicate, true);
+
+    /// <summary>
+    /// Adds a Where clause to the specification if the condition is true.
+    /// </summary>
+    /// <typeparam name="T">The type of the entity.</typeparam>
+    /// <param name="builder">The specification builder.</param>
+    /// <param name="predicate">The predicate expression.</param>
+    /// <param name="condition">The condition to evaluate.</param>
+    /// <returns>The updated specification builder.</returns>
+    public static ISpecificationBuilder<T> Where<T>(
+        this ISpecificationBuilder<T> builder,
+        Expression<Func<T, bool>> predicate,
+        bool condition)
+    {
+        if (condition)
+        {
+            var expr = new WhereExpressionInfo<T>(predicate);
+            builder.Specification.Add(expr);
+        }
+
+        return builder;
+    }
+}
diff --git a/src/Ardalis.Specification/Builders/IncludableSpecificationBuilder.cs b/src/Ardalis.Specification/Builders/IncludableSpecificationBuilder.cs
new file mode 100644
index 00000000..4c84b981
--- /dev/null
+++ b/src/Ardalis.Specification/Builders/IncludableSpecificationBuilder.cs
@@ -0,0 +1,25 @@
+namespace Ardalis.Specification;
+
+public interface IIncludableSpecificationBuilder<T, TResult, out TProperty> : ISpecificationBuilder<T, TResult> where T : class
+{
+}
+
+public interface IIncludableSpecificationBuilder<T, out TProperty> : ISpecificationBuilder<T> where T : class
+{
+}
+
+internal class IncludableSpecificationBuilder<T, TResult, TProperty>
+    : SpecificationBuilder<T, TResult>, IIncludableSpecificationBuilder<T, TResult, TProperty> where T : class
+{
+    public IncludableSpecificationBuilder(Specification<T, TResult> specification) : base(specification)
+    {
+    }
+}
+
+internal class IncludableSpecificationBuilder<T, TProperty>
+    : SpecificationBuilder<T>, IIncludableSpecificationBuilder<T, TProperty> where T : class
+{
+    public IncludableSpecificationBuilder(Specification<T> specification) : base(specification)
+    {
+    }
+}
diff --git a/src/Ardalis.Specification/Builders/SpecificationBuilder.cs b/src/Ardalis.Specification/Builders/SpecificationBuilder.cs
new file mode 100644
index 00000000..aa2f00bf
--- /dev/null
+++ b/src/Ardalis.Specification/Builders/SpecificationBuilder.cs
@@ -0,0 +1,49 @@
+namespace Ardalis.Specification;
+
+public interface ICacheSpecificationBuilder<T, TResult> : ISpecificationBuilder<T, TResult>
+{
+}
+
+public interface ICacheSpecificationBuilder<T> : ISpecificationBuilder<T>
+{
+}
+
+public interface IOrderedSpecificationBuilder<T, TResult> : ISpecificationBuilder<T, TResult>
+{
+}
+
+public interface IOrderedSpecificationBuilder<T> : ISpecificationBuilder<T>
+{
+}
+
+public interface ISpecificationBuilder<T, TResult>
+{
+    Specification<T, TResult> Specification { get; }
+}
+
+public interface ISpecificationBuilder<T>
+{
+    Specification<T> Specification { get; }
+}
+
+internal class SpecificationBuilder<T, TResult>
+    : ICacheSpecificationBuilder<T, TResult>, IOrderedSpecificationBuilder<T, TResult>, ISpecificationBuilder<T, TResult>
+{
+    public Specification<T, TResult> Specification { get; }
+
+    public SpecificationBuilder(Specification<T, TResult> specification)
+    {
+        Specification = specification;
+    }
+}
+
+internal class SpecificationBuilder<T>
+    : ICacheSpecificationBuilder<T>, IOrderedSpecificationBuilder<T>, ISpecificationBuilder<T>
+{
+    public Specification<T> Specification { get; }
+
+    public SpecificationBuilder(Specification<T> specification)
+    {
+        Specification = specification;
+    }
+}
diff --git a/src/Ardalis.Specification/Specification.cs b/src/Ardalis.Specification/Specification.cs
index 5ddfe86b..a9025f56 100644
--- a/src/Ardalis.Specification/Specification.cs
+++ b/src/Ardalis.Specification/Specification.cs
@@ -1,4 +1,6 @@
-namespace Ardalis.Specification;
+using System.ComponentModel;
+
+namespace Ardalis.Specification;
 
 /// <inheritdoc cref="ISpecification{T, TResult}"/>
 public class Specification<T, TResult> : Specification<T>, ISpecification<T, TResult>
@@ -24,6 +26,13 @@ public class Specification<T, TResult> : Specification<T>, ISpecification<T, TRe
 /// <inheritdoc cref="ISpecification{T}"/>
 public class Specification<T> : ISpecification<T>
 {
+    // It is utilized only during the building stage for the sub-chains. Once the state is built, we don't care about it anymore.
+    // The initial value is not important since the value is always initialized by the root of the chain. Therefore, we don't need ThreadLocal (it's more expensive).
+    // With this we're saving 8 bytes per include builder, and we don't need an order builder at all (saving 32 bytes per order builder instance).
+    [ThreadStatic]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public static bool IsChainDiscarded;
+
     // The state is null initially, but we're spending 8 bytes per reference (on x64).
     // This will be reconsidered for version 10 where we may store the whole state as a single array of structs.
     private List<WhereExpressionInfo<T>>? _whereExpressions;