diff --git a/config/spotbugs/exclude.xml b/config/spotbugs/exclude.xml
index f887757652f..9af4f8587ec 100644
--- a/config/spotbugs/exclude.xml
+++ b/config/spotbugs/exclude.xml
@@ -229,6 +229,12 @@
         <Method name="~.*invoke.*"/>
         <Bug pattern="BC_BAD_CAST_TO_ABSTRACT_COLLECTION"/>
     </Match>
+    <Match>
+        <!-- MongoDB status: "False Positive", SpotBugs rank: 17 -->
+        <Class name="com.mongodb.kotlin.client.model.Projections"/>
+        <Method name="~include|exclude"/>
+        <Bug pattern="BC_BAD_CAST_TO_ABSTRACT_COLLECTION"/>
+    </Match>
 
     <!-- Spotbugs reports false positives for suspendable operations with default params
          see: https://github.com/Kotlin/kotlinx.coroutines/issues/3099
diff --git a/driver-kotlin-extensions/build.gradle.kts b/driver-kotlin-extensions/build.gradle.kts
index 8bb79ad219f..33fa0fa4294 100644
--- a/driver-kotlin-extensions/build.gradle.kts
+++ b/driver-kotlin-extensions/build.gradle.kts
@@ -118,6 +118,11 @@ tasks.withType<Detekt>().configureEach {
 
 spotbugs { showProgress.set(true) }
 
+tasks.spotbugsMain {
+    // we need the xml report to find out the "rank" (see config/spotbugs/exclude.xml)
+    reports.getByName("xml") { required.set(true) }
+}
+
 // ===========================
 //     Test Configuration
 // ===========================
diff --git a/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Projections.kt b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Projections.kt
new file mode 100644
index 00000000000..d8f09d73be1
--- /dev/null
+++ b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Projections.kt
@@ -0,0 +1,347 @@
+/*
+ * Copyright 2008-present MongoDB, Inc.
+ * Copyright (C) 2016/2022 Litote
+ *
+ * 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.
+ *
+ * @custom-license-header
+ */
+package com.mongodb.kotlin.client.model
+
+import com.mongodb.annotations.Beta
+import com.mongodb.annotations.Reason
+import com.mongodb.client.model.Aggregates
+import com.mongodb.client.model.Projections
+import kotlin.reflect.KProperty
+import kotlin.reflect.KProperty1
+import org.bson.conversions.Bson
+
+/**
+ * Projection extension methods to improve Kotlin interop
+ *
+ * @since 5.3
+ */
+public object Projections {
+
+    /** The projection of the property. This is used in an aggregation pipeline to reference a property from a path. */
+    public val <T> KProperty<T>.projection: String
+        get() = path().projection
+
+    /** The projection of the property. */
+    public val String.projection: String
+        get() = "\$$this"
+
+    /** In order to write `$p.p2` */
+    @JvmSynthetic public infix fun <T0, T1> KProperty1<T0, T1?>.projectionWith(p2: String): String = "$projection.$p2"
+
+    /**
+     * Creates a projection of a property whose value is computed from the given expression. Projection with an
+     * expression can be used in the following contexts:
+     * <ul>
+     * <li>$project aggregation pipeline stage.</li>
+     * <li>Starting from MongoDB 4.4, it's also accepted in various find-related methods within the {@code
+     *   MongoCollection}-based API where projection is supported, for example: <ul>
+     * <li>{@code find()}</li>
+     * <li>{@code findOneAndReplace()}</li>
+     * <li>{@code findOneAndUpdate()}</li>
+     * <li>{@code findOneAndDelete()}</li>
+     * </ul>
+     *
+     * </li> </ul>
+     *
+     * @param expression the expression
+     * @param <T> the expression type
+     * @return the projection
+     * @see #computedSearchMeta(String)
+     * @see Aggregates#project(Bson)
+     */
+    @JvmSynthetic
+    @JvmName("computedFromExt")
+    public infix fun <T> KProperty<T>.computed(expression: Any): Bson =
+        Projections.computed(path(), (expression as? KProperty<*>)?.projection ?: expression)
+
+    /**
+     * Creates a projection of a property whose value is computed from the given expression. Projection with an
+     * expression can be used in the following contexts:
+     * <ul>
+     * <li>$project aggregation pipeline stage.</li>
+     * <li>Starting from MongoDB 4.4, it's also accepted in various find-related methods within the {@code
+     *   MongoCollection}-based API where projection is supported, for example: <ul>
+     * <li>{@code find()}</li>
+     * <li>{@code findOneAndReplace()}</li>
+     * <li>{@code findOneAndUpdate()}</li>
+     * <li>{@code findOneAndDelete()}</li>
+     * </ul>
+     *
+     * </li> </ul>
+     *
+     * @param property the data class property
+     * @param expression the expression
+     * @param <T> the expression type
+     * @return the projection
+     * @see #computedSearchMeta(String)
+     * @see Aggregates#project(Bson)
+     */
+    public fun <T> computed(property: KProperty<T>, expression: Any): Bson = property.computed(expression)
+
+    /**
+     * Creates a projection of a String whose value is computed from the given expression. Projection with an expression
+     * can be used in the following contexts:
+     * <ul>
+     * <li>$project aggregation pipeline stage.</li>
+     * <li>Starting from MongoDB 4.4, it's also accepted in various find-related methods within the {@code
+     *   MongoCollection}-based API where projection is supported, for example: <ul>
+     * <li>{@code find()}</li>
+     * <li>{@code findOneAndReplace()}</li>
+     * <li>{@code findOneAndUpdate()}</li>
+     * <li>{@code findOneAndDelete()}</li>
+     * </ul>
+     *
+     * </li> </ul>
+     *
+     * @param expression the expression
+     * @return the projection
+     * @see #computedSearchMeta(String)
+     * @see Aggregates#project(Bson)
+     */
+    @JvmSynthetic
+    @JvmName("computedFromExt")
+    public infix fun String.computed(expression: Any): Bson =
+        @Suppress("UNCHECKED_CAST")
+        Projections.computed(this, (expression as? KProperty<Any>)?.projection ?: expression)
+
+    /**
+     * Creates a projection of a String whose value is computed from the given expression. Projection with an expression
+     * can be used in the following contexts:
+     * <ul>
+     * <li>$project aggregation pipeline stage.</li>
+     * <li>Starting from MongoDB 4.4, it's also accepted in various find-related methods within the {@code
+     *   MongoCollection}-based API where projection is supported, for example: <ul>
+     * <li>{@code find()}</li>
+     * <li>{@code findOneAndReplace()}</li>
+     * <li>{@code findOneAndUpdate()}</li>
+     * <li>{@code findOneAndDelete()}</li>
+     * </ul>
+     *
+     * </li> </ul>
+     *
+     * @param property the data class property
+     * @param expression the expression
+     * @return the projection
+     * @see #computedSearchMeta(String)
+     * @see Aggregates#project(Bson)
+     */
+    public fun computed(property: String, expression: Any): Bson = property.computed(expression)
+
+    /**
+     * Creates a projection of a property whose value is equal to the {@code $$SEARCH_META} variable. for use with
+     * {@link Aggregates#search(SearchOperator, SearchOptions)} / {@link Aggregates#search(SearchCollector,
+     * SearchOptions)}. Calling this method is equivalent to calling {@link #computed(String, Object)} with {@code
+     * "$$SEARCH_META"} as the second argument.
+     *
+     * @param property the data class property
+     * @return the projection
+     * @see #computed(String)
+     * @see Aggregates#project(Bson)
+     */
+    @JvmSynthetic
+    @JvmName("computedSearchMetaExt")
+    public fun <T> KProperty<T>.computedSearchMeta(): Bson = Projections.computedSearchMeta(path())
+
+    /**
+     * Creates a projection of a property whose value is equal to the {@code $$SEARCH_META} variable. for use with
+     * {@link Aggregates#search(SearchOperator, SearchOptions)} / {@link Aggregates#search(SearchCollector,
+     * SearchOptions)}. Calling this method is equivalent to calling {@link #computed(String, Object)} with {@code
+     * "$$SEARCH_META"} as the second argument.
+     *
+     * @param property the data class property
+     * @return the projection
+     * @see #computed(String)
+     * @see Aggregates#project(Bson)
+     */
+    public fun <T> computedSearchMeta(property: KProperty<T>): Bson = property.computedSearchMeta()
+
+    /**
+     * Creates a projection that includes all of the given properties.
+     *
+     * @param properties the field names
+     * @return the projection
+     */
+    public fun include(vararg properties: KProperty<*>): Bson = include(properties.asList())
+
+    /**
+     * Creates a projection that includes all of the given properties.
+     *
+     * @param properties the field names
+     * @return the projection
+     */
+    public fun include(properties: Iterable<KProperty<*>>): Bson = Projections.include(properties.map { it.path() })
+
+    /**
+     * Creates a projection that excludes all of the given properties.
+     *
+     * @param properties the field names
+     * @return the projection
+     */
+    public fun exclude(vararg properties: KProperty<*>): Bson = exclude(properties.asList())
+
+    /**
+     * Creates a projection that excludes all of the given properties.
+     *
+     * @param properties the field names
+     * @return the projection
+     */
+    public fun exclude(properties: Iterable<KProperty<*>>): Bson = Projections.exclude(properties.map { it.path() })
+
+    /**
+     * Creates a projection that excludes the _id field. This suppresses the automatic inclusion of _id that is the
+     * default, even when other fields are explicitly included.
+     *
+     * @return the projection
+     */
+    public fun excludeId(): Bson = Projections.excludeId()
+
+    /**
+     * Creates a projection that includes for the given property only the first element of an array that matches the
+     * query filter. This is referred to as the positional $ operator.
+     *
+     * @return the projection @mongodb.driver.manual reference/operator/projection/positional/#projection Project the
+     *   first matching element ($ operator)
+     */
+    public val <T> KProperty<T>.elemMatch: Bson
+        get() = Projections.elemMatch(path())
+
+    /**
+     * Creates a projection that includes for the given property only the first element of the array value of that field
+     * that matches the given query filter.
+     *
+     * @param filter the filter to apply
+     * @return the projection @mongodb.driver.manual reference/operator/projection/elemMatch elemMatch
+     */
+    @JvmSynthetic
+    @JvmName("elemMatchProjExt")
+    public infix fun <T> KProperty<T>.elemMatch(filter: Bson): Bson = Projections.elemMatch(path(), filter)
+
+    /**
+     * Creates a projection that includes for the given property only the first element of the array value of that field
+     * that matches the given query filter.
+     *
+     * @param property the data class property
+     * @param filter the filter to apply
+     * @return the projection @mongodb.driver.manual reference/operator/projection/elemMatch elemMatch
+     */
+    public fun <T> elemMatch(property: KProperty<T>, filter: Bson): Bson = property.elemMatch(filter)
+
+    /**
+     * Creates a $meta projection for the given property
+     *
+     * @param metaFieldName the meta field name
+     * @return the projection @mongodb.driver.manual reference/operator/aggregation/meta/
+     * @see #metaTextScore(String)
+     * @see #metaSearchScore(String)
+     * @see #metaVectorSearchScore(String)
+     * @see #metaSearchHighlights(String)
+     */
+    @JvmSynthetic
+    @JvmName("metaExt")
+    public infix fun <T> KProperty<T>.meta(metaFieldName: String): Bson = Projections.meta(path(), metaFieldName)
+
+    /**
+     * Creates a $meta projection for the given property
+     *
+     * @param property the data class property
+     * @param metaFieldName the meta field name
+     * @return the projection @mongodb.driver.manual reference/operator/aggregation/meta/
+     * @see #metaTextScore(String)
+     * @see #metaSearchScore(String)
+     * @see #metaVectorSearchScore(String)
+     * @see #metaSearchHighlights(String)
+     */
+    public fun <T> meta(property: KProperty<T>, metaFieldName: String): Bson = property.meta(metaFieldName)
+
+    /**
+     * Creates a textScore projection for the given property, for use with text queries. Calling this method is
+     * equivalent to calling {@link #meta(String)} with {@code "textScore"} as the argument.
+     *
+     * @return the projection
+     * @see Filters#text(String, TextSearchOptions) @mongodb.driver.manual
+     *   reference/operator/aggregation/meta/#text-score-metadata--meta---textscore- textScore
+     */
+    public fun <T> KProperty<T>.metaTextScore(): Bson = Projections.metaTextScore(path())
+
+    /**
+     * Creates a searchScore projection for the given property, for use with {@link Aggregates#search(SearchOperator,
+     * SearchOptions)} / {@link Aggregates#search(SearchCollector, SearchOptions)}. Calling this method is equivalent to
+     * calling {@link #meta(String, String)} with {@code "searchScore"} as the argument.
+     *
+     * @return the projection @mongodb.atlas.manual atlas-search/scoring/ Scoring
+     */
+    public fun <T> KProperty<T>.metaSearchScore(): Bson = Projections.metaSearchScore(path())
+
+    /**
+     * Creates a vectorSearchScore projection for the given property, for use with {@link
+     * Aggregates#vectorSearch(FieldSearchPath, Iterable, String, long, VectorSearchOptions)} . Calling this method is
+     * equivalent to calling {@link #meta(String, String)} with {@code "vectorSearchScore"} as the argument.
+     *
+     * @return the projection @mongodb.atlas.manual atlas-search/scoring/ Scoring @mongodb.server.release 6.0.10
+     */
+    @Beta(Reason.SERVER)
+    public fun <T> KProperty<T>.metaVectorSearchScore(): Bson = Projections.metaVectorSearchScore(path())
+
+    /**
+     * Creates a searchHighlights projection for the given property, for use with {@link
+     * Aggregates#search(SearchOperator, SearchOptions)} / {@link Aggregates#search(SearchCollector, SearchOptions)}.
+     * Calling this method is equivalent to calling {@link #meta(String, String)} with {@code "searchHighlights"} as the
+     * argument.
+     *
+     * @return the projection
+     * @see com.mongodb.client.model.search.SearchHighlight @mongodb.atlas.manual atlas-search/highlighting/
+     *   Highlighting
+     */
+    public fun <T> KProperty<T>.metaSearchHighlights(): Bson = Projections.metaSearchHighlights(path())
+
+    /**
+     * Creates a projection to the given property of a slice of the array value of that field.
+     *
+     * @param limit the number of elements to project.
+     * @return the projection @mongodb.driver.manual reference/operator/projection/slice Slice
+     */
+    public infix fun <T> KProperty<T>.slice(limit: Int): Bson = Projections.slice(path(), limit)
+
+    /**
+     * Creates a projection to the given property of a slice of the array value of that field.
+     *
+     * @param skip the number of elements to skip before applying the limit
+     * @param limit the number of elements to project
+     * @return the projection @mongodb.driver.manual reference/operator/projection/slice Slice
+     */
+    public fun <T> KProperty<T>.slice(skip: Int, limit: Int): Bson = Projections.slice(path(), skip, limit)
+
+    /**
+     * Creates a projection that combines the list of projections into a single one. If there are duplicate keys, the
+     * last one takes precedence.
+     *
+     * @param projections the list of projections to combine
+     * @return the combined projection
+     */
+    public fun fields(vararg projections: Bson): Bson = Projections.fields(*projections)
+
+    /**
+     * Creates a projection that combines the list of projections into a single one. If there are duplicate keys, the
+     * last one takes precedence.
+     *
+     * @param projections the list of projections to combine
+     * @return the combined projection @mongodb.driver.manual
+     */
+    public fun fields(projections: List<Bson>): Bson = Projections.fields(projections)
+}
diff --git a/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Properties.kt b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Properties.kt
index 2c5cf956b94..b35b44d4d93 100644
--- a/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Properties.kt
+++ b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Properties.kt
@@ -67,7 +67,6 @@ public operator fun <T0, K, T1, T2> KProperty1<T0, Map<out K, T1>?>.div(
  * - BsonProperty annotation
  * - Property name
  */
-@SuppressWarnings("BC_BAD_CAST_TO_ABSTRACT_COLLECTION")
 internal fun <T> KProperty<T>.path(): String {
     return if (this is KPropertyPath<*, T>) {
         this.name
@@ -84,12 +83,19 @@ internal fun <T> KProperty<T>.path(): String {
             // If no path (serialName) then check for BsonId / BsonProperty
             if (path == null) {
                 val originator = if (this is CustomProperty<*, *>) this.previous.property else this
-                val constructorProperty =
-                    originator.javaField!!.declaringClass.kotlin.primaryConstructor?.findParameterByName(this.name)
-
-                // Prefer BsonId annotation over BsonProperty
-                path = constructorProperty?.annotations?.filterIsInstance<BsonId>()?.firstOrNull()?.let { "_id" }
-                path = path ?: constructorProperty?.annotations?.filterIsInstance<BsonProperty>()?.firstOrNull()?.value
+                // If this property is calculated (doesn't have a backing field) ex
+                // "(Student::grades / Grades::score).posOp then
+                // originator.javaField will NPE.
+                // Only read various annotations on a declared property with a backing field
+                if (originator.javaField != null) {
+                    val constructorProperty =
+                        originator.javaField!!.declaringClass.kotlin.primaryConstructor?.findParameterByName(this.name)
+
+                    // Prefer BsonId annotation over BsonProperty
+                    path = constructorProperty?.annotations?.filterIsInstance<BsonId>()?.firstOrNull()?.let { "_id" }
+                    path =
+                        path ?: constructorProperty?.annotations?.filterIsInstance<BsonProperty>()?.firstOrNull()?.value
+                }
                 path = path ?: this.name
             }
             path
diff --git a/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/ExtensionsApiTest.kt b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/ExtensionsApiTest.kt
index e2c4e945adb..d71312f31ab 100644
--- a/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/ExtensionsApiTest.kt
+++ b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/ExtensionsApiTest.kt
@@ -30,6 +30,15 @@ class ExtensionsApiTest {
         assertTrue(notImplemented.isEmpty(), "Some possible Filters were not implemented: $notImplemented")
     }
 
+    @Test
+    fun shouldHaveAllProjectionsExtensions() {
+        val kotlinExtensions: Set<String> = getKotlinExtensions("Projections")
+        val javaMethods: Set<String> = getJavaMethods("Projections")
+
+        val notImplemented = javaMethods subtract kotlinExtensions
+        assertTrue(notImplemented.isEmpty(), "Some possible Projections were not implemented: $notImplemented")
+    }
+
     private fun getKotlinExtensions(className: String): Set<String> {
         return ClassGraph()
             .enableClassInfo()
diff --git a/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/KPropertiesTest.kt b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/KPropertiesTest.kt
index 80b835e0042..9d27b86c7ef 100644
--- a/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/KPropertiesTest.kt
+++ b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/KPropertiesTest.kt
@@ -41,7 +41,8 @@ class KPropertiesTest {
         @BsonProperty("prop") val bsonProperty: String,
         @SerialName("rating") val score: String,
         val name: String,
-        @BsonProperty("old") val previous: Review?
+        @BsonProperty("old") val previous: Review?,
+        @BsonProperty("nested") val misc: List<String>
     )
 
     @Test
@@ -84,6 +85,7 @@ class KPropertiesTest {
     fun testArrayPositionalOperator() {
         assertEquals("reviews.\$", Restaurant::reviews.posOp.path())
         assertEquals("reviews.rating", (Restaurant::reviews / Review::score).path())
+        assertEquals("reviews.nested.\$", (Restaurant::reviews / Review::misc).posOp.path())
         assertEquals("reviews.\$.rating", (Restaurant::reviews.posOp / Review::score).path())
     }
 
@@ -91,6 +93,7 @@ class KPropertiesTest {
     fun testArrayAllPositionalOperator() {
         assertEquals("reviews.\$[]", Restaurant::reviews.allPosOp.path())
         assertEquals("reviews.\$[].rating", (Restaurant::reviews.allPosOp / Review::score).path())
+        assertEquals("reviews.nested.\$[]", (Restaurant::reviews / Review::misc).allPosOp.path())
     }
 
     @Test
diff --git a/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/ProjectionTest.kt b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/ProjectionTest.kt
new file mode 100644
index 00000000000..b4e49ee7dda
--- /dev/null
+++ b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/ProjectionTest.kt
@@ -0,0 +1,239 @@
+/*
+ * Copyright 2008-present MongoDB, Inc.
+ * Copyright (C) 2016/2022 Litote
+ *
+ * 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.
+ *
+ * @custom-license-header
+ */
+package com.mongodb.kotlin.client.model
+
+import com.mongodb.client.model.Aggregates.project
+import com.mongodb.client.model.Projections.excludeId
+import com.mongodb.client.model.Projections.fields
+import com.mongodb.kotlin.client.model.Filters.and
+import com.mongodb.kotlin.client.model.Filters.eq
+import com.mongodb.kotlin.client.model.Filters.gt
+import com.mongodb.kotlin.client.model.Projections.computed
+import com.mongodb.kotlin.client.model.Projections.computedSearchMeta
+import com.mongodb.kotlin.client.model.Projections.elemMatch
+import com.mongodb.kotlin.client.model.Projections.exclude
+import com.mongodb.kotlin.client.model.Projections.include
+import com.mongodb.kotlin.client.model.Projections.meta
+import com.mongodb.kotlin.client.model.Projections.metaSearchHighlights
+import com.mongodb.kotlin.client.model.Projections.metaSearchScore
+import com.mongodb.kotlin.client.model.Projections.metaTextScore
+import com.mongodb.kotlin.client.model.Projections.metaVectorSearchScore
+import com.mongodb.kotlin.client.model.Projections.projection
+import com.mongodb.kotlin.client.model.Projections.projectionWith
+import com.mongodb.kotlin.client.model.Projections.slice
+import kotlin.test.assertEquals
+import org.bson.BsonDocument
+import org.bson.conversions.Bson
+import org.junit.Test
+
+class ProjectionTest {
+
+    @Test
+    fun projection() {
+        assertEquals("\$name", Person::name.projection)
+        assertEquals("\$name.foo", Student::name.projectionWith("foo"))
+    }
+
+    @Test
+    fun include() {
+        assertEquals(
+            """{"name": 1, "age": 1, "results": 1, "address": 1}""",
+            include(Person::name, Person::age, Person::results, Person::address))
+
+        assertEquals("""{"name": 1, "age": 1}""", include(listOf(Person::name, Person::age)))
+        assertEquals("""{"name": 1, "age": 1}""", include(listOf(Person::name, Person::age, Person::name)))
+    }
+
+    @Test
+    fun exclude() {
+        assertEquals(
+            """{"name": 0, "age": 0, "results": 0, "address": 0}""",
+            exclude(Person::name, Person::age, Person::results, Person::address))
+        assertEquals("""{"name": 0, "age": 0}""", exclude(listOf(Person::name, Person::age)))
+        assertEquals("""{"name": 0, "age": 0}""", exclude(listOf(Person::name, Person::age, Person::name)))
+
+        assertEquals("""{"name": 0, "age": 0}""", exclude(listOf(Person::name, Person::age, Person::name)))
+
+        assertEquals("""{"_id": 0}""", excludeId())
+        assertEquals(
+            "Projections{projections=[{\"_id\": 0}, {\"name\": 1}]}",
+            fields(excludeId(), include(Person::name)).toString())
+    }
+
+    @Test
+    fun firstElem() {
+        assertEquals(""" {"name.${'$'}" : 1} """, Person::name.elemMatch)
+    }
+
+    @Test
+    fun elemMatch() {
+        val expected =
+            """
+            {"grades": {"${'$'}elemMatch": {"${'$'}and": [{"subject": "Math"}, {"score": {"${'$'}gt": 80}}]}}}
+        """
+        assertEquals(expected, Student::grades.elemMatch(and((Grade::subject eq "Math"), (Grade::score gt 80))))
+
+        assertEquals(Student::grades elemMatch (Grade::score gt 80), elemMatch(Student::grades, Grade::score gt 80))
+
+        // Should create string representation for elemMatch with filter
+        assertEquals(
+            "ElemMatch Projection{fieldName='grades'," +
+                " filter=And Filter{filters=[Filter{fieldName='score', value=90}, " +
+                "Filter{fieldName='subject', value=Math}]}}",
+            Student::grades.elemMatch(and(Grade::score eq 90, Grade::subject eq "Math")).toString())
+    }
+
+    @Test
+    fun slice() {
+        var expected = """
+            {"grades": {"${'$'}slice": -1}}
+        """
+
+        assertEquals(expected, Student::grades.slice(-1))
+
+        // skip one, limit to two
+        expected = """
+            {"grades": {"${'$'}slice": [1, 2]}}
+        """
+
+        assertEquals(expected, Student::grades.slice(1, 2))
+
+        // Combining projection
+        expected = """
+           {"name": 0, "grades": {"${'$'}slice": [2, 1]}}
+        """
+
+        assertEquals(expected, fields(exclude(Student::name), Student::grades.slice(2, 1)))
+    }
+
+    @Test
+    fun meta() {
+        var expected = """
+            {"score": {"${'$'}meta": "textScore"}}
+        """
+        assertEquals(expected, Grade::score.metaTextScore())
+
+        // combining
+        expected =
+            """
+            {"_id": 0, "score": {"${'$'}meta": "textScore"}, "grades": {"${'$'}elemMatch": {"score": {"${'$'}gt": 87}}}}
+        """
+        assertEquals(
+            expected, fields(excludeId(), Grade::score.metaTextScore(), Student::grades.elemMatch(Grade::score gt 87)))
+
+        expected = """
+            {"score": {"${'$'}meta": "searchScore"}}
+        """
+        assertEquals(expected, Grade::score.metaSearchScore())
+
+        expected = """
+            {"score": {"${'$'}meta": "searchHighlights"}}
+        """
+        assertEquals(expected, Grade::score.metaSearchHighlights())
+
+        expected = """
+            {"score": {"${'$'}meta": "vectorSearchScore"}}
+        """
+        assertEquals(expected, Grade::score.metaVectorSearchScore())
+        assertEquals(expected, Grade::score.meta("vectorSearchScore"))
+
+        expected = """
+            {"_id": 0, "score": {"${'$'}meta": "vectorSearchScore"}}
+        """
+        assertEquals(expected, fields(excludeId(), Grade::score meta "vectorSearchScore"))
+
+        assertEquals(Grade::score meta "vectorSearchScore", meta(Grade::score, "vectorSearchScore"))
+    }
+
+    @Test
+    fun `computed projection`() {
+        assertEquals(""" {"c": "${'$'}y"} """, "c" computed "\$y")
+
+        assertEquals(computed(Grade::score, Student::age), Grade::score computed Student::age)
+
+        assertEquals(
+            """{"${'$'}project": {"c": "${'$'}name", "score": "${'$'}age"}}""",
+            project(fields("c" computed Student::name, Grade::score computed Student::age)))
+
+        assertEquals(
+            fields("c" computed Student::name, Grade::score computed Student::age),
+            fields(computed("c", Student::name), Grade::score computed Student::age))
+
+        assertEquals(
+            """{"${'$'}project": {"c": "${'$'}name", "score": "${'$'}age"}}""",
+            project(fields("c" computed Student::name, Grade::score computed Student::age)))
+
+        assertEquals(
+            fields(listOf("c" computed Student::name, Grade::score computed Student::age)),
+            fields("c" computed Student::name, Grade::score computed Student::age))
+
+        // combine fields
+        assertEquals("{name : 1, age : 1, _id : 0}", fields(include(Student::name, Student::age), excludeId()))
+
+        assertEquals("{name : 1, age : 1, _id : 0}", fields(include(listOf(Student::name, Student::age)), excludeId()))
+
+        assertEquals("{name : 1, age : 0}", fields(include(Student::name, Student::age), exclude(Student::age)))
+
+        // computedSearchMeta
+        assertEquals("""{"name": "${'$'}${'$'}SEARCH_META"}""", Student::name.computedSearchMeta())
+        assertEquals(Student::name.computedSearchMeta(), computedSearchMeta(Student::name))
+
+        // Should create string representation for include and exclude
+        assertEquals("""{"age": 1, "name": 1}""", include(Student::name, Student::age, Student::name).toString())
+        assertEquals("""{"age": 0, "name": 0}""", exclude(Student::name, Student::age, Student::name).toString())
+        assertEquals("""{"_id": 0}""", excludeId().toString())
+
+        // Should create string representation for computed
+        assertEquals(
+            "Expression{name='c', expression=\$y}",
+            com.mongodb.client.model.Projections.computed("c", "\$y").toString())
+        assertEquals("Expression{name='c', expression=\$y}", ("c" computed "\$y").toString())
+        assertEquals("Expression{name='name', expression=\$y}", (Student::name computed "\$y").toString())
+    }
+
+    @Test
+    fun `array projection`() {
+        assertEquals("{ \"grades.${'$'}\": 1 }", include(Student::grades.posOp))
+        assertEquals("{ \"grades.comments.${'$'}\": 1 }", include((Student::grades / Grade::comments).posOp))
+    }
+
+    @Test
+    fun `projection in aggregation`() {
+        // Field Reference in Aggregation
+        assertEquals(
+            """ {"${'$'}project": {"score": "${'$'}grades.score"}} """,
+            project((Grade::score computed (Student::grades.projectionWith("score")))))
+
+        assertEquals(
+            "{\"${'$'}project\": {\"My Score\": \"${'$'}grades.score\"}}",
+            project("My Score" computed (Student::grades / Grade::score)))
+
+        assertEquals("{\"${'$'}project\": {\"My Age\": \"${'$'}age\"}}", project("My Age" computed Student::age))
+
+        assertEquals(
+            "{\"${'$'}project\": {\"My Age\": \"${'$'}age\"}}", project("My Age" computed Student::age.projection))
+    }
+
+    private data class Person(val name: String, val age: Int, val address: List<String>, val results: List<Int>)
+    private data class Student(val name: String, val age: Int, val grades: List<Grade>)
+    private data class Grade(val subject: String, val score: Int, val comments: List<String>)
+
+    private fun assertEquals(expected: String, result: Bson) =
+        assertEquals(BsonDocument.parse(expected), result.toBsonDocument())
+}