diff --git a/CoreIntegrationTests/Infrastructure/MongoDbDocumentTestBase.Main.cs b/CoreIntegrationTests/Infrastructure/MongoDbDocumentTestBase.Main.cs
index 98fc846..24a5cd9 100644
--- a/CoreIntegrationTests/Infrastructure/MongoDbDocumentTestBase.Main.cs
+++ b/CoreIntegrationTests/Infrastructure/MongoDbDocumentTestBase.Main.cs
@@ -8,6 +8,7 @@
 using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
+using MongoDB.Driver;
 using Xunit;
 
 namespace CoreIntegrationTests.Infrastructure
@@ -228,6 +229,19 @@ public void GetOne()
             Assert.True(null != result, GetTestName());
         }
 
+        [Fact]
+        public void GetFilterDefinitionCursor()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne(document);
+            // Act
+            var cursor = SUT.GetCursor(Builders<T>.Filter.Eq(x => x.Id, document.Id), partitionKey: PartitionKey);
+            var count = cursor.CountDocuments();
+            // Assert
+            Assert.True(1 == count, GetTestName());
+        }
+        
         [Fact]
         public void GetCursor()
         {
@@ -361,6 +375,19 @@ public void DeleteOne()
             Assert.True(1 == result);
             Assert.False(SUT.Any<T>(e => e.Id.Equals(document.Id), PartitionKey), GetTestName());
         }
+        
+        [Fact]
+        public void DeleteOneFilterDefinition()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<T>(document);
+            // Act
+            var result = SUT.DeleteOne<T>(Builders<T>.Filter.Eq(x => x.Id, document.Id), partitionKey: PartitionKey);
+            // Assert
+            Assert.True(1 == result);
+            Assert.False(SUT.Any<T>(e => e.Id.Equals(document.Id), PartitionKey), GetTestName());
+        }
 
         [Fact]
         public void DeleteOneLinq()
@@ -388,6 +415,19 @@ public async Task DeleteOneAsync()
             Assert.False(SUT.Any<T>(e => e.Id.Equals(document.Id), PartitionKey), GetTestName());
         }
 
+        [Fact]
+        public async Task DeleteOneAsyncFilterDefinition()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<T>(document);
+            // Act
+            var result = await SUT.DeleteOneAsync<T>(Builders<T>.Filter.Eq(x => x.Id, document.Id), partitionKey: PartitionKey);
+            // Assert
+            Assert.True(1 == result);
+            Assert.False(SUT.Any<T>(e => e.Id.Equals(document.Id), PartitionKey), GetTestName());
+        }
+        
         [Fact]
         public async Task DeleteOneAsyncLinq()
         {
@@ -401,6 +441,21 @@ public async Task DeleteOneAsyncLinq()
             Assert.False(SUT.Any<T>(e => e.Id.Equals(document.Id), PartitionKey), GetTestName());
         }
 
+        [Fact]
+        public async Task DeleteManyAsyncFilterDefinition()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}";
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = criteria);
+            SUT.AddMany<T>(documents);
+            // Act
+            var result = await SUT.DeleteManyAsync<T>(Builders<T>.Filter.Eq(x => x.SomeContent, criteria), partitionKey: PartitionKey);
+            // Assert
+            Assert.True(5 == result);
+            Assert.False(SUT.Any<T>(e => e.SomeContent == criteria, PartitionKey), GetTestName());
+        }
+        
         [Fact]
         public async Task DeleteManyAsyncLinq()
         {
@@ -444,6 +499,21 @@ public async Task DeleteManyAsync()
             }
         }
 
+        [Fact]
+        public void DeleteManyFilterDefinition()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}";
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = criteria);
+            SUT.AddMany<T>(documents);
+            // Act
+            var result = SUT.DeleteMany<T>(Builders<T>.Filter.Eq(x => x.SomeContent, criteria), partitionKey: PartitionKey);
+            // Assert
+            Assert.True(5 == result);
+            Assert.False(SUT.Any<T>(e => e.SomeContent == criteria, PartitionKey), GetTestName());
+        }
+        
         [Fact]
         public void DeleteManyLinq()
         {
@@ -516,6 +586,61 @@ public async Task ProjectOneAsync()
             Assert.True(someDate.Minute == result.SomeDate.Minute, GetTestName());
             Assert.True(someDate.Second == result.SomeDate.Second, GetTestName());
         }
+        
+        [Fact]
+        public async Task ProjectOneAsyncFilterDefinitionWithProjectionDefinition()
+        {
+            // Arrange
+            var someContent = GetContent();
+            var someDate = DateTime.UtcNow;
+            var document = CreateTestDocument();
+            document.SomeContent = someContent;
+            document.Nested.SomeDate = someDate;
+            SUT.AddOne<T>(document);
+
+            var projectionBuilder = new ProjectionDefinitionBuilder<T>();
+            // Act
+            var result = await SUT.ProjectOneAsync<T, MyTestProjection>(
+                Builders<T>.Filter.Eq(x => x.Id, document.Id),
+                projectionBuilder.Expression(x => new MyTestProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                }),
+                partitionKey: PartitionKey);
+            // Assert
+            Assert.True(null != result, GetTestName());
+            Assert.True(someContent == result.SomeContent, GetTestName());
+            Assert.True(someDate.Minute == result.SomeDate.Minute, GetTestName());
+            Assert.True(someDate.Second == result.SomeDate.Second, GetTestName());
+        }
+        
+        [Fact]
+        public async Task ProjectOneAsyncFilterDefinitionWithExpression()
+        {
+            // Arrange
+            var someContent = GetContent();
+            var someDate = DateTime.UtcNow;
+            var document = CreateTestDocument();
+            document.SomeContent = someContent;
+            document.Nested.SomeDate = someDate;
+            SUT.AddOne<T>(document);
+
+            // Act
+            var result = await SUT.ProjectOneAsync<T, MyTestProjection>(
+                Builders<T>.Filter.Eq(x => x.Id, document.Id),
+                x => new MyTestProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                },
+                partitionKey: PartitionKey);
+            // Assert
+            Assert.True(null != result, GetTestName());
+            Assert.True(someContent == result.SomeContent, GetTestName());
+            Assert.True(someDate.Minute == result.SomeDate.Minute, GetTestName());
+            Assert.True(someDate.Second == result.SomeDate.Second, GetTestName());
+        }
 
         [Fact]
         public void ProjectOne()
@@ -542,6 +667,61 @@ public void ProjectOne()
             Assert.True(someDate.Minute == result.SomeDate.Minute, GetTestName());
             Assert.True(someDate.Second == result.SomeDate.Second, GetTestName());
         }
+        
+        [Fact]
+        public void ProjectOneFilterDefinitionWithProjectionDefinition()
+        {
+            // Arrange
+            var someContent = GetContent();
+            var someDate = DateTime.UtcNow;
+            var document = CreateTestDocument();
+            document.SomeContent = someContent;
+            document.Nested.SomeDate = someDate;
+            SUT.AddOne<T>(document);
+            var projectionBuilder = new ProjectionDefinitionBuilder<T>();
+            
+            // Act
+            var result = SUT.ProjectOne<T, MyTestProjection>(
+                Builders<T>.Filter.Eq(x => x.Id, document.Id),
+                projectionBuilder.Expression(x => new MyTestProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                }),
+                partitionKey: PartitionKey);
+            // Assert
+            Assert.True(null != result, GetTestName());
+            Assert.True(someContent == result.SomeContent, GetTestName());
+            Assert.True(someDate.Minute == result.SomeDate.Minute, GetTestName());
+            Assert.True(someDate.Second == result.SomeDate.Second, GetTestName());
+        }
+        
+        [Fact]
+        public void ProjectOneFilterDefinitionWithExpression()
+        {
+            // Arrange
+            var someContent = GetContent();
+            var someDate = DateTime.UtcNow;
+            var document = CreateTestDocument();
+            document.SomeContent = someContent;
+            document.Nested.SomeDate = someDate;
+            SUT.AddOne<T>(document);
+            
+            // Act
+            var result = SUT.ProjectOne<T, MyTestProjection>(
+                Builders<T>.Filter.Eq(x => x.Id, document.Id),
+                x => new MyTestProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                },
+                partitionKey: PartitionKey);
+            // Assert
+            Assert.True(null != result, GetTestName());
+            Assert.True(someContent == result.SomeContent, GetTestName());
+            Assert.True(someDate.Minute == result.SomeDate.Minute, GetTestName());
+            Assert.True(someDate.Second == result.SomeDate.Second, GetTestName());
+        }
 
         [Fact]
         public async Task ProjectManyAsync()
@@ -572,6 +752,67 @@ public async Task ProjectManyAsync()
             Assert.True(someDate.Minute == result.First().SomeDate.Minute, GetTestName());
             Assert.True(someDate.Second == result.First().SomeDate.Second, GetTestName());
         }
+        
+        [Fact]
+        public async Task ProjectManyAsyncFilterDefinitionWithProjectionDefinition()
+        {
+            // Arrange
+            var someContent = GetContent();
+            var someDate = DateTime.UtcNow;
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e =>
+            {
+                e.SomeContent = someContent;
+                e.Nested.SomeDate = someDate;
+            });
+            var projectionBuilder = new ProjectionDefinitionBuilder<T>();
+
+            SUT.AddMany<T>(documents);
+            // Act
+            var result = await SUT.ProjectManyAsync<T, MyTestProjection>(
+                Builders<T>.Filter.Eq(x => x.SomeContent, someContent),
+                projectionBuilder.Expression(x => new MyTestProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                }),
+                partitionKey: PartitionKey);
+            // Assert
+            Assert.True(5 == result.Count, GetTestName());
+            Assert.True(someContent == result.First().SomeContent, GetTestName());
+            Assert.True(someDate.Minute == result.First().SomeDate.Minute, GetTestName());
+            Assert.True(someDate.Second == result.First().SomeDate.Second, GetTestName());
+        }
+        
+        [Fact]
+        public async Task ProjectManyAsyncFilterDefinitionWithProjectionExpression()
+        {
+            // Arrange
+            var someContent = GetContent();
+            var someDate = DateTime.UtcNow;
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e =>
+            {
+                e.SomeContent = someContent;
+                e.Nested.SomeDate = someDate;
+            });
+
+            SUT.AddMany<T>(documents);
+            // Act
+            var result = await SUT.ProjectManyAsync<T, MyTestProjection>(
+                Builders<T>.Filter.Eq(x => x.SomeContent, someContent),
+                x => new MyTestProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                },
+                partitionKey: PartitionKey);
+            // Assert
+            Assert.True(5 == result.Count, GetTestName());
+            Assert.True(someContent == result.First().SomeContent, GetTestName());
+            Assert.True(someDate.Minute == result.First().SomeDate.Minute, GetTestName());
+            Assert.True(someDate.Second == result.First().SomeDate.Second, GetTestName());
+        }
 
         [Fact]
         public void ProjectMany()
@@ -602,6 +843,67 @@ public void ProjectMany()
             Assert.True(someDate.Minute == result.First().SomeDate.Minute, GetTestName());
             Assert.True(someDate.Second == result.First().SomeDate.Second, GetTestName());
         }
+        
+        [Fact]
+        public void ProjectManyFilterDefinitionWithProjectionDefinition()
+        {
+            // Arrange
+            var someContent = GetContent();
+            var someDate = DateTime.UtcNow;
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e =>
+            {
+                e.SomeContent = someContent;
+                e.Nested.SomeDate = someDate;
+            });
+            var projectionBuilder = new ProjectionDefinitionBuilder<T>();
+
+            SUT.AddMany<T>(documents);
+            // Act
+            var result = SUT.ProjectMany<T, MyTestProjection>(
+                Builders<T>.Filter.Eq(x => x.SomeContent, someContent),
+                projectionBuilder.Expression(x => new MyTestProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                }),
+                partitionKey: PartitionKey);
+            // Assert
+            Assert.True(5 == result.Count, GetTestName());
+            Assert.True(someContent == result.First().SomeContent, GetTestName());
+            Assert.True(someDate.Minute == result.First().SomeDate.Minute, GetTestName());
+            Assert.True(someDate.Second == result.First().SomeDate.Second, GetTestName());
+        }
+        
+        [Fact]
+        public void ProjectManyFilterDefinitionWithProjectionExpression()
+        {
+            // Arrange
+            var someContent = GetContent();
+            var someDate = DateTime.UtcNow;
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e =>
+            {
+                e.SomeContent = someContent;
+                e.Nested.SomeDate = someDate;
+            });
+
+            SUT.AddMany<T>(documents);
+            // Act
+            var result = SUT.ProjectMany<T, MyTestProjection>(
+                Builders<T>.Filter.Eq(x => x.SomeContent, someContent),
+                x => new MyTestProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                },
+                partitionKey: PartitionKey);
+            // Assert
+            Assert.True(5 == result.Count, GetTestName());
+            Assert.True(someContent == result.First().SomeContent, GetTestName());
+            Assert.True(someDate.Minute == result.First().SomeDate.Minute, GetTestName());
+            Assert.True(someDate.Second == result.First().SomeDate.Second, GetTestName());
+        }
 
         #endregion Project
 
@@ -629,6 +931,30 @@ public async Task GetByMaxAsync()
             Assert.NotNull(result);
             Assert.Equal(expectedMax.Id, result.Id);
         }
+        
+        [Fact]
+        public async Task GetByMaxAsyncFilterDefinition()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
+            var documents = CreateTestDocuments(5);
+            var i = 1;
+            documents.ForEach(e =>
+            {
+                e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
+                e.SomeContent = criteria;
+            });
+            SUT.AddMany<T>(documents);
+            var expectedMax = documents.OrderByDescending(e => e.Nested.SomeDate).First();
+
+            // Act
+            var result = await SUT.GetByMaxAsync<T>(Builders<T>.Filter.Eq(x => x.SomeContent, criteria), e => e.Nested.SomeDate,
+                partitionKey: PartitionKey);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(expectedMax.Id, result.Id);
+        }
 
         [Fact]
         public void GetByMax()
@@ -652,6 +978,29 @@ public void GetByMax()
             Assert.NotNull(result);
             Assert.Equal(expectedMax.Id, result.Id);
         }
+        
+        [Fact]
+        public void GetByMaxFilterDefinition()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
+            var documents = CreateTestDocuments(5);
+            var i = 1;
+            documents.ForEach(e =>
+            {
+                e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
+                e.SomeContent = criteria;
+            });
+            SUT.AddMany<T>(documents);
+            var expectedMax = documents.OrderByDescending(e => e.Nested.SomeDate).First();
+
+            // Act
+            var result = SUT.GetByMax<T>(Builders<T>.Filter.Eq(x => x.SomeContent, criteria), e => e.Nested.SomeDate, partitionKey: PartitionKey);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(expectedMax.Id, result.Id);
+        }
 
         [Fact]
         public async Task GetByMinAsync()
@@ -675,6 +1024,30 @@ public async Task GetByMinAsync()
             Assert.NotNull(result);
             Assert.Equal(expectedMin.Id, result.Id);
         }
+        
+        [Fact]
+        public async Task GetByMinAsyncFilterDefinition()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
+            var documents = CreateTestDocuments(5);
+            var i = 1;
+            documents.ForEach(e =>
+            {
+                e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
+                e.SomeContent = criteria;
+            });
+            SUT.AddMany<T>(documents);
+            var expectedMin = documents.OrderBy(e => e.Nested.SomeDate).First();
+
+            // Act
+            var result = await SUT.GetByMinAsync<T>(Builders<T>.Filter.Eq(x => x.SomeContent, criteria), e => e.Nested.SomeDate,
+                partitionKey: PartitionKey);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(expectedMin.Id, result.Id);
+        }
 
         [Fact]
         public void GetByMin()
@@ -698,6 +1071,30 @@ public void GetByMin()
             Assert.NotNull(result);
             Assert.Equal(expectedMin.Id, result.Id);
         }
+        
+        [Fact]
+        public void GetByMinFilterDefinition()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
+            var documents = CreateTestDocuments(5);
+            var i = 1;
+            documents.ForEach(e =>
+            {
+                e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
+                e.SomeContent = criteria;
+            });
+            SUT.AddMany<T>(documents);
+            var expectedMin = documents.OrderBy(e => e.Nested.SomeDate).First();
+
+            // Act
+            var result = SUT.GetByMin<T>(Builders<T>.Filter.Eq(x => x.SomeContent, criteria), e => e.Nested.SomeDate,
+                partitionKey: PartitionKey);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(expectedMin.Id, result.Id);
+        }
 
         [Fact]
         public void GetMinValue()
@@ -721,6 +1118,30 @@ public void GetMinValue()
             Assert.True(result != default(DateTime));
             Assert.Equal(expectedMin.Nested.SomeDate.Date, result.Date);
         }
+        
+        [Fact]
+        public void GetMinValueFilterDefinition()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
+            var documents = CreateTestDocuments(5);
+            var i = 1;
+            documents.ForEach(e =>
+            {
+                e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
+                e.SomeContent = criteria;
+            });
+            SUT.AddMany<T>(documents);
+            var expectedMin = documents.OrderBy(e => e.Nested.SomeDate).First();
+
+            // Act
+            var result = SUT.GetMinValue<T, DateTime>(Builders<T>.Filter.Eq(x => x.SomeContent, criteria), e => e.Nested.SomeDate,
+                partitionKey: PartitionKey);
+
+            // Assert
+            Assert.True(result != default(DateTime));
+            Assert.Equal(expectedMin.Nested.SomeDate.Date, result.Date);
+        }
 
         [Fact]
         public async Task GetMinValueAsync()
@@ -744,6 +1165,30 @@ public async Task GetMinValueAsync()
             Assert.True(result != default(DateTime));
             Assert.Equal(expectedMin.Nested.SomeDate.Date, result.Date);
         }
+        
+        [Fact]
+        public async Task GetMinValueAsyncFilterDefinition()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
+            var documents = CreateTestDocuments(5);
+            var i = 1;
+            documents.ForEach(e =>
+            {
+                e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
+                e.SomeContent = criteria;
+            });
+            SUT.AddMany<T>(documents);
+            var expectedMin = documents.OrderBy(e => e.Nested.SomeDate).First();
+
+            // Act
+            var result = await SUT.GetMinValueAsync<T, DateTime>(Builders<T>.Filter.Eq(x => x.SomeContent, criteria),
+                e => e.Nested.SomeDate, partitionKey: PartitionKey);
+
+            // Assert
+            Assert.True(result != default(DateTime));
+            Assert.Equal(expectedMin.Nested.SomeDate.Date, result.Date);
+        }
 
         [Fact]
         public void GetMaxValue()
@@ -767,6 +1212,30 @@ public void GetMaxValue()
             Assert.True(result != default(DateTime));
             Assert.Equal(expectedMax.Nested.SomeDate.Date, result.Date);
         }
+        
+        [Fact]
+        public void GetMaxValueFilterDefinition()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
+            var documents = CreateTestDocuments(5);
+            var i = 1;
+            documents.ForEach(e =>
+            {
+                e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
+                e.SomeContent = criteria;
+            });
+            SUT.AddMany<T>(documents);
+            var expectedMax = documents.OrderByDescending(e => e.Nested.SomeDate).First();
+
+            // Act
+            var result = SUT.GetMaxValue<T, DateTime>(Builders<T>.Filter.Eq(x => x.SomeContent, criteria), e => e.Nested.SomeDate,
+                partitionKey: PartitionKey);
+
+            // Assert
+            Assert.True(result != default(DateTime));
+            Assert.Equal(expectedMax.Nested.SomeDate.Date, result.Date);
+        }
 
         [Fact]
         public async Task GetMaxValueAsync()
@@ -790,6 +1259,30 @@ public async Task GetMaxValueAsync()
             Assert.True(result != default(DateTime));
             Assert.Equal(expectedMin.Nested.SomeDate.Date, result.Date);
         }
+        
+        [Fact]
+        public async Task GetMaxValueAsyncFilterDefinition()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
+            var documents = CreateTestDocuments(5);
+            var i = 1;
+            documents.ForEach(e =>
+            {
+                e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
+                e.SomeContent = criteria;
+            });
+            SUT.AddMany<T>(documents);
+            var expectedMin = documents.OrderByDescending(e => e.Nested.SomeDate).First();
+
+            // Act
+            var result = await SUT.GetMaxValueAsync<T, DateTime>(Builders<T>.Filter.Eq(x => x.SomeContent, criteria),
+                e => e.Nested.SomeDate, partitionKey: PartitionKey);
+
+            // Assert
+            Assert.True(result != default(DateTime));
+            Assert.Equal(expectedMin.Nested.SomeDate.Date, result.Date);
+        }
 
         #endregion Max / Min Queries
 
diff --git a/CoreIntegrationTests/Infrastructure/MongoDbTKeyDocumentTestBase.Main.cs b/CoreIntegrationTests/Infrastructure/MongoDbTKeyDocumentTestBase.Main.cs
index 1162a32..06dc97c 100644
--- a/CoreIntegrationTests/Infrastructure/MongoDbTKeyDocumentTestBase.Main.cs
+++ b/CoreIntegrationTests/Infrastructure/MongoDbTKeyDocumentTestBase.Main.cs
@@ -266,6 +266,19 @@ public void GetCursor()
             Assert.True(1 == count, GetTestName());
         }
         
+        [Fact]
+        public void GetCursorFilterDefinition()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<T, TKey>(document);
+            // Act
+            var cursor = SUT.GetCursor<T, TKey>(Builders<T>.Filter.Eq(x => x.Id, document.Id), partitionKey: PartitionKey);
+            var count = cursor.CountDocuments();
+            // Assert
+            Assert.True(1 == count, GetTestName());
+        }
+        
         [Fact]
         public async Task AnyAsyncByDefinitionReturnsTrue()
         {
@@ -503,6 +516,19 @@ public void DeleteOneLinq()
             Assert.True(1 == result);
             Assert.False(SUT.Any<T, TKey>(e => e.Id.Equals(document.Id), PartitionKey), GetTestName());
         }
+        
+        [Fact]
+        public void DeleteOneFilterDefinition()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<T, TKey>(document);
+            // Act
+            var result = SUT.DeleteOne<T, TKey>(Builders<T>.Filter.Eq(x => x.Id, document.Id), partitionKey: PartitionKey);
+            // Assert
+            Assert.True(1 == result);
+            Assert.False(SUT.Any<T, TKey>(e => e.Id.Equals(document.Id), PartitionKey), GetTestName());
+        }
 
         [Fact]
         public async Task DeleteOneAsync()
@@ -529,6 +555,19 @@ public async Task DeleteOneAsyncLinq()
             Assert.True(1 == result);
             Assert.False(SUT.Any<T, TKey>(e => e.Id.Equals(document.Id), PartitionKey), GetTestName());
         }
+        
+        [Fact]
+        public async Task DeleteOneAsyncFilterDefinition()
+        {
+            // Arrange
+            var document = CreateTestDocument();
+            SUT.AddOne<T, TKey>(document);
+            // Act
+            var result = await SUT.DeleteOneAsync<T, TKey>(Builders<T>.Filter.Eq(x => x.Id, document.Id), partitionKey: PartitionKey);
+            // Assert
+            Assert.True(1 == result);
+            Assert.False(SUT.Any<T, TKey>(e => e.Id.Equals(document.Id), PartitionKey), GetTestName());
+        }
 
         [Fact]
         public async Task DeleteManyAsyncLinq()
@@ -544,6 +583,21 @@ public async Task DeleteManyAsyncLinq()
             Assert.True(5 == result);
             Assert.False(SUT.Any<T, TKey>(e => e.SomeContent == criteria, PartitionKey), GetTestName());
         }
+        
+        [Fact]
+        public async Task DeleteManyAsyncFilterDefinition()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}";
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = criteria);
+            SUT.AddMany<T, TKey>(documents);
+            // Act
+            var result = await SUT.DeleteManyAsync<T, TKey>(Builders<T>.Filter.Eq(x => x.SomeContent, criteria), partitionKey: PartitionKey);
+            // Assert
+            Assert.True(5 == result);
+            Assert.False(SUT.Any<T, TKey>(e => e.SomeContent == criteria, PartitionKey), GetTestName());
+        }
 
         [Fact]
         public async Task DeleteManyAsync()
@@ -587,6 +641,21 @@ public void DeleteManyLinq()
             Assert.True(5 == result);
             Assert.False(SUT.Any<T, TKey>(e => e.SomeContent == criteria, PartitionKey), GetTestName());
         }
+        
+        [Fact]
+        public void DeleteManyFilterDefinition()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}";
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e => e.SomeContent = criteria);
+            SUT.AddMany<T, TKey>(documents);
+            // Act
+            var result = SUT.DeleteMany<T, TKey>(Builders<T>.Filter.Eq(x => x.SomeContent, criteria), partitionKey: PartitionKey);
+            // Assert
+            Assert.True(5 == result);
+            Assert.False(SUT.Any<T, TKey>(e => e.SomeContent == criteria, PartitionKey), GetTestName());
+        }
 
         [Fact]
         public void DeleteMany()
@@ -645,6 +714,59 @@ public async Task ProjectOneAsync()
             Assert.True(someDate.Minute == result.SomeDate.Minute, GetTestName());
             Assert.True(someDate.Second == result.SomeDate.Second, GetTestName());
         }
+        
+        [Fact]
+        public async Task ProjectOneAsyncFilterDefinitionProjectDefinition()
+        {
+            // Arrange
+            var projectionBuilder = new ProjectionDefinitionBuilder<T>();
+            var someContent = GetContent();
+            var someDate = DateTime.UtcNow;
+            var document = CreateTestDocument();
+            document.SomeContent = someContent;
+            document.Nested.SomeDate = someDate;
+            SUT.AddOne<T, TKey>(document);
+            // Act
+            var result = await SUT.ProjectOneAsync<T, MyTestProjection, TKey>(
+                Builders<T>.Filter.Eq(x => x.Id, document.Id),
+                projectionBuilder.Expression(x => new MyTestProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                }),
+                partitionKey: PartitionKey);
+            // Assert
+            Assert.True(null != result, GetTestName());
+            Assert.True(someContent == result.SomeContent, GetTestName());
+            Assert.True(someDate.Minute == result.SomeDate.Minute, GetTestName());
+            Assert.True(someDate.Second == result.SomeDate.Second, GetTestName());
+        }
+        
+        [Fact]
+        public async Task ProjectOneAsyncFilterDefinitionProjectExpression()
+        {
+            // Arrange
+            var someContent = GetContent();
+            var someDate = DateTime.UtcNow;
+            var document = CreateTestDocument();
+            document.SomeContent = someContent;
+            document.Nested.SomeDate = someDate;
+            SUT.AddOne<T, TKey>(document);
+            // Act
+            var result = await SUT.ProjectOneAsync<T, MyTestProjection, TKey>(
+                Builders<T>.Filter.Eq(x => x.Id, document.Id),
+                x => new MyTestProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                },
+                partitionKey: PartitionKey);
+            // Assert
+            Assert.True(null != result, GetTestName());
+            Assert.True(someContent == result.SomeContent, GetTestName());
+            Assert.True(someDate.Minute == result.SomeDate.Minute, GetTestName());
+            Assert.True(someDate.Second == result.SomeDate.Second, GetTestName());
+        }
 
         [Fact]
         public void ProjectOne()
@@ -671,6 +793,59 @@ public void ProjectOne()
             Assert.True(someDate.Minute == result.SomeDate.Minute, GetTestName());
             Assert.True(someDate.Second == result.SomeDate.Second, GetTestName());
         }
+        
+        [Fact]
+        public void ProjectOneFilterDefinitionProjectDefinition()
+        {
+            // Arrange
+            var projectionBuilder = new ProjectionDefinitionBuilder<T>();
+            var someContent = GetContent();
+            var someDate = DateTime.UtcNow;
+            var document = CreateTestDocument();
+            document.SomeContent = someContent;
+            document.Nested.SomeDate = someDate;
+            SUT.AddOne<T, TKey>(document);
+            // Act
+            var result = SUT.ProjectOne<T, MyTestProjection, TKey>(
+                Builders<T>.Filter.Eq(x => x.Id, document.Id),
+                projectionBuilder.Expression(x => new MyTestProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                }),
+                partitionKey: PartitionKey);
+            // Assert
+            Assert.True(null != result, GetTestName());
+            Assert.True(someContent == result.SomeContent, GetTestName());
+            Assert.True(someDate.Minute == result.SomeDate.Minute, GetTestName());
+            Assert.True(someDate.Second == result.SomeDate.Second, GetTestName());
+        }
+        
+        [Fact]
+        public void ProjectOneFilterDefinitionProjectExpression()
+        {
+            // Arrange
+            var someContent = GetContent();
+            var someDate = DateTime.UtcNow;
+            var document = CreateTestDocument();
+            document.SomeContent = someContent;
+            document.Nested.SomeDate = someDate;
+            SUT.AddOne<T, TKey>(document);
+            // Act
+            var result = SUT.ProjectOne<T, MyTestProjection, TKey>(
+                Builders<T>.Filter.Eq(x => x.Id, document.Id),
+                x => new MyTestProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                },
+                partitionKey: PartitionKey);
+            // Assert
+            Assert.True(null != result, GetTestName());
+            Assert.True(someContent == result.SomeContent, GetTestName());
+            Assert.True(someDate.Minute == result.SomeDate.Minute, GetTestName());
+            Assert.True(someDate.Second == result.SomeDate.Second, GetTestName());
+        }
 
         [Fact]
         public async Task ProjectManyAsync()
@@ -701,6 +876,67 @@ public async Task ProjectManyAsync()
             Assert.True(someDate.Minute == result.First().SomeDate.Minute, GetTestName());
             Assert.True(someDate.Second == result.First().SomeDate.Second, GetTestName());
         }
+        
+        [Fact]
+        public async Task ProjectManyAsyncFilterDefinitionProjectDefinition()
+        {
+            // Arrange
+            var projectionBuilder = new ProjectionDefinitionBuilder<T>();
+            var someContent = GetContent();
+            var someDate = DateTime.UtcNow;
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e =>
+            {
+                e.SomeContent = someContent;
+                e.Nested.SomeDate = someDate;
+            });
+
+            SUT.AddMany<T, TKey>(documents);
+            // Act
+            var result = await SUT.ProjectManyAsync<T, MyTestProjection, TKey>(
+                Builders<T>.Filter.Eq(x => x.SomeContent, someContent),
+                projectionBuilder.Expression(x => new MyTestProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                }),
+                partitionKey: PartitionKey);
+            // Assert
+            Assert.True(5 == result.Count, GetTestName());
+            Assert.True(someContent == result.First().SomeContent, GetTestName());
+            Assert.True(someDate.Minute == result.First().SomeDate.Minute, GetTestName());
+            Assert.True(someDate.Second == result.First().SomeDate.Second, GetTestName());
+        }
+        
+        [Fact]
+        public async Task ProjectManyAsyncFilterDefinitionProjectExpression()
+        {
+            // Arrange
+            var someContent = GetContent();
+            var someDate = DateTime.UtcNow;
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e =>
+            {
+                e.SomeContent = someContent;
+                e.Nested.SomeDate = someDate;
+            });
+
+            SUT.AddMany<T, TKey>(documents);
+            // Act
+            var result = await SUT.ProjectManyAsync<T, MyTestProjection, TKey>(
+                Builders<T>.Filter.Eq(x => x.SomeContent, someContent),
+                x => new MyTestProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                },
+                partitionKey: PartitionKey);
+            // Assert
+            Assert.True(5 == result.Count, GetTestName());
+            Assert.True(someContent == result.First().SomeContent, GetTestName());
+            Assert.True(someDate.Minute == result.First().SomeDate.Minute, GetTestName());
+            Assert.True(someDate.Second == result.First().SomeDate.Second, GetTestName());
+        }
 
         [Fact]
         public void ProjectMany()
@@ -731,6 +967,67 @@ public void ProjectMany()
             Assert.True(someDate.Minute == result.First().SomeDate.Minute, GetTestName());
             Assert.True(someDate.Second == result.First().SomeDate.Second, GetTestName());
         }
+        
+        [Fact]
+        public void ProjectManyFilterDefinitionProjectDefinition()
+        {
+            // Arrange
+            var projectionBuilder = new ProjectionDefinitionBuilder<T>();
+            var someContent = GetContent();
+            var someDate = DateTime.UtcNow;
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e =>
+            {
+                e.SomeContent = someContent;
+                e.Nested.SomeDate = someDate;
+            });
+
+            SUT.AddMany<T, TKey>(documents);
+            // Act
+            var result = SUT.ProjectMany<T, MyTestProjection, TKey>(
+                Builders<T>.Filter.Eq(x => x.SomeContent, someContent),
+                projectionBuilder.Expression(x => new MyTestProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                }),
+                partitionKey:PartitionKey);
+            // Assert
+            Assert.True(5 == result.Count, GetTestName());
+            Assert.True(someContent == result.First().SomeContent, GetTestName());
+            Assert.True(someDate.Minute == result.First().SomeDate.Minute, GetTestName());
+            Assert.True(someDate.Second == result.First().SomeDate.Second, GetTestName());
+        }
+        
+        [Fact]
+        public void ProjectManyFilterDefinitionProjectExpression()
+        {
+            // Arrange
+            var someContent = GetContent();
+            var someDate = DateTime.UtcNow;
+            var documents = CreateTestDocuments(5);
+            documents.ForEach(e =>
+            {
+                e.SomeContent = someContent;
+                e.Nested.SomeDate = someDate;
+            });
+
+            SUT.AddMany<T, TKey>(documents);
+            // Act
+            var result = SUT.ProjectMany<T, MyTestProjection, TKey>(
+                Builders<T>.Filter.Eq(x => x.SomeContent, someContent),
+                x => new MyTestProjection
+                {
+                    SomeContent = x.SomeContent,
+                    SomeDate = x.Nested.SomeDate
+                },
+                partitionKey:PartitionKey);
+            // Assert
+            Assert.True(5 == result.Count, GetTestName());
+            Assert.True(someContent == result.First().SomeContent, GetTestName());
+            Assert.True(someDate.Minute == result.First().SomeDate.Minute, GetTestName());
+            Assert.True(someDate.Second == result.First().SomeDate.Second, GetTestName());
+        }
 
         #endregion Project
 
@@ -759,6 +1056,29 @@ public async Task GetByMaxAsync()
             Assert.Equal(expectedMax.Id, result.Id);
         }
 
+        [Fact] 
+        public async Task GetByMaxAsyncFilterDefinition()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
+            var documents = CreateTestDocuments(5);
+            var i = 1;
+            documents.ForEach(e =>
+            {
+                e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
+                e.SomeContent = criteria;
+            });
+            SUT.AddMany<T, TKey>(documents);
+            var expectedMax = documents.OrderByDescending(e => e.Nested.SomeDate).First();
+
+            // Act
+            var result = await SUT.GetByMaxAsync<T, TKey>( Builders<T>.Filter.Eq(e => e.SomeContent, criteria), e => e.Nested.SomeDate, partitionKey: PartitionKey);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(expectedMax.Id, result.Id);
+        }
+
         [Fact]
         public void GetByMax()
         {
@@ -781,6 +1101,29 @@ public void GetByMax()
             Assert.NotNull(result);
             Assert.Equal(expectedMax.Id, result.Id);
         }
+        
+        [Fact]
+        public void GetByMaxFilterDefinition()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
+            var documents = CreateTestDocuments(5);
+            var i = 1;
+            documents.ForEach(e =>
+            {
+                e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
+                e.SomeContent = criteria;
+            });
+            SUT.AddMany<T, TKey>(documents);
+            var expectedMax = documents.OrderByDescending(e => e.Nested.SomeDate).First();
+
+            // Act
+            var result = SUT.GetByMax<T, TKey>(Builders<T>.Filter.Eq(e => e.SomeContent, criteria), e => e.Nested.SomeDate, partitionKey: PartitionKey);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(expectedMax.Id, result.Id);
+        }
 
         [Fact]
         public void GetMaxValue()
@@ -804,6 +1147,29 @@ public void GetMaxValue()
             Assert.False(result == default(DateTime));
             Assert.Equal(expectedMax.Nested.SomeDate.Date, result.Date);
         }
+        
+        [Fact]
+        public void GetMaxValueFilterDefinition()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
+            var documents = CreateTestDocuments(5);
+            var i = 1;
+            documents.ForEach(e =>
+            {
+                e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
+                e.SomeContent = criteria;
+            });
+            SUT.AddMany<T, TKey>(documents);
+            var expectedMax = documents.OrderByDescending(e => e.Nested.SomeDate).First();
+
+            // Act
+            var result = SUT.GetMaxValue<T, TKey, DateTime>(Builders<T>.Filter.Eq(e => e.SomeContent, criteria), e => e.Nested.SomeDate, partitionKey: PartitionKey);
+
+            // Assert
+            Assert.False(result == default(DateTime));
+            Assert.Equal(expectedMax.Nested.SomeDate.Date, result.Date);
+        }
 
         [Fact]
         public async Task GetMaxValueAsync()
@@ -827,6 +1193,30 @@ public async Task GetMaxValueAsync()
             Assert.False(result == default(DateTime));
             Assert.Equal(expectedMax.Nested.SomeDate.Date, result.Date);
         }
+        
+        [Fact]
+        public async Task GetMaxValueAsyncFilterDefinition()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
+            var documents = CreateTestDocuments(5);
+            var i = 1;
+            documents.ForEach(e =>
+            {
+                e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
+                e.SomeContent = criteria;
+            });
+            SUT.AddMany<T, TKey>(documents);
+            var expectedMax = documents.OrderByDescending(e => e.Nested.SomeDate).First();
+
+            // Act
+            var result = await SUT.GetMaxValueAsync<T, TKey, DateTime>(Builders<T>.Filter.Eq(e => e.SomeContent, criteria),
+                e => e.Nested.SomeDate, partitionKey: PartitionKey);
+
+            // Assert
+            Assert.False(result == default(DateTime));
+            Assert.Equal(expectedMax.Nested.SomeDate.Date, result.Date);
+        }
 
         [Fact]
         public async Task GetByMinAsync()
@@ -850,6 +1240,30 @@ public async Task GetByMinAsync()
             Assert.NotNull(result);
             Assert.Equal(expectedMin.Id, result.Id);
         }
+        
+        [Fact]
+        public async Task GetByMinAsyncFilterDefinition()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
+            var documents = CreateTestDocuments(5);
+            var i = 1;
+            documents.ForEach(e =>
+            {
+                e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
+                e.SomeContent = criteria;
+            });
+            SUT.AddMany<T, TKey>(documents);
+            var expectedMin = documents.OrderBy(e => e.Nested.SomeDate).First();
+
+            // Act
+            var result = await SUT.GetByMinAsync<T, TKey>(Builders<T>.Filter.Eq(e => e.SomeContent, criteria), e => e.Nested.SomeDate,
+                partitionKey: PartitionKey);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(expectedMin.Id, result.Id);
+        }
 
         [Fact]
         public void GetByMin()
@@ -873,6 +1287,30 @@ public void GetByMin()
             Assert.NotNull(result);
             Assert.Equal(expectedMin.Id, result.Id);
         }
+        
+        [Fact]
+        public void GetByMinFilterCriteria()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
+            var documents = CreateTestDocuments(5);
+            var i = 1;
+            documents.ForEach(e =>
+            {
+                e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
+                e.SomeContent = criteria;
+            });
+            SUT.AddMany<T, TKey>(documents);
+            var expectedMin = documents.OrderBy(e => e.Nested.SomeDate).First();
+
+            // Act
+            var result = SUT.GetByMin<T, TKey>(Builders<T>.Filter.Eq(e => e.SomeContent, criteria), e => e.Nested.SomeDate,
+                partitionKey: PartitionKey);
+
+            // Assert
+            Assert.NotNull(result);
+            Assert.Equal(expectedMin.Id, result.Id);
+        }
 
         [Fact]
         public void GetMinValue()
@@ -896,6 +1334,30 @@ public void GetMinValue()
             Assert.True(result != default(DateTime));
             Assert.Equal(expectedMin.Nested.SomeDate.Date, result.Date);
         }
+        
+        [Fact]
+        public void GetMinValueFilterDefinition()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
+            var documents = CreateTestDocuments(5);
+            var i = 1;
+            documents.ForEach(e =>
+            {
+                e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
+                e.SomeContent = criteria;
+            });
+            SUT.AddMany<T, TKey>(documents);
+            var expectedMin = documents.OrderBy(e => e.Nested.SomeDate).First();
+
+            // Act
+            var result = SUT.GetMinValue<T, TKey, DateTime>(Builders<T>.Filter.Eq(e => e.SomeContent, criteria), e => e.Nested.SomeDate,
+                partitionKey: PartitionKey);
+
+            // Assert
+            Assert.True(result != default(DateTime));
+            Assert.Equal(expectedMin.Nested.SomeDate.Date, result.Date);
+        }
 
         [Fact]
         public async Task GetMinValueAsync()
@@ -919,6 +1381,30 @@ public async Task GetMinValueAsync()
             Assert.True(result != default(DateTime));
             Assert.Equal(expectedMin.Nested.SomeDate.Date, result.Date);
         }
+        
+        [Fact]
+        public async Task GetMinValueAsyncFilterDefinition()
+        {
+            // Arrange
+            var criteria = $"{GetTestName()}.{DocumentTypeName}.{Guid.NewGuid()}";
+            var documents = CreateTestDocuments(5);
+            var i = 1;
+            documents.ForEach(e =>
+            {
+                e.Nested.SomeDate = e.Nested.SomeDate.AddDays(i++);
+                e.SomeContent = criteria;
+            });
+            SUT.AddMany<T, TKey>(documents);
+            var expectedMin = documents.OrderBy(e => e.Nested.SomeDate).First();
+
+            // Act
+            var result = await SUT.GetMinValueAsync<T, TKey, DateTime>(Builders<T>.Filter.Eq(e => e.SomeContent, criteria),
+                e => e.Nested.SomeDate, partitionKey: PartitionKey);
+
+            // Assert
+            Assert.True(result != default(DateTime));
+            Assert.Equal(expectedMin.Nested.SomeDate.Date, result.Date);
+        }
 
         #endregion Max / Min Queries
 
@@ -1230,6 +1716,46 @@ public async Task GetSortedPaginatedAsync()
             Assert.True(!result.Contains(notExpected));
             Assert.Equal(expectedFirstResult.Id, result[0].Id);
         }
+        
+        [Fact]
+        public async Task GetSortedPaginatedAsyncFilterDefinition()
+        {
+            // Arrange
+            var content = $"{Guid.NewGuid()}";
+            var documents = CreateTestDocuments(10);
+            for (var i = 0; i < 5; i++)
+            {
+                documents[i].GroupingKey = 8;
+                documents[i].Nested.SomeAmount = Random.Next(1, 500000);
+                documents[i].SomeContent = content;
+            }
+            for (var i = 5; i < documents.Count; i++)
+            {
+                documents[i].GroupingKey = 9;
+                documents[i].SomeContent = content;
+            }
+            SUT.AddMany<T, TKey>(documents);
+
+            documents = documents.OrderByDescending(e => e.Nested.SomeAmount).ToList();
+            var notExpected = documents.First();
+            var expectedFirstResult = documents[1];
+
+            // Act
+            var condition = Builders<T>.Filter.And(Builders<T>.Filter.Eq(x => x.GroupingKey, 8),
+                Builders<T>.Filter.Eq(x => x.SomeContent, content));
+            var result = await SUT.GetSortedPaginatedAsync<T, TKey>(
+                condition,
+                e => e.Nested.SomeAmount,
+                null,
+                false,
+                1,5,
+                PartitionKey);
+
+            // Assert
+            Assert.Equal(4, result.Count);
+            Assert.True(!result.Contains(notExpected));
+            Assert.Equal(expectedFirstResult.Id, result[0].Id);
+        }
 
         [Fact]
         public async Task GetSortedPaginatedAsyncWithSortOptions()
@@ -1267,6 +1793,46 @@ public async Task GetSortedPaginatedAsyncWithSortOptions()
             Assert.True(!result.Contains(notExpected));
             Assert.Equal(expectedFirstResult.Id, result[0].Id);
         }
+        
+        [Fact]
+        public async Task GetSortedPaginatedAsyncFilterDefinitionWithSortOptions()
+        {
+            // Arrange
+            var content = $"{Guid.NewGuid()}";
+            var documents = CreateTestDocuments(10);
+            for (var i = 0; i < 5; i++)
+            {
+                documents[i].GroupingKey = 8;
+                documents[i].Nested.SomeAmount = Random.Next(1, 500000);
+                documents[i].SomeContent = content;
+            }
+            for (var i = 5; i < documents.Count; i++)
+            {
+                documents[i].GroupingKey = 9;
+                documents[i].SomeContent = content;
+            }
+            SUT.AddMany<T, TKey>(documents);
+
+            documents = documents.OrderByDescending(e => e.Nested.SomeAmount).ToList();
+            var notExpected = documents.First();
+            var expectedFirstResult = documents[1];
+            var sorting = Builders<T>.Sort.Descending(e => e.Nested.SomeAmount);
+
+            // Act
+            var condition = Builders<T>.Filter.And(Builders<T>.Filter.Eq(x => x.GroupingKey, 8),
+                Builders<T>.Filter.Eq(x => x.SomeContent, content));
+            var result = await SUT.GetSortedPaginatedAsync<T, TKey>(
+                condition,
+                sorting,
+                null,
+                1, 5,
+                PartitionKey);
+
+            // Assert
+            Assert.Equal(4, result.Count);
+            Assert.True(!result.Contains(notExpected));
+            Assert.Equal(expectedFirstResult.Id, result[0].Id);
+        }
 
         #endregion Pagination
 
diff --git a/MongoDbGenericRepository/Abstractions/IBaseMongoRepository.cs b/MongoDbGenericRepository/Abstractions/IBaseMongoRepository.cs
index f163354..70f740b 100644
--- a/MongoDbGenericRepository/Abstractions/IBaseMongoRepository.cs
+++ b/MongoDbGenericRepository/Abstractions/IBaseMongoRepository.cs
@@ -17,6 +17,18 @@ public interface IBaseMongoRepository :
         IBaseMongoRepository_Delete, 
         IBaseMongoRepository_Index
     {
+        /// <summary>
+        /// Asynchronously returns a paginated list of the documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="skipNumber">The number of documents you want to skip. Default value is 0.</param>
+        /// <param name="takeNumber">The number of documents you want to take. Default value is 50.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        Task<List<TDocument>> GetPaginatedAsync<TDocument>(FilterDefinition<TDocument> condition, FindOptions findOption = null, int skipNumber = 0, int takeNumber = 50, string partitionKey = null)
+            where TDocument : IDocument;
+        
         /// <summary>
         /// Asynchronously returns a paginated list of the documents matching the filter condition.
         /// </summary>
@@ -28,6 +40,20 @@ public interface IBaseMongoRepository :
         Task<List<TDocument>> GetPaginatedAsync<TDocument>(Expression<Func<TDocument, bool>> filter, int skipNumber = 0, int takeNumber = 50, string partitionKey = null)
             where TDocument : IDocument;
 
+        /// <summary>
+        /// Asynchronously returns a paginated list of the documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="skipNumber">The number of documents you want to skip. Default value is 0.</param>
+        /// <param name="takeNumber">The number of documents you want to take. Default value is 50.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        Task<List<TDocument>> GetPaginatedAsync<TDocument, TKey>(FilterDefinition<TDocument> condition, FindOptions findOption = null, int skipNumber = 0, int takeNumber = 50, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+        
         /// <summary>
         /// Asynchronously returns a paginated list of the documents matching the filter condition.
         /// </summary>
diff --git a/MongoDbGenericRepository/Abstractions/IBaseReadOnlyRepository.cs b/MongoDbGenericRepository/Abstractions/IBaseReadOnlyRepository.cs
index 185ef77..281508f 100644
--- a/MongoDbGenericRepository/Abstractions/IBaseReadOnlyRepository.cs
+++ b/MongoDbGenericRepository/Abstractions/IBaseReadOnlyRepository.cs
@@ -96,6 +96,18 @@ TDocument GetOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, stri
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>;
 
+        /// <summary>
+        /// Returns a collection cursor.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        IFindFluent<TDocument, TDocument> GetCursor<TDocument, TKey>(FilterDefinition<TDocument> condition, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+        
         /// <summary>
         /// Returns a collection cursor.
         /// </summary>
@@ -253,6 +265,24 @@ long Count<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string par
 
         #region Min / Max
 
+        /// <summary>
+        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="maxValueSelector">A property selector to order by descending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        Task<TDocument> GetByMaxAsync<TDocument, TKey>(
+            FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, object>> maxValueSelector,
+            FindOptions findOption = null,
+            string partitionKey = null, CancellationToken cancellationToken = default)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+        
         /// <summary>
         /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
         /// </summary>
@@ -269,6 +299,19 @@ Task<TDocument> GetByMaxAsync<TDocument, TKey>(
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>;
 
+        /// <summary>
+        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="orderByDescending">A property selector to order by descending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        TDocument GetByMax<TDocument, TKey>(FilterDefinition<TDocument> condition, Expression<Func<TDocument, object>> orderByDescending, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+        
         /// <summary>
         /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
         /// </summary>
@@ -281,6 +324,24 @@ TDocument GetByMax<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Ex
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>;
 
+        /// <summary>
+        /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="minValueSelector">A property selector for the minimum value you are looking for.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        Task<TDocument> GetByMinAsync<TDocument, TKey>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, object>> minValueSelector,
+            FindOptions findOption = null,
+            string partitionKey = null,
+            CancellationToken cancellationToken = default)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+        
         /// <summary>
         /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
         /// </summary>
@@ -297,6 +358,19 @@ Task<TDocument> GetByMinAsync<TDocument, TKey>(Expression<Func<TDocument, bool>>
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>;
 
+        /// <summary>
+        /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="minValueSelector">A property selector for the minimum value you are looking for.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        TDocument GetByMin<TDocument, TKey>(FilterDefinition<TDocument> condition, Expression<Func<TDocument, object>> minValueSelector, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+        
         /// <summary>
         /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
         /// </summary>
@@ -309,6 +383,26 @@ TDocument GetByMin<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, Ex
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>;
 
+        /// <summary>
+        /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="maxValueSelector">A property selector for the maximum value you are looking for.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        Task<TValue> GetMaxValueAsync<TDocument, TKey, TValue>(
+            FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TValue>> maxValueSelector,
+            FindOptions findOption = null,
+            string partitionKey = null,
+            CancellationToken cancellationToken = default)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+        
         /// <summary>
         /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
         /// </summary>
@@ -327,6 +421,20 @@ Task<TValue> GetMaxValueAsync<TDocument, TKey, TValue>(
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>;
 
+        /// <summary>
+        /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="maxValueSelector">A property selector to order by ascending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        TValue GetMaxValue<TDocument, TKey, TValue>(FilterDefinition<TDocument> condition, Expression<Func<TDocument, TValue>> maxValueSelector, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+        
         /// <summary>
         /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
         /// </summary>
@@ -340,6 +448,26 @@ TValue GetMaxValue<TDocument, TKey, TValue>(Expression<Func<TDocument, bool>> fi
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>;
 
+        /// <summary>
+        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="minValueSelector">A property selector to order by ascending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        Task<TValue> GetMinValueAsync<TDocument, TKey, TValue>(
+            FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TValue>> minValueSelector,
+            FindOptions findOption = null,
+            string partitionKey = null,
+            CancellationToken cancellationToken = default)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+        
         /// <summary>
         /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
         /// </summary>
@@ -358,6 +486,20 @@ Task<TValue> GetMinValueAsync<TDocument, TKey, TValue>(
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>;
 
+        /// <summary>
+        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="minValueSelector">A property selector to order by ascending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        TValue GetMinValue<TDocument, TKey, TValue>(FilterDefinition<TDocument> condition, Expression<Func<TDocument, TValue>> minValueSelector, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+        
         /// <summary>
         /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
         /// </summary>
@@ -437,6 +579,48 @@ decimal SumBy<TDocument, TKey>(Expression<Func<TDocument, bool>> filter,
 
         #region Project TKey
 
+        /// <summary>
+        /// Asynchronously returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">A projection definition.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        Task<TProjection> ProjectOneAsync<TDocument, TProjection, TKey>(
+            FilterDefinition<TDocument> condition,
+            ProjectionDefinition<TDocument, TProjection> projection,
+            FindOptions findOption = null,
+            string partitionKey = null,
+            CancellationToken cancellationToken = default)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+            where TProjection : class;
+        
+        /// <summary>
+        /// Asynchronously returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        Task<TProjection> ProjectOneAsync<TDocument, TProjection, TKey>(
+            FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TProjection>> projection,
+            FindOptions findOption = null,
+            string partitionKey = null,
+            CancellationToken cancellationToken = default)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+            where TProjection : class;
+        
         /// <summary>
         /// Asynchronously returns a projected document matching the filter condition.
         /// </summary>
@@ -456,6 +640,36 @@ Task<TProjection> ProjectOneAsync<TDocument, TProjection, TKey>(
             where TKey : IEquatable<TKey>
             where TProjection : class;
 
+        /// <summary>
+        /// Returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">A projection definition.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        TProjection ProjectOne<TDocument, TProjection, TKey>(FilterDefinition<TDocument> condition, ProjectionDefinition<TDocument, TProjection> projection, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+            where TProjection : class;
+        
+        /// <summary>
+        /// Returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        TProjection ProjectOne<TDocument, TProjection, TKey>(FilterDefinition<TDocument> condition, Expression<Func<TDocument, TProjection>> projection, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+            where TProjection : class;
+        
         /// <summary>
         /// Returns a projected document matching the filter condition.
         /// </summary>
@@ -470,6 +684,48 @@ TProjection ProjectOne<TDocument, TProjection, TKey>(Expression<Func<TDocument,
                                         where TKey : IEquatable<TKey>
                                         where TProjection : class;
 
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">A projection definition.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        Task<List<TProjection>> ProjectManyAsync<TDocument, TProjection, TKey>(
+            FilterDefinition<TDocument> condition,
+            ProjectionDefinition<TDocument, TProjection> projection,
+            FindOptions findOption = null,
+            string partitionKey = null,
+            CancellationToken cancellationToken = default)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+            where TProjection : class;
+        
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        Task<List<TProjection>> ProjectManyAsync<TDocument, TProjection, TKey>(
+            FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TProjection>> projection,
+            FindOptions findOption = null,
+            string partitionKey = null,
+            CancellationToken cancellationToken = default)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+            where TProjection : class;
+        
         /// <summary>
         /// Asynchronously returns a list of projected documents matching the filter condition.
         /// </summary>
@@ -489,6 +745,36 @@ Task<List<TProjection>> ProjectManyAsync<TDocument, TProjection, TKey>(
             where TKey : IEquatable<TKey>
             where TProjection : class;
 
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">A projection definition.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        List<TProjection> ProjectMany<TDocument, TProjection, TKey>(FilterDefinition<TDocument> condition, ProjectionDefinition<TDocument, TProjection> projection, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+            where TProjection : class;
+        
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        List<TProjection> ProjectMany<TDocument, TProjection, TKey>(FilterDefinition<TDocument> condition, Expression<Func<TDocument, TProjection>> projection, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+            where TProjection : class;
+        
         /// <summary>
         /// Asynchronously returns a list of projected documents matching the filter condition.
         /// </summary>
@@ -551,6 +837,29 @@ List<TProjection> GroupBy<TDocument, TGroupKey, TProjection, TKey>(
 
         #region Pagination
 
+        /// <summary>
+        /// Asynchronously returns a paginated list of the documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="sortSelector">The property selector.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="ascending">Order of the sorting.</param>
+        /// <param name="skipNumber">The number of documents you want to skip. Default value is 0.</param>
+        /// <param name="takeNumber">The number of documents you want to take. Default value is 50.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        Task<List<TDocument>> GetSortedPaginatedAsync<TDocument, TKey>(
+            FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, object>> sortSelector,
+            FindOptions findOption = null,
+            bool ascending = true,
+            int skipNumber = 0,
+            int takeNumber = 50,
+            string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+        
         /// <summary>
         /// Asynchronously returns a paginated list of the documents matching the filter condition.
         /// </summary>
@@ -572,6 +881,29 @@ Task<List<TDocument>> GetSortedPaginatedAsync<TDocument, TKey>(
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>;
 
+        /// <summary>
+        /// Asynchronously returns a paginated list of the documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="sortDefinition">The sort definition.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="skipNumber">The number of documents you want to skip. Default value is 0.</param>
+        /// <param name="takeNumber">The number of documents you want to take. Default value is 50.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        Task<List<TDocument>> GetSortedPaginatedAsync<TDocument, TKey>(
+            FilterDefinition<TDocument> condition,
+            SortDefinition<TDocument> sortDefinition,
+            FindOptions findOption = null,
+            int skipNumber = 0,
+            int takeNumber = 50,
+            string partitionKey = null,
+            CancellationToken cancellationToken = default)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+        
         /// <summary>
         /// Asynchronously returns a paginated list of the documents matching the filter condition.
         /// </summary>
diff --git a/MongoDbGenericRepository/Abstractions/IReadOnlyMongoRepository.TKey.cs b/MongoDbGenericRepository/Abstractions/IReadOnlyMongoRepository.TKey.cs
index a61374c..bc36258 100644
--- a/MongoDbGenericRepository/Abstractions/IReadOnlyMongoRepository.TKey.cs
+++ b/MongoDbGenericRepository/Abstractions/IReadOnlyMongoRepository.TKey.cs
@@ -45,6 +45,15 @@ public interface IReadOnlyMongoRepository<TKey> where TKey : IEquatable<TKey>
         /// <param name="partitionKey">An optional partition key.</param>
         TDocument GetOne<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null) where TDocument : IDocument<TKey>;
 
+        /// <summary>
+        /// Returns a collection cursor.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        IFindFluent<TDocument, TDocument> GetCursor<TDocument>(FilterDefinition<TDocument> condition, FindOptions findOption = null, string partitionKey = null) where TDocument : IDocument<TKey>;
+        
         /// <summary>
         /// Returns a collection cursor.
         /// </summary>
@@ -105,6 +114,20 @@ public interface IReadOnlyMongoRepository<TKey> where TKey : IEquatable<TKey>
 
         #region Min / Max
 
+        /// <summary>
+        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="maxValueSelector">A property selector to order by descending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        Task<TDocument> GetByMaxAsync<TDocument>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, object>> maxValueSelector, FindOptions findOption = null, string partitionKey = null,
+            CancellationToken cancellationToken = default)
+            where TDocument : IDocument<TKey>;
+        
         /// <summary>
         /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
         /// </summary>
@@ -115,6 +138,18 @@ public interface IReadOnlyMongoRepository<TKey> where TKey : IEquatable<TKey>
         Task<TDocument> GetByMaxAsync<TDocument>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> orderByDescending, string partitionKey = null)
             where TDocument : IDocument<TKey>;
 
+        /// <summary>
+        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="maxValueSelector">A property selector to order by descending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        TDocument GetByMax<TDocument>(FilterDefinition<TDocument> condition, Expression<Func<TDocument, object>> maxValueSelector,
+            FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>;
+        
         /// <summary>
         /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
         /// </summary>
@@ -126,6 +161,20 @@ Task<TDocument> GetByMaxAsync<TDocument>(Expression<Func<TDocument, bool>> filte
         TDocument GetByMax<TDocument>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> orderByDescending, string partitionKey = null)
             where TDocument : IDocument<TKey>;
 
+        /// <summary>
+        /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="minValueSelector">A property selector to order by ascending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        Task<TDocument> GetByMinAsync<TDocument>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, object>> minValueSelector, FindOptions findOption = null, string partitionKey = null,
+            CancellationToken cancellationToken = default)
+            where TDocument : IDocument<TKey>;
+        
         /// <summary>
         /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
         /// </summary>
@@ -136,6 +185,18 @@ TDocument GetByMax<TDocument>(Expression<Func<TDocument, bool>> filter, Expressi
         Task<TDocument> GetByMinAsync<TDocument>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> orderByAscending, string partitionKey = null)
             where TDocument : IDocument<TKey>;
 
+        /// <summary>
+        /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="minValueSelector">A property selector to order by ascending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        TDocument GetByMin<TDocument>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, object>> minValueSelector, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>;
+        
         /// <summary>
         /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
         /// </summary>
@@ -146,6 +207,21 @@ Task<TDocument> GetByMinAsync<TDocument>(Expression<Func<TDocument, bool>> filte
         TDocument GetByMin<TDocument>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, object>> orderByAscending, string partitionKey = null)
             where TDocument : IDocument<TKey>;
 
+        /// <summary>
+        /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TValue">The type of the field for which you want the maximum value.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="maxValueSelector">A property selector to order by ascending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        Task<TValue> GetMaxValueAsync<TDocument, TValue>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TValue>> maxValueSelector, FindOptions findOption = null, string partitionKey = null,
+            CancellationToken cancellationToken = default)
+            where TDocument : IDocument<TKey>;
+
         /// <summary>
         /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
         /// </summary>
@@ -157,6 +233,19 @@ TDocument GetByMin<TDocument>(Expression<Func<TDocument, bool>> filter, Expressi
         Task<TValue> GetMaxValueAsync<TDocument, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> maxValueSelector, string partitionKey = null)
             where TDocument : IDocument<TKey>;
 
+        /// <summary>
+        /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="maxValueSelector">A property selector to order by ascending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        TValue GetMaxValue<TDocument, TValue>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TValue>> maxValueSelector, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>;
+
         /// <summary>
         /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
         /// </summary>
@@ -168,6 +257,21 @@ Task<TValue> GetMaxValueAsync<TDocument, TValue>(Expression<Func<TDocument, bool
         TValue GetMaxValue<TDocument, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> maxValueSelector, string partitionKey = null)
             where TDocument : IDocument<TKey>;
 
+        /// <summary>
+        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="minValueSelector">A property selector to order by ascending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        Task<TValue> GetMinValueAsync<TDocument, TValue>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TValue>> minValueSelector, FindOptions findOption = null, string partitionKey = null,
+            CancellationToken cancellationToken = default)
+            where TDocument : IDocument<TKey>;
+
         /// <summary>
         /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
         /// </summary>
@@ -179,6 +283,19 @@ TValue GetMaxValue<TDocument, TValue>(Expression<Func<TDocument, bool>> filter,
         Task<TValue> GetMinValueAsync<TDocument, TValue>(Expression<Func<TDocument, bool>> filter, Expression<Func<TDocument, TValue>> minValueSelector, string partitionKey = null)
             where TDocument : IDocument<TKey>;
 
+        /// <summary>
+        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="minValueSelector">A property selector to order by ascending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        TValue GetMinValue<TDocument, TValue>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TValue>> minValueSelector, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>;
+
         /// <summary>
         /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
         /// </summary>
@@ -246,6 +363,44 @@ decimal SumBy<TDocument>(Expression<Func<TDocument, bool>> filter,
 
         #region Project
 
+        /// <summary>
+        /// Asynchronously returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">A project definition.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        Task<TProjection> ProjectOneAsync<TDocument, TProjection>(
+            FilterDefinition<TDocument> condition,
+            ProjectionDefinition<TDocument, TProjection> projection,
+            FindOptions findOption = null,
+            string partitionKey = null,
+            CancellationToken cancellationToken = default)
+            where TDocument : IDocument<TKey>
+            where TProjection : class;
+
+        /// <summary>
+        /// Asynchronously returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        Task<TProjection> ProjectOneAsync<TDocument, TProjection>(
+            FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TProjection>> projection,
+            FindOptions findOption = null,
+            string partitionKey = null,
+            CancellationToken cancellationToken = default)
+            where TDocument : IDocument<TKey>
+            where TProjection : class;
+        
         /// <summary>
         /// Asynchronously returns a projected document matching the filter condition.
         /// </summary>
@@ -259,6 +414,34 @@ Task<TProjection> ProjectOneAsync<TDocument, TProjection>(Expression<Func<TDocum
             where TDocument : IDocument<TKey>
             where TProjection : class;
 
+        /// <summary>
+        /// Returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">A project definition.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        TProjection ProjectOne<TDocument, TProjection>(FilterDefinition<TDocument> condition,
+            ProjectionDefinition<TDocument, TProjection> projection, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TProjection : class;
+
+        /// <summary>
+        /// Returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        TProjection ProjectOne<TDocument, TProjection>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TProjection>> projection, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TProjection : class;
+
         /// <summary>
         /// Returns a projected document matching the filter condition.
         /// </summary>
@@ -271,6 +454,44 @@ TProjection ProjectOne<TDocument, TProjection>(Expression<Func<TDocument, bool>>
             where TDocument : IDocument<TKey>
             where TProjection : class;
 
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">A project definition.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        Task<List<TProjection>> ProjectManyAsync<TDocument, TProjection>(
+            FilterDefinition<TDocument> condition,
+            ProjectionDefinition<TDocument, TProjection> projection,
+            FindOptions findOption = null,
+            string partitionKey = null,
+            CancellationToken cancellationToken = default)
+            where TDocument : IDocument<TKey>
+            where TProjection : class;
+
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        Task<List<TProjection>> ProjectManyAsync<TDocument, TProjection>(
+            FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TProjection>> projection,
+            FindOptions findOption = null,
+            string partitionKey = null,
+            CancellationToken cancellationToken = default)
+            where TDocument : IDocument<TKey>
+            where TProjection : class;
+        
         /// <summary>
         /// Asynchronously returns a list of projected documents matching the filter condition.
         /// </summary>
@@ -283,6 +504,34 @@ Task<List<TProjection>> ProjectManyAsync<TDocument, TProjection>(Expression<Func
             where TDocument : IDocument<TKey>
             where TProjection : class;
 
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">A project definition.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        List<TProjection> ProjectMany<TDocument, TProjection>(FilterDefinition<TDocument> condition,
+            ProjectionDefinition<TDocument, TProjection> projection, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TProjection : class;
+
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        List<TProjection> ProjectMany<TDocument, TProjection>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TProjection>> projection, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TProjection : class;
+
         /// <summary>
         /// Asynchronously returns a list of projected documents matching the filter condition.
         /// </summary>
diff --git a/MongoDbGenericRepository/BaseMongoRepository.Delete.cs b/MongoDbGenericRepository/BaseMongoRepository.Delete.cs
index e86b060..bb6ef2e 100644
--- a/MongoDbGenericRepository/BaseMongoRepository.Delete.cs
+++ b/MongoDbGenericRepository/BaseMongoRepository.Delete.cs
@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Linq.Expressions;
 using System.Threading.Tasks;
+using MongoDB.Driver;
 
 namespace MongoDbGenericRepository
 {
@@ -31,6 +32,19 @@ Task<long> DeleteOneAsync<TDocument, TKey>(TDocument document)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>;
 
+        /// <summary>
+        /// Deletes a document matching the condition of the filter definition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="deleteOption">A mongodb delete option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        long DeleteOne<TDocument, TKey>(FilterDefinition<TDocument> condition, DeleteOptions deleteOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+        
         /// <summary>
         /// Deletes a document matching the condition of the LINQ expression filter.
         /// </summary>
@@ -43,6 +57,20 @@ long DeleteOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>;
 
+        /// <summary>
+        /// Asynchronously deletes a document matching the condition of the filter definition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="deleteOption">A mongodb delete option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        Task<long> DeleteOneAsync<TDocument, TKey>(FilterDefinition<TDocument> condition, DeleteOptions deleteOption = null,
+            string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
+        
         /// <summary>
         /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
         /// </summary>
@@ -54,6 +82,19 @@ long DeleteOne<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string
         Task<long> DeleteOneAsync<TDocument, TKey>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>;
+        
+        /// <summary>
+        /// Asynchronously deletes the documents matching the condition of the filter definition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="deleteOption">A mongodb delete option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        Task<long> DeleteManyAsync<TDocument, TKey>(FilterDefinition<TDocument> condition, DeleteOptions deleteOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
 
         /// <summary>
         /// Asynchronously deletes the documents matching the condition of the LINQ expression filter.
@@ -88,6 +129,19 @@ Task<long> DeleteManyAsync<TDocument, TKey>(IEnumerable<TDocument> documents)
         long DeleteMany<TDocument, TKey>(IEnumerable<TDocument> documents)
             where TDocument : IDocument<TKey>
             where TKey : IEquatable<TKey>;
+        
+        /// <summary>
+        /// Deletes the documents matching the condition of the filter definition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="deleteOption">A mongodb delete option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        long DeleteMany<TDocument, TKey>(FilterDefinition<TDocument> condition, DeleteOptions deleteOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>;
 
         /// <summary>
         /// Deletes the documents matching the condition of the LINQ expression filter.
@@ -147,6 +201,19 @@ public virtual long DeleteOne<TDocument>(TDocument document) where TDocument : I
         {
             return MongoDbEraser.DeleteOne<TDocument, Guid>(document);
         }
+        
+        /// <summary>
+        /// Deletes a document.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="deleteOption">A mongodb delete option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual long DeleteOne<TDocument>(FilterDefinition<TDocument> condition, DeleteOptions deleteOption = null, string partitionKey = null) where TDocument : IDocument<Guid>
+        {
+            return MongoDbEraser.DeleteOne<TDocument, Guid>(condition, deleteOption, partitionKey).DeletedCount;
+        }
 
         /// <summary>
         /// Deletes a document matching the condition of the LINQ expression filter.
@@ -160,6 +227,20 @@ public virtual long DeleteOne<TDocument>(Expression<Func<TDocument, bool>> filte
             return MongoDbEraser.DeleteOne<TDocument, Guid>(filter, partitionKey);
         }
 
+        /// <summary>
+        /// Asynchronously deletes a document matching the condition of the filter definition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="deleteOption">A mongodb delete option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual async Task<long> DeleteOneAsync<TDocument>(FilterDefinition<TDocument> condition, DeleteOptions deleteOption = null, string partitionKey = null) where TDocument : IDocument<Guid>
+        {
+            var result = await MongoDbEraser.DeleteOneAsync<TDocument, Guid>(condition, deleteOption, partitionKey);
+            return result.DeletedCount;
+        }
+
         /// <summary>
         /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
         /// </summary>
@@ -172,6 +253,20 @@ public virtual async Task<long> DeleteOneAsync<TDocument>(Expression<Func<TDocum
             return await MongoDbEraser.DeleteOneAsync<TDocument, Guid>(filter, partitionKey);
         }
 
+        /// <summary>
+        /// Asynchronously deletes the documents matching the condition of the filter definition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="deleteOption">A mongodb delete option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual async Task<long> DeleteManyAsync<TDocument>(FilterDefinition<TDocument> condition, DeleteOptions deleteOption = null, string partitionKey = null) where TDocument : IDocument<Guid>
+        {
+            var result = await MongoDbEraser.DeleteManyAsync<TDocument, Guid>(condition, deleteOption, partitionKey);
+            return result.DeletedCount;
+        }
+
         /// <summary>
         /// Asynchronously deletes the documents matching the condition of the LINQ expression filter.
         /// </summary>
@@ -206,6 +301,19 @@ public virtual long DeleteMany<TDocument>(IEnumerable<TDocument> documents) wher
             return DeleteMany<TDocument, Guid>(documents);
         }
 
+        /// <summary>
+        /// Deletes the documents matching the condition of the filter definition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="deleteOption">A mongodb delete option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public long DeleteMany<TDocument>(FilterDefinition<TDocument> condition, DeleteOptions deleteOption = null, string partitionKey = null) where TDocument : IDocument<Guid>
+        {
+            return MongoDbEraser.DeleteMany<TDocument, Guid>(condition, deleteOption, partitionKey).DeletedCount;
+        }
+
         /// <summary>
         /// Deletes the documents matching the condition of the LINQ expression filter.
         /// </summary>
@@ -250,6 +358,23 @@ public virtual async Task<long> DeleteOneAsync<TDocument, TKey>(TDocument docume
             return await MongoDbEraser.DeleteOneAsync<TDocument, TKey>(document);
         }
 
+        /// <summary>
+        /// Deletes a document matching the condition of the filter definition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="deleteOption">A mongodb delete option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual long DeleteOne<TDocument, TKey>(FilterDefinition<TDocument> condition, DeleteOptions deleteOption = null,
+            string partitionKey = null) 
+            where TDocument : IDocument<TKey> 
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbEraser.DeleteOne<TDocument, TKey>(condition, deleteOption, partitionKey).DeletedCount;
+        }
+
         /// <summary>
         /// Deletes a document matching the condition of the LINQ expression filter.
         /// </summary>
@@ -265,6 +390,24 @@ public virtual long DeleteOne<TDocument, TKey>(Expression<Func<TDocument, bool>>
             return MongoDbEraser.DeleteOne<TDocument, TKey>(filter, partitionKey);
         }
 
+        /// <summary>
+        /// Deletes a document matching the condition of the filter definition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="deleteOption">A mongodb delete option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual async Task<long> DeleteOneAsync<TDocument, TKey>(FilterDefinition<TDocument> condition,
+            DeleteOptions deleteOption = null, string partitionKey = null) 
+            where TDocument : IDocument<TKey> 
+            where TKey : IEquatable<TKey>
+        {
+            var result = await MongoDbEraser.DeleteOneAsync<TDocument, TKey>(condition, deleteOption, partitionKey);
+            return result.DeletedCount;
+        }
+
         /// <summary>
         /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
         /// </summary>
@@ -280,6 +423,24 @@ public virtual async Task<long> DeleteOneAsync<TDocument, TKey>(Expression<Func<
             return await MongoDbEraser.DeleteOneAsync<TDocument, TKey>(filter, partitionKey);
         }
 
+        /// <summary>
+        /// Asynchronously deletes the documents matching the condition of the filter definition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="deleteOption">A mongodb delete option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual async Task<long> DeleteManyAsync<TDocument, TKey>(FilterDefinition<TDocument> condition,
+            DeleteOptions deleteOption = null, string partitionKey = null) 
+            where TDocument : IDocument<TKey> 
+            where TKey : IEquatable<TKey>
+        {
+            var result = await MongoDbEraser.DeleteManyAsync<TDocument, TKey>(condition, deleteOption, partitionKey);
+            return result.DeletedCount;
+        }
+
         /// <summary>
         /// Asynchronously deletes the documents matching the condition of the LINQ expression filter.
         /// </summary>
@@ -323,6 +484,20 @@ public virtual long DeleteMany<TDocument, TKey>(IEnumerable<TDocument> documents
             return MongoDbEraser.DeleteMany<TDocument, TKey>(documents);
         }
 
+        /// <summary>
+        /// Deletes the documents matching the condition of the filter definition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="deleteOption">A mongodb delete option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual long DeleteMany<TDocument, TKey>(FilterDefinition<TDocument> condition, DeleteOptions deleteOption = null, string partitionKey = null) where TDocument : IDocument<TKey> where TKey : IEquatable<TKey>
+        {
+            return MongoDbEraser.DeleteMany<TDocument, TKey>(condition, deleteOption, partitionKey).DeletedCount;
+        }
+
         /// <summary>
         /// Deletes the documents matching the condition of the LINQ expression filter.
         /// </summary>
diff --git a/MongoDbGenericRepository/BaseMongoRepository.Main.cs b/MongoDbGenericRepository/BaseMongoRepository.Main.cs
index 09664e8..8498a83 100644
--- a/MongoDbGenericRepository/BaseMongoRepository.Main.cs
+++ b/MongoDbGenericRepository/BaseMongoRepository.Main.cs
@@ -24,7 +24,7 @@ protected BaseMongoRepository(string connectionString, string databaseName = nul
         }
 
         /// <summary>
-        /// The contructor taking a <see cref="IMongoDbContext"/>.
+        /// The constructor taking a <see cref="IMongoDbContext"/>.
         /// </summary>
         /// <param name="mongoDbContext">A mongodb context implementing <see cref="IMongoDbContext"/></param>
         protected BaseMongoRepository(IMongoDbContext mongoDbContext) : base(mongoDbContext)
@@ -32,13 +32,28 @@ protected BaseMongoRepository(IMongoDbContext mongoDbContext) : base(mongoDbCont
         }
 
         /// <summary>
-        /// The contructor taking a <see cref="IMongoDatabase"/>.
+        /// The constructor taking a <see cref="IMongoDatabase"/>.
         /// </summary>
         /// <param name="mongoDatabase">A mongodb context implementing <see cref="IMongoDatabase"/></param>
         protected BaseMongoRepository(IMongoDatabase mongoDatabase) : base(mongoDatabase)
         {
         }
 
+        /// <summary>
+        /// Asynchronously returns a paginated list of the documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="skipNumber">The number of documents you want to skip. Default value is 0.</param>
+        /// <param name="takeNumber">The number of documents you want to take. Default value is 50.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual Task<List<TDocument>> GetPaginatedAsync<TDocument>(FilterDefinition<TDocument> condition, FindOptions findOption = null, int skipNumber = 0, int takeNumber = 50,
+            string partitionKey = null) where TDocument : IDocument
+        {
+            return HandlePartitioned<TDocument>(partitionKey).Find(condition, findOption).Skip(skipNumber).Limit(takeNumber).ToListAsync();
+        }
+
         /// <summary>
         /// Asynchronously returns a paginated list of the documents matching the filter condition.
         /// </summary>
@@ -57,6 +72,22 @@ public virtual async Task<List<TDocument>> GetPaginatedAsync<TDocument>(
             return await HandlePartitioned<TDocument>(partitionKey).Find(filter).Skip(skipNumber).Limit(takeNumber).ToListAsync();
         }
 
+        /// <summary>
+        /// Asynchronously returns a paginated list of the documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="skipNumber">The number of documents you want to skip. Default value is 0.</param>
+        /// <param name="takeNumber">The number of documents you want to take. Default value is 50.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual Task<List<TDocument>> GetPaginatedAsync<TDocument, TKey>(FilterDefinition<TDocument> condition, FindOptions findOption = null, int skipNumber = 0, int takeNumber = 50,
+            string partitionKey = null) where TDocument : IDocument<TKey> where TKey : IEquatable<TKey>
+        {
+            return HandlePartitioned<TDocument, TKey>(partitionKey).Find(condition, findOption).Skip(skipNumber).Limit(takeNumber).ToListAsync();
+        }
+
         /// <summary>
         /// Asynchronously returns a paginated list of the documents matching the filter condition.
         /// </summary>
diff --git a/MongoDbGenericRepository/DataAccess/Base/DataAccessBase.cs b/MongoDbGenericRepository/DataAccess/Base/DataAccessBase.cs
index eded8d5..d588166 100644
--- a/MongoDbGenericRepository/DataAccess/Base/DataAccessBase.cs
+++ b/MongoDbGenericRepository/DataAccess/Base/DataAccessBase.cs
@@ -132,6 +132,24 @@ protected virtual CreateIndexOptions MapIndexOptions(IndexCreationOptions indexC
             };
         }
 
+        /// <summary>
+        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="minValueSelector">A property selector to order by ascending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        protected virtual IFindFluent<TDocument, TDocument> GetMinMongoQuery<TDocument, TKey, TValue>(FilterDefinition<TDocument> condition, Expression<Func<TDocument, TValue>> minValueSelector, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return GetCollection<TDocument, TKey>(partitionKey).Find(condition, findOption)
+                .SortBy(ConvertExpression(minValueSelector))
+                .Limit(1);
+        }
 
         /// <summary>
         /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
@@ -151,6 +169,25 @@ protected virtual IFindFluent<TDocument, TDocument> GetMinMongoQuery<TDocument,
                                                                .Limit(1);
         }
 
+        /// <summary>
+        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="maxValueSelector">A property selector to order by descending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        protected virtual IFindFluent<TDocument, TDocument> GetMaxMongoQuery<TDocument, TKey, TValue>(FilterDefinition<TDocument> condition, Expression<Func<TDocument, TValue>> maxValueSelector, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return GetCollection<TDocument, TKey>(partitionKey).Find(condition, findOption)
+                .SortByDescending(ConvertExpression(maxValueSelector))
+                .Limit(1);
+        }
+        
         /// <summary>
         /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
         /// </summary>
diff --git a/MongoDbGenericRepository/DataAccess/Delete/MongoDbEraser.cs b/MongoDbGenericRepository/DataAccess/Delete/MongoDbEraser.cs
index 1daabac..29108d9 100644
--- a/MongoDbGenericRepository/DataAccess/Delete/MongoDbEraser.cs
+++ b/MongoDbGenericRepository/DataAccess/Delete/MongoDbEraser.cs
@@ -48,6 +48,23 @@ public virtual async Task<long> DeleteOneAsync<TDocument, TKey>(TDocument docume
             return (await HandlePartitioned<TDocument, TKey>(document).DeleteOneAsync(filter)).DeletedCount;
         }
 
+        /// <summary>
+        /// Deletes a document matching the condition of the filter definition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="deleteOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual DeleteResult DeleteOne<TDocument, TKey>(FilterDefinition<TDocument> condition, DeleteOptions deleteOption = null,
+            string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return HandlePartitioned<TDocument, TKey>(partitionKey).DeleteOne(condition, deleteOption);
+        }
+        
         /// <summary>
         /// Deletes a document matching the condition of the LINQ expression filter.
         /// </summary>
@@ -63,6 +80,22 @@ public virtual long DeleteOne<TDocument, TKey>(Expression<Func<TDocument, bool>>
             return HandlePartitioned<TDocument, TKey>(partitionKey).DeleteOne(filter).DeletedCount;
         }
 
+        /// <summary>
+        /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="deleteOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual Task<DeleteResult> DeleteOneAsync<TDocument, TKey>(FilterDefinition<TDocument> condition, DeleteOptions deleteOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return HandlePartitioned<TDocument, TKey>(partitionKey).DeleteOneAsync(condition, deleteOption);
+        }
+        
         /// <summary>
         /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
         /// </summary>
@@ -78,6 +111,23 @@ public virtual async Task<long> DeleteOneAsync<TDocument, TKey>(Expression<Func<
             return (await HandlePartitioned<TDocument, TKey>(partitionKey).DeleteOneAsync(filter)).DeletedCount;
         }
 
+        /// <summary>
+        /// Asynchronously deletes the documents matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="deleteOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual Task<DeleteResult> DeleteManyAsync<TDocument, TKey>(FilterDefinition<TDocument> condition,
+            DeleteOptions deleteOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return HandlePartitioned<TDocument, TKey>(partitionKey).DeleteManyAsync(condition, deleteOption);
+        }
+        
         /// <summary>
         /// Asynchronously deletes the documents matching the condition of the LINQ expression filter.
         /// </summary>
@@ -159,6 +209,23 @@ public virtual long DeleteMany<TDocument, TKey>(IEnumerable<TDocument> documents
             }
         }
 
+        /// <summary>
+        /// Deletes the documents matching the condition of the LINQ expression filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="deleteOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual DeleteResult DeleteMany<TDocument, TKey>(FilterDefinition<TDocument> condition, DeleteOptions deleteOption = null,
+            string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return HandlePartitioned<TDocument, TKey>(partitionKey).DeleteMany(condition, deleteOption);
+        }
+        
         /// <summary>
         /// Deletes the documents matching the condition of the LINQ expression filter.
         /// </summary>
diff --git a/MongoDbGenericRepository/DataAccess/Read/MongoDbReader.Main.cs b/MongoDbGenericRepository/DataAccess/Read/MongoDbReader.Main.cs
index c343668..adde753 100644
--- a/MongoDbGenericRepository/DataAccess/Read/MongoDbReader.Main.cs
+++ b/MongoDbGenericRepository/DataAccess/Read/MongoDbReader.Main.cs
@@ -119,6 +119,22 @@ public virtual TDocument GetOne<TDocument, TKey>(Expression<Func<TDocument, bool
             return HandlePartitioned<TDocument, TKey>(partitionKey).Find(filter).FirstOrDefault();
         }
 
+        /// <summary>
+        /// Returns a collection cursor.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual IFindFluent<TDocument, TDocument> GetCursor<TDocument, TKey>(FilterDefinition<TDocument> condition, FindOptions findOption = null,
+            string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return HandlePartitioned<TDocument, TKey>(partitionKey).Find(condition, findOption);
+        }
+
         /// <summary>
         /// Returns a collection cursor.
         /// </summary>
@@ -327,6 +343,28 @@ public virtual long Count<TDocument, TKey>(Expression<Func<TDocument, bool>> fil
 
         #region Min / Max
 
+        /// <summary>
+        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="maxValueSelector">A property selector to order by descending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        public virtual Task<TDocument> GetByMaxAsync<TDocument, TKey>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, object>> maxValueSelector, FindOptions findOption = null, string partitionKey = null,
+            CancellationToken cancellationToken = default)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return GetCollection<TDocument, TKey>(partitionKey).Find(condition, findOption)
+                .SortByDescending(maxValueSelector)
+                .Limit(1)
+                .FirstOrDefaultAsync(cancellationToken);
+        }
+
         /// <summary>
         /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
         /// </summary>
@@ -345,6 +383,25 @@ public async virtual Task<TDocument> GetByMaxAsync<TDocument, TKey>(Expression<F
                                                                      .Limit(1)
                                                                      .FirstOrDefaultAsync(cancellationToken);
         }
+        
+        /// <summary>
+        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="maxValueSelector">A property selector to order by descending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public virtual TDocument GetByMax<TDocument, TKey>(FilterDefinition<TDocument> condition, Expression<Func<TDocument, object>> maxValueSelector, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return GetCollection<TDocument, TKey>(partitionKey).Find(condition, findOption)
+                .SortByDescending(maxValueSelector)
+                .Limit(1)
+                .FirstOrDefault();
+        }
 
         /// <summary>
         /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
@@ -364,6 +421,28 @@ public virtual TDocument GetByMax<TDocument, TKey>(Expression<Func<TDocument, bo
                                                                .FirstOrDefault();
         }
 
+        /// <summary>
+        /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="minValueSelector">A property selector to order by ascending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        public virtual Task<TDocument> GetByMinAsync<TDocument, TKey>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, object>> minValueSelector, FindOptions findOption = null, string partitionKey = null,
+            CancellationToken cancellationToken = default)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return GetCollection<TDocument, TKey>(partitionKey).Find(condition, findOption)
+                .SortBy(minValueSelector)
+                .Limit(1)
+                .FirstOrDefaultAsync(cancellationToken);
+        }
+        
         /// <summary>
         /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
         /// </summary>
@@ -383,6 +462,26 @@ public async virtual Task<TDocument> GetByMinAsync<TDocument, TKey>(Expression<F
                                                                      .FirstOrDefaultAsync(cancellationToken);
         }
 
+        /// <summary>
+        /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="minValueSelector">A property selector to order by ascending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public virtual TDocument GetByMin<TDocument, TKey>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, object>> minValueSelector, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return GetCollection<TDocument, TKey>(partitionKey).Find(condition, findOption)
+                .SortBy(minValueSelector)
+                .Limit(1)
+                .FirstOrDefault();
+        }
+
         /// <summary>
         /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
         /// </summary>
@@ -401,6 +500,28 @@ public virtual TDocument GetByMin<TDocument, TKey>(Expression<Func<TDocument, bo
                                                                .FirstOrDefault();
         }
 
+        /// <summary>
+        /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <typeparam name="TValue">The type of the field for which you want the maximum value.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="maxValueSelector">A property selector to order by ascending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        public virtual Task<TValue> GetMaxValueAsync<TDocument, TKey, TValue>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TValue>> maxValueSelector, FindOptions findOption = null, string partitionKey = null,
+            CancellationToken cancellationToken = default)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return GetMaxMongoQuery<TDocument, TKey, TValue>(condition, maxValueSelector, findOption, partitionKey)
+                .Project(maxValueSelector)
+                .FirstOrDefaultAsync(cancellationToken);
+        }
+
         /// <summary>
         /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
         /// </summary>
@@ -420,6 +541,25 @@ public async virtual Task<TValue> GetMaxValueAsync<TDocument, TKey, TValue>(Expr
                                 .FirstOrDefaultAsync(cancellationToken);
         }
 
+        /// <summary>
+        /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="maxValueSelector">A property selector to order by ascending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public virtual TValue GetMaxValue<TDocument, TKey, TValue>(FilterDefinition<TDocument> condition, Expression<Func<TDocument, TValue>> maxValueSelector, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return GetMaxMongoQuery<TDocument, TKey, TValue>(condition, maxValueSelector, findOption, partitionKey)
+                .Project(maxValueSelector)
+                .FirstOrDefault();
+        }
+        
         /// <summary>
         /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
         /// </summary>
@@ -438,6 +578,27 @@ public virtual TValue GetMaxValue<TDocument, TKey, TValue>(Expression<Func<TDocu
                       .FirstOrDefault();
         }
 
+        /// <summary>
+        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="minValueSelector">A property selector to order by ascending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        public virtual Task<TValue> GetMinValueAsync<TDocument, TKey, TValue>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TValue>> minValueSelector, FindOptions findOption = null, string partitionKey = null,
+            CancellationToken cancellationToken = default)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return GetMinMongoQuery<TDocument, TKey, TValue>(condition, minValueSelector, findOption, partitionKey)
+                .Project(minValueSelector).FirstOrDefaultAsync(cancellationToken);
+        }
+        
         /// <summary>
         /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
         /// </summary>
@@ -455,6 +616,25 @@ public virtual async Task<TValue> GetMinValueAsync<TDocument, TKey, TValue>(Expr
             return await GetMinMongoQuery<TDocument, TKey, TValue>(filter, minValueSelector, partitionKey).Project(minValueSelector).FirstOrDefaultAsync(cancellationToken);
         }
 
+        /// <summary>
+        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="minValueSelector">A property selector to order by ascending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual TValue GetMinValue<TDocument, TKey, TValue>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TValue>> minValueSelector, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+        {
+            return GetMinMongoQuery<TDocument, TKey, TValue>(condition, minValueSelector, findOption, partitionKey)
+                .Project(minValueSelector).FirstOrDefault();
+        }
+        
         /// <summary>
         /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
         /// </summary>
diff --git a/MongoDbGenericRepository/DataAccess/Read/MongoDbReader.Project.cs b/MongoDbGenericRepository/DataAccess/Read/MongoDbReader.Project.cs
index 378e86e..23c32cf 100644
--- a/MongoDbGenericRepository/DataAccess/Read/MongoDbReader.Project.cs
+++ b/MongoDbGenericRepository/DataAccess/Read/MongoDbReader.Project.cs
@@ -12,6 +12,58 @@ namespace MongoDbGenericRepository.DataAccess.Read
 {
     public partial class MongoDbReader
     {
+        /// <summary>
+        /// Asynchronously returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">A project definition.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        public virtual Task<TProjection> ProjectOneAsync<TDocument, TProjection, TKey>(
+            FilterDefinition<TDocument> condition, 
+            ProjectionDefinition<TDocument, TProjection> projection,
+            FindOptions findOption = null,
+            string partitionKey = null,
+            CancellationToken cancellationToken = default)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+            where TProjection : class
+        {
+            return HandlePartitioned<TDocument, TKey>(partitionKey).Find(condition, findOption)
+                .Project(projection)
+                .FirstOrDefaultAsync(cancellationToken);
+        }
+        
+        /// <summary>
+        /// Asynchronously returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        public virtual Task<TProjection> ProjectOneAsync<TDocument, TProjection, TKey>(
+            FilterDefinition<TDocument> condition, 
+            Expression<Func<TDocument, TProjection>> projection,
+            FindOptions findOption = null,
+            string partitionKey = null,
+            CancellationToken cancellationToken = default)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+            where TProjection : class
+        {
+            return HandlePartitioned<TDocument, TKey>(partitionKey).Find(condition, findOption)
+                .Project(projection)
+                .FirstOrDefaultAsync(cancellationToken);
+        }
+        
         /// <summary>
         /// Asynchronously returns a projected document matching the filter condition.
         /// </summary>
@@ -36,6 +88,48 @@ public virtual async Task<TProjection> ProjectOneAsync<TDocument, TProjection, T
                                                                          .FirstOrDefaultAsync(cancellationToken);
         }
 
+        /// <summary>
+        /// Returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">A project definition.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual TProjection ProjectOne<TDocument, TProjection, TKey>(FilterDefinition<TDocument> condition,
+            ProjectionDefinition<TDocument, TProjection> projection, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+            where TProjection : class
+        {
+            return HandlePartitioned<TDocument, TKey>(partitionKey).Find(condition, findOption)
+                .Project(projection)
+                .FirstOrDefault();
+        }
+        
+        /// <summary>
+        /// Returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual TProjection ProjectOne<TDocument, TProjection, TKey>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TProjection>> projection, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+            where TProjection : class
+        {
+            return HandlePartitioned<TDocument, TKey>(partitionKey).Find(condition, findOption)
+                .Project(projection)
+                .FirstOrDefault();
+        }
+        
         /// <summary>
         /// Returns a projected document matching the filter condition.
         /// </summary>
@@ -55,6 +149,58 @@ public virtual TProjection ProjectOne<TDocument, TProjection, TKey>(Expression<F
                                                                    .FirstOrDefault();
         }
 
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">A project definition.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        public virtual Task<List<TProjection>> ProjectManyAsync<TDocument, TProjection, TKey>(
+            FilterDefinition<TDocument> condition, 
+            ProjectionDefinition<TDocument, TProjection> projection, 
+            FindOptions findOption = null,
+            string partitionKey = null,
+            CancellationToken cancellationToken = default)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+            where TProjection : class
+        {
+            return HandlePartitioned<TDocument, TKey>(partitionKey).Find(condition, findOption)
+                .Project(projection)
+                .ToListAsync(cancellationToken);
+        }
+        
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        public virtual Task<List<TProjection>> ProjectManyAsync<TDocument, TProjection, TKey>(
+            FilterDefinition<TDocument> condition, 
+            Expression<Func<TDocument, TProjection>> projection, 
+            FindOptions findOption = null,
+            string partitionKey = null,
+            CancellationToken cancellationToken = default)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+            where TProjection : class
+        {
+            return HandlePartitioned<TDocument, TKey>(partitionKey).Find(condition, findOption)
+                .Project(projection)
+                .ToListAsync(cancellationToken);
+        }
+        
         /// <summary>
         /// Asynchronously returns a list of projected documents matching the filter condition.
         /// </summary>
@@ -79,6 +225,48 @@ public virtual async Task<List<TProjection>> ProjectManyAsync<TDocument, TProjec
                                                                    .ToListAsync(cancellationToken);
         }
 
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">A project definition.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual List<TProjection> ProjectMany<TDocument, TProjection, TKey>(FilterDefinition<TDocument> condition,
+            ProjectionDefinition<TDocument, TProjection> projection, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+            where TProjection : class
+        {
+            return HandlePartitioned<TDocument, TKey>(partitionKey).Find(condition, findOption)
+                .Project(projection)
+                .ToList();
+        }
+        
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual List<TProjection> ProjectMany<TDocument, TProjection, TKey>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TProjection>> projection, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+            where TKey : IEquatable<TKey>
+            where TProjection : class
+        {
+            return HandlePartitioned<TDocument, TKey>(partitionKey).Find(condition, findOption)
+                .Project(projection)
+                .ToList();
+        }
+        
         /// <summary>
         /// Asynchronously returns a list of projected documents matching the filter condition.
         /// </summary>
diff --git a/MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.Delete.cs b/MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.Delete.cs
index 7324b2e..e71b65d 100644
--- a/MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.Delete.cs
+++ b/MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.Delete.cs
@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Linq.Expressions;
 using System.Threading.Tasks;
+using MongoDB.Driver;
 
 namespace MongoDbGenericRepository
 {
@@ -31,6 +32,17 @@ long DeleteOne<TDocument>(TDocument document)
         Task<long> DeleteOneAsync<TDocument>(TDocument document)
             where TDocument : IDocument<TKey>;
 
+        /// <summary>
+        /// Deletes a document matching the condition of the filter definition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="deleteOption">A mongodb delete option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        long DeleteOne<TDocument>(FilterDefinition<TDocument> condition, DeleteOptions deleteOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>;
+        
         /// <summary>
         /// Deletes a document matching the condition of the LINQ expression filter.
         /// </summary>
@@ -40,6 +52,17 @@ Task<long> DeleteOneAsync<TDocument>(TDocument document)
         /// <returns>The number of documents deleted.</returns>
         long DeleteOne<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
             where TDocument : IDocument<TKey>;
+        
+        /// <summary>
+        /// Asynchronously deletes a document matching the condition of the filter definition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="deleteOption">A mongodb delete option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        Task<long> DeleteOneAsync<TDocument>(FilterDefinition<TDocument> condition, DeleteOptions deleteOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>;
 
         /// <summary>
         /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
@@ -51,6 +74,17 @@ long DeleteOne<TDocument>(Expression<Func<TDocument, bool>> filter, string parti
         Task<long> DeleteOneAsync<TDocument>(Expression<Func<TDocument, bool>> filter, string partitionKey = null)
             where TDocument : IDocument<TKey>;
 
+        /// <summary>
+        /// Asynchronously deletes the documents matching the condition of the filter definition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="deleteOption">A mongodb delete option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        Task<long> DeleteManyAsync<TDocument>(FilterDefinition<TDocument> condition, DeleteOptions deleteOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>;
+
         /// <summary>
         /// Asynchronously deletes the documents matching the condition of the LINQ expression filter.
         /// </summary>
@@ -79,6 +113,18 @@ Task<long> DeleteManyAsync<TDocument>(IEnumerable<TDocument> documents)
         long DeleteMany<TDocument>(IEnumerable<TDocument> documents)
             where TDocument : IDocument<TKey>;
 
+        /// <summary>
+        /// Deletes the documents matching the condition of the filter definition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="deleteOption">A mongodb delete option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        long DeleteMany<TDocument>(FilterDefinition<TDocument> condition, DeleteOptions deleteOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>;
+        
         /// <summary>
         /// Deletes the documents matching the condition of the LINQ expression filter.
         /// </summary>
@@ -140,6 +186,20 @@ public virtual async Task<long> DeleteOneAsync<TDocument>(TDocument document)
             return await MongoDbEraser.DeleteOneAsync<TDocument, TKey>(document);
         }
 
+        /// <summary>
+        /// Deletes a document matching the condition of the filter definition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="deleteOption">A mongodb delete option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual long DeleteOne<TDocument>(FilterDefinition<TDocument> condition, DeleteOptions deleteOption = null,
+            string partitionKey = null) where TDocument : IDocument<TKey>
+        {
+            return MongoDbEraser.DeleteOne<TDocument, TKey>(condition, deleteOption, partitionKey).DeletedCount;
+        }
+
         /// <summary>
         /// Deletes a document matching the condition of the LINQ expression filter.
         /// </summary>
@@ -153,6 +213,20 @@ public virtual long DeleteOne<TDocument>(Expression<Func<TDocument, bool>> filte
             return MongoDbEraser.DeleteOne<TDocument, TKey>(filter, partitionKey);
         }
 
+        /// <summary>
+        /// Deletes a document matching the condition of the filter definition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="deleteOption">A mongodb delete option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual async Task<long> DeleteOneAsync<TDocument>(FilterDefinition<TDocument> condition, DeleteOptions deleteOption = null, string partitionKey = null) where TDocument : IDocument<TKey>
+        {
+            var result = await MongoDbEraser.DeleteOneAsync<TDocument, TKey>(condition, deleteOption, partitionKey);
+            return result.DeletedCount;
+        }
+
         /// <summary>
         /// Asynchronously deletes a document matching the condition of the LINQ expression filter.
         /// </summary>
@@ -166,6 +240,21 @@ public virtual async Task<long> DeleteOneAsync<TDocument>(Expression<Func<TDocum
             return await MongoDbEraser.DeleteOneAsync<TDocument, TKey>(filter, partitionKey);
         }
 
+        /// <summary>
+        /// Asynchronously deletes the documents matching the condition of the filter definition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="deleteOption">A mongodb delete option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public virtual async Task<long> DeleteManyAsync<TDocument>(FilterDefinition<TDocument> condition, DeleteOptions deleteOption = null,
+            string partitionKey = null) where TDocument : IDocument<TKey>
+        {
+            var result = await MongoDbEraser.DeleteManyAsync<TDocument, TKey>(condition, deleteOption, partitionKey);
+            return result.DeletedCount;
+        }
+
         /// <summary>
         /// Asynchronously deletes the documents matching the condition of the LINQ expression filter.
         /// </summary>
@@ -203,6 +292,19 @@ public virtual long DeleteMany<TDocument>(IEnumerable<TDocument> documents)
             return MongoDbEraser.DeleteMany<TDocument, TKey>(documents);
         }
 
+        /// <summary>
+        /// Deletes the documents matching the condition of the filter definition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="deleteOption">A mongodb delete option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <returns>The number of documents deleted.</returns>
+        public long DeleteMany<TDocument>(FilterDefinition<TDocument> condition, DeleteOptions deleteOption = null, string partitionKey = null) where TDocument : IDocument<TKey>
+        {
+            return MongoDbEraser.DeleteMany<TDocument, TKey>(condition, deleteOption, partitionKey).DeletedCount;
+        }
+
         /// <summary>
         /// Deletes the documents matching the condition of the LINQ expression filter.
         /// </summary>
diff --git a/MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.ReadOnly.cs b/MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.ReadOnly.cs
index cdbb862..7f1c865 100644
--- a/MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.ReadOnly.cs
+++ b/MongoDbGenericRepository/KeyTypedRepository/BaseMongoRepository.TKey.ReadOnly.cs
@@ -127,6 +127,18 @@ public TDocument GetOne<TDocument>(Expression<Func<TDocument, bool>> filter, str
             return MongoDbReader.GetOne<TDocument, TKey>(filter, partitionKey);
         }
 
+        /// <summary>
+        /// Returns a collection cursor.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public IFindFluent<TDocument, TDocument> GetCursor<TDocument>(FilterDefinition<TDocument> condition, FindOptions findOption = null, string partitionKey = null) where TDocument : IDocument<TKey>
+        {
+            return MongoDbReader.GetCursor<TDocument, TKey>(condition, findOption, partitionKey);
+        }
+
         /// <summary>
         /// Returns a collection cursor.
         /// </summary>
@@ -204,6 +216,23 @@ public long Count<TDocument>(Expression<Func<TDocument, bool>> filter, string pa
             return MongoDbReader.Count<TDocument, TKey>(filter, partitionKey);
         }
 
+        /// <summary>
+        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="maxValueSelector">A property selector to order by descending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        public virtual Task<TDocument> GetByMaxAsync<TDocument>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, object>> maxValueSelector, FindOptions findOption = null, string partitionKey = null,
+            CancellationToken cancellationToken = default) 
+            where TDocument : IDocument<TKey>
+        {
+            return MongoDbReader.GetByMaxAsync<TDocument, TKey>(condition, maxValueSelector, findOption, partitionKey, cancellationToken);
+        }
+
         /// <summary>
         /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
         /// </summary>
@@ -217,6 +246,21 @@ public async Task<TDocument> GetByMaxAsync<TDocument>(Expression<Func<TDocument,
             return await MongoDbReader.GetByMaxAsync<TDocument, TKey>(filter, maxValueSelector, partitionKey);
         }
 
+        /// <summary>
+        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="maxValueSelector">A property selector to order by descending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public virtual TDocument GetByMax<TDocument>(FilterDefinition<TDocument> condition, Expression<Func<TDocument, object>> maxValueSelector,
+            FindOptions findOption = null, string partitionKey = null) 
+            where TDocument : IDocument<TKey>
+        {
+            return MongoDbReader.GetByMax<TDocument, TKey>(condition, maxValueSelector, findOption, partitionKey);
+        }
+
         /// <summary>
         /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
         /// </summary>
@@ -231,6 +275,23 @@ public TDocument GetByMax<TDocument>(Expression<Func<TDocument, bool>> filter, E
             return MongoDbReader.GetByMax<TDocument, TKey>(filter, maxValueSelector, partitionKey);
         }
 
+        /// <summary>
+        /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="minValueSelector">A property selector to order by ascending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        public virtual Task<TDocument> GetByMinAsync<TDocument>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, object>> minValueSelector, FindOptions findOption = null, string partitionKey = null,
+            CancellationToken cancellationToken = default) 
+            where TDocument : IDocument<TKey>
+        {
+            return MongoDbReader.GetByMinAsync<TDocument, TKey>(condition, minValueSelector, findOption, partitionKey, cancellationToken);
+        }
+
         /// <summary>
         /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
         /// </summary>
@@ -244,6 +305,20 @@ public async Task<TDocument> GetByMinAsync<TDocument>(Expression<Func<TDocument,
             return await MongoDbReader.GetByMinAsync<TDocument, TKey>(filter, minValueSelector, partitionKey);
         }
 
+        /// <summary>
+        /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="minValueSelector">A property selector to order by ascending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public virtual TDocument GetByMin<TDocument>(FilterDefinition<TDocument> condition, Expression<Func<TDocument, object>> minValueSelector,
+            FindOptions findOption = null, string partitionKey = null) where TDocument : IDocument<TKey>
+        {
+            return MongoDbReader.GetByMin<TDocument, TKey>(condition, minValueSelector, findOption, partitionKey);
+        }
+
         /// <summary>
         /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
         /// </summary>
@@ -257,6 +332,24 @@ public TDocument GetByMin<TDocument>(Expression<Func<TDocument, bool>> filter, E
             return MongoDbReader.GetByMin<TDocument, TKey>(filter, minValueSelector, partitionKey);
         }
 
+        /// <summary>
+        /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TValue">The type of the field for which you want the maximum value.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="maxValueSelector">A property selector to order by ascending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        public virtual Task<TValue> GetMaxValueAsync<TDocument, TValue>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TValue>> maxValueSelector, FindOptions findOption = null, string partitionKey = null,
+            CancellationToken cancellationToken = default) 
+            where TDocument : IDocument<TKey>
+        {
+            return MongoDbReader.GetMaxValueAsync<TDocument, TKey, TValue>(condition, maxValueSelector, findOption, partitionKey, cancellationToken);
+        }
+
         /// <summary>
         /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
         /// </summary>
@@ -271,6 +364,22 @@ public async Task<TValue> GetMaxValueAsync<TDocument, TValue>(Expression<Func<TD
             return await MongoDbReader.GetMaxValueAsync<TDocument, TKey, TValue>(filter, maxValueSelector, partitionKey);
         }
 
+        /// <summary>
+        /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="maxValueSelector">A property selector to order by ascending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public virtual TValue GetMaxValue<TDocument, TValue>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TValue>> maxValueSelector, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+        {
+            return MongoDbReader.GetMaxValue<TDocument, TKey, TValue>(condition, maxValueSelector, findOption, partitionKey);
+        }
+
         /// <summary>
         /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
         /// </summary>
@@ -285,6 +394,25 @@ public TValue GetMaxValue<TDocument, TValue>(Expression<Func<TDocument, bool>> f
             return MongoDbReader.GetMaxValue<TDocument, TKey, TValue>(filter, maxValueSelector, partitionKey);
         }
 
+        /// <summary>
+        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="minValueSelector">A property selector to order by ascending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        public virtual Task<TValue> GetMinValueAsync<TDocument, TValue>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TValue>> minValueSelector, FindOptions findOption = null, string partitionKey = null,
+            CancellationToken cancellationToken = default) 
+            where TDocument : IDocument<TKey>
+        {
+            return MongoDbReader.GetMinValueAsync<TDocument, TKey, TValue>(condition, minValueSelector, findOption, partitionKey, cancellationToken);
+        }
+
         /// <summary>
         /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
         /// </summary>
@@ -299,6 +427,22 @@ public virtual async Task<TValue> GetMinValueAsync<TDocument, TValue>(Expression
             return await MongoDbReader.GetMinValueAsync<TDocument, TKey, TValue>(filter, minValueSelector, partitionKey);
         }
 
+        /// <summary>
+        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="minValueSelector">A property selector to order by ascending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual TValue GetMinValue<TDocument, TValue>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TValue>> minValueSelector, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey>
+        {
+            return MongoDbReader.GetMinValue<TDocument, TKey, TValue>(condition, minValueSelector, findOption, partitionKey);
+        }
+
         /// <summary>
         /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
         /// </summary>
@@ -381,6 +525,44 @@ public virtual decimal SumBy<TDocument>(Expression<Func<TDocument, bool>> filter
 
         #region Project
 
+        /// <summary>
+        /// Asynchronously returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">A project definition.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        public virtual Task<TProjection> ProjectOneAsync<TDocument, TProjection>(FilterDefinition<TDocument> condition,
+            ProjectionDefinition<TDocument, TProjection> projection, FindOptions findOption = null, string partitionKey = null,
+            CancellationToken cancellationToken = default) 
+            where TDocument : IDocument<TKey> 
+            where TProjection : class
+        {
+            return MongoDbReader.ProjectOneAsync<TDocument, TProjection, TKey>(condition, projection, findOption, partitionKey, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        public virtual Task<TProjection> ProjectOneAsync<TDocument, TProjection>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TProjection>> projection, FindOptions findOption = null, string partitionKey = null,
+            CancellationToken cancellationToken = default) 
+            where TDocument : IDocument<TKey> 
+            where TProjection : class
+        {
+            return MongoDbReader.ProjectOneAsync<TDocument, TProjection, TKey>(condition, projection, findOption, partitionKey, cancellationToken);
+        }
+
         /// <summary>
         /// Asynchronously returns a projected document matching the filter condition.
         /// </summary>
@@ -397,6 +579,40 @@ public virtual async Task<TProjection> ProjectOneAsync<TDocument, TProjection>(E
             return await MongoDbReader.ProjectOneAsync<TDocument, TProjection, TKey>(filter, projection, partitionKey);
         }
 
+        /// <summary>
+        /// Returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">A project definition.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual TProjection ProjectOne<TDocument, TProjection>(FilterDefinition<TDocument> condition,
+            ProjectionDefinition<TDocument, TProjection> projection, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey> 
+            where TProjection : class
+        {
+            return MongoDbReader.ProjectOne<TDocument, TProjection, TKey>(condition, projection, findOption, partitionKey);
+        }
+
+        /// <summary>
+        /// Returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual TProjection ProjectOne<TDocument, TProjection>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TProjection>> projection, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey> 
+            where TProjection : class
+        {
+            return MongoDbReader.ProjectOne<TDocument, TProjection, TKey>(condition, projection, findOption, partitionKey);
+        }
+
         /// <summary>
         /// Returns a projected document matching the filter condition.
         /// </summary>
@@ -412,6 +628,44 @@ public virtual TProjection ProjectOne<TDocument, TProjection>(Expression<Func<TD
             return MongoDbReader.ProjectOne<TDocument, TProjection, TKey>(filter, projection, partitionKey);
         }
 
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">A project definition.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        public virtual Task<List<TProjection>> ProjectManyAsync<TDocument, TProjection>(FilterDefinition<TDocument> condition,
+            ProjectionDefinition<TDocument, TProjection> projection, FindOptions findOption = null, string partitionKey = null,
+            CancellationToken cancellationToken = default) 
+            where TDocument : IDocument<TKey> 
+            where TProjection : class
+        {
+            return MongoDbReader.ProjectManyAsync<TDocument, TProjection, TKey>(condition, projection, findOption, partitionKey, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        public virtual Task<List<TProjection>> ProjectManyAsync<TDocument, TProjection>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TProjection>> projection, FindOptions findOption = null, string partitionKey = null,
+            CancellationToken cancellationToken = default) 
+            where TDocument : IDocument<TKey> 
+            where TProjection : class
+        {
+            return MongoDbReader.ProjectManyAsync<TDocument, TProjection, TKey>(condition, projection, findOption, partitionKey, cancellationToken);
+        }
+
         /// <summary>
         /// Asynchronously returns a list of projected documents matching the filter condition.
         /// </summary>
@@ -427,6 +681,40 @@ public virtual async Task<List<TProjection>> ProjectManyAsync<TDocument, TProjec
             return await MongoDbReader.ProjectManyAsync<TDocument, TProjection, TKey>(filter, projection, partitionKey);
         }
 
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">A project definition.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public List<TProjection> ProjectMany<TDocument, TProjection>(FilterDefinition<TDocument> condition,
+            ProjectionDefinition<TDocument, TProjection> projection, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey> 
+            where TProjection : class
+        {
+            return MongoDbReader.ProjectMany<TDocument, TProjection, TKey>(condition, projection, findOption, partitionKey);
+        }
+
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public List<TProjection> ProjectMany<TDocument, TProjection>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TProjection>> projection, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey> 
+            where TProjection : class
+        {
+            return MongoDbReader.ProjectMany<TDocument, TProjection, TKey>(condition, projection, findOption, partitionKey);
+        }
+
         /// <summary>
         /// Asynchronously returns a list of projected documents matching the filter condition.
         /// </summary>
diff --git a/MongoDbGenericRepository/ReadOnlyMongoRepository.cs b/MongoDbGenericRepository/ReadOnlyMongoRepository.cs
index 1959003..39dbda4 100644
--- a/MongoDbGenericRepository/ReadOnlyMongoRepository.cs
+++ b/MongoDbGenericRepository/ReadOnlyMongoRepository.cs
@@ -130,6 +130,19 @@ public virtual TDocument GetOne<TDocument, TKey>(Expression<Func<TDocument, bool
             return MongoDbReader.GetOne<TDocument, TKey>(filter, partitionKey);
         }
 
+        /// <summary>
+        /// Returns a collection cursor.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual IFindFluent<TDocument, TDocument> GetCursor<TDocument, TKey>(FilterDefinition<TDocument> condition, FindOptions findOption = null, string partitionKey = null) where TDocument : IDocument<TKey> where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.GetCursor<TDocument, TKey>(condition, findOption, partitionKey);
+        }
+
         /// <summary>
         /// Returns a collection cursor.
         /// </summary>
@@ -317,6 +330,22 @@ public virtual long Count<TDocument, TKey>(Expression<Func<TDocument, bool>> fil
             return MongoDbReader.Count<TDocument, TKey>(filter, partitionKey);
         }
 
+        /// <summary>
+        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="maxValueSelector">A property selector to order by descending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        public virtual Task<TDocument> GetByMaxAsync<TDocument, TKey>(FilterDefinition<TDocument> condition, Expression<Func<TDocument, object>> maxValueSelector, FindOptions findOption = null,
+            string partitionKey = null, CancellationToken cancellationToken = default) where TDocument : IDocument<TKey> where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.GetByMaxAsync<TDocument, TKey>(condition, maxValueSelector, findOption, partitionKey, cancellationToken);
+        }
+
         /// <summary>
         /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
         /// </summary>
@@ -336,6 +365,22 @@ public async virtual Task<TDocument> GetByMaxAsync<TDocument, TKey>(
             return await MongoDbReader.GetByMaxAsync<TDocument, TKey>(filter, maxValueSelector, partitionKey, cancellationToken);
         }
 
+        /// <summary>
+        /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="maxValueSelector">A property selector to order by descending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public virtual TDocument GetByMax<TDocument, TKey>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, object>> maxValueSelector, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey> where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.GetByMax<TDocument, TKey>(condition, maxValueSelector, findOption, partitionKey);
+        }
+
         /// <summary>
         /// Gets the document with the maximum value of a specified property in a MongoDB collections that is satisfying the filter.
         /// </summary>
@@ -351,6 +396,23 @@ public virtual TDocument GetByMax<TDocument, TKey>(Expression<Func<TDocument, bo
             return MongoDbReader.GetByMax<TDocument, TKey>(filter, maxValueSelector, partitionKey);
         }
 
+        /// <summary>
+        /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="minValueSelector">A property selector for the minimum value you are looking for.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        public virtual Task<TDocument> GetByMinAsync<TDocument, TKey>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, object>> minValueSelector, FindOptions findOption = null, string partitionKey = null,
+            CancellationToken cancellationToken = default) where TDocument : IDocument<TKey> where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.GetByMinAsync<TDocument, TKey>(condition, minValueSelector, findOption, partitionKey, cancellationToken);
+        }
+
         /// <summary>
         /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
         /// </summary>
@@ -370,6 +432,22 @@ public async virtual Task<TDocument> GetByMinAsync<TDocument, TKey>(Expression<F
             return await MongoDbReader.GetByMinAsync<TDocument, TKey>(filter, minValueSelector, partitionKey, cancellationToken);
         }
 
+        /// <summary>
+        /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="minValueSelector">A property selector for the minimum value you are looking for.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public virtual TDocument GetByMin<TDocument, TKey>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, object>> minValueSelector, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey> where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.GetByMin<TDocument, TKey>(condition, minValueSelector, findOption, partitionKey);
+        }
+
         /// <summary>
         /// Gets the document with the minimum value of a specified property in a MongoDB collections that is satisfying the filter.
         /// </summary>
@@ -385,6 +463,13 @@ public virtual TDocument GetByMin<TDocument, TKey>(Expression<Func<TDocument, bo
             return MongoDbReader.GetByMin<TDocument, TKey>(filter, minValueSelector, partitionKey);
         }
 
+        public virtual Task<TValue> GetMaxValueAsync<TDocument, TKey, TValue>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TValue>> maxValueSelector, FindOptions findOption = null, string partitionKey = null,
+            CancellationToken cancellationToken = default) where TDocument : IDocument<TKey> where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.GetMaxValueAsync<TDocument, TKey, TValue>(condition, maxValueSelector, findOption, partitionKey, cancellationToken);
+        }
+
         /// <summary>
         /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
         /// </summary>
@@ -406,6 +491,23 @@ public async virtual Task<TValue> GetMaxValueAsync<TDocument, TKey, TValue>(
             return await MongoDbReader.GetMaxValueAsync<TDocument, TKey, TValue>(filter, maxValueSelector, partitionKey, cancellationToken);
         }
 
+        /// <summary>
+        /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="maxValueSelector">A property selector to order by ascending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partitionKey.</param>
+        public virtual TValue GetMaxValue<TDocument, TKey, TValue>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TValue>> maxValueSelector, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey> where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.GetMaxValue<TDocument, TKey, TValue>(condition, maxValueSelector, findOption, partitionKey);
+        }
+
         /// <summary>
         /// Gets the maximum value of a property in a mongodb collections that is satisfying the filter.
         /// </summary>
@@ -422,6 +524,24 @@ public virtual TValue GetMaxValue<TDocument, TKey, TValue>(Expression<Func<TDocu
             return MongoDbReader.GetMaxValue<TDocument, TKey, TValue>(filter, maxValueSelector, partitionKey);
         }
 
+        /// <summary>
+        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="minValueSelector">A property selector to order by ascending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        public virtual Task<TValue> GetMinValueAsync<TDocument, TKey, TValue>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TValue>> minValueSelector, FindOptions findOption = null, string partitionKey = null,
+            CancellationToken cancellationToken = default) where TDocument : IDocument<TKey> where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.GetMinValueAsync<TDocument, TKey, TValue>(condition, minValueSelector, findOption, partitionKey, cancellationToken);
+        }
+
         /// <summary>
         /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
         /// </summary>
@@ -443,6 +563,23 @@ public virtual async Task<TValue> GetMinValueAsync<TDocument, TKey, TValue>(
             return await MongoDbReader.GetMinValueAsync<TDocument, TKey, TValue>(filter, minValueSelector, partitionKey, cancellationToken);
         }
 
+        /// <summary>
+        /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
+        /// </summary>
+        /// <typeparam name="TDocument">The document type.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key.</typeparam>
+        /// <typeparam name="TValue">The type of the value used to order the query.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="minValueSelector">A property selector to order by ascending.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public TValue GetMinValue<TDocument, TKey, TValue>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TValue>> minValueSelector, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey> where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.GetMinValue<TDocument, TKey, TValue>(condition, minValueSelector, findOption, partitionKey);
+        }
+
         /// <summary>
         /// Gets the minimum value of a property in a mongodb collections that is satisfying the filter.
         /// </summary>
@@ -537,6 +674,48 @@ public virtual decimal SumBy<TDocument, TKey>(Expression<Func<TDocument, bool>>
 
         #region Project TKey
 
+        /// <summary>
+        /// Asynchronously returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">A projection definition.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        public virtual Task<TProjection> ProjectOneAsync<TDocument, TProjection, TKey>(FilterDefinition<TDocument> condition,
+            ProjectionDefinition<TDocument, TProjection> projection, FindOptions findOption = null, string partitionKey = null,
+            CancellationToken cancellationToken = default) 
+            where TDocument : IDocument<TKey>
+            where TProjection : class
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.ProjectOneAsync<TDocument, TProjection, TKey>(condition, projection, findOption, partitionKey, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        public virtual Task<TProjection> ProjectOneAsync<TDocument, TProjection, TKey>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TProjection>> projection, FindOptions findOption = null, string partitionKey = null,
+            CancellationToken cancellationToken = default) 
+            where TDocument : IDocument<TKey>
+            where TProjection : class
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.ProjectOneAsync<TDocument, TProjection, TKey>(condition, projection, findOption, partitionKey, cancellationToken);
+        }
+
         /// <summary>
         /// Asynchronously returns a projected document matching the filter condition.
         /// </summary>
@@ -559,6 +738,44 @@ public virtual async Task<TProjection> ProjectOneAsync<TDocument, TProjection, T
             return await MongoDbReader.ProjectOneAsync<TDocument, TProjection, TKey>(filter, projection, partitionKey, cancellationToken);
         }
 
+        /// <summary>
+        /// Returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">A projection definition.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual TProjection ProjectOne<TDocument, TProjection, TKey>(FilterDefinition<TDocument> condition,
+            ProjectionDefinition<TDocument, TProjection> projection, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey> 
+            where TProjection : class 
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.ProjectOne<TDocument, TProjection, TKey>(condition, projection, findOption, partitionKey);
+        }
+
+        /// <summary>
+        /// Returns a projected document matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual TProjection ProjectOne<TDocument, TProjection, TKey>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TProjection>> projection, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey> 
+            where TProjection : class 
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.ProjectOne<TDocument, TProjection, TKey>(condition, projection, findOption, partitionKey);
+        }
+
         /// <summary>
         /// Returns a projected document matching the filter condition.
         /// </summary>
@@ -576,6 +793,48 @@ public virtual TProjection ProjectOne<TDocument, TProjection, TKey>(Expression<F
             return MongoDbReader.ProjectOne<TDocument, TProjection, TKey>(filter, projection, partitionKey);
         }
 
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">A projection definition.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        public virtual Task<List<TProjection>> ProjectManyAsync<TDocument, TProjection, TKey>(FilterDefinition<TDocument> condition,
+            ProjectionDefinition<TDocument, TProjection> projection, FindOptions findOption = null, string partitionKey = null,
+            CancellationToken cancellationToken = default) 
+            where TDocument : IDocument<TKey>
+            where TProjection : class
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.ProjectManyAsync<TDocument, TProjection, TKey>(condition, projection, findOption, partitionKey, cancellationToken);
+        }
+
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        public virtual Task<List<TProjection>> ProjectManyAsync<TDocument, TProjection, TKey>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, TProjection>> projection, FindOptions findOption = null, string partitionKey = null,
+            CancellationToken cancellationToken = default) 
+            where TDocument : IDocument<TKey>
+            where TProjection : class
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.ProjectManyAsync<TDocument, TProjection, TKey>(condition, projection, findOption, partitionKey, cancellationToken);
+        }
+
         /// <summary>
         /// Asynchronously returns a list of projected documents matching the filter condition.
         /// </summary>
@@ -597,6 +856,41 @@ public virtual async Task<List<TProjection>> ProjectManyAsync<TDocument, TProjec
             return await MongoDbReader.ProjectManyAsync<TDocument, TProjection, TKey>(filter, projection, partitionKey, cancellationToken);
         }
 
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">A projection definition.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual List<TProjection> ProjectMany<TDocument, TProjection, TKey>(FilterDefinition<TDocument> condition,
+            ProjectionDefinition<TDocument, TProjection> projection, FindOptions findOption = null, string partitionKey = null)
+            where TDocument : IDocument<TKey> 
+            where TProjection : class 
+            where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.ProjectMany<TDocument, TProjection, TKey>(condition, projection, findOption, partitionKey);
+        }
+
+        /// <summary>
+        /// Asynchronously returns a list of projected documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <typeparam name="TProjection">The type representing the model you want to project to.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="projection">The projection expression.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual List<TProjection> ProjectMany<TDocument, TProjection, TKey>(FilterDefinition<TDocument> condition, Expression<Func<TDocument, TProjection>> projection, FindOptions findOption = null,
+            string partitionKey = null) where TDocument : IDocument<TKey> where TProjection : class where TKey : IEquatable<TKey>
+        {
+            return MongoDbReader.ProjectMany<TDocument, TProjection, TKey>(condition, projection, findOption, partitionKey);
+        }
+
         /// <summary>
         /// Asynchronously returns a list of projected documents matching the filter condition.
         /// </summary>
@@ -666,9 +960,36 @@ public virtual List<TProjection> GroupBy<TDocument, TGroupKey, TProjection, TKey
 
         #endregion Group By TKey
 
-
         #region Pagination
 
+        /// <summary>
+        /// Asynchronously returns a paginated list of the documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="sortSelector">The property selector.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="ascending">Order of the sorting.</param>
+        /// <param name="skipNumber">The number of documents you want to skip. Default value is 0.</param>
+        /// <param name="takeNumber">The number of documents you want to take. Default value is 50.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        public virtual Task<List<TDocument>> GetSortedPaginatedAsync<TDocument, TKey>(FilterDefinition<TDocument> condition,
+            Expression<Func<TDocument, object>> sortSelector, FindOptions findOption = null, bool ascending = true, int skipNumber = 0,
+            int takeNumber = 50, string partitionKey = null) where TDocument : IDocument<TKey> where TKey : IEquatable<TKey>
+        {
+            var sorting = ascending
+                ? Builders<TDocument>.Sort.Ascending(sortSelector)
+                : Builders<TDocument>.Sort.Descending(sortSelector);
+
+            return HandlePartitioned<TDocument, TKey>(partitionKey)
+                .Find(condition, findOption)
+                .Sort(sorting)
+                .Skip(skipNumber)
+                .Limit(takeNumber)
+                .ToListAsync();
+        }
+
         /// <summary>
         /// Asynchronously returns a paginated list of the documents matching the filter condition.
         /// </summary>
@@ -702,6 +1023,29 @@ public virtual async Task<List<TDocument>> GetSortedPaginatedAsync<TDocument, TK
                                     .ToListAsync();
         }
 
+        /// <summary>
+        /// Asynchronously returns a paginated list of the documents matching the filter condition.
+        /// </summary>
+        /// <typeparam name="TDocument">The type representing a Document.</typeparam>
+        /// <typeparam name="TKey">The type of the primary key for a Document.</typeparam>
+        /// <param name="condition">A mongodb filter definition.</param>
+        /// <param name="sortDefinition">The sort definition.</param>
+        /// <param name="findOption">A mongodb filter option.</param>
+        /// <param name="skipNumber">The number of documents you want to skip. Default value is 0.</param>
+        /// <param name="takeNumber">The number of documents you want to take. Default value is 50.</param>
+        /// <param name="partitionKey">An optional partition key.</param>
+        /// <param name="cancellationToken">An optional cancellation Token.</param>
+        public virtual Task<List<TDocument>> GetSortedPaginatedAsync<TDocument, TKey>(FilterDefinition<TDocument> condition, SortDefinition<TDocument> sortDefinition, FindOptions findOption = null,
+            int skipNumber = 0, int takeNumber = 50, string partitionKey = null, CancellationToken cancellationToken = default) where TDocument : IDocument<TKey> where TKey : IEquatable<TKey>
+        {
+            return HandlePartitioned<TDocument, TKey>(partitionKey)
+                .Find(condition, findOption)
+                .Sort(sortDefinition)
+                .Skip(skipNumber)
+                .Limit(takeNumber)
+                .ToListAsync(cancellationToken);
+        }
+
         /// <summary>
         /// Asynchronously returns a paginated list of the documents matching the filter condition.
         /// </summary>
@@ -733,8 +1077,6 @@ public virtual async Task<List<TDocument>> GetSortedPaginatedAsync<TDocument, TK
 
         #endregion Pagination
 
-
-
         /// <summary>
         /// Gets a collections for a potentially partitioned document type.
         /// </summary>