diff --git a/Benchmark/Benchmark.csproj b/Benchmark/Benchmark.csproj
index 40cbcf133..0917af5cb 100644
--- a/Benchmark/Benchmark.csproj
+++ b/Benchmark/Benchmark.csproj
@@ -14,7 +14,7 @@
 
     <ItemGroup>
         <PackageReference Include="BenchmarkDotNet" Version="0.14.0"/>
-        <PackageReference Include="MongoDB.Driver.GridFS" Version="2.28.0"/>
+        <PackageReference Include="MongoDB.Driver.GridFS" Version="2.30.0"/>
     </ItemGroup>
 
     <ItemGroup>
diff --git a/MongoDB.Entities/Builders/Find.cs b/MongoDB.Entities/Builders/Find.cs
index d295a8489..3959fe3f0 100644
--- a/MongoDB.Entities/Builders/Find.cs
+++ b/MongoDB.Entities/Builders/Find.cs
@@ -151,7 +151,11 @@ public Find<T, TProjection> Match(Template template)
     /// <param name="caseSensitive">Case sensitivity of the search (optional)</param>
     /// <param name="diacriticSensitive">Diacritic sensitivity of the search (optional)</param>
     /// <param name="language">The language for the search (optional)</param>
-    public Find<T, TProjection> Match(Search searchType, string searchTerm, bool caseSensitive = false, bool diacriticSensitive = false, string? language = null)
+    public Find<T, TProjection> Match(Search searchType,
+                                      string searchTerm,
+                                      bool caseSensitive = false,
+                                      bool diacriticSensitive = false,
+                                      string? language = null)
     {
         if (searchType != Search.Fuzzy)
         {
@@ -461,7 +465,7 @@ void AddTxtScoreToProjection(string propName)
 
         options.Projection =
             options.Projection
-                   .Render(BsonSerializer.SerializerRegistry.GetSerializer<T>(), BsonSerializer.SerializerRegistry, Driver.Linq.LinqProvider.V3)
+                   .Render(new(BsonSerializer.SerializerRegistry.GetSerializer<T>(), BsonSerializer.SerializerRegistry))
                    .Document.Add(propName, new BsonDocument { { "$meta", "textScore" } });
     }
 }
diff --git a/MongoDB.Entities/Builders/Update.cs b/MongoDB.Entities/Builders/Update.cs
index d483a8b2a..dc43fff98 100644
--- a/MongoDB.Entities/Builders/Update.cs
+++ b/MongoDB.Entities/Builders/Update.cs
@@ -179,7 +179,10 @@ public Update<T> Match(Search searchType, string searchTerm, bool caseSensitive
     /// <param name="nearCoordinates">The search point</param>
     /// <param name="maxDistance">Maximum distance in meters from the search point</param>
     /// <param name="minDistance">Minimum distance in meters from the search point</param>
-    public Update<T> Match(Expression<Func<T, object?>> coordinatesProperty, Coordinates2D nearCoordinates, double? maxDistance = null, double? minDistance = null)
+    public Update<T> Match(Expression<Func<T, object?>> coordinatesProperty,
+                           Coordinates2D nearCoordinates,
+                           double? maxDistance = null,
+                           double? minDistance = null)
     {
         return Match(f => f.Near(coordinatesProperty, nearCoordinates.ToGeoJsonPoint(), maxDistance, minDistance));
     }
@@ -503,7 +506,7 @@ bool ShouldSetModDate()
             Cache<T>.HasModifiedOn &&
             !Defs.Any(
                 d => d
-                     .Render(BsonSerializer.SerializerRegistry.GetSerializer<T>(), BsonSerializer.SerializerRegistry, Driver.Linq.LinqProvider.V3)
+                     .Render(new(BsonSerializer.SerializerRegistry.GetSerializer<T>(), BsonSerializer.SerializerRegistry))
                      .ToString()
                      .Contains($"\"{Cache<T>.ModifiedOnPropName}\""));
     }
diff --git a/MongoDB.Entities/Builders/UpdateAndGet.cs b/MongoDB.Entities/Builders/UpdateAndGet.cs
index 55f195a3e..4dc435219 100644
--- a/MongoDB.Entities/Builders/UpdateAndGet.cs
+++ b/MongoDB.Entities/Builders/UpdateAndGet.cs
@@ -32,7 +32,7 @@ public class UpdateAndGet<T, TProjection> : UpdateBase<T> where T : IEntity
 {
     readonly List<PipelineStageDefinition<T, TProjection>> _stages = new();
     FilterDefinition<T> _filter = Builders<T>.Filter.Empty;
-    protected private readonly FindOneAndUpdateOptions<T, TProjection> options = new() { ReturnDocument = ReturnDocument.After };
+    private protected readonly FindOneAndUpdateOptions<T, TProjection> options = new() { ReturnDocument = ReturnDocument.After };
     readonly IClientSessionHandle? _session;
     readonly Dictionary<Type, (object filterDef, bool prepend)>? _globalFilters;
     readonly Action<UpdateBase<T>>? _onUpdateAction;
@@ -107,7 +107,11 @@ public UpdateAndGet<T, TProjection> Match(Template template)
     /// <param name="caseSensitive">Case sensitivity of the search (optional)</param>
     /// <param name="diacriticSensitive">Diacritic sensitivity of the search (optional)</param>
     /// <param name="language">The language for the search (optional)</param>
-    public UpdateAndGet<T, TProjection> Match(Search searchType, string searchTerm, bool caseSensitive = false, bool diacriticSensitive = false, string? language = null)
+    public UpdateAndGet<T, TProjection> Match(Search searchType,
+                                              string searchTerm,
+                                              bool caseSensitive = false,
+                                              bool diacriticSensitive = false,
+                                              string? language = null)
     {
         if (searchType != Search.Fuzzy)
         {
@@ -457,7 +461,7 @@ bool ShouldSetModDate()
             Cache<T>.HasModifiedOn &&
             !Defs.Any(
                 d => d
-                     .Render(BsonSerializer.SerializerRegistry.GetSerializer<T>(), BsonSerializer.SerializerRegistry, Driver.Linq.LinqProvider.V3)
+                     .Render(new(BsonSerializer.SerializerRegistry.GetSerializer<T>(), BsonSerializer.SerializerRegistry))
                      .ToString()
                      .Contains($"\"{Cache<T>.ModifiedOnPropName}\""));
     }
diff --git a/MongoDB.Entities/Core/Cache.cs b/MongoDB.Entities/Core/Cache.cs
index 2fc3ad5a1..693fc2977 100644
--- a/MongoDB.Entities/Core/Cache.cs
+++ b/MongoDB.Entities/Core/Cache.cs
@@ -53,7 +53,10 @@ static void Initialize()
             IdSetter = type.SetterForProp(IdPropName);
         }
         else
-            throw new InvalidOperationException($"Type {type.FullName} must specify an Identity property. '_id', 'Id', 'ID', or [BsonId] annotation expected!");
+        {
+            throw new InvalidOperationException(
+                $"Type {type.FullName} must specify an Identity property. '_id', 'Id', 'ID', or [BsonId] annotation expected!");
+        }
 
         Database = TypeMap.GetDatabase(type);
         DbName = Database.DatabaseNamespace.DatabaseName;
@@ -135,9 +138,7 @@ internal static ProjectionDefinition<T, TProjection> CombineWithRequiredProps<TP
         }
 
         ProjectionDefinition<T> userProj = userProjection.Render(
-            BsonSerializer.LookupSerializer<T>(),
-            BsonSerializer.SerializerRegistry,
-            LinqProvider.V3).Document;
+            new(BsonSerializer.SerializerRegistry.GetSerializer<T>(), BsonSerializer.SerializerRegistry)).Document;
 
         return Builders<T>.Projection.Combine(_requiredPropsProjection, userProj);
     }
diff --git a/MongoDB.Entities/Core/Watcher.cs b/MongoDB.Entities/Core/Watcher.cs
index b5c8d6484..ef6f701ca 100644
--- a/MongoDB.Entities/Core/Watcher.cs
+++ b/MongoDB.Entities/Core/Watcher.cs
@@ -95,16 +95,18 @@ internal Watcher(string name)
     /// <param name="filter">x => x.FullDocument.Prop1 == "SomeValue"</param>
     /// <param name="batchSize">The max number of entities to receive for a single event occurence</param>
     /// <param name="onlyGetIDs">Set to true if you don't want the complete entity details. All properties except the ID will then be null.</param>
-    /// <param name="autoResume">Set to false if you'd like to skip the changes that happened while the watching was stopped. This will also make you unable to retrieve a ResumeToken.</param>
+    /// <param name="autoResume">
+    /// Set to false if you'd like to skip the changes that happened while the watching was stopped. This will also make you unable to
+    /// retrieve a ResumeToken.
+    /// </param>
     /// <param name="cancellation">A cancellation token for ending the watching/change stream</param>
-    public void Start(
-        EventType eventTypes,
-        Expression<Func<ChangeStreamDocument<T>, bool>>? filter = null,
-        int batchSize = 25,
-        bool onlyGetIDs = false,
-        bool autoResume = true,
-        CancellationToken cancellation = default)
-    => Init(null, eventTypes, filter, null, batchSize, onlyGetIDs, autoResume, cancellation);
+    public void Start(EventType eventTypes,
+                      Expression<Func<ChangeStreamDocument<T>, bool>>? filter = null,
+                      int batchSize = 25,
+                      bool onlyGetIDs = false,
+                      bool autoResume = true,
+                      CancellationToken cancellation = default)
+        => Init(null, eventTypes, filter, null, batchSize, onlyGetIDs, autoResume, cancellation);
 
     /// <summary>
     /// Starts the watcher instance with the supplied parameters. Supports projection.
@@ -113,16 +115,18 @@ public void Start(
     /// <param name="projection">A projection expression for the entity</param>
     /// <param name="filter">x => x.FullDocument.Prop1 == "SomeValue"</param>
     /// <param name="batchSize">The max number of entities to receive for a single event occurence</param>
-    /// <param name="autoResume">Set to false if you'd like to skip the changes that happened while the watching was stopped. This will also make you unable to retrieve a ResumeToken.</param>
+    /// <param name="autoResume">
+    /// Set to false if you'd like to skip the changes that happened while the watching was stopped. This will also make you unable to
+    /// retrieve a ResumeToken.
+    /// </param>
     /// <param name="cancellation">A cancellation token for ending the watching/change stream</param>
-    public void Start(
-        EventType eventTypes,
-        Expression<Func<T, T>> projection,
-        Expression<Func<ChangeStreamDocument<T>, bool>>? filter = null,
-        int batchSize = 25,
-        bool autoResume = true,
-        CancellationToken cancellation = default)
-    => Init(null, eventTypes, filter, projection, batchSize, false, autoResume, cancellation);
+    public void Start(EventType eventTypes,
+                      Expression<Func<T, T>> projection,
+                      Expression<Func<ChangeStreamDocument<T>, bool>>? filter = null,
+                      int batchSize = 25,
+                      bool autoResume = true,
+                      CancellationToken cancellation = default)
+        => Init(null, eventTypes, filter, projection, batchSize, false, autoResume, cancellation);
 
     /// <summary>
     /// Starts the watcher instance with the supplied parameters
@@ -131,16 +135,18 @@ public void Start(
     /// <param name="filter">b => b.Eq(d => d.FullDocument.Prop1, "value")</param>
     /// <param name="batchSize">The max number of entities to receive for a single event occurence</param>
     /// <param name="onlyGetIDs">Set to true if you don't want the complete entity details. All properties except the ID will then be null.</param>
-    /// <param name="autoResume">Set to false if you'd like to skip the changes that happened while the watching was stopped. This will also make you unable to retrieve a ResumeToken.</param>
+    /// <param name="autoResume">
+    /// Set to false if you'd like to skip the changes that happened while the watching was stopped. This will also make you unable to
+    /// retrieve a ResumeToken.
+    /// </param>
     /// <param name="cancellation">A cancellation token for ending the watching/change stream</param>
-    public void Start(
-        EventType eventTypes,
-        Func<FilterDefinitionBuilder<ChangeStreamDocument<T>>, FilterDefinition<ChangeStreamDocument<T>>> filter,
-        int batchSize = 25,
-        bool onlyGetIDs = false,
-        bool autoResume = true,
-        CancellationToken cancellation = default)
-    => Init(null, eventTypes, filter(Builders<ChangeStreamDocument<T>>.Filter), null, batchSize, onlyGetIDs, autoResume, cancellation);
+    public void Start(EventType eventTypes,
+                      Func<FilterDefinitionBuilder<ChangeStreamDocument<T>>, FilterDefinition<ChangeStreamDocument<T>>> filter,
+                      int batchSize = 25,
+                      bool onlyGetIDs = false,
+                      bool autoResume = true,
+                      CancellationToken cancellation = default)
+        => Init(null, eventTypes, filter(Builders<ChangeStreamDocument<T>>.Filter), null, batchSize, onlyGetIDs, autoResume, cancellation);
 
     /// <summary>
     /// Starts the watcher instance with the supplied parameters. Supports projection.
@@ -149,16 +155,18 @@ public void Start(
     /// <param name="projection">A projection expression for the entity</param>
     /// <param name="filter">b => b.Eq(d => d.FullDocument.Prop1, "value")</param>
     /// <param name="batchSize">The max number of entities to receive for a single event occurence</param>
-    /// <param name="autoResume">Set to false if you'd like to skip the changes that happened while the watching was stopped. This will also make you unable to retrieve a ResumeToken.</param>
+    /// <param name="autoResume">
+    /// Set to false if you'd like to skip the changes that happened while the watching was stopped. This will also make you unable to
+    /// retrieve a ResumeToken.
+    /// </param>
     /// <param name="cancellation">A cancellation token for ending the watching/change stream</param>
-    public void Start(
-        EventType eventTypes,
-        Expression<Func<T, T>> projection,
-        Func<FilterDefinitionBuilder<ChangeStreamDocument<T>>, FilterDefinition<ChangeStreamDocument<T>>> filter,
-        int batchSize = 25,
-        bool autoResume = true,
-        CancellationToken cancellation = default)
-    => Init(null, eventTypes, filter(Builders<ChangeStreamDocument<T>>.Filter), projection, batchSize, false, autoResume, cancellation);
+    public void Start(EventType eventTypes,
+                      Expression<Func<T, T>> projection,
+                      Func<FilterDefinitionBuilder<ChangeStreamDocument<T>>, FilterDefinition<ChangeStreamDocument<T>>> filter,
+                      int batchSize = 25,
+                      bool autoResume = true,
+                      CancellationToken cancellation = default)
+        => Init(null, eventTypes, filter(Builders<ChangeStreamDocument<T>>.Filter), projection, batchSize, false, autoResume, cancellation);
 
     /// <summary>
     /// Starts the watcher instance with the supplied configuration
@@ -169,14 +177,13 @@ public void Start(
     /// <param name="batchSize">The max number of entities to receive for a single event occurence</param>
     /// <param name="onlyGetIDs">Set to true if you don't want the complete entity details. All properties except the ID will then be null.</param>
     /// <param name="cancellation">A cancellation token for ending the watching/change stream</param>
-    public void StartWithToken(
-        BsonDocument resumeToken,
-        EventType eventTypes,
-        Expression<Func<ChangeStreamDocument<T>, bool>>? filter = null,
-        int batchSize = 25,
-        bool onlyGetIDs = false,
-        CancellationToken cancellation = default)
-    => Init(resumeToken, eventTypes, filter, null, batchSize, onlyGetIDs, true, cancellation);
+    public void StartWithToken(BsonDocument resumeToken,
+                               EventType eventTypes,
+                               Expression<Func<ChangeStreamDocument<T>, bool>>? filter = null,
+                               int batchSize = 25,
+                               bool onlyGetIDs = false,
+                               CancellationToken cancellation = default)
+        => Init(resumeToken, eventTypes, filter, null, batchSize, onlyGetIDs, true, cancellation);
 
     /// <summary>
     /// Starts the watcher instance with the supplied configuration. Supports projection.
@@ -187,14 +194,13 @@ public void StartWithToken(
     /// <param name="filter">x => x.FullDocument.Prop1 == "SomeValue"</param>
     /// <param name="batchSize">The max number of entities to receive for a single event occurence</param>
     /// <param name="cancellation">A cancellation token for ending the watching/change stream</param>
-    public void StartWithToken(
-        BsonDocument resumeToken,
-        EventType eventTypes,
-        Expression<Func<T, T>> projection,
-        Expression<Func<ChangeStreamDocument<T>, bool>>? filter = null,
-        int batchSize = 25,
-        CancellationToken cancellation = default)
-    => Init(resumeToken, eventTypes, filter, projection, batchSize, false, true, cancellation);
+    public void StartWithToken(BsonDocument resumeToken,
+                               EventType eventTypes,
+                               Expression<Func<T, T>> projection,
+                               Expression<Func<ChangeStreamDocument<T>, bool>>? filter = null,
+                               int batchSize = 25,
+                               CancellationToken cancellation = default)
+        => Init(resumeToken, eventTypes, filter, projection, batchSize, false, true, cancellation);
 
     /// <summary>
     /// Starts the watcher instance with the supplied configuration
@@ -205,14 +211,13 @@ public void StartWithToken(
     /// <param name="batchSize">The max number of entities to receive for a single event occurence</param>
     /// <param name="onlyGetIDs">Set to true if you don't want the complete entity details. All properties except the ID will then be null.</param>
     /// <param name="cancellation">A cancellation token for ending the watching/change stream</param>
-    public void StartWithToken(
-        BsonDocument resumeToken,
-        EventType eventTypes,
-        Func<FilterDefinitionBuilder<ChangeStreamDocument<T>>, FilterDefinition<ChangeStreamDocument<T>>> filter,
-        int batchSize = 25,
-        bool onlyGetIDs = false,
-        CancellationToken cancellation = default)
-    => Init(resumeToken, eventTypes, filter(Builders<ChangeStreamDocument<T>>.Filter), null, batchSize, onlyGetIDs, true, cancellation);
+    public void StartWithToken(BsonDocument resumeToken,
+                               EventType eventTypes,
+                               Func<FilterDefinitionBuilder<ChangeStreamDocument<T>>, FilterDefinition<ChangeStreamDocument<T>>> filter,
+                               int batchSize = 25,
+                               bool onlyGetIDs = false,
+                               CancellationToken cancellation = default)
+        => Init(resumeToken, eventTypes, filter(Builders<ChangeStreamDocument<T>>.Filter), null, batchSize, onlyGetIDs, true, cancellation);
 
     /// <summary>
     /// Starts the watcher instance with the supplied configuration. Supports projection.
@@ -223,24 +228,22 @@ public void StartWithToken(
     /// <param name="filter">b => b.Eq(d => d.FullDocument.Prop1, "value")</param>
     /// <param name="batchSize">The max number of entities to receive for a single event occurence</param>
     /// <param name="cancellation">A cancellation token for ending the watching/change stream</param>
-    public void StartWithToken(
-        BsonDocument resumeToken,
-        EventType eventTypes,
-        Expression<Func<T, T>> projection,
-        Func<FilterDefinitionBuilder<ChangeStreamDocument<T>>, FilterDefinition<ChangeStreamDocument<T>>> filter,
-        int batchSize = 25,
-        CancellationToken cancellation = default)
-    => Init(resumeToken, eventTypes, filter(Builders<ChangeStreamDocument<T>>.Filter), projection, batchSize, false, true, cancellation);
-
-    void Init(
-        BsonDocument? resumeToken,
-        EventType eventTypes,
-        FilterDefinition<ChangeStreamDocument<T>> filter,
-        Expression<Func<T, T>>? projection,
-        int batchSize,
-        bool onlyGetIDs,
-        bool autoResume,
-        CancellationToken cancellation)
+    public void StartWithToken(BsonDocument resumeToken,
+                               EventType eventTypes,
+                               Expression<Func<T, T>> projection,
+                               Func<FilterDefinitionBuilder<ChangeStreamDocument<T>>, FilterDefinition<ChangeStreamDocument<T>>> filter,
+                               int batchSize = 25,
+                               CancellationToken cancellation = default)
+        => Init(resumeToken, eventTypes, filter(Builders<ChangeStreamDocument<T>>.Filter), projection, batchSize, false, true, cancellation);
+
+    void Init(BsonDocument? resumeToken,
+              EventType eventTypes,
+              FilterDefinition<ChangeStreamDocument<T>> filter,
+              Expression<Func<T, T>>? projection,
+              int batchSize,
+              bool onlyGetIDs,
+              bool autoResume,
+              CancellationToken cancellation)
     {
         if (IsInitialized)
             throw new InvalidOperationException("This watcher has already been initialized!");
@@ -267,17 +270,17 @@ void Init(
             if (filter != null)
             {
                 throw new ArgumentException(
-                "Filtering is not supported when watching for deletions " +
-                "as the entity data no longer exists in the db " +
-                "at the time of receiving the event.");
+                    "Filtering is not supported when watching for deletions " +
+                    "as the entity data no longer exists in the db " +
+                    "at the time of receiving the event.");
             }
 
             if (projection != null)
             {
                 throw new ArgumentException(
-                "Projecting is not supported when watching for deletions " +
-                "as the entity data no longer exists in the db " +
-                "at the time of receiving the event.");
+                    "Projecting is not supported when watching for deletions " +
+                    "as the entity data no longer exists in the db " +
+                    "at the time of receiving the event.");
             }
         }
 
@@ -286,9 +289,10 @@ void Init(
         if (filter != null)
             filters &= filter;
 
-        var stages = new List<IPipelineStageDefinition>(3) {
+        var stages = new List<IPipelineStageDefinition>(3)
+        {
             PipelineStageDefinitionBuilder.Match(filters),
-            PipelineStageDefinitionBuilder.Project<ChangeStreamDocument<T>,ChangeStreamDocument<T>>(
+            PipelineStageDefinitionBuilder.Project<ChangeStreamDocument<T>, ChangeStreamDocument<T>>(
                 """
                 {
                     _id: 1,
@@ -305,7 +309,8 @@ void Init(
 
         pipeline = stages;
 
-        options = new() {
+        options = new()
+        {
             StartAfter = resumeToken,
             BatchSize = batchSize,
             FullDocument = onlyGetIDs ? ChangeStreamFullDocumentOption.Default : ChangeStreamFullDocumentOption.UpdateLookup,
@@ -320,10 +325,8 @@ void Init(
     static ProjectionDefinition<ChangeStreamDocument<T>, ChangeStreamDocument<T>> BuildProjection(Expression<Func<T, T>> projection)
     {
         var rendered = Builders<T>.Projection
-            .Expression(projection)
-            .Render(BsonSerializer.SerializerRegistry.GetSerializer<T>(),
-                    BsonSerializer.SerializerRegistry,
-                    Driver.Linq.LinqProvider.V3);
+                                  .Expression(projection)
+                                  .Render(new(BsonSerializer.SerializerRegistry.GetSerializer<T>(), BsonSerializer.SerializerRegistry));
 
         BsonDocument doc = new()
         {
@@ -355,9 +358,9 @@ public void ReStart(BsonDocument? resumeToken = null)
         if (!CanRestart)
         {
             throw new InvalidOperationException(
-                                "This watcher has been aborted/cancelled. " +
-                                "The subscribers have already been purged. " +
-                                "Please instantiate a new watcher and subscribe to the events again.");
+                "This watcher has been aborted/cancelled. " +
+                "The subscribers have already been purged. " +
+                "Please instantiate a new watcher and subscribe to the events again.");
         }
 
         if (!IsInitialized)
@@ -387,6 +390,7 @@ async Task IterateCursorAsync()
             try
             {
                 using var cursor = await DB.Collection<T>().WatchAsync(pipeline, options, cancelToken).ConfigureAwait(false);
+
                 while (!cancelToken.IsCancellationRequested && await cursor.MoveNextAsync(cancelToken).ConfigureAwait(false))
                 {
                     if (!cursor.Current.Any())
@@ -399,15 +403,14 @@ async Task IterateCursorAsync()
                     {
                         await OnChangesAsync.InvokeAllAsync(
                             cursor.Current
-                                .Where(d => d.OperationType != ChangeStreamOperationType.Invalidate)
-                                .Select(d => d.FullDocument)
-                        ).ConfigureAwait(false);
+                                  .Where(d => d.OperationType != ChangeStreamOperationType.Invalidate)
+                                  .Select(d => d.FullDocument)).ConfigureAwait(false);
                     }
 
                     OnChanges?.Invoke(
                         cursor.Current
-                            .Where(d => d.OperationType != ChangeStreamOperationType.Invalidate)
-                            .Select(d => d.FullDocument));
+                              .Where(d => d.OperationType != ChangeStreamOperationType.Invalidate)
+                              .Select(d => d.FullDocument));
 
                     if (OnChangesCSDAsync != null)
                         await OnChangesCSDAsync.InvokeAllAsync(cursor.Current).ConfigureAwait(false);
diff --git a/MongoDB.Entities/DBContext/DBContext.Pipeline.cs b/MongoDB.Entities/DBContext/DBContext.Pipeline.cs
index deb806d8f..f6e01131f 100644
--- a/MongoDB.Entities/DBContext/DBContext.Pipeline.cs
+++ b/MongoDB.Entities/DBContext/DBContext.Pipeline.cs
@@ -19,7 +19,10 @@ public partial class DBContext
     /// <param name="options">The options for the aggregation. This is not required.</param>
     /// <param name="cancellation">An optional cancellation token</param>
     /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-    public Task<IAsyncCursor<TResult>> PipelineCursorAsync<T, TResult>(Template<T, TResult> template, AggregateOptions? options = null, CancellationToken cancellation = default, bool ignoreGlobalFilters = false) where T : IEntity
+    public Task<IAsyncCursor<TResult>> PipelineCursorAsync<T, TResult>(Template<T, TResult> template,
+                                                                       AggregateOptions? options = null,
+                                                                       CancellationToken cancellation = default,
+                                                                       bool ignoreGlobalFilters = false) where T : IEntity
         => DB.PipelineCursorAsync(MergeGlobalFilter(template, ignoreGlobalFilters), options, Session, cancellation);
 
     /// <summary>
@@ -32,7 +35,10 @@ public Task<IAsyncCursor<TResult>> PipelineCursorAsync<T, TResult>(Template<T, T
     /// <param name="options">The options for the aggregation. This is not required.</param>
     /// <param name="cancellation">An optional cancellation token</param>
     /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-    public Task<List<TResult>> PipelineAsync<T, TResult>(Template<T, TResult> template, AggregateOptions? options = null, CancellationToken cancellation = default, bool ignoreGlobalFilters = false) where T : IEntity
+    public Task<List<TResult>> PipelineAsync<T, TResult>(Template<T, TResult> template,
+                                                         AggregateOptions? options = null,
+                                                         CancellationToken cancellation = default,
+                                                         bool ignoreGlobalFilters = false) where T : IEntity
         => DB.PipelineAsync(MergeGlobalFilter(template, ignoreGlobalFilters), options, Session, cancellation);
 
     /// <summary>
@@ -45,7 +51,10 @@ public Task<List<TResult>> PipelineAsync<T, TResult>(Template<T, TResult> templa
     /// <param name="options">The options for the aggregation. This is not required.</param>
     /// <param name="cancellation">An optional cancellation token</param>
     /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-    public Task<TResult> PipelineSingleAsync<T, TResult>(Template<T, TResult> template, AggregateOptions? options = null, CancellationToken cancellation = default, bool ignoreGlobalFilters = false) where T : IEntity
+    public Task<TResult> PipelineSingleAsync<T, TResult>(Template<T, TResult> template,
+                                                         AggregateOptions? options = null,
+                                                         CancellationToken cancellation = default,
+                                                         bool ignoreGlobalFilters = false) where T : IEntity
         => DB.PipelineSingleAsync(MergeGlobalFilter(template, ignoreGlobalFilters), options, Session, cancellation);
 
     /// <summary>
@@ -58,7 +67,10 @@ public Task<TResult> PipelineSingleAsync<T, TResult>(Template<T, TResult> templa
     /// <param name="options">The options for the aggregation. This is not required.</param>
     /// <param name="cancellation">An optional cancellation token</param>
     /// <param name="ignoreGlobalFilters">Set to true if you'd like to ignore any global filters for this operation</param>
-    public Task<TResult> PipelineFirstAsync<T, TResult>(Template<T, TResult> template, AggregateOptions? options = null, CancellationToken cancellation = default, bool ignoreGlobalFilters = false) where T : IEntity
+    public Task<TResult> PipelineFirstAsync<T, TResult>(Template<T, TResult> template,
+                                                        AggregateOptions? options = null,
+                                                        CancellationToken cancellation = default,
+                                                        bool ignoreGlobalFilters = false) where T : IEntity
         => DB.PipelineFirstAsync(MergeGlobalFilter(template, ignoreGlobalFilters), options, Session, cancellation);
 
     Template<T, TResult> MergeGlobalFilter<T, TResult>(Template<T, TResult> template, bool ignoreGlobalFilters) where T : IEntity
@@ -71,7 +83,7 @@ Template<T, TResult> MergeGlobalFilter<T, TResult>(Template<T, TResult> template
 
         var filter = gFilter.filterDef switch
         {
-            FilterDefinition<T> def => def.Render(BsonSerializer.SerializerRegistry.GetSerializer<T>(), BsonSerializer.SerializerRegistry, Driver.Linq.LinqProvider.V3),
+            FilterDefinition<T> def => def.Render(new(BsonSerializer.SerializerRegistry.GetSerializer<T>(), BsonSerializer.SerializerRegistry)),
             BsonDocument doc => doc,
             string jsonString => BsonDocument.Parse(jsonString),
             _ => null
@@ -81,6 +93,7 @@ Template<T, TResult> MergeGlobalFilter<T, TResult>(Template<T, TResult> template
             template.builder.Insert(1, $"{{$match:{filter}}},");
         else
             template.builder.Insert(template.builder.Length - 1, $",{{$match:{filter}}}");
+
         return template;
     }
 }
\ No newline at end of file
diff --git a/MongoDB.Entities/MongoDB.Entities.csproj b/MongoDB.Entities/MongoDB.Entities.csproj
index c123ac700..2a8161d3a 100644
--- a/MongoDB.Entities/MongoDB.Entities.csproj
+++ b/MongoDB.Entities/MongoDB.Entities.csproj
@@ -2,7 +2,7 @@
 
     <PropertyGroup>
 
-        <Version>23.1.1</Version>
+        <Version>23.2.0</Version>
 
         <TargetFramework>netstandard2.1</TargetFramework>
         <RootNamespace>MongoDB.Entities</RootNamespace>
@@ -31,7 +31,7 @@
 
     <ItemGroup>
         <PackageReference Include="Microsoft.CSharp" Version="4.7.0"/>
-        <PackageReference Include="MongoDB.Driver" Version="2.28.0"/>
+        <PackageReference Include="MongoDB.Driver" Version="2.30.0"/>
         <PackageReference Include="Microsoft.SourceLink.GitHub" Version="8.0.0" PrivateAssets="All"/>
     </ItemGroup>
 
diff --git a/Tests/Tests.csproj b/Tests/Tests.csproj
index e6e2ebf28..097ae2717 100644
--- a/Tests/Tests.csproj
+++ b/Tests/Tests.csproj
@@ -11,10 +11,10 @@
 
     <ItemGroup>
         <PackageReference Include="Medo.Uuid7" Version="2.0.0"/>
-        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.10.0"/>
-        <PackageReference Include="MSTest.TestAdapter" Version="3.5.2"/>
-        <PackageReference Include="MSTest.TestFramework" Version="3.5.2"/>
-        <PackageReference Include="Testcontainers.MongoDb" Version="3.10.0" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1"/>
+        <PackageReference Include="MSTest.TestAdapter" Version="3.6.1"/>
+        <PackageReference Include="MSTest.TestFramework" Version="3.6.1"/>
+        <PackageReference Include="Testcontainers.MongoDb" Version="3.10.0"/>
         <PackageReference Include="coverlet.collector" Version="6.0.2">
             <PrivateAssets>all</PrivateAssets>
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
diff --git a/changelog.md b/changelog.md
index 6fb81051b..88738f568 100644
--- a/changelog.md
+++ b/changelog.md
@@ -2,6 +2,8 @@
 
 ### IMPROVEMENTS
 
-- upgrade mongodb driver to v2.28
+- upgrade mongodb driver to v2.30
+
+> NOTE: v2.30 is the last driver version for v2 series. In turn this will be the last release for v23 major version of MongoDB.Entities. v24 will switch to v3 of the official driver which has lots of breaking changes that are not backwards compatible.
 
 [//]: # (### BREAKING CHANGES)
\ No newline at end of file