From 494a486d7343e663c2b10c5e0e34e6f4e0279918 Mon Sep 17 00:00:00 2001
From: adelinowona <adelinowona@gmail.com>
Date: Thu, 1 May 2025 01:03:27 -0400
Subject: [PATCH 01/10] CSHARP-5543: Add new options for Atlas Search Text and
 Phrase operators

# Conflicts:
#	src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs
---
 .../Search/OperatorSearchDefinitions.cs       | 40 +++++++++++--
 .../Search/SearchDefinitionBuilder.cs         | 58 +++++++++++++++++++
 .../Search/SearchPhraseOptions.cs             | 38 ++++++++++++
 .../Search/SearchTextOptions.cs               | 44 ++++++++++++++
 .../Search/AtlasSearchTests.cs                | 40 +++++++++++++
 .../Search/SearchDefinitionBuilderTests.cs    | 27 +++++++++
 6 files changed, 242 insertions(+), 5 deletions(-)
 create mode 100644 src/MongoDB.Driver/Search/SearchPhraseOptions.cs
 create mode 100644 src/MongoDB.Driver/Search/SearchTextOptions.cs

diff --git a/src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs b/src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs
index b4686e3a815..399c0a92bb1 100644
--- a/src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs
+++ b/src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs
@@ -328,6 +328,7 @@ internal sealed class PhraseSearchDefinition<TDocument> : OperatorSearchDefiniti
     {
         private readonly SearchQueryDefinition _query;
         private readonly int? _slop;
+        private readonly string _synonyms;
 
         public PhraseSearchDefinition(
             SearchPathDefinition<TDocument> path,
@@ -340,12 +341,25 @@ public PhraseSearchDefinition(
             _slop = slop;
         }
 
+        public PhraseSearchDefinition(
+            SearchPathDefinition<TDocument> path,
+            SearchQueryDefinition query,
+            SearchPhraseOptions<TDocument> options)
+            : base(OperatorType.Phrase, path, options?.Score)
+        {
+            _query = Ensure.IsNotNull(query, nameof(query));
+            _slop = options?.Slop;
+            _synonyms = options?.Synonyms;
+        }
+
         private protected override BsonDocument RenderArguments(
             RenderArgs<TDocument> args,
-            IBsonSerializer fieldSerializer) => new()
+            IBsonSerializer fieldSerializer) =>
+            new()
             {
                 { "query", _query.Render() },
-                { "slop", _slop, _slop != null }
+                { "slop", _slop, _slop != null },
+                { "synonyms", _synonyms, _synonyms != null }
             };
     }
 
@@ -463,6 +477,7 @@ internal sealed class TextSearchDefinition<TDocument> : OperatorSearchDefinition
         private readonly SearchFuzzyOptions _fuzzy;
         private readonly SearchQueryDefinition _query;
         private readonly string _synonyms;
+        private readonly string _matchCriteria;
 
         public TextSearchDefinition(
             SearchPathDefinition<TDocument> path,
@@ -477,12 +492,27 @@ public TextSearchDefinition(
             _synonyms = synonyms;
         }
 
-        private protected override BsonDocument RenderArguments(RenderArgs<TDocument> args,
-            IBsonSerializer fieldSerializer) => new()
+        public TextSearchDefinition(
+            SearchPathDefinition<TDocument> path,
+            SearchQueryDefinition query,
+            SearchTextOptions<TDocument> options)
+            : base(OperatorType.Text, path, options?.Score)
+        {
+            _query = Ensure.IsNotNull(query, nameof(query));
+            _fuzzy = options?.Fuzzy;
+            _synonyms = options?.Synonyms;
+            _matchCriteria = options?.MatchCriteria;
+        }
+
+        private protected override BsonDocument RenderArguments(
+            RenderArgs<TDocument> args,
+            IBsonSerializer fieldSerializer) =>
+            new()
             {
                 { "query", _query.Render() },
                 { "fuzzy", () => _fuzzy.Render(), _fuzzy != null },
-                { "synonyms", _synonyms, _synonyms != null }
+                { "synonyms", _synonyms, _synonyms != null },
+                { "matchCriteria", _matchCriteria, _matchCriteria != null }
             };
     }
 
diff --git a/src/MongoDB.Driver/Search/SearchDefinitionBuilder.cs b/src/MongoDB.Driver/Search/SearchDefinitionBuilder.cs
index 09c5172a7f8..1fc4e49475a 100644
--- a/src/MongoDB.Driver/Search/SearchDefinitionBuilder.cs
+++ b/src/MongoDB.Driver/Search/SearchDefinitionBuilder.cs
@@ -552,6 +552,20 @@ public SearchDefinition<TDocument> Phrase(
             SearchScoreDefinition<TDocument> score = null) =>
                 new PhraseSearchDefinition<TDocument>(path, query, slop, score);
 
+        /// <summary>
+        /// Creates a search definition that performs search for documents containing an ordered
+        /// sequence of terms.
+        /// </summary>
+        /// <param name="path">The indexed field or fields to search.</param>
+        /// <param name="query">The string or strings to search for.</param>
+        /// <param name="options">The options.</param>
+        /// <returns>A phrase search definition.</returns>
+        public SearchDefinition<TDocument> Phrase(
+            SearchPathDefinition<TDocument> path,
+            SearchQueryDefinition query,
+            SearchPhraseOptions<TDocument> options) =>
+            new PhraseSearchDefinition<TDocument>(path, query, options);
+
         /// <summary>
         /// Creates a search definition that performs search for documents containing an ordered
         /// sequence of terms.
@@ -569,6 +583,21 @@ public SearchDefinition<TDocument> Phrase<TField>(
             SearchScoreDefinition<TDocument> score = null) =>
                 Phrase(new ExpressionFieldDefinition<TDocument>(path), query, slop, score);
 
+        /// <summary>
+        /// Creates a search definition that performs search for documents containing an ordered
+        /// sequence of terms.
+        /// </summary>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="path">The indexed field or fields to search.</param>
+        /// <param name="query">The string or strings to search for.</param>
+        /// <param name="options">The options.</param>
+        /// <returns>A phrase search definition.</returns>
+        public SearchDefinition<TDocument> Phrase<TField>(
+            Expression<Func<TDocument, TField>> path,
+            SearchQueryDefinition query,
+            SearchPhraseOptions<TDocument> options) =>
+            Phrase(new ExpressionFieldDefinition<TDocument>(path), query, options);
+
         /// <summary>
         /// Creates a search definition that queries a combination of indexed fields and values.
         /// </summary>
@@ -732,6 +761,20 @@ public SearchDefinition<TDocument> Regex<TField>(
         public SearchDefinition<TDocument> Span(SearchSpanDefinition<TDocument> clause) =>
             new SpanSearchDefinition<TDocument>(clause);
 
+        /// <summary>
+        /// Creates a search definition that performs full-text search using the analyzer specified
+        /// in the index configuration.
+        /// </summary>
+        /// <param name="path">The indexed field or fields to search.</param>
+        /// <param name="query">The string or strings to search for.</param>
+        /// <param name="options">The options.</param>
+        /// <returns>A text search definition.</returns>
+        public SearchDefinition<TDocument> Text(
+            SearchPathDefinition<TDocument> path,
+            SearchQueryDefinition query,
+            SearchTextOptions<TDocument> options) =>
+            new TextSearchDefinition<TDocument>(path, query, options);
+
         /// <summary>
         /// Creates a search definition that performs full-text search using the analyzer specified
         /// in the index configuration.
@@ -764,6 +807,21 @@ public SearchDefinition<TDocument> Text(
             SearchScoreDefinition<TDocument> score = null) =>
                 new TextSearchDefinition<TDocument>(path, query, null, score, synonyms);
 
+        /// <summary>
+        /// Creates a search definition that performs full-text search using the analyzer specified
+        /// in the index configuration.
+        /// </summary>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="path">The indexed field or field to search.</param>
+        /// <param name="query">The string or strings to search for.</param>
+        /// <param name="options">The options.</param>
+        /// <returns>A text search definition.</returns>
+        public SearchDefinition<TDocument> Text<TField>(
+            Expression<Func<TDocument, TField>> path,
+            SearchQueryDefinition query,
+            SearchTextOptions<TDocument> options) =>
+            Text(new ExpressionFieldDefinition<TDocument>(path), query, options);
+
         /// <summary>
         /// Creates a search definition that performs full-text search using the analyzer specified
         /// in the index configuration.
diff --git a/src/MongoDB.Driver/Search/SearchPhraseOptions.cs b/src/MongoDB.Driver/Search/SearchPhraseOptions.cs
new file mode 100644
index 00000000000..c5e4165e9d7
--- /dev/null
+++ b/src/MongoDB.Driver/Search/SearchPhraseOptions.cs
@@ -0,0 +1,38 @@
+/* Copyright 2010-present MongoDB Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace MongoDB.Driver.Search
+{
+    /// <summary>
+    /// Options for atlas search phrase operator.
+    /// </summary>
+    public sealed class SearchPhraseOptions<TDocument>
+    {
+        /// <summary>
+        /// The allowable distance between words in the query phrase.
+        /// </summary>
+        public int? Slop { get; set; }
+
+        /// <summary>
+        /// The score modifier.
+        /// </summary>
+        public SearchScoreDefinition<TDocument> Score { get; set; }
+
+        /// <summary>
+        /// The name of the synonym mapping definition in the index definition. Value can't be an empty string.
+        /// </summary>
+        public string Synonyms { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/src/MongoDB.Driver/Search/SearchTextOptions.cs b/src/MongoDB.Driver/Search/SearchTextOptions.cs
new file mode 100644
index 00000000000..247da2a5deb
--- /dev/null
+++ b/src/MongoDB.Driver/Search/SearchTextOptions.cs
@@ -0,0 +1,44 @@
+/* Copyright 2010-present MongoDB Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace MongoDB.Driver.Search
+{
+    /// <summary>
+    /// Options for atlas search text operator.
+    /// </summary>
+    public sealed class SearchTextOptions<TDocument>
+    {
+        /// <summary>
+        /// The options for fuzzy search.
+        /// </summary>
+        public SearchFuzzyOptions Fuzzy { get; set; }
+
+        /// <summary>
+        /// The criteria to use to match the terms in the query. Value can be either "any" or "all".
+        /// Defaults to "all" if omitted.
+        /// </summary>
+        public string MatchCriteria { get; set; }
+
+        /// <summary>
+        /// The score modifier.
+        /// </summary>
+        public SearchScoreDefinition<TDocument> Score { get; set; }
+
+        /// <summary>
+        /// The name of the synonym mapping definition in the index definition. Value can't be an empty string.
+        /// </summary>
+        public string Synonyms { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/tests/MongoDB.Driver.Tests/Search/AtlasSearchTests.cs b/tests/MongoDB.Driver.Tests/Search/AtlasSearchTests.cs
index 0ea49ce015e..0fc0507ccb7 100644
--- a/tests/MongoDB.Driver.Tests/Search/AtlasSearchTests.cs
+++ b/tests/MongoDB.Driver.Tests/Search/AtlasSearchTests.cs
@@ -421,6 +421,26 @@ public void PhraseAnalyzerPath()
             result.Title.Should().Be("Declaration of Independence");
         }
 
+        [Fact]
+        public void PhraseSynonym()
+        {
+            var result =
+                GetSynonymTestCollection().Aggregate()
+                    .Search(
+                        Builders<Movie>.Search.Phrase("plot", "automobile race", new SearchPhraseOptions<Movie> { Synonyms = "transportSynonyms" }),
+                        indexName: "synonyms-tests")
+                    .Project<Movie>(Builders<Movie>.Projection.Include("Title").Exclude("_id"))
+                    .Limit(5)
+                    .ToList();
+
+            result.Count.Should().Be(5);
+            result[0].Title.Should().Be("The Great Race");
+            result[1].Title.Should().Be("The Cannonball Run");
+            result[2].Title.Should().Be("National Mechanics");
+            result[3].Title.Should().Be("Genevieve");
+            result[4].Title.Should().Be("Speedway Junky");
+        }
+
         [Fact]
         public void PhraseWildcardPath()
         {
@@ -723,6 +743,26 @@ public void Text()
             result.Title.Should().Be("Declaration of Independence");
         }
 
+        [Fact]
+        public void TextMatchCriteria()
+        {
+            var result =
+                GetSynonymTestCollection().Aggregate()
+                    .Search(
+                        Builders<Movie>.Search.Text("plot", "attire", new SearchTextOptions<Movie> { Synonyms = "attireSynonyms", MatchCriteria = "any"}),
+                        indexName: "synonyms-tests")
+                    .Project<Movie>(Builders<Movie>.Projection.Include("Title").Exclude("_id"))
+                    .Limit(5)
+                    .ToList();
+
+            result.Count.Should().Be(5);
+            result[0].Title.Should().Be("The Royal Tailor");
+            result[1].Title.Should().Be("La guerre des tuques");
+            result[2].Title.Should().Be("The Dress");
+            result[3].Title.Should().Be("The Club");
+            result[4].Title.Should().Be("The Triple Echo");
+        }
+
         [Theory]
         [InlineData("automobile", "transportSynonyms", "Blue Car")]
         [InlineData("boat", "transportSynonyms", "And the Ship Sails On")]
diff --git a/tests/MongoDB.Driver.Tests/Search/SearchDefinitionBuilderTests.cs b/tests/MongoDB.Driver.Tests/Search/SearchDefinitionBuilderTests.cs
index 7e06af49c7b..ce37e49e281 100644
--- a/tests/MongoDB.Driver.Tests/Search/SearchDefinitionBuilderTests.cs
+++ b/tests/MongoDB.Driver.Tests/Search/SearchDefinitionBuilderTests.cs
@@ -949,10 +949,22 @@ public void Phrase()
                 subject.Phrase("x", "foo", 5),
                 "{ phrase: { query: 'foo', path: 'x', slop: 5 } }");
 
+            AssertRendered(
+                subject.Phrase("x", "foo", new SearchPhraseOptions<BsonDocument> { Synonyms = "testSynonyms" }),
+                "{ phrase: { query: 'foo', path: 'x', synonyms: 'testSynonyms' } }");
+
+            AssertRendered(
+                subject.Phrase("x", "foo", 5),
+                "{ phrase: { query: 'foo', path: 'x', slop: 5 } }");
+
             var scoreBuilder = new SearchScoreDefinitionBuilder<BsonDocument>();
             AssertRendered(
                 subject.Phrase("x", "foo", score: scoreBuilder.Constant(1)),
                 "{ phrase: { query: 'foo', path: 'x', score: { constant: { value: 1 } } } }");
+
+            AssertRendered(
+                subject.Phrase("x", "foo", new SearchPhraseOptions<BsonDocument> { Score = scoreBuilder.Constant(1), Slop = 5}),
+                "{ phrase: { query: 'foo', slop: 5, path: 'x', score: { constant: { value: 1 } } } }");
         }
 
         [Fact]
@@ -970,6 +982,10 @@ public void Phrase_typed()
                 subject.Phrase(x => x.Hobbies, "foo"),
                 "{ phrase: { query: 'foo', path: 'hobbies' } }");
 
+            AssertRendered(
+                subject.Phrase(x => x.FirstName, "foo", new SearchPhraseOptions<Person> { Synonyms = "testSynonyms" }),
+                "{ phrase: { query: 'foo', synonyms: 'testSynonyms', path: 'fn' } }");
+
             AssertRendered(
                 subject.Phrase(
                     new FieldDefinition<Person>[]
@@ -1308,6 +1324,10 @@ public void Text()
                 subject.Text(new[] { "x", "y" }, new[] { "foo", "bar" }, "testSynonyms"),
                 "{ text: { query: ['foo', 'bar'], synonyms: 'testSynonyms', path: ['x', 'y'] } }");
 
+            AssertRendered(
+                subject.Text(new[] { "x", "y" }, new[] { "foo", "bar" }, new SearchTextOptions<BsonDocument>{ MatchCriteria = "any" }),
+                "{ text: { query: ['foo', 'bar'], matchCriteria: 'any', path: ['x', 'y'] } }");
+
             AssertRendered(
                 subject.Text("x", "foo", new SearchFuzzyOptions()),
                 "{ text: { query: 'foo', path: 'x', fuzzy: {} } }");
@@ -1327,6 +1347,10 @@ public void Text()
             AssertRendered(
                 subject.Text("x", "foo", "testSynonyms", scoreBuilder.Constant(1)),
                 "{ text: { query: 'foo', synonyms: 'testSynonyms', path: 'x', score: { constant: { value: 1 } } } }");
+
+            AssertRendered(
+                subject.Text("x", "foo", new SearchTextOptions<BsonDocument> {Score = scoreBuilder.Constant(1), MatchCriteria = "all"}),
+                "{ text: { query: 'foo', matchCriteria: 'all', path: 'x', score: { constant: { value: 1 } } } }");
         }
 
         [Fact]
@@ -1337,6 +1361,9 @@ public void Text_typed()
             AssertRendered(
                 subject.Text(x => x.FirstName, "foo"),
                 "{ text: { query: 'foo', path: 'fn' } }");
+            AssertRendered(
+                subject.Text(x => x.FirstName, "foo", new SearchTextOptions<Person> { MatchCriteria = "all"}),
+                "{ text: { query: 'foo', matchCriteria: 'all', path: 'fn' } }");
             AssertRendered(
                 subject.Text("FirstName", "foo"),
                 "{ text: { query: 'foo', path: 'fn' } }");

From c563ebe04c2e9a317009a61549593be1c0869538 Mon Sep 17 00:00:00 2001
From: adelinowona <adelinowona@gmail.com>
Date: Mon, 28 Apr 2025 17:54:10 -0400
Subject: [PATCH 02/10] put options in alphabetical order

---
 src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs | 2 +-
 src/MongoDB.Driver/Search/SearchPhraseOptions.cs       | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs b/src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs
index 399c0a92bb1..0cc3d8d4a68 100644
--- a/src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs
+++ b/src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs
@@ -475,9 +475,9 @@ private protected override BsonDocument RenderArguments(
     internal sealed class TextSearchDefinition<TDocument> : OperatorSearchDefinition<TDocument>
     {
         private readonly SearchFuzzyOptions _fuzzy;
+        private readonly string _matchCriteria;
         private readonly SearchQueryDefinition _query;
         private readonly string _synonyms;
-        private readonly string _matchCriteria;
 
         public TextSearchDefinition(
             SearchPathDefinition<TDocument> path,
diff --git a/src/MongoDB.Driver/Search/SearchPhraseOptions.cs b/src/MongoDB.Driver/Search/SearchPhraseOptions.cs
index c5e4165e9d7..407a74d7e7c 100644
--- a/src/MongoDB.Driver/Search/SearchPhraseOptions.cs
+++ b/src/MongoDB.Driver/Search/SearchPhraseOptions.cs
@@ -21,14 +21,14 @@ namespace MongoDB.Driver.Search
     public sealed class SearchPhraseOptions<TDocument>
     {
         /// <summary>
-        /// The allowable distance between words in the query phrase.
+        /// The score modifier.
         /// </summary>
-        public int? Slop { get; set; }
+        public SearchScoreDefinition<TDocument> Score { get; set; }
 
         /// <summary>
-        /// The score modifier.
+        /// The allowable distance between words in the query phrase.
         /// </summary>
-        public SearchScoreDefinition<TDocument> Score { get; set; }
+        public int? Slop { get; set; }
 
         /// <summary>
         /// The name of the synonym mapping definition in the index definition. Value can't be an empty string.

From 5e845d6a33a742553b6a63a9ca478c9d7d90c29a Mon Sep 17 00:00:00 2001
From: adelinowona <adelinowona@gmail.com>
Date: Mon, 28 Apr 2025 18:15:43 -0400
Subject: [PATCH 03/10] make matchCriteria an enum

---
 src/MongoDB.Driver/MatchCriteria.cs           | 32 +++++++++++++++++++
 .../Search/OperatorSearchDefinitions.cs       |  4 +--
 .../Search/SearchTextOptions.cs               |  2 +-
 .../Search/AtlasSearchTests.cs                |  2 +-
 .../Search/SearchDefinitionBuilderTests.cs    |  6 ++--
 5 files changed, 39 insertions(+), 7 deletions(-)
 create mode 100644 src/MongoDB.Driver/MatchCriteria.cs

diff --git a/src/MongoDB.Driver/MatchCriteria.cs b/src/MongoDB.Driver/MatchCriteria.cs
new file mode 100644
index 00000000000..aa3462f358a
--- /dev/null
+++ b/src/MongoDB.Driver/MatchCriteria.cs
@@ -0,0 +1,32 @@
+/* Copyright 2010-present MongoDB Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace MongoDB.Driver
+{
+    /// <summary>
+    /// Represents the criteria used to match terms in a query for the Atlas Search Text operator.
+    /// </summary>
+    public enum MatchCriteria
+    {
+        /// <summary>
+        /// Match documents containing any of the terms from a query.
+        /// </summary>
+        Any,
+        /// <summary>
+        /// Match documents containing all the terms from a query.
+        /// </summary>
+        All
+    }
+}
\ No newline at end of file
diff --git a/src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs b/src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs
index 0cc3d8d4a68..d759d1632d7 100644
--- a/src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs
+++ b/src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs
@@ -475,7 +475,7 @@ private protected override BsonDocument RenderArguments(
     internal sealed class TextSearchDefinition<TDocument> : OperatorSearchDefinition<TDocument>
     {
         private readonly SearchFuzzyOptions _fuzzy;
-        private readonly string _matchCriteria;
+        private readonly MatchCriteria? _matchCriteria;
         private readonly SearchQueryDefinition _query;
         private readonly string _synonyms;
 
@@ -512,7 +512,7 @@ private protected override BsonDocument RenderArguments(
                 { "query", _query.Render() },
                 { "fuzzy", () => _fuzzy.Render(), _fuzzy != null },
                 { "synonyms", _synonyms, _synonyms != null },
-                { "matchCriteria", _matchCriteria, _matchCriteria != null }
+                { "matchCriteria", _matchCriteria == MatchCriteria.Any ? "any" : "all", _matchCriteria != null }
             };
     }
 
diff --git a/src/MongoDB.Driver/Search/SearchTextOptions.cs b/src/MongoDB.Driver/Search/SearchTextOptions.cs
index 247da2a5deb..fdc5d3e488b 100644
--- a/src/MongoDB.Driver/Search/SearchTextOptions.cs
+++ b/src/MongoDB.Driver/Search/SearchTextOptions.cs
@@ -29,7 +29,7 @@ public sealed class SearchTextOptions<TDocument>
         /// The criteria to use to match the terms in the query. Value can be either "any" or "all".
         /// Defaults to "all" if omitted.
         /// </summary>
-        public string MatchCriteria { get; set; }
+        public MatchCriteria MatchCriteria { get; set; }
 
         /// <summary>
         /// The score modifier.
diff --git a/tests/MongoDB.Driver.Tests/Search/AtlasSearchTests.cs b/tests/MongoDB.Driver.Tests/Search/AtlasSearchTests.cs
index 0fc0507ccb7..b014e9152a8 100644
--- a/tests/MongoDB.Driver.Tests/Search/AtlasSearchTests.cs
+++ b/tests/MongoDB.Driver.Tests/Search/AtlasSearchTests.cs
@@ -749,7 +749,7 @@ public void TextMatchCriteria()
             var result =
                 GetSynonymTestCollection().Aggregate()
                     .Search(
-                        Builders<Movie>.Search.Text("plot", "attire", new SearchTextOptions<Movie> { Synonyms = "attireSynonyms", MatchCriteria = "any"}),
+                        Builders<Movie>.Search.Text("plot", "attire", new SearchTextOptions<Movie> { Synonyms = "attireSynonyms", MatchCriteria = MatchCriteria.Any}),
                         indexName: "synonyms-tests")
                     .Project<Movie>(Builders<Movie>.Projection.Include("Title").Exclude("_id"))
                     .Limit(5)
diff --git a/tests/MongoDB.Driver.Tests/Search/SearchDefinitionBuilderTests.cs b/tests/MongoDB.Driver.Tests/Search/SearchDefinitionBuilderTests.cs
index ce37e49e281..6ad97715287 100644
--- a/tests/MongoDB.Driver.Tests/Search/SearchDefinitionBuilderTests.cs
+++ b/tests/MongoDB.Driver.Tests/Search/SearchDefinitionBuilderTests.cs
@@ -1325,7 +1325,7 @@ public void Text()
                 "{ text: { query: ['foo', 'bar'], synonyms: 'testSynonyms', path: ['x', 'y'] } }");
 
             AssertRendered(
-                subject.Text(new[] { "x", "y" }, new[] { "foo", "bar" }, new SearchTextOptions<BsonDocument>{ MatchCriteria = "any" }),
+                subject.Text(new[] { "x", "y" }, new[] { "foo", "bar" }, new SearchTextOptions<BsonDocument>{ MatchCriteria = MatchCriteria.Any }),
                 "{ text: { query: ['foo', 'bar'], matchCriteria: 'any', path: ['x', 'y'] } }");
 
             AssertRendered(
@@ -1349,7 +1349,7 @@ public void Text()
                 "{ text: { query: 'foo', synonyms: 'testSynonyms', path: 'x', score: { constant: { value: 1 } } } }");
 
             AssertRendered(
-                subject.Text("x", "foo", new SearchTextOptions<BsonDocument> {Score = scoreBuilder.Constant(1), MatchCriteria = "all"}),
+                subject.Text("x", "foo", new SearchTextOptions<BsonDocument> {Score = scoreBuilder.Constant(1), MatchCriteria = MatchCriteria.All}),
                 "{ text: { query: 'foo', matchCriteria: 'all', path: 'x', score: { constant: { value: 1 } } } }");
         }
 
@@ -1362,7 +1362,7 @@ public void Text_typed()
                 subject.Text(x => x.FirstName, "foo"),
                 "{ text: { query: 'foo', path: 'fn' } }");
             AssertRendered(
-                subject.Text(x => x.FirstName, "foo", new SearchTextOptions<Person> { MatchCriteria = "all"}),
+                subject.Text(x => x.FirstName, "foo", new SearchTextOptions<Person> { MatchCriteria = MatchCriteria.All}),
                 "{ text: { query: 'foo', matchCriteria: 'all', path: 'fn' } }");
             AssertRendered(
                 subject.Text("FirstName", "foo"),

From 573fcc1980594c6aebf03514ffb9a577789b90a4 Mon Sep 17 00:00:00 2001
From: adelinowona <adelinowona@gmail.com>
Date: Tue, 29 Apr 2025 16:07:02 -0400
Subject: [PATCH 04/10] address pr comments

---
 .../{ => Search}/MatchCriteria.cs             |  2 +-
 .../Search/OperatorSearchDefinitions.cs       | 24 -------------------
 .../Search/SearchDefinitionBuilder.cs         |  6 ++---
 .../Search/SearchTextOptions.cs               |  2 +-
 4 files changed, 5 insertions(+), 29 deletions(-)
 rename src/MongoDB.Driver/{ => Search}/MatchCriteria.cs (96%)

diff --git a/src/MongoDB.Driver/MatchCriteria.cs b/src/MongoDB.Driver/Search/MatchCriteria.cs
similarity index 96%
rename from src/MongoDB.Driver/MatchCriteria.cs
rename to src/MongoDB.Driver/Search/MatchCriteria.cs
index aa3462f358a..4f7b74aaf42 100644
--- a/src/MongoDB.Driver/MatchCriteria.cs
+++ b/src/MongoDB.Driver/Search/MatchCriteria.cs
@@ -13,7 +13,7 @@
  * limitations under the License.
  */
 
-namespace MongoDB.Driver
+namespace MongoDB.Driver.Search
 {
     /// <summary>
     /// Represents the criteria used to match terms in a query for the Atlas Search Text operator.
diff --git a/src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs b/src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs
index d759d1632d7..f17ac372ca2 100644
--- a/src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs
+++ b/src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs
@@ -330,17 +330,6 @@ internal sealed class PhraseSearchDefinition<TDocument> : OperatorSearchDefiniti
         private readonly int? _slop;
         private readonly string _synonyms;
 
-        public PhraseSearchDefinition(
-            SearchPathDefinition<TDocument> path,
-            SearchQueryDefinition query,
-            int? slop,
-            SearchScoreDefinition<TDocument> score)
-                : base(OperatorType.Phrase, path, score)
-        {
-            _query = Ensure.IsNotNull(query, nameof(query));
-            _slop = slop;
-        }
-
         public PhraseSearchDefinition(
             SearchPathDefinition<TDocument> path,
             SearchQueryDefinition query,
@@ -479,19 +468,6 @@ internal sealed class TextSearchDefinition<TDocument> : OperatorSearchDefinition
         private readonly SearchQueryDefinition _query;
         private readonly string _synonyms;
 
-        public TextSearchDefinition(
-            SearchPathDefinition<TDocument> path,
-            SearchQueryDefinition query,
-            SearchFuzzyOptions fuzzy,
-            SearchScoreDefinition<TDocument> score,
-            string synonyms)
-                : base(OperatorType.Text, path, score)
-        {
-            _query = Ensure.IsNotNull(query, nameof(query));
-            _fuzzy = fuzzy;
-            _synonyms = synonyms;
-        }
-
         public TextSearchDefinition(
             SearchPathDefinition<TDocument> path,
             SearchQueryDefinition query,
diff --git a/src/MongoDB.Driver/Search/SearchDefinitionBuilder.cs b/src/MongoDB.Driver/Search/SearchDefinitionBuilder.cs
index 1fc4e49475a..3f4d12198dd 100644
--- a/src/MongoDB.Driver/Search/SearchDefinitionBuilder.cs
+++ b/src/MongoDB.Driver/Search/SearchDefinitionBuilder.cs
@@ -550,7 +550,7 @@ public SearchDefinition<TDocument> Phrase(
             SearchQueryDefinition query,
             int? slop = null,
             SearchScoreDefinition<TDocument> score = null) =>
-                new PhraseSearchDefinition<TDocument>(path, query, slop, score);
+                new PhraseSearchDefinition<TDocument>(path, query, new SearchPhraseOptions<TDocument> { Slop = slop, Score = score });
 
         /// <summary>
         /// Creates a search definition that performs search for documents containing an ordered
@@ -789,7 +789,7 @@ public SearchDefinition<TDocument> Text(
             SearchQueryDefinition query,
             SearchFuzzyOptions fuzzy = null,
             SearchScoreDefinition<TDocument> score = null) =>
-                new TextSearchDefinition<TDocument>(path, query, fuzzy, score, null);
+                new TextSearchDefinition<TDocument>(path, query, new SearchTextOptions<TDocument> { Fuzzy = fuzzy, Score = score });
 
         /// <summary>
         /// Creates a search definition that performs full-text search with synonyms using the analyzer specified
@@ -805,7 +805,7 @@ public SearchDefinition<TDocument> Text(
             SearchQueryDefinition query,
             string synonyms,
             SearchScoreDefinition<TDocument> score = null) =>
-                new TextSearchDefinition<TDocument>(path, query, null, score, synonyms);
+                new TextSearchDefinition<TDocument>(path, query, new SearchTextOptions<TDocument> { Score = score, Synonyms = synonyms });
 
         /// <summary>
         /// Creates a search definition that performs full-text search using the analyzer specified
diff --git a/src/MongoDB.Driver/Search/SearchTextOptions.cs b/src/MongoDB.Driver/Search/SearchTextOptions.cs
index fdc5d3e488b..f806f0da1fa 100644
--- a/src/MongoDB.Driver/Search/SearchTextOptions.cs
+++ b/src/MongoDB.Driver/Search/SearchTextOptions.cs
@@ -29,7 +29,7 @@ public sealed class SearchTextOptions<TDocument>
         /// The criteria to use to match the terms in the query. Value can be either "any" or "all".
         /// Defaults to "all" if omitted.
         /// </summary>
-        public MatchCriteria MatchCriteria { get; set; }
+        public MatchCriteria? MatchCriteria { get; set; }
 
         /// <summary>
         /// The score modifier.

From a7a6fa5a02452b370d2b555a15cd1b9e69f4180a Mon Sep 17 00:00:00 2001
From: adelinowona <adelinowona@gmail.com>
Date: Wed, 30 Apr 2025 12:53:58 -0400
Subject: [PATCH 05/10] fix indentation and clarify api docs

---
 src/MongoDB.Driver/Search/SearchDefinitionBuilder.cs | 8 ++++----
 src/MongoDB.Driver/Search/SearchPhraseOptions.cs     | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/MongoDB.Driver/Search/SearchDefinitionBuilder.cs b/src/MongoDB.Driver/Search/SearchDefinitionBuilder.cs
index 3f4d12198dd..21f51069093 100644
--- a/src/MongoDB.Driver/Search/SearchDefinitionBuilder.cs
+++ b/src/MongoDB.Driver/Search/SearchDefinitionBuilder.cs
@@ -564,7 +564,7 @@ public SearchDefinition<TDocument> Phrase(
             SearchPathDefinition<TDocument> path,
             SearchQueryDefinition query,
             SearchPhraseOptions<TDocument> options) =>
-            new PhraseSearchDefinition<TDocument>(path, query, options);
+                new PhraseSearchDefinition<TDocument>(path, query, options);
 
         /// <summary>
         /// Creates a search definition that performs search for documents containing an ordered
@@ -596,7 +596,7 @@ public SearchDefinition<TDocument> Phrase<TField>(
             Expression<Func<TDocument, TField>> path,
             SearchQueryDefinition query,
             SearchPhraseOptions<TDocument> options) =>
-            Phrase(new ExpressionFieldDefinition<TDocument>(path), query, options);
+                Phrase(new ExpressionFieldDefinition<TDocument>(path), query, options);
 
         /// <summary>
         /// Creates a search definition that queries a combination of indexed fields and values.
@@ -773,7 +773,7 @@ public SearchDefinition<TDocument> Text(
             SearchPathDefinition<TDocument> path,
             SearchQueryDefinition query,
             SearchTextOptions<TDocument> options) =>
-            new TextSearchDefinition<TDocument>(path, query, options);
+                new TextSearchDefinition<TDocument>(path, query, options);
 
         /// <summary>
         /// Creates a search definition that performs full-text search using the analyzer specified
@@ -820,7 +820,7 @@ public SearchDefinition<TDocument> Text<TField>(
             Expression<Func<TDocument, TField>> path,
             SearchQueryDefinition query,
             SearchTextOptions<TDocument> options) =>
-            Text(new ExpressionFieldDefinition<TDocument>(path), query, options);
+                Text(new ExpressionFieldDefinition<TDocument>(path), query, options);
 
         /// <summary>
         /// Creates a search definition that performs full-text search using the analyzer specified
diff --git a/src/MongoDB.Driver/Search/SearchPhraseOptions.cs b/src/MongoDB.Driver/Search/SearchPhraseOptions.cs
index 407a74d7e7c..8c239a1323e 100644
--- a/src/MongoDB.Driver/Search/SearchPhraseOptions.cs
+++ b/src/MongoDB.Driver/Search/SearchPhraseOptions.cs
@@ -31,7 +31,7 @@ public sealed class SearchPhraseOptions<TDocument>
         public int? Slop { get; set; }
 
         /// <summary>
-        /// The name of the synonym mapping definition in the index definition. Value can't be an empty string.
+        /// The name of the synonym mapping definition in the index definition. Value can't be an empty string (e.g. "").
         /// </summary>
         public string Synonyms { get; set; }
     }

From b75bcc8b559199655f831c9dcedba4e106d72587 Mon Sep 17 00:00:00 2001
From: adelinowona <adelinowona@gmail.com>
Date: Wed, 30 Apr 2025 16:12:36 -0400
Subject: [PATCH 06/10] fix indentation and more robust matchCriteria checks

---
 .../Search/OperatorSearchDefinitions.cs            | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs b/src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs
index f17ac372ca2..685031d3ce0 100644
--- a/src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs
+++ b/src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs
@@ -334,7 +334,7 @@ public PhraseSearchDefinition(
             SearchPathDefinition<TDocument> path,
             SearchQueryDefinition query,
             SearchPhraseOptions<TDocument> options)
-            : base(OperatorType.Phrase, path, options?.Score)
+                : base(OperatorType.Phrase, path, options?.Score)
         {
             _query = Ensure.IsNotNull(query, nameof(query));
             _slop = options?.Slop;
@@ -472,7 +472,7 @@ public TextSearchDefinition(
             SearchPathDefinition<TDocument> path,
             SearchQueryDefinition query,
             SearchTextOptions<TDocument> options)
-            : base(OperatorType.Text, path, options?.Score)
+                : base(OperatorType.Text, path, options?.Score)
         {
             _query = Ensure.IsNotNull(query, nameof(query));
             _fuzzy = options?.Fuzzy;
@@ -488,7 +488,15 @@ private protected override BsonDocument RenderArguments(
                 { "query", _query.Render() },
                 { "fuzzy", () => _fuzzy.Render(), _fuzzy != null },
                 { "synonyms", _synonyms, _synonyms != null },
-                { "matchCriteria", _matchCriteria == MatchCriteria.Any ? "any" : "all", _matchCriteria != null }
+                {
+                    "matchCriteria", () => _matchCriteria switch
+                    {
+                        MatchCriteria.All => "all",
+                        MatchCriteria.Any => "any",
+                        _ => throw new ArgumentException("Invalid match criteria set for Atlas Search text operator.")
+                    },
+                    _matchCriteria != null
+                }
             };
     }
 

From 71ec65b4ffd786eef927bfe57c030ce3703e63f6 Mon Sep 17 00:00:00 2001
From: adelinowona <adelinowona@gmail.com>
Date: Wed, 30 Apr 2025 16:30:40 -0400
Subject: [PATCH 07/10] add test for exception

---
 .../Search/SearchDefinitionBuilderTests.cs        | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/tests/MongoDB.Driver.Tests/Search/SearchDefinitionBuilderTests.cs b/tests/MongoDB.Driver.Tests/Search/SearchDefinitionBuilderTests.cs
index 6ad97715287..c77fa4033b2 100644
--- a/tests/MongoDB.Driver.Tests/Search/SearchDefinitionBuilderTests.cs
+++ b/tests/MongoDB.Driver.Tests/Search/SearchDefinitionBuilderTests.cs
@@ -1353,6 +1353,21 @@ public void Text()
                 "{ text: { query: 'foo', matchCriteria: 'all', path: 'x', score: { constant: { value: 1 } } } }");
         }
 
+        [Fact]
+        public void Text_should_throw_with_invalid_options()
+        {
+            var subject = CreateSubject<BsonDocument>();
+
+            var query = subject.Text("x", "foo", new SearchTextOptions<BsonDocument> { MatchCriteria = (MatchCriteria)3 });
+
+            Action act = () =>
+                query.Render(new RenderArgs<BsonDocument>(
+                    BsonSerializer.SerializerRegistry.GetSerializer<BsonDocument>(),
+                    BsonSerializer.SerializerRegistry));
+
+            act.ShouldThrow<ArgumentException>();
+        }
+
         [Fact]
         public void Text_typed()
         {

From d9a74340a2243214310d219031d35bb2e4650e1f Mon Sep 17 00:00:00 2001
From: adelinowona <adelinowona@gmail.com>
Date: Thu, 1 May 2025 01:05:38 -0400
Subject: [PATCH 08/10] avoid context capturing

# Conflicts:
#	src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs
---
 .../Search/OperatorSearchDefinitions.cs       | 26 +++++++++----------
 .../Search/SearchDefinitionBuilderTests.cs    |  6 +----
 2 files changed, 14 insertions(+), 18 deletions(-)

diff --git a/src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs b/src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs
index 685031d3ce0..e52824f7bd3 100644
--- a/src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs
+++ b/src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs
@@ -464,7 +464,7 @@ private protected override BsonDocument RenderArguments(
     internal sealed class TextSearchDefinition<TDocument> : OperatorSearchDefinition<TDocument>
     {
         private readonly SearchFuzzyOptions _fuzzy;
-        private readonly MatchCriteria? _matchCriteria;
+        private readonly string _matchCriteria;
         private readonly SearchQueryDefinition _query;
         private readonly string _synonyms;
 
@@ -477,27 +477,27 @@ public TextSearchDefinition(
             _query = Ensure.IsNotNull(query, nameof(query));
             _fuzzy = options?.Fuzzy;
             _synonyms = options?.Synonyms;
-            _matchCriteria = options?.MatchCriteria;
+            _matchCriteria = options?.MatchCriteria switch
+            {
+                MatchCriteria.All => "all",
+                MatchCriteria.Any => "any",
+                null => null,
+                _ => throw new ArgumentException("Invalid match criteria set for Atlas Search text operator.")
+            };
         }
 
         private protected override BsonDocument RenderArguments(
             RenderArgs<TDocument> args,
-            IBsonSerializer fieldSerializer) =>
-            new()
+            IBsonSerializer fieldSerializer)
+        {
+            return new BsonDocument
             {
                 { "query", _query.Render() },
                 { "fuzzy", () => _fuzzy.Render(), _fuzzy != null },
                 { "synonyms", _synonyms, _synonyms != null },
-                {
-                    "matchCriteria", () => _matchCriteria switch
-                    {
-                        MatchCriteria.All => "all",
-                        MatchCriteria.Any => "any",
-                        _ => throw new ArgumentException("Invalid match criteria set for Atlas Search text operator.")
-                    },
-                    _matchCriteria != null
-                }
+                { "matchCriteria", _matchCriteria, _matchCriteria != null }
             };
+        }
     }
 
     internal sealed class WildcardSearchDefinition<TDocument> : OperatorSearchDefinition<TDocument>
diff --git a/tests/MongoDB.Driver.Tests/Search/SearchDefinitionBuilderTests.cs b/tests/MongoDB.Driver.Tests/Search/SearchDefinitionBuilderTests.cs
index c77fa4033b2..0afd28ea4ee 100644
--- a/tests/MongoDB.Driver.Tests/Search/SearchDefinitionBuilderTests.cs
+++ b/tests/MongoDB.Driver.Tests/Search/SearchDefinitionBuilderTests.cs
@@ -1358,12 +1358,8 @@ public void Text_should_throw_with_invalid_options()
         {
             var subject = CreateSubject<BsonDocument>();
 
-            var query = subject.Text("x", "foo", new SearchTextOptions<BsonDocument> { MatchCriteria = (MatchCriteria)3 });
-
             Action act = () =>
-                query.Render(new RenderArgs<BsonDocument>(
-                    BsonSerializer.SerializerRegistry.GetSerializer<BsonDocument>(),
-                    BsonSerializer.SerializerRegistry));
+                subject.Text("x", "foo", new SearchTextOptions<BsonDocument> { MatchCriteria = (MatchCriteria)3 });
 
             act.ShouldThrow<ArgumentException>();
         }

From 24f4c85c16c7a2cae63c3279c5d3e1d95a4a972c Mon Sep 17 00:00:00 2001
From: adelinowona <adelinowona@gmail.com>
Date: Thu, 1 May 2025 01:07:42 -0400
Subject: [PATCH 09/10] minor indentation fix

---
 src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs b/src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs
index e52824f7bd3..28304fae5ad 100644
--- a/src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs
+++ b/src/MongoDB.Driver/Search/OperatorSearchDefinitions.cs
@@ -343,8 +343,7 @@ public PhraseSearchDefinition(
 
         private protected override BsonDocument RenderArguments(
             RenderArgs<TDocument> args,
-            IBsonSerializer fieldSerializer) =>
-            new()
+            IBsonSerializer fieldSerializer) => new()
             {
                 { "query", _query.Render() },
                 { "slop", _slop, _slop != null },

From 79bb9e03081bfe5a184a9d55ad1543c7dc37ab1b Mon Sep 17 00:00:00 2001
From: adelinowona <adelinowona@gmail.com>
Date: Thu, 1 May 2025 01:10:22 -0400
Subject: [PATCH 10/10] sync xml docs

---
 src/MongoDB.Driver/Search/SearchTextOptions.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/MongoDB.Driver/Search/SearchTextOptions.cs b/src/MongoDB.Driver/Search/SearchTextOptions.cs
index f806f0da1fa..ceb09e564a9 100644
--- a/src/MongoDB.Driver/Search/SearchTextOptions.cs
+++ b/src/MongoDB.Driver/Search/SearchTextOptions.cs
@@ -37,7 +37,7 @@ public sealed class SearchTextOptions<TDocument>
         public SearchScoreDefinition<TDocument> Score { get; set; }
 
         /// <summary>
-        /// The name of the synonym mapping definition in the index definition. Value can't be an empty string.
+        /// The name of the synonym mapping definition in the index definition. Value can't be an empty string (e.g. "").
         /// </summary>
         public string Synonyms { get; set; }
     }