diff --git a/src/MongoDB.Driver.Core/Core/Misc/Ensure.cs b/src/MongoDB.Driver.Core/Core/Misc/Ensure.cs
index 9d9def7ebe4..3e91cb84a28 100644
--- a/src/MongoDB.Driver.Core/Core/Misc/Ensure.cs
+++ b/src/MongoDB.Driver.Core/Core/Misc/Ensure.cs
@@ -83,16 +83,18 @@ public static T IsGreaterThanOrEqualTo<T>(T value, T comparand, string paramName
         }
 
         /// <summary>
-        /// Ensures that the value of a parameter is greater than or equal to zero.
+        /// Ensures that the value of a parameter is greater than a comparand.
         /// </summary>
+        /// <typeparam name="T">Type type of the value.</typeparam>
         /// <param name="value">The value of the parameter.</param>
+        /// <param name="comparand">The comparand.</param>
         /// <param name="paramName">The name of the parameter.</param>
         /// <returns>The value of the parameter.</returns>
-        public static int IsGreaterThanOrEqualToZero(int value, string paramName)
+        public static T IsGreaterThan<T>(T value, T comparand, string paramName) where T : IComparable<T>
         {
-            if (value < 0)
+            if (value.CompareTo(comparand) <= 0)
             {
-                var message = string.Format("Value is not greater than or equal to 0: {0}.", value);
+                var message = $"Value is not greater than {comparand}: {value}.";
                 throw new ArgumentOutOfRangeException(paramName, message);
             }
             return value;
@@ -104,15 +106,8 @@ public static int IsGreaterThanOrEqualToZero(int value, string paramName)
         /// <param name="value">The value of the parameter.</param>
         /// <param name="paramName">The name of the parameter.</param>
         /// <returns>The value of the parameter.</returns>
-        public static long IsGreaterThanOrEqualToZero(long value, string paramName)
-        {
-            if (value < 0)
-            {
-                var message = string.Format("Value is not greater than or equal to 0: {0}.", value);
-                throw new ArgumentOutOfRangeException(paramName, message);
-            }
-            return value;
-        }
+        public static int IsGreaterThanOrEqualToZero(int value, string paramName) =>
+            IsGreaterThanOrEqualTo(value, 0, paramName);
 
         /// <summary>
         /// Ensures that the value of a parameter is greater than or equal to zero.
@@ -120,15 +115,17 @@ public static long IsGreaterThanOrEqualToZero(long value, string paramName)
         /// <param name="value">The value of the parameter.</param>
         /// <param name="paramName">The name of the parameter.</param>
         /// <returns>The value of the parameter.</returns>
-        public static TimeSpan IsGreaterThanOrEqualToZero(TimeSpan value, string paramName)
-        {
-            if (value < TimeSpan.Zero)
-            {
-                var message = string.Format("Value is not greater than or equal to zero: {0}.", TimeSpanParser.ToString(value));
-                throw new ArgumentOutOfRangeException(paramName, message);
-            }
-            return value;
-        }
+        public static long IsGreaterThanOrEqualToZero(long value, string paramName) =>
+            IsGreaterThanOrEqualTo(value, 0, paramName);
+
+        /// <summary>
+        /// Ensures that the value of a parameter is greater than or equal to zero.
+        /// </summary>
+        /// <param name="value">The value of the parameter.</param>
+        /// <param name="paramName">The name of the parameter.</param>
+        /// <returns>The value of the parameter.</returns>
+        public static TimeSpan IsGreaterThanOrEqualToZero(TimeSpan value, string paramName) =>
+            IsGreaterThanOrEqualTo(value, TimeSpan.Zero, paramName);
 
         /// <summary>
         /// Ensures that the value of a parameter is greater than zero.
@@ -136,15 +133,8 @@ public static TimeSpan IsGreaterThanOrEqualToZero(TimeSpan value, string paramNa
         /// <param name="value">The value of the parameter.</param>
         /// <param name="paramName">The name of the parameter.</param>
         /// <returns>The value of the parameter.</returns>
-        public static int IsGreaterThanZero(int value, string paramName)
-        {
-            if (value <= 0)
-            {
-                var message = string.Format("Value is not greater than zero: {0}.", value);
-                throw new ArgumentOutOfRangeException(paramName, message);
-            }
-            return value;
-        }
+        public static int IsGreaterThanZero(int value, string paramName) =>
+            IsGreaterThan(value, 0, paramName);
 
         /// <summary>
         /// Ensures that the value of a parameter is greater than zero.
@@ -152,15 +142,8 @@ public static int IsGreaterThanZero(int value, string paramName)
         /// <param name="value">The value of the parameter.</param>
         /// <param name="paramName">The name of the parameter.</param>
         /// <returns>The value of the parameter.</returns>
-        public static long IsGreaterThanZero(long value, string paramName)
-        {
-            if (value <= 0)
-            {
-                var message = string.Format("Value is not greater than zero: {0}.", value);
-                throw new ArgumentOutOfRangeException(paramName, message);
-            }
-            return value;
-        }
+        public static long IsGreaterThanZero(long value, string paramName) =>
+            IsGreaterThan(value, 0, paramName);
 
         /// <summary>
         /// Ensures that the value of a parameter is greater than zero.
@@ -168,15 +151,17 @@ public static long IsGreaterThanZero(long value, string paramName)
         /// <param name="value">The value of the parameter.</param>
         /// <param name="paramName">The name of the parameter.</param>
         /// <returns>The value of the parameter.</returns>
-        public static TimeSpan IsGreaterThanZero(TimeSpan value, string paramName)
-        {
-            if (value <= TimeSpan.Zero)
-            {
-                var message = string.Format("Value is not greater than zero: {0}.", value);
-                throw new ArgumentOutOfRangeException(paramName, message);
-            }
-            return value;
-        }
+        public static double IsGreaterThanZero(double value, string paramName) =>
+            IsGreaterThan(value, 0, paramName);
+
+        /// <summary>
+        /// Ensures that the value of a parameter is greater than zero.
+        /// </summary>
+        /// <param name="value">The value of the parameter.</param>
+        /// <param name="paramName">The name of the parameter.</param>
+        /// <returns>The value of the parameter.</returns>
+        public static TimeSpan IsGreaterThanZero(TimeSpan value, string paramName) =>
+            IsGreaterThan(value, TimeSpan.Zero, paramName);
 
         /// <summary>
         /// Ensures that the value of a parameter is infinite or greater than or equal to zero.
@@ -298,6 +283,24 @@ public static T IsNull<T>(T value, string paramName) where T : class
             return value;
         }
 
+        /// <summary>
+        /// Ensures that the value of a parameter is null or is between a minimum and a maximum value.
+        /// </summary>
+        /// <typeparam name="T">Type type of the value.</typeparam>
+        /// <param name="value">The value of the parameter.</param>
+        /// <param name="min">The minimum value.</param>
+        /// <param name="max">The maximum value.</param>
+        /// <param name="paramName">The name of the parameter.</param>
+        /// <returns>The value of the parameter.</returns>
+        public static T? IsNullOrBetween<T>(T? value, T min, T max, string paramName) where T : struct, IComparable<T>
+        {
+            if (value != null)
+            {
+                IsBetween(value.Value, min, max, paramName);
+            }
+            return value;
+        }
+
         /// <summary>
         /// Ensures that the value of a parameter is null or greater than or equal to zero.
         /// </summary>
diff --git a/src/MongoDB.Driver/AggregateFluent.cs b/src/MongoDB.Driver/AggregateFluent.cs
index 6479c61822c..a03a75f7e81 100644
--- a/src/MongoDB.Driver/AggregateFluent.cs
+++ b/src/MongoDB.Driver/AggregateFluent.cs
@@ -13,13 +13,14 @@
 * limitations under the License.
 */
 
-using MongoDB.Bson;
-using MongoDB.Bson.Serialization;
-using MongoDB.Driver.Core.Misc;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization;
+using MongoDB.Driver.Core.Misc;
+using MongoDB.Driver.Search;
 
 namespace MongoDB.Driver
 {
@@ -238,6 +239,16 @@ public override IAggregateFluent<TNewResult> ReplaceWith<TNewResult>(AggregateEx
             return WithPipeline(_pipeline.ReplaceWith(newRoot));
         }
 
+        public override IAggregateFluent<TResult> Search(
+            SearchDefinition<TResult> query,
+            HighlightOptions<TResult> highlight = null,
+            string indexName = null,
+            SearchCountOptions count = null,
+            bool returnStoredSource = false)
+        {
+            return WithPipeline(_pipeline.Search(query, highlight, indexName, count, returnStoredSource));
+        }
+
         public override IAggregateFluent<BsonDocument> SetWindowFields<TWindowFields>(
             AggregateExpressionDefinition<ISetWindowFieldsPartition<TResult>, TWindowFields> output)
         {
diff --git a/src/MongoDB.Driver/AggregateFluentBase.cs b/src/MongoDB.Driver/AggregateFluentBase.cs
index 2393da49074..9223eccd87e 100644
--- a/src/MongoDB.Driver/AggregateFluentBase.cs
+++ b/src/MongoDB.Driver/AggregateFluentBase.cs
@@ -19,6 +19,7 @@
 using System.Threading.Tasks;
 using MongoDB.Bson;
 using MongoDB.Bson.Serialization;
+using MongoDB.Driver.Search;
 
 namespace MongoDB.Driver
 {
@@ -215,6 +216,17 @@ public virtual IAggregateFluent<TNewResult> ReplaceWith<TNewResult>(AggregateExp
             throw new NotImplementedException();
         }
 
+        /// <inheritdoc />
+        public virtual IAggregateFluent<TResult> Search(
+            SearchDefinition<TResult> query,
+            HighlightOptions<TResult> highlight = null,
+            string indexName = null,
+            SearchCountOptions count = null,
+            bool returnStoredSource = false)
+        {
+            throw new NotImplementedException();
+        }
+
         /// <inheritdoc />
         public virtual IAggregateFluent<BsonDocument> SetWindowFields<TWindowFields>(
             AggregateExpressionDefinition<ISetWindowFieldsPartition<TResult>, TWindowFields> output)
diff --git a/src/MongoDB.Driver/Builders.cs b/src/MongoDB.Driver/Builders.cs
index 2748d915ce5..b339da7644f 100644
--- a/src/MongoDB.Driver/Builders.cs
+++ b/src/MongoDB.Driver/Builders.cs
@@ -13,6 +13,8 @@
 * limitations under the License.
 */
 
+using MongoDB.Driver.Search;
+
 namespace MongoDB.Driver
 {
     /// <summary>
@@ -21,50 +23,29 @@ namespace MongoDB.Driver
     /// <typeparam name="TDocument">The type of the document.</typeparam>
     public static class Builders<TDocument>
     {
-        private static FilterDefinitionBuilder<TDocument> __filter = new FilterDefinitionBuilder<TDocument>();
-        private static IndexKeysDefinitionBuilder<TDocument> __index = new IndexKeysDefinitionBuilder<TDocument>();
-        private static ProjectionDefinitionBuilder<TDocument> __projection = new ProjectionDefinitionBuilder<TDocument>();
-        private static SortDefinitionBuilder<TDocument> __sort = new SortDefinitionBuilder<TDocument>();
-        private static UpdateDefinitionBuilder<TDocument> __update = new UpdateDefinitionBuilder<TDocument>();
+        /// <summary>Gets a <see cref="FilterDefinitionBuilder{TDocument}"/>.</summary>
+        public static FilterDefinitionBuilder<TDocument> Filter { get; } = new FilterDefinitionBuilder<TDocument>();
+
+        /// <summary>Gets an <see cref="IndexKeysDefinitionBuilder{TDocument}"/>.</summary>
+        public static IndexKeysDefinitionBuilder<TDocument> IndexKeys { get; } = new IndexKeysDefinitionBuilder<TDocument>();
+
+        /// <summary>Gets a <see cref="ProjectionDefinitionBuilder{TDocument}"/>.</summary>
+        public static ProjectionDefinitionBuilder<TDocument> Projection { get; } = new ProjectionDefinitionBuilder<TDocument>();
 
-        /// <summary>
-        /// Gets a <see cref="FilterDefinitionBuilder{TDocument}"/>.
-        /// </summary>
-        public static FilterDefinitionBuilder<TDocument> Filter
-        {
-            get { return __filter; }
-        }
+        /// <summary>Gets a <see cref="SortDefinitionBuilder{TDocument}"/>.</summary>
+        public static SortDefinitionBuilder<TDocument> Sort { get; } = new SortDefinitionBuilder<TDocument>();
 
-        /// <summary>
-        /// Gets an <see cref="IndexKeysDefinitionBuilder{TDocument}"/>.
-        /// </summary>
-        public static IndexKeysDefinitionBuilder<TDocument> IndexKeys
-        {
-            get { return __index; }
-        }
+        /// <summary>Gets an <see cref="UpdateDefinitionBuilder{TDocument}"/>.</summary>
+        public static UpdateDefinitionBuilder<TDocument> Update { get; } = new UpdateDefinitionBuilder<TDocument>();
 
-        /// <summary>
-        /// Gets a <see cref="ProjectionDefinitionBuilder{TDocument}"/>.
-        /// </summary>
-        public static ProjectionDefinitionBuilder<TDocument> Projection
-        {
-            get { return __projection; }
-        }
+        // Search builders
+        /// <summary>Gets a <see cref="PathDefinition{TDocument}"/>.</summary>
+        public static PathDefinitionBuilder<TDocument> Path { get; } = new PathDefinitionBuilder<TDocument>();
 
-        /// <summary>
-        /// Gets a <see cref="SortDefinitionBuilder{TDocument}"/>.
-        /// </summary>
-        public static SortDefinitionBuilder<TDocument> Sort
-        {
-            get { return __sort; }
-        }
+        /// <summary>Gets a <see cref="ScoreDefinitionBuilder{TDocument}"/>.</summary>
+        public static ScoreDefinitionBuilder<TDocument> Score { get; } = new ScoreDefinitionBuilder<TDocument>();
 
-        /// <summary>
-        /// Gets an <see cref="UpdateDefinitionBuilder{TDocument}"/>.
-        /// </summary>
-        public static UpdateDefinitionBuilder<TDocument> Update
-        {
-            get { return __update; }
-        }
+        /// <summary>Gets a <see cref="SearchDefinitionBuilder{TDocument}"/>.</summary>
+        public static SearchDefinitionBuilder<TDocument> Search { get; } = new SearchDefinitionBuilder<TDocument>();
     }
 }
diff --git a/src/MongoDB.Driver/IAggregateFluent.cs b/src/MongoDB.Driver/IAggregateFluent.cs
index 703dba4956d..7ba11536235 100644
--- a/src/MongoDB.Driver/IAggregateFluent.cs
+++ b/src/MongoDB.Driver/IAggregateFluent.cs
@@ -19,6 +19,7 @@
 using System.Threading.Tasks;
 using MongoDB.Bson;
 using MongoDB.Bson.Serialization;
+using MongoDB.Driver.Search;
 
 namespace MongoDB.Driver
 {
@@ -353,6 +354,25 @@ IAggregateFluent<TNewResult> Lookup<TForeignDocument, TAsElement, TAs, TNewResul
         IAggregateFluent<BsonDocument> SetWindowFields<TWindowFields>(
             AggregateExpressionDefinition<ISetWindowFieldsPartition<TResult>, TWindowFields> output);
 
+        /// <summary>
+        /// Appends a $search stage to the pipeline.
+        /// </summary>
+        /// <param name="query">The search definition.</param>
+        /// <param name="highlight">The highlight options.</param>
+        /// <param name="indexName">The index name.</param>
+        /// <param name="count">The count options.</param>
+        /// <param name="returnStoredSource">
+        /// Flag that specifies whether to perform a full document lookup on the backend database
+        /// or return only stored source fields directly from Atlas Search.
+        /// </param>
+        /// <returns>The fluent aggregate interface.</returns>
+        IAggregateFluent<TResult> Search(
+            SearchDefinition<TResult> query,
+            HighlightOptions<TResult> highlight = null,
+            string indexName = null,
+            SearchCountOptions count = null,
+            bool returnStoredSource = false);
+
         /// <summary>
         /// Appends a $setWindowFields to the pipeline.
         /// </summary>
diff --git a/src/MongoDB.Driver/Linq/MongoQueryable.cs b/src/MongoDB.Driver/Linq/MongoQueryable.cs
index 3e3af9519e4..b1937521c15 100644
--- a/src/MongoDB.Driver/Linq/MongoQueryable.cs
+++ b/src/MongoDB.Driver/Linq/MongoQueryable.cs
@@ -21,6 +21,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using MongoDB.Bson.Serialization;
+using MongoDB.Driver.Search;
 
 namespace MongoDB.Driver.Linq
 {
@@ -923,6 +924,33 @@ public static IMongoQueryable<TSource> Sample<TSource>(this IMongoQueryable<TSou
                     Expression.Constant(count)));
         }
 
+        /// <summary>
+        /// Appends a $search stage to the LINQ pipeline
+        /// </summary>
+        /// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
+        /// <param name="source">A sequence of values.</param>
+        /// <param name="searchDefinition">The search definition.</param>
+        /// <param name="highlight">The highlight options.</param>
+        /// <param name="indexName">The index name.</param>
+        /// <param name="count">The count options.</param>
+        /// <param name="returnStoredSource">
+        /// Flag that specifies whether to perform a full document lookup on the backend database
+        /// or return only stored source fields directly from Atlas Search.
+        /// </param>
+        /// <returns>The fluent aggregate interface.</returns>
+        public static IMongoQueryable<TSource> Search<TSource>(
+            this IMongoQueryable<TSource> source,
+            SearchDefinition<TSource> searchDefinition,
+            HighlightOptions<TSource> highlight = null,
+            string indexName = null,
+            SearchCountOptions count = null,
+            bool returnStoredSource = false)
+        {
+            return AppendStage(
+                source,
+                PipelineStageDefinitionBuilder.Search(searchDefinition, highlight, indexName, count, returnStoredSource));
+        }
+
         /// <summary>
         /// Projects each element of a sequence into a new form by incorporating the
         /// element's index.
diff --git a/src/MongoDB.Driver/MongoUtils.cs b/src/MongoDB.Driver/MongoUtils.cs
index 60cff0bcb9a..43717b4dfc9 100644
--- a/src/MongoDB.Driver/MongoUtils.cs
+++ b/src/MongoDB.Driver/MongoUtils.cs
@@ -14,8 +14,6 @@
 */
 
 using System;
-using System.Runtime.InteropServices;
-using System.Security;
 using System.Security.Cryptography;
 using System.Text;
 using MongoDB.Bson;
@@ -61,5 +59,8 @@ public static string ToCamelCase(string value)
         {
             return value.Length == 0 ? "" : value.Substring(0, 1).ToLower() + value.Substring(1);
         }
+
+        internal static string ToCamelCase<TEnum>(this TEnum @enum) where TEnum : Enum =>
+           ToCamelCase(@enum.ToString());
     }
 }
diff --git a/src/MongoDB.Driver/PipelineDefinitionBuilder.cs b/src/MongoDB.Driver/PipelineDefinitionBuilder.cs
index 7ece8ab2363..c4ecef2b701 100644
--- a/src/MongoDB.Driver/PipelineDefinitionBuilder.cs
+++ b/src/MongoDB.Driver/PipelineDefinitionBuilder.cs
@@ -21,6 +21,7 @@
 using MongoDB.Bson.Serialization;
 using MongoDB.Driver.Core.Misc;
 using MongoDB.Driver.Linq;
+using MongoDB.Driver.Search;
 
 namespace MongoDB.Driver
 {
@@ -1162,6 +1163,35 @@ public static PipelineDefinition<TInput, TOutput> ReplaceWith<TInput, TIntermedi
             return pipeline.AppendStage(PipelineStageDefinitionBuilder.ReplaceWith(newRoot, translationOptions));
         }
 
+        /// <summary>
+        /// Appends a $search stage to the pipeline.
+        /// </summary>
+        /// <typeparam name="TInput">The type of the input documents.</typeparam>
+        /// <typeparam name="TOutput">The type of the output documents.</typeparam>
+        /// <param name="pipeline">The pipeline.</param>
+        /// <param name="searchDefinition">The search definition.</param>
+        /// <param name="highlight">The highlight options.</param>
+        /// <param name="indexName">The index name.</param>
+        /// <param name="count">The count options.</param>
+        /// <param name="returnStoredSource">
+        /// Flag that specifies whether to perform a full document lookup on the backend database
+        /// or return only stored source fields directly from Atlas Search.
+        /// </param>
+        /// <returns>
+        /// A new pipeline with an additional stage.
+        /// </returns>
+        public static PipelineDefinition<TInput, TOutput> Search<TInput, TOutput>(
+            this PipelineDefinition<TInput, TOutput> pipeline,
+            SearchDefinition<TOutput> searchDefinition,
+            HighlightOptions<TOutput> highlight = null,
+            string indexName = null,
+            SearchCountOptions count = null,
+            bool returnStoredSource = false)
+        {
+            Ensure.IsNotNull(pipeline, nameof(pipeline));
+            return pipeline.AppendStage(PipelineStageDefinitionBuilder.Search(searchDefinition, highlight, indexName, count, returnStoredSource));
+        }
+
         /// <summary>
         /// Create a $setWindowFields stage.
         /// </summary>
diff --git a/src/MongoDB.Driver/PipelineStageDefinitionBuilder.cs b/src/MongoDB.Driver/PipelineStageDefinitionBuilder.cs
index 4ef2c53d80a..78477da9fa6 100644
--- a/src/MongoDB.Driver/PipelineStageDefinitionBuilder.cs
+++ b/src/MongoDB.Driver/PipelineStageDefinitionBuilder.cs
@@ -22,9 +22,9 @@
 using MongoDB.Bson.Serialization;
 using MongoDB.Driver.Core.Misc;
 using MongoDB.Driver.Linq;
-using MongoDB.Driver.Linq.Linq3Implementation.Misc;
 using MongoDB.Driver.Linq.Linq3Implementation.Serializers;
 using MongoDB.Driver.Linq.Linq3Implementation.Translators;
+using MongoDB.Driver.Search;
 
 namespace MongoDB.Driver
 {
@@ -1309,6 +1309,46 @@ public static PipelineStageDefinition<TInput, TOutput> Project<TInput, TOutput>(
             return Project(new ProjectExpressionProjection<TInput, TOutput>(projection, translationOptions));
         }
 
+        /// <summary>
+        /// Creates a $search stage.
+        /// </summary>
+        /// <typeparam name="TInput">The type of the input documents.</typeparam>
+        /// <param name="searchDefinition">The search definition.</param>
+        /// <param name="highlight">The highlight options.</param>
+        /// <param name="indexName">The index name.</param>
+        /// <param name="count">The count options.</param>
+        /// <param name="returnStoredSource">
+        /// Flag that specifies whether to perform a full document lookup on the backend database
+        /// or return only stored source fields directly from Atlas Search.
+        /// </param>
+        /// <returns>The stage.</returns>
+        public static PipelineStageDefinition<TInput, TInput> Search<TInput>(
+            SearchDefinition<TInput> searchDefinition,
+            HighlightOptions<TInput> highlight = null,
+            string indexName = null,
+            SearchCountOptions count = null,
+            bool returnStoredSource = false)
+        {
+            Ensure.IsNotNull(searchDefinition, nameof(searchDefinition));
+
+            const string operatorName = "$search";
+            var stage = new DelegatedPipelineStageDefinition<TInput, TInput>(
+                operatorName,
+                (s, sr, linqProvider) =>
+                {
+                    var renderedSearchDefinition = searchDefinition.Render(s, sr);
+                    renderedSearchDefinition.Add("highlight", () => highlight.Render(s, sr), highlight != null);
+                    renderedSearchDefinition.Add("count", () => count.Render(), count != null);
+                    renderedSearchDefinition.Add("index", indexName, indexName != null);
+                    renderedSearchDefinition.Add("returnStoredSource", returnStoredSource, returnStoredSource);
+
+                    var document = new BsonDocument(operatorName, renderedSearchDefinition);
+                    return new RenderedPipelineStageDefinition<TInput>(operatorName, document, s);
+                });
+
+            return stage;
+        }
+
         /// <summary>
         /// Creates a $replaceRoot stage.
         /// </summary>
diff --git a/src/MongoDB.Driver/Search/FuzzyOptions.cs b/src/MongoDB.Driver/Search/FuzzyOptions.cs
new file mode 100644
index 00000000000..1ad9456dade
--- /dev/null
+++ b/src/MongoDB.Driver/Search/FuzzyOptions.cs
@@ -0,0 +1,66 @@
+// 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.
+
+using MongoDB.Bson;
+using MongoDB.Driver.Core.Misc;
+
+namespace MongoDB.Driver.Search
+{
+    /// <summary>
+    /// Options for fuzzy search.
+    /// </summary>
+    public sealed class FuzzyOptions
+    {
+        private int? _maxEdits;
+        private int? _prefixLength;
+        private int? _maxExpansions;
+
+        /// <summary>
+        /// Gets or sets the maximum number of single-character edits required to match the
+        /// specified search term.
+        /// </summary>
+        public int? MaxEdits
+        {
+            get => _maxEdits;
+            set => _maxEdits = Ensure.IsNullOrBetween(value, 1, 2, nameof(value));
+        }
+
+        /// <summary>
+        /// Gets or sets the number of characters at the beginning of each term in the result that
+        /// must exactly match.
+        /// </summary>
+        public int? PrefixLength
+        {
+            get => _prefixLength;
+            set => _prefixLength = Ensure.IsNullOrGreaterThanOrEqualToZero(value, nameof(value));
+        }
+
+        /// <summary>
+        /// Gets or sets the number of variations to generate and search for.
+        /// </summary>
+        public int? MaxExpansions
+        {
+            get => _maxExpansions;
+            set => _maxExpansions = Ensure.IsNullOrGreaterThanZero(value, nameof(value));
+        }
+
+        internal BsonDocument Render()
+            => new()
+            {
+                { "maxEdits", _maxEdits, _maxEdits != null },
+                { "prefixLength", _prefixLength, _prefixLength != null },
+                { "maxExpansions", _maxExpansions, _maxExpansions != null }
+            };
+    }
+}
diff --git a/src/MongoDB.Driver/Search/HighlightOptions.cs b/src/MongoDB.Driver/Search/HighlightOptions.cs
new file mode 100644
index 00000000000..1eb3b2e81b2
--- /dev/null
+++ b/src/MongoDB.Driver/Search/HighlightOptions.cs
@@ -0,0 +1,74 @@
+// 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.
+
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization;
+using MongoDB.Driver.Core.Misc;
+
+namespace MongoDB.Driver.Search
+{
+    /// <summary>
+    /// Options for highlighting.
+    /// </summary>
+    /// <typeparam name="TDocument">The type of the document.</typeparam>
+    public sealed class HighlightOptions<TDocument>
+    {
+        private PathDefinition<TDocument> _path;
+        private int? _maxCharsToExamine;
+        private int? _maxNumPassages;
+
+        /// <summary>
+        /// Gets or sets the document field to search.
+        /// </summary>
+        public PathDefinition<TDocument> Path
+        {
+            get => _path;
+            set => _path = Ensure.IsNotNull(value, nameof(value));
+        }
+
+        /// <summary>
+        /// Gets or sets the maximum number of characters to examine on a document when performing
+        /// highlighting for a field.
+        /// </summary>
+        public int? MaxCharsToExamine
+        {
+            get => _maxCharsToExamine;
+            set => _maxCharsToExamine = Ensure.IsNullOrGreaterThanZero(value, nameof(value));
+        }
+
+        /// <summary>
+        /// Gets or sets the number of high-scoring passages to return per document in the
+        /// highlighting results for each field.
+        /// </summary>
+        public int? MaxNumPassages
+        {
+            get => _maxNumPassages;
+            set => _maxNumPassages = Ensure.IsNullOrGreaterThanZero(value, nameof(value));
+        }
+
+        /// <summary>
+        /// Renders the options to a <see cref="BsonDocument"/>.
+        /// </summary>
+        /// <param name="documentSerializer">The document serializer.</param>
+        /// <param name="serializerRegistry">The serializer registry.</param>
+        /// <returns>A <see cref="BsonDocument"/>.</returns>
+        public BsonDocument Render(IBsonSerializer<TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry)
+            => new()
+            {
+                { "path", _path.Render(documentSerializer, serializerRegistry) },
+                { "maxCharsToExamine", _maxCharsToExamine, _maxCharsToExamine != null},
+                { "maxNumPassages", _maxNumPassages, _maxNumPassages != null }
+            };
+    }
+}
diff --git a/src/MongoDB.Driver/Search/HighlightOptionsBuilder.cs b/src/MongoDB.Driver/Search/HighlightOptionsBuilder.cs
new file mode 100644
index 00000000000..4005a5a2945
--- /dev/null
+++ b/src/MongoDB.Driver/Search/HighlightOptionsBuilder.cs
@@ -0,0 +1,70 @@
+// 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.
+
+using System;
+using System.Linq.Expressions;
+
+namespace MongoDB.Driver.Search
+{
+    /// <summary>
+    /// A build for highlighting options.
+    /// </summary>
+    /// <typeparam name="TDocument">The type of the document.</typeparam>
+    public sealed class HighlightOptionsBuilder<TDocument>
+    {
+        /// <summary>
+        /// Creates highlighting options.
+        /// </summary>
+        /// <param name="path">The document field to search.</param>
+        /// <param name="maxCharsToExamine">
+        /// The maximum number of characters to examine on a document when performing highlighting
+        /// for a field.
+        /// </param>
+        /// <param name="maxNumPassages">
+        /// The number of high-scoring passages to return per document in the highlighting results
+        /// for each field.
+        /// </param>
+        /// <returns>Highlighting options.</returns>
+        public HighlightOptions<TDocument> Options(
+            PathDefinition<TDocument> path,
+            int? maxCharsToExamine = null,
+            int? maxNumPassages = null)
+            => new()
+            {
+                Path = path,
+                MaxCharsToExamine = maxCharsToExamine,
+                MaxNumPassages = maxNumPassages
+            };
+
+        /// <summary>
+        /// Creates highlighting options.
+        /// </summary>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="path">The document field to search.</param>
+        /// <param name="maxCharsToExamine">
+        /// The maximum number of characters to examine on a document when performing highlighting
+        /// for a field.
+        /// </param>
+        /// <param name="maxNumPassages">
+        /// The number of high-scoring passages to return per document in the highlighting results
+        /// for each field.
+        /// </param>
+        /// <returns>Highlighting options.</returns>
+        public HighlightOptions<TDocument> Options<TField>(
+            Expression<Func<TDocument, TField>> path,
+            int? maxCharsToExamine = null,
+            int? maxNumPassages = null) =>
+            Options(new ExpressionFieldDefinition<TDocument>(path), maxCharsToExamine, maxNumPassages);
+    }
+}
diff --git a/src/MongoDB.Driver/Search/PathDefinition.cs b/src/MongoDB.Driver/Search/PathDefinition.cs
new file mode 100644
index 00000000000..80d138de38c
--- /dev/null
+++ b/src/MongoDB.Driver/Search/PathDefinition.cs
@@ -0,0 +1,90 @@
+// 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.
+
+using System.Collections.Generic;
+using System.Linq;
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization;
+
+namespace MongoDB.Driver.Search
+{
+    /// <summary>
+    /// Base class for search paths.
+    /// </summary>
+    /// <typeparam name="TDocument">The type of the document.</typeparam>
+    public abstract class PathDefinition<TDocument>
+    {
+        /// <summary>
+        /// Renders the path to a <see cref="BsonValue"/>.
+        /// </summary>
+        /// <param name="documentSerializer">The document serializer.</param>
+        /// <param name="serializerRegistry">The serializer registry.</param>
+        /// <returns>A <see cref="BsonValue"/>.</returns>
+        public abstract BsonValue Render(IBsonSerializer<TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry);
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="FieldDefinition{TDocument}"/> to
+        /// <see cref="PathDefinition{TDocument}"/>.
+        /// </summary>
+        /// <param name="field">The field.</param>
+        /// <returns>
+        /// The result of the conversion.
+        /// </returns>
+        public static implicit operator PathDefinition<TDocument>(FieldDefinition<TDocument> field) =>
+            new SinglePathDefinition<TDocument>(field);
+
+        /// <summary>
+        /// Performs an implicit conversion from a field name to <see cref="PathDefinition{TDocument}"/>.
+        /// </summary>
+        /// <param name="fieldName">The field name.</param>
+        /// <returns>
+        /// The result of the conversion.
+        /// </returns>
+        public static implicit operator PathDefinition<TDocument>(string fieldName) =>
+            new SinglePathDefinition<TDocument>(new StringFieldDefinition<TDocument>(fieldName));
+
+        /// <summary>
+        /// Performs an implicit conversion from an array of <see cref="FieldDefinition{TDocument}"/> to
+        /// <see cref="PathDefinition{TDocument}"/>.
+        /// </summary>
+        /// <param name="fields">The array of fields.</param>
+        /// <returns>
+        /// The result of the conversion.
+        /// </returns>
+        public static implicit operator PathDefinition<TDocument>(FieldDefinition<TDocument>[] fields) =>
+            new MultiPathDefinition<TDocument>(fields);
+
+        /// <summary>
+        /// Performs an implicit conversion from a list of <see cref="FieldDefinition{TDocument}"/> to
+        /// <see cref="PathDefinition{TDocument}"/>.
+        /// </summary>
+        /// <param name="fields">The list of fields.</param>
+        /// <returns>
+        /// The result of the conversion.
+        /// </returns>
+        public static implicit operator PathDefinition<TDocument>(List<FieldDefinition<TDocument>> fields) =>
+            new MultiPathDefinition<TDocument>(fields);
+
+        /// <summary>
+        /// Performs an implicit conversion from an array of field names to 
+        /// <see cref="PathDefinition{TDocument}"/>.
+        /// </summary>
+        /// <param name="fieldNames">The array of field names.</param>
+        /// <returns>
+        /// The result of the conversion.
+        /// </returns>
+        public static implicit operator PathDefinition<TDocument>(string[] fieldNames) =>
+            new MultiPathDefinition<TDocument>(fieldNames.Select(fieldName => new StringFieldDefinition<TDocument>(fieldName)));
+    }
+}
diff --git a/src/MongoDB.Driver/Search/PathDefinitionBuilder.cs b/src/MongoDB.Driver/Search/PathDefinitionBuilder.cs
new file mode 100644
index 00000000000..437d0f8c6e9
--- /dev/null
+++ b/src/MongoDB.Driver/Search/PathDefinitionBuilder.cs
@@ -0,0 +1,165 @@
+// 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.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization;
+using MongoDB.Driver.Core.Misc;
+
+namespace MongoDB.Driver.Search
+{
+    /// <summary>
+    /// A builder for a search path.
+    /// </summary>
+    /// <typeparam name="TDocument">The type of the document.</typeparam>
+    public sealed class PathDefinitionBuilder<TDocument>
+    {
+        /// <summary>
+        /// Creates a search path for a single field.
+        /// </summary>
+        /// <param name="field">The field definition.</param>
+        /// <returns>A single-field search path.</returns>
+        public PathDefinition<TDocument> Single(FieldDefinition<TDocument> field) =>
+            new SinglePathDefinition<TDocument>(field);
+
+        /// <summary>
+        /// Creates a search path for a single field.
+        /// </summary>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="field">The field definition.</param>
+        /// <returns>A single-field search path.</returns>
+        public PathDefinition<TDocument> Single<TField>(Expression<Func<TDocument, TField>> field) =>
+            Single(new ExpressionFieldDefinition<TDocument>(field));
+
+        /// <summary>
+        /// Creates a search path for multiple fields.
+        /// </summary>
+        /// <param name="fields">The collection of field definitions.</param>
+        /// <returns>A multi-field search path.</returns>
+        public PathDefinition<TDocument> Multi(IEnumerable<FieldDefinition<TDocument>> fields) =>
+            new MultiPathDefinition<TDocument>(fields);
+
+        /// <summary>
+        /// Creates a search path for multiple fields.
+        /// </summary>
+        /// <param name="fields">The array of field definitions.</param>
+        /// <returns>A multi-field search path.</returns>
+        public PathDefinition<TDocument> Multi(params FieldDefinition<TDocument>[] fields) =>
+            Multi((IEnumerable<FieldDefinition<TDocument>>)fields);
+
+        /// <summary>
+        /// Creates a search path for multiple fields.
+        /// </summary>
+        /// <typeparam name="TField">The type of the fields.</typeparam>
+        /// <param name="fields">The array of field definitions.</param>
+        /// <returns>A multi-field search path.</returns>
+        public PathDefinition<TDocument> Multi<TField>(params Expression<Func<TDocument, TField>>[] fields) =>
+            Multi(fields.Select(x => new ExpressionFieldDefinition<TDocument>(x)));
+
+        /// <summary>
+        /// Creates a search path that searches using the specified analyzer.
+        /// </summary>
+        /// <param name="field">The field definition</param>
+        /// <param name="analyzerName">The name of the analyzer.</param>
+        /// <returns>An analyzer search path.</returns>
+        public PathDefinition<TDocument> Analyzer(FieldDefinition<TDocument> field, string analyzerName) =>
+            new AnalyzerPathDefinition<TDocument>(field, analyzerName);
+
+        /// <summary>
+        /// Creates a search path that searches using the specified analyzer.
+        /// </summary>
+        /// <typeparam name="TField">The type of the field.</typeparam>
+        /// <param name="field">The field definition</param>
+        /// <param name="analyzerName">The name of the analyzer.</param>
+        /// <returns>An analyzer search path.</returns>
+        public PathDefinition<TDocument> Analyzer<TField>(Expression<Func<TDocument, TField>> field, string analyzerName) =>
+            Analyzer(new ExpressionFieldDefinition<TDocument>(field), analyzerName);
+
+        /// <summary>
+        /// Creates a search path that uses special characters in the field name
+        /// that can match any character.
+        /// </summary>
+        /// <param name="query">
+        /// The wildcard string that the field name must match.
+        /// </param>
+        /// <returns>A wildcard search path.</returns>
+        public PathDefinition<TDocument> Wildcard(string query) =>
+            new WildcardPathDefinition<TDocument>(query);
+    }
+
+    internal sealed class SinglePathDefinition<TDocument> : PathDefinition<TDocument>
+    {
+        private readonly FieldDefinition<TDocument> _field;
+
+        public SinglePathDefinition(FieldDefinition<TDocument> field)
+        {
+            _field = Ensure.IsNotNull(field, nameof(field));
+        }
+
+        public override BsonValue Render(IBsonSerializer<TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry)
+        {
+            var renderedField = _field.Render(documentSerializer, serializerRegistry);
+            return new BsonString(renderedField.FieldName);
+        }
+    }
+
+    internal sealed class MultiPathDefinition<TDocument> : PathDefinition<TDocument>
+    {
+        private readonly IEnumerable<FieldDefinition<TDocument>> _fields;
+
+        public MultiPathDefinition(IEnumerable<FieldDefinition<TDocument>> fields)
+        {
+            _fields = Ensure.IsNotNull(fields, nameof(fields));
+        }
+
+        public override BsonValue Render(IBsonSerializer<TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry) =>
+            new BsonArray(_fields.Select(field => field.Render(documentSerializer, serializerRegistry).FieldName));
+    }
+
+    internal sealed class AnalyzerPathDefinition<TDocument> : PathDefinition<TDocument>
+    {
+        private readonly FieldDefinition<TDocument> _field;
+        private readonly string _analyzerName;
+
+        public AnalyzerPathDefinition(FieldDefinition<TDocument> field, string analyzerName)
+        {
+            _field = Ensure.IsNotNull(field, nameof(field));
+            _analyzerName = Ensure.IsNotNull(analyzerName, nameof(analyzerName));
+        }
+
+        public override BsonValue Render(IBsonSerializer<TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry) => new BsonDocument()
+        {
+            {  "value", _field.Render(documentSerializer, serializerRegistry).FieldName },
+            {  "multi", _analyzerName }
+        };
+    }
+
+    internal sealed class WildcardPathDefinition<TDocument> : PathDefinition<TDocument>
+    {
+        private readonly string _query;
+
+        public WildcardPathDefinition(string query)
+        {
+            _query = Ensure.IsNotNull(query, nameof(query));
+        }
+
+        public override BsonValue Render(IBsonSerializer<TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry) => new BsonDocument()
+        {
+            { "wildcard", _query }
+        };
+    }
+}
diff --git a/src/MongoDB.Driver/Search/QueryDefinition.cs b/src/MongoDB.Driver/Search/QueryDefinition.cs
new file mode 100644
index 00000000000..d8a92bbd011
--- /dev/null
+++ b/src/MongoDB.Driver/Search/QueryDefinition.cs
@@ -0,0 +1,102 @@
+// 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.
+
+using System.Collections.Generic;
+using MongoDB.Bson;
+using MongoDB.Driver.Core.Misc;
+
+namespace MongoDB.Driver.Search
+{
+    /// <summary>
+    /// Base class for search queries.
+    /// </summary>
+    public abstract class QueryDefinition
+    {
+        /// <summary>
+        /// Renders the query to a <see cref="BsonValue"/>.
+        /// </summary>
+        /// <returns>A <see cref="BsonValue"/>.</returns>
+        public abstract BsonValue Render();
+
+        /// <summary>
+        /// Performs an implicit conversion from a string to <see cref="QueryDefinition"/>.
+        /// </summary>
+        /// <param name="query">The string.</param>
+        /// <returns>
+        /// The result of the conversion.
+        /// </returns>
+        public static implicit operator QueryDefinition(string query) =>
+            new SingleQueryDefinition(query);
+
+        /// <summary>
+        /// Performs an implicit conversion from an array of strings to <see cref="QueryDefinition"/>.
+        /// </summary>
+        /// <param name="queries">The array of strings.</param>
+        /// <returns>
+        /// The result of the conversion.
+        /// </returns>
+        public static implicit operator QueryDefinition(string[] queries) =>
+            new MultiQueryDefinition(queries);
+
+        /// <summary>
+        /// Performs an implicit conversion from a list of strings to <see cref="QueryDefinition"/>.
+        /// </summary>
+        /// <param name="queries">The list of strings.</param>
+        /// <returns>
+        /// The result of the conversion.
+        /// </returns>
+        public static implicit operator QueryDefinition(List<string> queries) =>
+            new MultiQueryDefinition(queries);
+    }
+
+    /// <summary>
+    /// A query definition for a single string.
+    /// </summary>
+    public sealed class SingleQueryDefinition : QueryDefinition
+    {
+        private readonly string _query;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SinglePathDefinition{TDocument}"/> class.
+        /// </summary>
+        /// <param name="query">The query string.</param>
+        public SingleQueryDefinition(string query)
+        {
+            _query = Ensure.IsNotNull(query, nameof(query));
+        }
+
+        /// <inheritdoc />
+        public override BsonValue Render() => new BsonString(_query);
+    }
+
+    /// <summary>
+    /// A query definition for multiple strings.
+    /// </summary>
+    public sealed class MultiQueryDefinition : QueryDefinition
+    {
+        private readonly IEnumerable<string> _queries;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MultiPathDefinition{TDocument}"/> class.
+        /// </summary>
+        /// <param name="queries">The query strings.</param>
+        public MultiQueryDefinition(IEnumerable<string> queries)
+        {
+            _queries = Ensure.IsNotNull(queries, nameof(queries));
+        }
+
+        /// <inheritdoc/>
+        public override BsonValue Render() => new BsonArray(_queries);
+    }
+}
diff --git a/src/MongoDB.Driver/Search/ScoreDefinition.cs b/src/MongoDB.Driver/Search/ScoreDefinition.cs
new file mode 100644
index 00000000000..78bc649b0bf
--- /dev/null
+++ b/src/MongoDB.Driver/Search/ScoreDefinition.cs
@@ -0,0 +1,34 @@
+// 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.
+
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization;
+
+namespace MongoDB.Driver.Search
+{
+    /// <summary>
+    /// Base class for search score modifiers.
+    /// </summary>
+    /// <typeparam name="TDocument">The type of the document.</typeparam>
+    public abstract class ScoreDefinition<TDocument>
+    {
+        /// <summary>
+        /// Renders the score modifier to a <see cref="BsonDocument"/>.
+        /// </summary>
+        /// <param name="documentSerializer">The document serializer.</param>
+        /// <param name="serializerRegistry">The serializer registry.</param>
+        /// <returns>A <see cref="BsonDocument"/>.</returns>
+        public abstract BsonDocument Render(IBsonSerializer<TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry);
+    }
+}
diff --git a/src/MongoDB.Driver/Search/ScoreDefinitionBuilder.cs b/src/MongoDB.Driver/Search/ScoreDefinitionBuilder.cs
new file mode 100644
index 00000000000..c4f3190533b
--- /dev/null
+++ b/src/MongoDB.Driver/Search/ScoreDefinitionBuilder.cs
@@ -0,0 +1,134 @@
+// 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.
+
+using System;
+using System.Linq.Expressions;
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization;
+using MongoDB.Driver.Core.Misc;
+
+namespace MongoDB.Driver.Search
+{
+    /// <summary>
+    /// A builder for a score modifier.
+    /// </summary>
+    /// <typeparam name="TDocument">The type of the document.</typeparam>
+    public sealed class ScoreDefinitionBuilder<TDocument>
+    {
+        /// <summary>
+        /// Creates a score modifier that multiplies a result's base score by a given number.
+        /// </summary>
+        /// <param name="value">The number to multiply the default base score by.</param>
+        /// <returns>
+        /// A boost score modifier.
+        /// </returns>
+        public ScoreDefinition<TDocument> Boost(double value) => new BoostValueScoreDefinition<TDocument>(value);
+
+        /// <summary>
+        /// Creates a score modifier that multiples a result's base score by the value of a numeric
+        /// field in the documents.
+        /// </summary>
+        /// <param name="path">
+        /// The path to the numeric field whose value to multiply the default base score by.
+        /// </param>
+        /// <param name="undefined">
+        /// The numeric value to substitute if the numeric field is not found in the documents.
+        /// </param>
+        /// <returns>
+        /// A boost score modifier.
+        /// </returns>
+        public ScoreDefinition<TDocument> Boost(PathDefinition<TDocument> path, double undefined = 0) =>
+            new BoostPathScoreDefinition<TDocument>(path, undefined);
+
+        /// <summary>
+        /// Creates a score modifier that multiplies a result's base score by the value of a numeric
+        /// field in the documents.
+        /// </summary>
+        /// <param name="path">
+        /// The path to the numeric field whose value to multiply the default base score by.
+        /// </param>
+        /// <param name="undefined">
+        /// The numeric value to substitute if the numeric field is not found in the documents.
+        /// </param>
+        /// <returns>
+        /// A boost score modifier.
+        /// </returns>
+        public ScoreDefinition<TDocument> Boost(Expression<Func<TDocument, double>> path, double undefined = 0) =>
+            Boost(new ExpressionFieldDefinition<TDocument>(path), undefined);
+
+        /// <summary>
+        /// Creates a score modifier that replaces the base score with a given number.
+        /// </summary>
+        /// <param name="value">The number to replace the base score with.</param>
+        /// <returns>
+        /// A constant score modifier.
+        /// </returns>
+        public ScoreDefinition<TDocument> Constant(double value) =>
+            new ConstantScoreDefinition<TDocument>(value);
+    }
+
+    internal class BoostValueScoreDefinition<TDocument> : ScoreDefinition<TDocument>
+    {
+        private readonly double _value;
+
+        public BoostValueScoreDefinition(double value)
+        {
+            _value = Ensure.IsGreaterThanZero(value, nameof(value));
+        }
+
+        public override BsonDocument Render(IBsonSerializer<TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry)
+            => new()
+            {
+                { "boost",  new BsonDocument("value", _value) }
+            };
+    }
+
+    internal class BoostPathScoreDefinition<TDocument> : ScoreDefinition<TDocument>
+    {
+        private readonly PathDefinition<TDocument> _path;
+        private readonly double _undefined;
+
+        public BoostPathScoreDefinition(PathDefinition<TDocument> path, double undefined)
+        {
+            _path = Ensure.IsNotNull(path, nameof(path));
+            _undefined = undefined;
+        }
+
+        public override BsonDocument Render(IBsonSerializer<TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry)
+        {
+            var document = new BsonDocument()
+            {
+                { "path", _path.Render(documentSerializer, serializerRegistry) },
+                { "undefined", _undefined, _undefined != 0 }
+            };
+
+            return new("boost", document);
+        }
+    }
+    
+    internal sealed class ConstantScoreDefinition<TDocument> : ScoreDefinition<TDocument>
+    {
+        private readonly double _value;
+
+        public ConstantScoreDefinition(double value)
+        {
+            _value = Ensure.IsGreaterThanZero(value, nameof(value));
+        }
+
+        public override BsonDocument Render(IBsonSerializer<TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry) => new()
+        {
+            { "constant", new BsonDocument("value", _value) }
+        };
+    }
+}
diff --git a/src/MongoDB.Driver/Search/SearchCountOptions.cs b/src/MongoDB.Driver/Search/SearchCountOptions.cs
new file mode 100644
index 00000000000..7f26fef5c8c
--- /dev/null
+++ b/src/MongoDB.Driver/Search/SearchCountOptions.cs
@@ -0,0 +1,54 @@
+// 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.
+
+using MongoDB.Bson;
+using MongoDB.Driver.Core.Misc;
+
+namespace MongoDB.Driver.Search
+{
+    /// <summary>
+    /// Options for counting the search results.
+    /// </summary>
+    public class SearchCountOptions
+    {
+        private SearchCountType _type = SearchCountType.LowerBound;
+        private int? _threshold;
+
+        /// <summary>
+        /// Gets or sets the type of count of the documents in the result set.
+        /// </summary>
+        public SearchCountType Type
+        {
+            get => _type;
+            set => _type = value;
+        }
+
+        /// <summary>
+        /// Gets or sets the number of documents to include in the exact count if
+        /// <see cref="Type"/> is <see cref="SearchCountType.LowerBound"/>.
+        /// </summary>
+        public int? Threshold
+        {
+            get => _threshold;
+            set => _threshold = Ensure.IsNullOrGreaterThanZero(value, nameof(value));
+        }
+
+        internal BsonDocument Render()
+            => new()
+            {
+                { "type", _type.ToCamelCase(), _type != SearchCountType.LowerBound },
+                { "threshold", _threshold, _threshold != null }
+            };
+    }
+}
diff --git a/src/MongoDB.Driver/Search/SearchCountType.cs b/src/MongoDB.Driver/Search/SearchCountType.cs
new file mode 100644
index 00000000000..4dfac693a98
--- /dev/null
+++ b/src/MongoDB.Driver/Search/SearchCountType.cs
@@ -0,0 +1,32 @@
+// Copyright 2021-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>
+    /// The type of count of the documents in a search result set.
+    /// </summary>
+    public enum SearchCountType
+    {
+        /// <summary>
+        /// A lower bound count of the number of documents that match the query.
+        /// </summary>
+        LowerBound,
+
+        /// <summary>
+        /// An exact count of the number of documents that match the query.
+        /// </summary>
+        Total
+    }
+}
diff --git a/src/MongoDB.Driver/Search/SearchDefinition.cs b/src/MongoDB.Driver/Search/SearchDefinition.cs
new file mode 100644
index 00000000000..8b7ec459bf2
--- /dev/null
+++ b/src/MongoDB.Driver/Search/SearchDefinition.cs
@@ -0,0 +1,105 @@
+// 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.
+
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization;
+using MongoDB.Driver.Core.Misc;
+
+namespace MongoDB.Driver.Search
+{
+    /// <summary>
+    /// Base class for search definitions.
+    /// </summary>
+    /// <typeparam name="TDocument">The type of the document.</typeparam>
+    public abstract class SearchDefinition<TDocument>
+    {
+        /// <summary>
+        /// Renders the search definition to a <see cref="BsonDocument"/>.
+        /// </summary>
+        /// <param name="documentSerializer">The document serializer.</param>
+        /// <param name="serializerRegistry">The serializer registry.</param>
+        /// <returns>A <see cref="BsonDocument"/>.</returns>
+        public abstract BsonDocument Render(IBsonSerializer<TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry);
+
+        /// <summary>
+        /// Performs an implicit conversion from a BSON document to a <see cref="SearchDefinition{TDocument}"/>.
+        /// </summary>
+        /// <param name="document">The BSON document specifying the search definition.</param>
+        /// <returns>
+        /// The result of the conversion.
+        /// </returns>
+        public static implicit operator SearchDefinition<TDocument>(BsonDocument document) =>
+            document != null ? new BsonDocumentSearchDefinition<TDocument>(document) : null;
+
+        /// <summary>
+        /// Performs an implicit conversion from a string to a <see cref="SearchDefinition{TDocument}"/>.
+        /// </summary>
+        /// <param name="json">The string specifying the search definition in JSON.</param>
+        /// <returns>
+        /// The result of the conversion.
+        /// </returns>
+        public static implicit operator SearchDefinition<TDocument>(string json) =>
+            json != null ? new JsonSearchDefinition<TDocument>(json) : null;
+    }
+
+    /// <summary>
+    /// A search definition based on a BSON document.
+    /// </summary>
+    /// <typeparam name="TDocument">The type of the document.</typeparam>
+    public sealed class BsonDocumentSearchDefinition<TDocument> : SearchDefinition<TDocument>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BsonDocumentSearchDefinition{TDocument}"/> class.
+        /// </summary>
+        /// <param name="document">The BSON document specifying the search definition.</param>
+        public BsonDocumentSearchDefinition(BsonDocument document)
+        {
+            Document = Ensure.IsNotNull(document, nameof(document));
+        }
+
+        /// <summary>
+        /// Gets the BSON document.
+        /// </summary>
+        public BsonDocument Document { get; private set; }
+
+        /// <inheritdoc />
+        public override BsonDocument Render(IBsonSerializer<TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry) =>
+            Document;
+    }
+
+    /// <summary>
+    /// A search definition based on a JSON string.
+    /// </summary>
+    /// <typeparam name="TDocument">The type of the document.</typeparam>
+    public sealed class JsonSearchDefinition<TDocument> : SearchDefinition<TDocument>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BsonDocumentSearchDefinition{TDocument}"/> class.
+        /// </summary>
+        /// <param name="json">The JSON string specifying the search definition.</param>
+        public JsonSearchDefinition(string json)
+        {
+            Json = Ensure.IsNotNullOrEmpty(json, nameof(json));
+        }
+
+        /// <summary>
+        /// Gets the JSON string.
+        /// </summary>
+        public string Json { get; private set; }
+
+        /// <inheritdoc />
+        public override BsonDocument Render(IBsonSerializer<TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry) =>
+            BsonDocument.Parse(Json);
+    }
+}
diff --git a/src/MongoDB.Driver/Search/SearchDefinitionBuilder.cs b/src/MongoDB.Driver/Search/SearchDefinitionBuilder.cs
new file mode 100644
index 00000000000..14598e090c4
--- /dev/null
+++ b/src/MongoDB.Driver/Search/SearchDefinitionBuilder.cs
@@ -0,0 +1,97 @@
+// 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.
+
+using System;
+using System.Linq.Expressions;
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization;
+using MongoDB.Driver.Core.Misc;
+
+namespace MongoDB.Driver.Search
+{
+    /// <summary>
+    /// A builder for a search definition.
+    /// </summary>
+    /// <typeparam name="TDocument">The type of the document.</typeparam>
+    public sealed class SearchDefinitionBuilder<TDocument>
+    {
+        /// <summary>
+        /// Creates a search definition that performs full-text search using the analyzer specified
+        /// in the index configuration.
+        /// </summary>
+        /// <param name="query">The string or strings to search for.</param>
+        /// <param name="path">The indexed field or fields to search.</param>
+        /// <param name="fuzzy">The options for fuzzy search.</param>
+        /// <param name="score">The score modifier.</param>
+        /// <returns>A text search definition.</returns>
+        public SearchDefinition<TDocument> Text(
+            QueryDefinition query,
+            PathDefinition<TDocument> path,
+            FuzzyOptions fuzzy = null,
+            ScoreDefinition<TDocument> score = null) =>
+            new TextSearchDefinition<TDocument>(query, path, fuzzy, score);
+
+        /// <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="query">The string or strings to search for.</param>
+        /// <param name="path">The indexed field or field to search.</param>
+        /// <param name="fuzzy">The options for fuzzy search.</param>
+        /// <param name="score">The score modifier.</param>
+        /// <returns>A text search definition.</returns>
+        public SearchDefinition<TDocument> Text<TField>(
+            QueryDefinition query,
+            Expression<Func<TDocument, TField>> path,
+            FuzzyOptions fuzzy = null,
+            ScoreDefinition<TDocument> score = null) =>
+            Text(query, new ExpressionFieldDefinition<TDocument>(path), fuzzy, score);
+    }
+
+    internal sealed class TextSearchDefinition<TDocument> : SearchDefinition<TDocument>
+    {
+        private readonly QueryDefinition _query;
+        private readonly PathDefinition<TDocument> _path;
+        private readonly FuzzyOptions _fuzzy;
+        private readonly ScoreDefinition<TDocument> _score;
+
+        public TextSearchDefinition(
+            QueryDefinition query,
+            PathDefinition<TDocument> path,
+            FuzzyOptions fuzzy,
+            ScoreDefinition<TDocument> score)
+        {
+            _query = Ensure.IsNotNull(query, nameof(query));
+            _path = Ensure.IsNotNull(path, nameof(path));
+            _fuzzy = fuzzy;
+            _score = score;
+        }
+
+        public override BsonDocument Render(IBsonSerializer<TDocument> documentSerializer, IBsonSerializerRegistry serializerRegistry)
+            => new()
+            {
+                {
+                    "text",
+                    new BsonDocument()
+                    {
+                        { "query", _query.Render() },
+                        { "path", _path.Render(documentSerializer, serializerRegistry) },
+                        { "fuzzy", () => _fuzzy.Render(), _fuzzy != null },
+                        { "score", () => _score.Render(documentSerializer, serializerRegistry), _score != null }
+                    }
+                }
+            };
+    }
+}
diff --git a/tests/MongoDB.Driver.Tests/Search/SearchDefinitionBuilderTests.cs b/tests/MongoDB.Driver.Tests/Search/SearchDefinitionBuilderTests.cs
new file mode 100644
index 00000000000..a27cd4d125a
--- /dev/null
+++ b/tests/MongoDB.Driver.Tests/Search/SearchDefinitionBuilderTests.cs
@@ -0,0 +1,155 @@
+// Copyright 2021-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.
+
+using System;
+using FluentAssertions;
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization;
+using MongoDB.Bson.Serialization.Attributes;
+using MongoDB.Driver.GeoJsonObjectModel;
+using MongoDB.Driver.Search;
+using Xunit;
+
+namespace MongoDB.Driver.Tests.Search
+{
+    public class SearchDefinitionBuilderTests
+    {
+        [Fact]
+        public void Text()
+        {
+            var subject = CreateSubject<BsonDocument>();
+
+            AssertRendered(subject.Text("foo", "x"),
+                "{ text: { query: 'foo', path: 'x' } }");
+
+            AssertRendered(
+                subject.Text("foo", new[] { "x", "y" }),
+                "{ text: { query: 'foo', path: ['x', 'y'] } }");
+            AssertRendered(
+                subject.Text(new[] { "foo", "bar" }, "x"),
+                "{ text: { query: ['foo', 'bar'], path: 'x' } }");
+            AssertRendered(
+                subject.Text(new[] { "foo", "bar" }, new[] { "x", "y" }),
+                "{ text: { query: ['foo', 'bar'], path: ['x', 'y'] } }");
+
+            AssertRendered(
+                subject.Text("foo", "x", new FuzzyOptions()),
+                "{ text: { query: 'foo', path: 'x', fuzzy: {} } }");
+            AssertRendered(
+                subject.Text("foo", "x", new FuzzyOptions()
+                {
+                    MaxEdits = 1,
+                    PrefixLength = 5,
+                    MaxExpansions = 25
+                }),
+                "{ text: { query: 'foo', path: 'x', fuzzy: { maxEdits: 1, prefixLength: 5, maxExpansions: 25 } } }");
+
+            var scoreBuilder = new ScoreDefinitionBuilder<BsonDocument>();
+            AssertRendered(
+                subject.Text("foo", "x", score: scoreBuilder.Constant(1)),
+                "{ text: { query: 'foo', path: 'x', score: { constant: { value: 1 } } } }");
+        }
+
+        [Fact]
+        public void Text_Typed()
+        {
+            var subject = CreateSubject<Person>();
+
+            AssertRendered(
+                subject.Text("foo", x => x.FirstName),
+                "{ text: { query: 'foo', path: 'fn' } }");
+            AssertRendered(
+                subject.Text("foo", "FirstName"),
+                "{ text: { query: 'foo', path: 'fn' } }");
+
+            AssertRendered(
+                subject.Text(
+                    "foo",
+                    new FieldDefinition<Person>[]
+                    {
+                        new ExpressionFieldDefinition<Person, string>(x => x.FirstName),
+                        new ExpressionFieldDefinition<Person, string>(x => x.LastName)
+                    }),
+                "{ text: { query: 'foo', path: ['fn', 'ln'] } }");
+            AssertRendered(
+                subject.Text("foo", new[] { "FirstName", "LastName" }),
+                "{ text: { query: 'foo', path: ['fn', 'ln'] } }");
+
+            AssertRendered(
+                subject.Text(new[] { "foo", "bar" }, x => x.FirstName),
+                "{ text: { query: ['foo', 'bar'], path: 'fn' } }");
+            AssertRendered(
+                subject.Text(new[] { "foo", "bar" }, "FirstName"),
+                "{ text: { query: ['foo', 'bar'], path: 'fn' } }");
+
+            AssertRendered(
+                subject.Text(
+                    new[] { "foo", "bar" },
+                    new FieldDefinition<Person>[]
+                    {
+                        new ExpressionFieldDefinition<Person, string>(x => x.FirstName),
+                        new ExpressionFieldDefinition<Person, string>(x => x.LastName)
+                    }),
+                "{ text: { query: ['foo', 'bar'], path: ['fn', 'ln'] } }");
+            AssertRendered(
+                subject.Text(new[] { "foo", "bar" }, new[] { "FirstName", "LastName" }),
+                "{ text: { query: ['foo', 'bar'], path: ['fn', 'ln'] } }");
+        }
+
+        private void AssertRendered<TDocument>(SearchDefinition<TDocument> query, string expected)
+        {
+            AssertRendered(query, BsonDocument.Parse(expected));
+        }
+
+        private void AssertRendered<TDocument>(SearchDefinition<TDocument> query, BsonDocument expected)
+        {
+            var documentSerializer = BsonSerializer.SerializerRegistry.GetSerializer<TDocument>();
+            var renderedQuery = query.Render(documentSerializer, BsonSerializer.SerializerRegistry);
+
+            renderedQuery.Should().Be(expected);
+        }
+
+        private SearchDefinitionBuilder<TDocument> CreateSubject<TDocument>()
+        {
+            return new SearchDefinitionBuilder<TDocument>();
+        }
+
+        private class SimplePerson
+        {
+            [BsonElement("fn")]
+            public string FirstName { get; set; }
+
+            [BsonElement("ln")]
+            public string LastName { get; set; }
+        }
+
+        private class Person : SimplePerson
+        {
+            [BsonId]
+            public ObjectId Id { get; set; }
+
+            [BsonElement("age")]
+            public int Age { get; set; }
+
+            [BsonElement("ret")]
+            public bool Retired { get; set; }
+
+            [BsonElement("dob")]
+            public DateTime Birthday { get; set; }
+
+            [BsonElement("location")]
+            public GeoJsonPoint<GeoJson2DGeographicCoordinates> Location { get; set; }
+        }
+    }
+}