diff --git a/.evergreen/run-kotlin-tests.sh b/.evergreen/run-kotlin-tests.sh
index fecceb28c53..a82c66e9e54 100755
--- a/.evergreen/run-kotlin-tests.sh
+++ b/.evergreen/run-kotlin-tests.sh
@@ -31,7 +31,10 @@ if [ "$SAFE_FOR_MULTI_MONGOS" == "true" ]; then
     export MULTI_MONGOS_URI_SYSTEM_PROPERTY="-Dorg.mongodb.test.multi.mongos.uri=${MONGODB_URI}"
 fi
 
-echo "Running Kotlin tests"
-
 ./gradlew -version
-./gradlew kotlinCheck -Dorg.mongodb.test.uri=${MONGODB_URI} ${MULTI_MONGOS_URI_SYSTEM_PROPERTY}
+
+echo "Running Kotlin Unit Tests"
+./gradlew :bson-kotlin:test :bson-kotlinx:test :driver-kotlin-sync:test :driver-kotlin-coroutine:test :driver-kotlin-extensions:test
+
+echo "Running Kotlin Integration Tests"
+./gradlew :driver-kotlin-sync:integrationTest :driver-kotlin-coroutine:integrationTest  -Dorg.mongodb.test.uri=${MONGODB_URI} ${MULTI_MONGOS_URI_SYSTEM_PROPERTY}
diff --git a/.evergreen/static-checks.sh b/.evergreen/static-checks.sh
index 8896692ca66..8b65b15e9a5 100755
--- a/.evergreen/static-checks.sh
+++ b/.evergreen/static-checks.sh
@@ -12,4 +12,4 @@ RELATIVE_DIR_PATH="$(dirname "${BASH_SOURCE[0]:-$0}")"
 echo "Compiling JVM drivers"
 
 ./gradlew -version
-./gradlew -PxmlReports.enabled=true --info -x test -x integrationTest -x spotlessApply clean check scalaCheck kotlinCheck jar testClasses docs
+./gradlew -PxmlReports.enabled=true --info -x test -x integrationTest -x spotlessApply clean check scalaCheck jar testClasses docs
diff --git a/THIRD-PARTY-NOTICES b/THIRD-PARTY-NOTICES
index 7229bf71926..f881b103544 100644
--- a/THIRD-PARTY-NOTICES
+++ b/THIRD-PARTY-NOTICES
@@ -161,3 +161,26 @@ https://github.com/mongodb/mongo-java-driver.
     See the License for the specific language governing permissions and
     limitations under the License.
 
+8) The following files (originally from https://github.com/Litote/kmongo):
+
+    Filters.kt
+    Properties.kt
+    KPropertyPath.kt
+    FiltersTest.kt
+    KPropertiesTest.kt
+
+    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.
+
diff --git a/bson-kotlin/build.gradle.kts b/bson-kotlin/build.gradle.kts
index 3840b3169cf..45e8c9c0e5d 100644
--- a/bson-kotlin/build.gradle.kts
+++ b/bson-kotlin/build.gradle.kts
@@ -111,13 +111,6 @@ spotbugs { showProgress.set(true) }
 // ===========================
 //     Test Configuration
 // ===========================
-tasks.create("kotlinCheck") {
-    description = "Runs all the kotlin checks"
-    group = "verification"
-
-    dependsOn("clean", "check")
-    tasks.findByName("check")?.mustRunAfter("clean")
-}
 
 tasks.test { useJUnitPlatform() }
 
diff --git a/bson-kotlinx/build.gradle.kts b/bson-kotlinx/build.gradle.kts
index a278b4a3ab2..ac0b07f18eb 100644
--- a/bson-kotlinx/build.gradle.kts
+++ b/bson-kotlinx/build.gradle.kts
@@ -128,13 +128,6 @@ spotbugs { showProgress.set(true) }
 // ===========================
 //     Test Configuration
 // ===========================
-tasks.create("kotlinCheck") {
-    description = "Runs all the kotlin checks"
-    group = "verification"
-
-    dependsOn("clean", "check")
-    tasks.findByName("check")?.mustRunAfter("clean")
-}
 
 tasks.test { useJUnitPlatform() }
 
diff --git a/config/spotbugs/exclude.xml b/config/spotbugs/exclude.xml
index 488c797a6a0..20684680865 100644
--- a/config/spotbugs/exclude.xml
+++ b/config/spotbugs/exclude.xml
@@ -223,6 +223,30 @@
         <Method name="~.*validateAnnotations.*"/>
         <Bug pattern="BC_BAD_CAST_TO_ABSTRACT_COLLECTION"/>
     </Match>
+    <Match>
+        <!-- MongoDB status: "False Positive", SpotBugs rank: 17 -->
+        <Class name="com.mongodb.kotlin.client.model.PropertiesKt$path$1"/>
+        <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>
+    <Match>
+        <!-- MongoDB status: "False Positive", SpotBugs rank: 17 -->
+        <Class name="com.mongodb.kotlin.client.model.Indexes"/>
+        <Method name="~ascending|descending|geo2dsphere"/>
+        <Bug pattern="BC_BAD_CAST_TO_ABSTRACT_COLLECTION"/>
+    </Match>
+    <Match>
+        <!-- MongoDB status: "False Positive", SpotBugs rank: 17 -->
+        <Class name="com.mongodb.kotlin.client.model.Sorts"/>
+        <Method name="~ascending|descending"/>
+        <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-core/src/main/com/mongodb/ServerAddress.java b/driver-core/src/main/com/mongodb/ServerAddress.java
index a537cd775a2..f9c31180dd9 100644
--- a/driver-core/src/main/com/mongodb/ServerAddress.java
+++ b/driver-core/src/main/com/mongodb/ServerAddress.java
@@ -103,7 +103,7 @@ public ServerAddress(@Nullable final String host, final int port) {
         if (hostToUse.startsWith("[")) {
             int idx = host.indexOf("]");
             if (idx == -1) {
-                throw new IllegalArgumentException("an IPV6 address must be encosed with '[' and ']'"
+                throw new IllegalArgumentException("an IPV6 address must be enclosed with '[' and ']'"
                                                    + " according to RFC 2732.");
             }
 
diff --git a/driver-core/src/main/com/mongodb/client/model/UnwindOptions.java b/driver-core/src/main/com/mongodb/client/model/UnwindOptions.java
index 832d274591e..c15e62e4b09 100644
--- a/driver-core/src/main/com/mongodb/client/model/UnwindOptions.java
+++ b/driver-core/src/main/com/mongodb/client/model/UnwindOptions.java
@@ -18,6 +18,8 @@
 
 import com.mongodb.lang.Nullable;
 
+import java.util.Objects;
+
 /**
  * The options for an unwind aggregation pipeline stage
  *
@@ -79,4 +81,24 @@ public String toString() {
                 + ", includeArrayIndex='" + includeArrayIndex + '\''
                 + '}';
     }
+
+    @Override
+    public boolean equals(final Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+
+        UnwindOptions that = (UnwindOptions) o;
+        return Objects.equals(preserveNullAndEmptyArrays, that.preserveNullAndEmptyArrays) && Objects.equals(includeArrayIndex, that.includeArrayIndex);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = Objects.hashCode(preserveNullAndEmptyArrays);
+        result = 31 * result + Objects.hashCode(includeArrayIndex);
+        return result;
+    }
 }
diff --git a/driver-kotlin-coroutine/build.gradle.kts b/driver-kotlin-coroutine/build.gradle.kts
index abd81fcd1d3..96ac4cc31eb 100644
--- a/driver-kotlin-coroutine/build.gradle.kts
+++ b/driver-kotlin-coroutine/build.gradle.kts
@@ -156,15 +156,6 @@ val integrationTest =
         classpath = sourceSets["integrationTest"].runtimeClasspath
     }
 
-tasks.create("kotlinCheck") {
-    description = "Runs all the kotlin checks"
-    group = "verification"
-
-    dependsOn("clean", "check", integrationTest)
-    tasks.findByName("check")?.mustRunAfter("clean")
-    tasks.findByName("integrationTest")?.mustRunAfter("check")
-}
-
 tasks.test { useJUnitPlatform() }
 
 // ===========================
diff --git a/driver-kotlin-extensions/build.gradle.kts b/driver-kotlin-extensions/build.gradle.kts
new file mode 100644
index 00000000000..25b437e0fad
--- /dev/null
+++ b/driver-kotlin-extensions/build.gradle.kts
@@ -0,0 +1,168 @@
+/*
+ * Copyright 2008-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.
+ */
+import io.gitlab.arturbosch.detekt.Detekt
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+    id("org.jetbrains.kotlin.jvm")
+    `java-library`
+
+    // Test based plugins
+    id("com.diffplug.spotless")
+    id("org.jetbrains.dokka")
+    id("io.gitlab.arturbosch.detekt")
+}
+
+repositories {
+    mavenCentral()
+    google()
+}
+
+base.archivesName.set("mongodb-driver-kotlin-extensions")
+
+description = "The MongoDB Kotlin Driver Extensions"
+
+ext.set("pomName", "MongoDB Kotlin Driver Extensions")
+
+java { registerFeature("kotlinDrivers") { usingSourceSet(sourceSets["main"]) } }
+
+dependencies {
+    // Align versions of all Kotlin components
+    implementation(platform("org.jetbrains.kotlin:kotlin-bom"))
+    implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
+
+    api(project(path = ":driver-core", configuration = "default"))
+
+    // Some extensions require higher API like MongoCollection which are defined in the sync &
+    // coroutine Kotlin driver
+    "kotlinDriversImplementation"(project(path = ":driver-kotlin-sync", configuration = "default"))
+    "kotlinDriversImplementation"(project(path = ":driver-kotlin-coroutine", configuration = "default"))
+
+    testImplementation("org.jetbrains.kotlin:kotlin-reflect")
+    testImplementation("org.jetbrains.kotlin:kotlin-test-junit")
+    testImplementation("org.assertj:assertj-core:3.24.2")
+    testImplementation("io.github.classgraph:classgraph:4.8.154")
+    testImplementation("org.mockito.kotlin:mockito-kotlin:4.1.0")
+}
+
+kotlin { explicitApi() }
+
+tasks.withType<KotlinCompile> {
+    kotlinOptions {
+        jvmTarget = "1.8"
+        freeCompilerArgs =
+            listOf(
+                // Adds OnlyInputTypes support
+                "-Xallow-kotlin-package",
+            )
+    }
+}
+
+// ===========================
+//     Code Quality checks
+// ===========================
+val customLicenseHeader = "/^(?s)(?!.*@custom-license-header).*/"
+
+spotless {
+    kotlinGradle {
+        ktfmt("0.39").dropboxStyle().configure { it.setMaxWidth(120) }
+        trimTrailingWhitespace()
+        indentWithSpaces()
+        endWithNewline()
+        licenseHeaderFile(rootProject.file("config/mongodb.license"), "(group|plugins|import|buildscript|rootProject)")
+    }
+
+    kotlin {
+        target("**/*.kt")
+        ktfmt().dropboxStyle().configure { it.setMaxWidth(120) }
+        trimTrailingWhitespace()
+        indentWithSpaces()
+        endWithNewline()
+
+        licenseHeaderFile(rootProject.file("config/mongodb.license"))
+            .named("standard")
+            .onlyIfContentMatches(customLicenseHeader)
+    }
+
+    format("extraneous") {
+        target("*.xml", "*.yml", "*.md")
+        trimTrailingWhitespace()
+        indentWithSpaces()
+        endWithNewline()
+    }
+}
+
+tasks.named("check") { dependsOn("spotlessApply") }
+
+detekt {
+    allRules = true // fail build on any finding
+    buildUponDefaultConfig = true // preconfigure defaults
+    config = rootProject.files("config/detekt/detekt.yml") // point to your custom config defining rules to run,
+    // overwriting default behavior
+    baseline = rootProject.file("config/detekt/baseline.xml") // a way of suppressing issues before introducing detekt
+    source = files(file("src/main/kotlin"), file("src/test/kotlin"))
+}
+
+tasks.withType<Detekt>().configureEach {
+    reports {
+        html.required.set(true) // observe findings in your browser with structure and code snippets
+        xml.required.set(true) // checkstyle like format mainly for integrations like Jenkins
+        txt.required.set(false) // similar to the console output, contains issue signature to manually edit
+    }
+}
+
+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
+// ===========================
+
+tasks.test { useJUnitPlatform() }
+
+// ===========================
+//     Dokka Configuration
+// ===========================
+val dokkaOutputDir = "${rootProject.buildDir}/docs/${base.archivesName.get()}"
+
+tasks.dokkaHtml.configure {
+    outputDirectory.set(file(dokkaOutputDir))
+    moduleName.set(base.archivesName.get())
+}
+
+val cleanDokka by tasks.register<Delete>("cleanDokka") { delete(dokkaOutputDir) }
+
+project.parent?.tasks?.named("docs") {
+    dependsOn(tasks.dokkaHtml)
+    mustRunAfter(cleanDokka)
+}
+
+tasks.javadocJar.configure {
+    dependsOn(cleanDokka, tasks.dokkaHtml)
+    archiveClassifier.set("javadoc")
+    from(dokkaOutputDir)
+}
+
+// ===========================
+//     Sources publishing configuration
+// ===========================
+tasks.sourcesJar { from(project.sourceSets.main.map { it.kotlin }) }
+
+afterEvaluate { tasks.jar { manifest { attributes["Automatic-Module-Name"] = "org.mongodb.driver.kotlin.core" } } }
diff --git a/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Accumulators.kt b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Accumulators.kt
new file mode 100644
index 00000000000..2edbd35341d
--- /dev/null
+++ b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Accumulators.kt
@@ -0,0 +1,503 @@
+/*
+ * 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.Accumulators
+import com.mongodb.client.model.BsonField
+import com.mongodb.client.model.QuantileMethod
+import kotlin.reflect.KProperty
+import org.bson.conversions.Bson
+
+/**
+ * Accumulators extension methods to improve Kotlin interop
+ *
+ * @since 5.3
+ */
+@Suppress("TooManyFunctions")
+public object Accumulators {
+    /**
+     * Gets a field name for a $group operation representing the sum of the values of the given expression when applied
+     * to all members of the group.
+     *
+     * @param property the data class property
+     * @param expression the expression
+     * @param <TExpression> the expression type
+     * @return the field @mongodb.driver.manual reference/operator/aggregation/sum/ $sum
+     */
+    public fun <TExpression> sum(property: KProperty<*>, expression: TExpression): BsonField =
+        Accumulators.sum(property.path(), expression)
+
+    /**
+     * Gets a field name for a $group operation representing the average of the values of the given expression when
+     * applied to all members of the group.
+     *
+     * @param property the data class property
+     * @param expression the expression
+     * @param <TExpression> the expression type
+     * @return the field @mongodb.driver.manual reference/operator/aggregation/avg/ $avg
+     */
+    public fun <TExpression> avg(property: KProperty<*>, expression: TExpression): BsonField =
+        Accumulators.avg(property.path(), expression)
+
+    /**
+     * Returns a combination of a computed field and an accumulator that generates a BSON {@link org.bson.BsonType#ARRAY
+     * Array} containing computed values from the given {@code inExpression} based on the provided {@code pExpression},
+     * which represents an array of percentiles of interest within a group, where each element is a numeric value
+     * between 0.0 and 1.0 (inclusive).
+     *
+     * @param property The data class property computed by the accumulator.
+     * @param inExpression The input expression.
+     * @param pExpression The expression representing a percentiles of interest.
+     * @param method The method to be used for computing the percentiles.
+     * @param <InExpression> The type of the input expression.
+     * @param <PExpression> The type of the percentile expression.
+     * @return The requested {@link BsonField}. @mongodb.driver.manual reference/operator/aggregation/percentile/
+     *   $percentile @mongodb.server.release 7.0
+     */
+    public fun <InExpression, PExpression> percentile(
+        property: KProperty<*>,
+        inExpression: InExpression,
+        pExpression: PExpression,
+        method: QuantileMethod
+    ): BsonField = Accumulators.percentile(property.path(), inExpression, pExpression, method)
+
+    /**
+     * Returns a combination of a computed field and an accumulator that generates a BSON {@link
+     * org.bson.BsonType#DOUBLE Double } representing the median value computed from the given {@code inExpression}
+     * within a group.
+     *
+     * @param property The data class property computed by the accumulator.
+     * @param inExpression The input expression.
+     * @param method The method to be used for computing the median.
+     * @param <InExpression> The type of the input expression.
+     * @return The requested {@link BsonField}. @mongodb.driver.manual reference/operator/aggregation/median/
+     *   $median @mongodb.server.release 7.0
+     */
+    public fun <InExpression> median(
+        property: KProperty<*>,
+        inExpression: InExpression,
+        method: QuantileMethod
+    ): BsonField = Accumulators.median(property.path(), inExpression, method)
+
+    /**
+     * Gets a field name for a $group operation representing the value of the given expression when applied to the first
+     * member of the group.
+     *
+     * @param property The data class property
+     * @param expression the expression
+     * @param <TExpression> the expression type
+     * @return the field @mongodb.driver.manual reference/operator/aggregation/first/ $first
+     */
+    public fun <TExpression> first(property: KProperty<*>, expression: TExpression): BsonField =
+        Accumulators.first(property.path(), expression)
+
+    /**
+     * Returns a combination of a computed field and an accumulator that produces a BSON {@link org.bson.BsonType#ARRAY
+     * Array} of values of the given {@code inExpression} computed for the first {@code N} elements within a presorted
+     * group, where {@code N} is the positive integral value of the {@code nExpression}.
+     *
+     * @param property The data class property computed by the accumulator.
+     * @param inExpression The input expression.
+     * @param nExpression The expression limiting the number of produced values.
+     * @param <InExpression> The type of the input expression.
+     * @param <NExpression> The type of the limiting expression.
+     * @return The requested {@link BsonField}. @mongodb.driver.manual reference/operator/aggregation/firstN/
+     *   $firstN @mongodb.server.release 5.2
+     */
+    public fun <InExpression, NExpression> firstN(
+        property: KProperty<*>,
+        inExpression: InExpression,
+        nExpression: NExpression
+    ): BsonField = Accumulators.firstN(property.path(), inExpression, nExpression)
+
+    /**
+     * Returns a combination of a computed field and an accumulator that produces a value of the given {@code
+     * outExpression} computed for the top element within a group sorted according to the provided {@code sortBy}
+     * specification.
+     *
+     * @param property The data class property computed by the accumulator.
+     * @param sortBy The {@linkplain Sorts sort specification}. The syntax is identical to the one expected by {@link
+     *   Aggregates#sort(Bson)}.
+     * @param outExpression The output expression.
+     * @param <OutExpression> The type of the output expression.
+     * @return The requested {@link BsonField}. @mongodb.driver.manual reference/operator/aggregation/top/
+     *   $top @mongodb.server.release 5.2
+     */
+    public fun <OutExpression> top(property: KProperty<*>, sortBy: Bson, outExpression: OutExpression): BsonField =
+        Accumulators.top(property.path(), sortBy, outExpression)
+
+    /**
+     * Returns a combination of a computed field and an accumulator that produces a BSON {@link org.bson.BsonType#ARRAY
+     * Array} of values of the given {@code outExpression} computed for the top {@code N} elements within a group sorted
+     * according to the provided {@code sortBy} specification, where {@code N} is the positive integral value of the
+     * {@code nExpression}.
+     *
+     * @param property The data class property computed by the accumulator.
+     * @param sortBy The {@linkplain Sorts sort specification}. The syntax is identical to the one expected by {@link
+     *   Aggregates#sort(Bson)}.
+     * @param outExpression The output expression.
+     * @param nExpression The expression limiting the number of produced values.
+     * @param <OutExpression> The type of the output expression.
+     * @param <NExpression> The type of the limiting expression.
+     * @return The requested {@link BsonField}. @mongodb.driver.manual reference/operator/aggregation/topN/ $topN
+     * @since 4.7 @mongodb.server.release 5.2
+     */
+    public fun <OutExpression, NExpression> topN(
+        property: KProperty<*>,
+        sortBy: Bson,
+        outExpression: OutExpression,
+        nExpression: NExpression
+    ): BsonField = Accumulators.topN(property.path(), sortBy, outExpression, nExpression)
+
+    /**
+     * Gets a field name for a $group operation representing the value of the given expression when applied to the last
+     * member of the group.
+     *
+     * @param property The data class property
+     * @param expression the expression
+     * @param <TExpression> the expression type
+     * @return the field @mongodb.driver.manual reference/operator/aggregation/last/ $last
+     */
+    public fun <TExpression> last(property: KProperty<*>, expression: TExpression): BsonField =
+        Accumulators.last(property.path(), expression)
+
+    /**
+     * Returns a combination of a computed field and an accumulator that produces a BSON {@link org.bson.BsonType#ARRAY
+     * Array} of values of the given {@code inExpression} computed for the last {@code N} elements within a presorted
+     * group, where {@code N} is the positive integral value of the {@code nExpression}.
+     *
+     * @param property The data class property computed by the accumulator.
+     * @param inExpression The input expression.
+     * @param nExpression The expression limiting the number of produced values.
+     * @param <InExpression> The type of the input expression.
+     * @param <NExpression> The type of the limiting expression.
+     * @return The requested {@link BsonField}. @mongodb.driver.manual reference/operator/aggregation/lastN/
+     *   $lastN @mongodb.server.release 5.2
+     */
+    public fun <InExpression, NExpression> lastN(
+        property: KProperty<*>,
+        inExpression: InExpression,
+        nExpression: NExpression
+    ): BsonField = Accumulators.lastN(property.path(), inExpression, nExpression)
+
+    /**
+     * Returns a combination of a computed field and an accumulator that produces a value of the given {@code
+     * outExpression} computed for the bottom element within a group sorted according to the provided {@code sortBy}
+     * specification.
+     *
+     * @param property The data class property computed by the accumulator.
+     * @param sortBy The {@linkplain Sorts sort specification}. The syntax is identical to the one expected by {@link
+     *   Aggregates#sort(Bson)}.
+     * @param outExpression The output expression.
+     * @param <OutExpression> The type of the output expression.
+     * @return The requested {@link BsonField}. @mongodb.driver.manual reference/operator/aggregation/bottom/
+     *   $bottom @mongodb.server.release 5.2
+     */
+    public fun <OutExpression> bottom(property: KProperty<*>, sortBy: Bson, outExpression: OutExpression): BsonField =
+        Accumulators.bottom(property.path(), sortBy, outExpression)
+
+    /**
+     * Returns a combination of a computed field and an accumulator that produces a BSON {@link org.bson.BsonType#ARRAY
+     * Array} of values of the given {@code outExpression} computed for the bottom {@code N} elements within a group
+     * sorted according to the provided {@code sortBy} specification, where {@code N} is the positive integral value of
+     * the {@code nExpression}.
+     *
+     * @param property The data class property computed by the accumulator.
+     * @param sortBy The {@linkplain Sorts sort specification}. The syntax is identical to the one expected by {@link
+     *   Aggregates#sort(Bson)}.
+     * @param outExpression The output expression.
+     * @param nExpression The expression limiting the number of produced values.
+     * @param <OutExpression> The type of the output expression.
+     * @param <NExpression> The type of the limiting expression.
+     * @return The requested {@link BsonField}. @mongodb.driver.manual reference/operator/aggregation/bottomN/ $bottomN
+     * @since 4.7 @mongodb.server.release 5.2
+     */
+    public fun <OutExpression, NExpression> bottomN(
+        property: KProperty<*>,
+        sortBy: Bson,
+        outExpression: OutExpression,
+        nExpression: NExpression
+    ): BsonField = Accumulators.bottomN(property.path(), sortBy, outExpression, nExpression)
+
+    /**
+     * Gets a field name for a $group operation representing the maximum of the values of the given expression when
+     * applied to all members of the group.
+     *
+     * @param property The data class property
+     * @param expression the expression
+     * @param <TExpression> the expression type
+     * @return the field @mongodb.driver.manual reference/operator/aggregation/max/ $max
+     */
+    public fun <TExpression> max(property: KProperty<*>, expression: TExpression): BsonField =
+        Accumulators.max(property.path(), expression)
+
+    /**
+     * Returns a combination of a computed field and an accumulator that produces a BSON {@link org.bson.BsonType#ARRAY
+     * Array} of {@code N} largest values of the given {@code inExpression}, where {@code N} is the positive integral
+     * value of the {@code nExpression}.
+     *
+     * @param property The data class property computed by the accumulator.
+     * @param inExpression The input expression.
+     * @param nExpression The expression limiting the number of produced values.
+     * @param <InExpression> The type of the input expression.
+     * @param <NExpression> The type of the limiting expression.
+     * @return The requested {@link BsonField}. @mongodb.driver.manual reference/operator/aggregation/maxN/ $maxN
+     * @since 4.7 @mongodb.server.release 5.2
+     */
+    public fun <InExpression, NExpression> maxN(
+        property: KProperty<*>,
+        inExpression: InExpression,
+        nExpression: NExpression
+    ): BsonField = Accumulators.maxN(property.path(), inExpression, nExpression)
+
+    /**
+     * Gets a field name for a $group operation representing the minimum of the values of the given expression when
+     * applied to all members of the group.
+     *
+     * @param property The data class property
+     * @param expression the expression
+     * @param <TExpression> the expression type
+     * @return the field @mongodb.driver.manual reference/operator/aggregation/min/ $min
+     */
+    public fun <TExpression> min(property: KProperty<*>, expression: TExpression): BsonField =
+        Accumulators.min(property.path(), expression)
+
+    /**
+     * Returns a combination of a computed field and an accumulator that produces a BSON {@link org.bson.BsonType#ARRAY
+     * Array} of {@code N} smallest values of the given {@code inExpression}, where {@code N} is the positive integral
+     * value of the {@code nExpression}.
+     *
+     * @param property The data class property computed by the accumulator.
+     * @param inExpression The input expression.
+     * @param nExpression The expression limiting the number of produced values.
+     * @param <InExpression> The type of the input expression.
+     * @param <NExpression> The type of the limiting expression.
+     * @return The requested {@link BsonField}. @mongodb.driver.manual reference/operator/aggregation/minN/
+     *   $minN @mongodb.server.release 5.2
+     */
+    public fun <InExpression, NExpression> minN(
+        property: KProperty<*>,
+        inExpression: InExpression,
+        nExpression: NExpression
+    ): BsonField = Accumulators.minN(property.path(), inExpression, nExpression)
+
+    /**
+     * Gets a field name for a $group operation representing an array of all values that results from applying an
+     * expression to each document in a group of documents that share the same group by key.
+     *
+     * @param property The data class property
+     * @param expression the expression
+     * @param <TExpression> the expression type
+     * @return the field @mongodb.driver.manual reference/operator/aggregation/push/ $push
+     */
+    public fun <TExpression> push(property: KProperty<*>, expression: TExpression): BsonField =
+        Accumulators.push(property.path(), expression)
+
+    /**
+     * Gets a field name for a $group operation representing all unique values that results from applying the given
+     * expression to each document in a group of documents that share the same group by key.
+     *
+     * @param property The data class property
+     * @param expression the expression
+     * @param <TExpression> the expression type
+     * @return the field @mongodb.driver.manual reference/operator/aggregation/addToSet/ $addToSet
+     */
+    public fun <TExpression> addToSet(property: KProperty<*>, expression: TExpression): BsonField =
+        Accumulators.addToSet(property.path(), expression)
+
+    /**
+     * Gets a field name for a $group operation representing the result of merging the fields of the documents. If
+     * documents to merge include the same field name, the field, in the resulting document, has the value from the last
+     * document merged for the field.
+     *
+     * @param property The data class property
+     * @param expression the expression
+     * @param <TExpression> the expression type
+     * @return the field @mongodb.driver.manual reference/operator/aggregation/mergeObjects/ $mergeObjects
+     */
+    public fun <TExpression> mergeObjects(property: KProperty<*>, expression: TExpression): BsonField =
+        Accumulators.mergeObjects(property.path(), expression)
+
+    /**
+     * Gets a field name for a $group operation representing the sample standard deviation of the values of the given
+     * expression when applied to all members of the group.
+     *
+     * <p>Use if the values encompass the entire population of data you want to represent and do not wish to generalize
+     * about a larger population.</p>
+     *
+     * @param property The data class property
+     * @param expression the expression
+     * @param <TExpression> the expression type
+     * @return the field @mongodb.driver.manual reference/operator/aggregation/stdDevPop/
+     *   $stdDevPop @mongodb.server.release 3.2
+     */
+    public fun <TExpression> stdDevPop(property: KProperty<*>, expression: TExpression): BsonField =
+        Accumulators.stdDevPop(property.path(), expression)
+
+    /**
+     * Gets a field name for a $group operation representing the sample standard deviation of the values of the given
+     * expression when applied to all members of the group.
+     *
+     * <p>Use if the values encompass a sample of a population of data from which to generalize about the
+     * population.</p>
+     *
+     * @param property the data class property
+     * @param expression the expression
+     * @param <TExpression> the expression type
+     * @return the field @mongodb.driver.manual reference/operator/aggregation/stdDevSamp/
+     *   $stdDevSamp @mongodb.server.release 3.2
+     */
+    public fun <TExpression> stdDevSamp(property: KProperty<*>, expression: TExpression): BsonField =
+        Accumulators.stdDevSamp(property.path(), expression)
+
+    /**
+     * Creates an $accumulator pipeline stage
+     *
+     * @param property the data class property
+     * @param initFunction a function used to initialize the state
+     * @param accumulateFunction a function used to accumulate documents
+     * @param mergeFunction a function used to merge two internal states, e.g. accumulated on different shards or
+     *   threads. It returns the resulting state of the accumulator.
+     * @return the $accumulator pipeline stage @mongodb.driver.manual reference/operator/aggregation/accumulator/
+     *   $accumulator @mongodb.server.release 4.4
+     */
+    public fun <T> accumulator(
+        property: KProperty<T>,
+        initFunction: String,
+        accumulateFunction: String,
+        mergeFunction: String
+    ): BsonField = Accumulators.accumulator(property.path(), initFunction, accumulateFunction, mergeFunction)
+
+    /**
+     * Creates an $accumulator pipeline stage
+     *
+     * @param property the data class property
+     * @param initFunction a function used to initialize the state
+     * @param accumulateFunction a function used to accumulate documents
+     * @param mergeFunction a function used to merge two internal states, e.g. accumulated on different shards or
+     *   threads. It returns the resulting state of the accumulator.
+     * @param finalizeFunction a function used to finalize the state and return the result (may be null)
+     * @return the $accumulator pipeline stage @mongodb.driver.manual reference/operator/aggregation/accumulator/
+     *   $accumulator @mongodb.server.release 4.4
+     */
+    public fun <T> accumulator(
+        property: KProperty<T>,
+        initFunction: String,
+        accumulateFunction: String,
+        mergeFunction: String,
+        finalizeFunction: String?
+    ): BsonField =
+        Accumulators.accumulator(property.path(), initFunction, accumulateFunction, mergeFunction, finalizeFunction)
+
+    /**
+     * Creates an $accumulator pipeline stage
+     *
+     * @param property the data class property
+     * @param initFunction a function used to initialize the state
+     * @param initArgs init function’s arguments (may be null)
+     * @param accumulateFunction a function used to accumulate documents
+     * @param accumulateArgs additional accumulate function’s arguments (may be null). The first argument to the
+     *   function is ‘state’.
+     * @param mergeFunction a function used to merge two internal states, e.g. accumulated on different shards or
+     *   threads. It returns the resulting state of the accumulator.
+     * @param finalizeFunction a function used to finalize the state and return the result (may be null)
+     * @return the $accumulator pipeline stage @mongodb.driver.manual reference/operator/aggregation/accumulator/
+     *   $accumulator @mongodb.server.release 4.4
+     */
+    @Suppress("LongParameterList")
+    public fun <T> accumulator(
+        property: KProperty<T>,
+        initFunction: String,
+        initArgs: List<String>?,
+        accumulateFunction: String,
+        accumulateArgs: List<String>?,
+        mergeFunction: String,
+        finalizeFunction: String?
+    ): BsonField =
+        Accumulators.accumulator(
+            property.path(),
+            initFunction,
+            initArgs,
+            accumulateFunction,
+            accumulateArgs,
+            mergeFunction,
+            finalizeFunction)
+
+    /**
+     * Creates an $accumulator pipeline stage
+     *
+     * @param property the data class property
+     * @param initFunction a function used to initialize the state
+     * @param accumulateFunction a function used to accumulate documents
+     * @param mergeFunction a function used to merge two internal states, e.g. accumulated on different shards or
+     *   threads. It returns the resulting state of the accumulator.
+     * @param finalizeFunction a function used to finalize the state and return the result (may be null)
+     * @param lang a language specifier
+     * @return the $accumulator pipeline stage @mongodb.driver.manual reference/operator/aggregation/accumulator/
+     *   $accumulator @mongodb.server.release 4.4
+     */
+    @Suppress("LongParameterList")
+    public fun <T> accumulator(
+        property: KProperty<T>,
+        initFunction: String,
+        accumulateFunction: String,
+        mergeFunction: String,
+        finalizeFunction: String?,
+        lang: String
+    ): BsonField =
+        Accumulators.accumulator(
+            property.path(), initFunction, accumulateFunction, mergeFunction, finalizeFunction, lang)
+
+    /**
+     * Creates an $accumulator pipeline stage
+     *
+     * @param property The data class property.
+     * @param initFunction a function used to initialize the state
+     * @param initArgs init function’s arguments (may be null)
+     * @param accumulateFunction a function used to accumulate documents
+     * @param accumulateArgs additional accumulate function’s arguments (may be null). The first argument to the
+     *   function is ‘state’.
+     * @param mergeFunction a function used to merge two internal states, e.g. accumulated on different shards or
+     *   threads. It returns the resulting state of the accumulator.
+     * @param finalizeFunction a function used to finalize the state and return the result (may be null)
+     * @param lang a language specifier
+     * @return the $accumulator pipeline stage @mongodb.driver.manual reference/operator/aggregation/accumulator/
+     *   $accumulator @mongodb.server.release 4.4
+     */
+    @Suppress("LongParameterList")
+    public fun <T> accumulator(
+        property: KProperty<T>,
+        initFunction: String,
+        initArgs: List<String>?,
+        accumulateFunction: String,
+        accumulateArgs: List<String>?,
+        mergeFunction: String,
+        finalizeFunction: String?,
+        lang: String
+    ): BsonField =
+        Accumulators.accumulator(
+            property.path(),
+            initFunction,
+            initArgs,
+            accumulateFunction,
+            accumulateArgs,
+            mergeFunction,
+            finalizeFunction,
+            lang)
+}
diff --git a/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Aggregates.kt b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Aggregates.kt
new file mode 100644
index 00000000000..395ce98d88d
--- /dev/null
+++ b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Aggregates.kt
@@ -0,0 +1,244 @@
+/*
+ * 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
+import com.mongodb.client.model.GraphLookupOptions
+import com.mongodb.client.model.MergeOptions
+import com.mongodb.client.model.UnwindOptions
+import com.mongodb.client.model.densify.DensifyOptions
+import com.mongodb.client.model.densify.DensifyRange
+import com.mongodb.kotlin.client.model.Projections.projection
+import kotlin.reflect.KProperty
+import kotlin.reflect.KProperty1
+import org.bson.conversions.Bson
+
+/**
+ * Aggregates extension methods to improve Kotlin interop
+ *
+ * @since 5.3
+ */
+public object Aggregates {
+    /**
+     * Creates a $count pipeline stage using the named field to store the result
+     *
+     * @param property the data class field in which to store the count
+     * @return the $count pipeline stage @mongodb.driver.manual reference/operator/aggregation/count/ $count
+     */
+    public fun <T> count(property: KProperty<T>): Bson = Aggregates.count(property.path())
+
+    /**
+     * Creates a $lookup pipeline stage, joining the current collection with the one specified in from using the given
+     * pipeline. If the first stage in the pipeline is a {@link Aggregates#documents(List) $documents} stage, then the
+     * {@code from} collection is ignored.
+     *
+     * @param from the collection in the same database to perform the join with.
+     * @param localField the data class field from the local collection to match values against.
+     * @param foreignField the data class field in the from collection to match values against.
+     * @param pipeline the pipeline to run on the joined collection.
+     * @param as the name of the new array field to add to the input documents.
+     * @return the $lookup pipeline stage @mongodb.driver.manual reference/operator/aggregation/lookup/
+     *   $lookup @mongodb.server.release 3.6
+     */
+    public fun <FROM : Any> lookup(
+        from: com.mongodb.kotlin.client.MongoCollection<FROM>,
+        localField: KProperty1<out Any, Any?>,
+        foreignField: KProperty1<FROM, Any?>,
+        newAs: String
+    ): Bson = Aggregates.lookup(from.namespace.collectionName, localField.path(), foreignField.path(), newAs)
+
+    /**
+     * Creates a $lookup pipeline stage, joining the current collection with the one specified in from using the given
+     * pipeline. If the first stage in the pipeline is a {@link Aggregates#documents(List) $documents} stage, then the
+     * {@code from} collection is ignored.
+     *
+     * @param from the collection in the same database to perform the join with.
+     * @param localField the data class field from the local collection to match values against.
+     * @param foreignField the data class field in the from collection to match values against.
+     * @param pipeline the pipeline to run on the joined collection.
+     * @param as the name of the new array field to add to the input documents.
+     * @return the $lookup pipeline stage @mongodb.driver.manual reference/operator/aggregation/lookup/
+     *   $lookup @mongodb.server.release 3.6
+     */
+    public fun <FROM : Any> lookup(
+        from: com.mongodb.kotlin.client.coroutine.MongoCollection<FROM>,
+        localField: KProperty1<out Any, Any?>,
+        foreignField: KProperty1<FROM, Any?>,
+        newAs: String
+    ): Bson = Aggregates.lookup(from.namespace.collectionName, localField.path(), foreignField.path(), newAs)
+
+    /**
+     * Creates a graphLookup pipeline stage for the specified filter
+     *
+     * @param <TExpression> the expression type
+     * @param from the collection to query
+     * @param startWith the expression to start the graph lookup with
+     * @param connectFromField the data class from field
+     * @param connectToField the data class to field
+     * @param fieldAs name of field in output document
+     * @param options optional values for the graphLookup
+     * @return the $graphLookup pipeline stage @mongodb.driver.manual reference/operator/aggregation/graphLookup/
+     *   $graphLookup @mongodb.server.release 3.4
+     */
+    @Suppress("LongParameterList")
+    public fun <TExpression, FROM : Any> graphLookup(
+        from: com.mongodb.kotlin.client.MongoCollection<FROM>,
+        startWith: TExpression,
+        connectFromField: KProperty1<FROM, Any?>,
+        connectToField: KProperty1<FROM, Any?>,
+        fieldAs: String,
+        options: GraphLookupOptions = GraphLookupOptions()
+    ): Bson =
+        Aggregates.graphLookup(
+            from.namespace.collectionName, startWith, connectFromField.path(), connectToField.path(), fieldAs, options)
+
+    /**
+     * Creates a graphLookup pipeline stage for the specified filter
+     *
+     * @param <TExpression> the expression type
+     * @param from the collection to query
+     * @param startWith the expression to start the graph lookup with
+     * @param connectFromField the data class from field
+     * @param connectToField the data class to field
+     * @param fieldAs name of field in output document
+     * @param options optional values for the graphLookup
+     * @return the $graphLookup pipeline stage @mongodb.driver.manual reference/operator/aggregation/graphLookup/
+     *   $graphLookup @mongodb.server.release 3.4
+     */
+    @Suppress("LongParameterList")
+    public fun <TExpression, FROM : Any> graphLookup(
+        from: com.mongodb.kotlin.client.coroutine.MongoCollection<FROM>,
+        startWith: TExpression,
+        connectFromField: KProperty1<FROM, Any?>,
+        connectToField: KProperty1<FROM, Any?>,
+        fieldAs: String,
+        options: GraphLookupOptions = GraphLookupOptions()
+    ): Bson =
+        Aggregates.graphLookup(
+            from.namespace.collectionName, startWith, connectFromField.path(), connectToField.path(), fieldAs, options)
+
+    /**
+     * Creates a $unionWith pipeline stage.
+     *
+     * @param collection the collection in the same database to perform the union with.
+     * @param pipeline the pipeline to run on the union.
+     * @return the $unionWith pipeline stage @mongodb.driver.manual reference/operator/aggregation/unionWith/
+     *   $unionWith @mongodb.server.release 4.4
+     */
+    public fun unionWith(collection: com.mongodb.kotlin.client.MongoCollection<*>, pipeline: List<Bson>): Bson =
+        Aggregates.unionWith(collection.namespace.collectionName, pipeline)
+
+    /**
+     * Creates a $unionWith pipeline stage.
+     *
+     * @param collection the collection in the same database to perform the union with.
+     * @param pipeline the pipeline to run on the union.
+     * @return the $unionWith pipeline stage @mongodb.driver.manual reference/operator/aggregation/unionWith/
+     *   $unionWith @mongodb.server.release 4.4
+     */
+    public fun unionWith(
+        collection: com.mongodb.kotlin.client.coroutine.MongoCollection<*>,
+        pipeline: List<Bson>
+    ): Bson = Aggregates.unionWith(collection.namespace.collectionName, pipeline)
+
+    /**
+     * Creates a $unwind pipeline stage for the specified field name, which must be prefixed by a {@code '$'} sign.
+     *
+     * @param property the data class field name
+     * @param unwindOptions options for the unwind pipeline stage
+     * @return the $unwind pipeline stage @mongodb.driver.manual reference/operator/aggregation/unwind/ $unwind
+     */
+    public fun <T> unwind(property: KProperty<Iterable<T>?>, unwindOptions: UnwindOptions = UnwindOptions()): Bson {
+        return if (unwindOptions == UnwindOptions()) {
+            Aggregates.unwind(property.projection)
+        } else {
+            Aggregates.unwind(property.projection, unwindOptions)
+        }
+    }
+
+    /**
+     * Creates a $out pipeline stage that writes into the specified collection
+     *
+     * @param collection the collection
+     * @return the $out pipeline stage @mongodb.driver.manual reference/operator/aggregation/out/ $out
+     */
+    public fun out(collection: com.mongodb.kotlin.client.MongoCollection<*>): Bson =
+        Aggregates.out(collection.namespace.collectionName)
+
+    /**
+     * Creates a $out pipeline stage that writes into the specified collection
+     *
+     * @param collection the collection
+     * @return the $out pipeline stage @mongodb.driver.manual reference/operator/aggregation/out/ $out
+     */
+    public fun out(collection: com.mongodb.kotlin.client.coroutine.MongoCollection<*>): Bson =
+        Aggregates.out(collection.namespace.collectionName)
+
+    /**
+     * Creates a $merge pipeline stage that merges into the specified collection
+     *
+     * @param collection the collection to merge into
+     * @param options the merge options
+     * @return the $merge pipeline stage @mongodb.driver.manual reference/operator/aggregation/merge/
+     *   $merge @mongodb.server.release 4.2
+     */
+    public fun merge(
+        collection: com.mongodb.kotlin.client.MongoCollection<*>,
+        options: MergeOptions = MergeOptions()
+    ): Bson = Aggregates.merge(collection.namespace.collectionName, options)
+
+    /**
+     * Creates a $merge pipeline stage that merges into the specified collection
+     *
+     * @param collection the collection to merge into
+     * @param options the merge options
+     * @return the $merge pipeline stage @mongodb.driver.manual reference/operator/aggregation/merge/
+     *   $merge @mongodb.server.release 4.2
+     */
+    public fun merge(
+        collection: com.mongodb.kotlin.client.coroutine.MongoCollection<*>,
+        options: MergeOptions = MergeOptions()
+    ): Bson = Aggregates.merge(collection.namespace.collectionName, options)
+
+    /**
+     * Creates a `$densify` pipeline stage, which adds documents to a sequence of documents where certain values in the
+     * `field` are missing.
+     *
+     * @param field The field to densify.
+     * @param range The range.
+     * @return The requested pipeline stage. @mongodb.driver.manual reference/operator/aggregation/densify/
+     *   $densify @mongodb.driver.manual core/document/#dot-notation Dot notation @mongodb.server.release 5.1
+     */
+    public fun <T> densify(property: KProperty<T>, range: DensifyRange): Bson =
+        Aggregates.densify(property.path(), range)
+
+    /**
+     * Creates a {@code $densify} pipeline stage, which adds documents to a sequence of documents where certain values
+     * in the {@code field} are missing.
+     *
+     * @param field The field to densify.
+     * @param range The range.
+     * @param options The densify options. Specifying {@link DensifyOptions#densifyOptions()} is equivalent to calling
+     *   {@link #densify(String, DensifyRange)}.
+     * @return The requested pipeline stage. @mongodb.driver.manual reference/operator/aggregation/densify/
+     *   $densify @mongodb.driver.manual core/document/#dot-notation Dot notation @mongodb.server.release 5.1
+     */
+    public fun <T> densify(property: KProperty<T>, range: DensifyRange, options: DensifyOptions): Bson =
+        Aggregates.densify(property.path(), range, options)
+}
diff --git a/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Filters.kt b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Filters.kt
new file mode 100644
index 00000000000..3faef6a8458
--- /dev/null
+++ b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Filters.kt
@@ -0,0 +1,1219 @@
+/*
+ * 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
+ */
+@file:Suppress("TooManyFunctions")
+
+package com.mongodb.kotlin.client.model
+
+import com.mongodb.client.model.Filters
+import com.mongodb.client.model.TextSearchOptions
+import com.mongodb.client.model.geojson.Geometry
+import com.mongodb.client.model.geojson.Point
+import java.util.regex.Pattern
+import kotlin.internal.OnlyInputTypes
+import kotlin.reflect.KProperty
+import org.bson.BsonType
+import org.bson.conversions.Bson
+
+/**
+ * Filters extension methods to improve Kotlin interop
+ *
+ * @since 5.3
+ */
+public object Filters {
+
+    /**
+     * Creates a filter that matches all documents where the value of the property equals the specified value. Note that
+     * this doesn't actually generate an $eq operator, as the query language doesn't require it.
+     *
+     * @param value the value, which may be null
+     * @param <T> the value type
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("eqExt")
+    public infix fun <@OnlyInputTypes T> KProperty<T?>.eq(value: T?): Bson = Filters.eq(path(), value)
+
+    /**
+     * Creates a filter that matches all documents where the value of the property equals the specified value. Note that
+     * this doesn't actually generate an $eq operator, as the query language doesn't require it.
+     *
+     * @param property the data class property
+     * @param value the value, which may be null
+     * @param <T> the value type
+     * @return the filter
+     */
+    public fun <@OnlyInputTypes T> eq(property: KProperty<T?>, value: T?): Bson = property.eq(value)
+
+    /**
+     * Creates a filter that matches all documents where the value of the property does not equal the specified value.
+     *
+     * @param value the value
+     * @param <T> the value type
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("neExt")
+    public infix fun <@OnlyInputTypes T> KProperty<T?>.ne(value: T?): Bson = Filters.ne(path(), value)
+
+    /**
+     * Creates a filter that matches all documents where the value of the property does not equal the specified value.
+     *
+     * @param property the data class property
+     * @param value the value
+     * @param <T> the value type
+     * @return the filter
+     */
+    public fun <@OnlyInputTypes T> ne(property: KProperty<T?>, value: T?): Bson = property.ne(value)
+
+    /**
+     * Creates a filter that matches all documents where the value of the given property is less than the specified
+     * value.
+     *
+     * @param value the value
+     * @param <T> the value type
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("ltExt")
+    public infix fun <@OnlyInputTypes T> KProperty<T?>.lt(value: T): Bson = Filters.lt(path(), value)
+
+    /**
+     * Creates a filter that matches all documents where the value of the given property is less than the specified
+     * value.
+     *
+     * @param property the data class property
+     * @param value the value
+     * @param <T> the value type
+     * @return the filter
+     */
+    public fun <@OnlyInputTypes T> lt(property: KProperty<T?>, value: T): Bson = property.lt(value)
+
+    /**
+     * Creates a filter that matches all documents where the value of the given property is less than or equal to the
+     * specified value.
+     *
+     * @param value the value
+     * @param <T> the value type
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("lteExt")
+    public infix fun <@OnlyInputTypes T> KProperty<T?>.lte(value: T): Bson = Filters.lte(path(), value)
+
+    /**
+     * Creates a filter that matches all documents where the value of the given property is less than or equal to the
+     * specified value.
+     *
+     * @param property the data class property
+     * @param value the value
+     * @param <T> the value type
+     * @return the filter
+     */
+    public fun <@OnlyInputTypes T> lte(property: KProperty<T?>, value: T): Bson = property.lte(value)
+
+    /**
+     * Creates a filter that matches all documents where the value of the given property is greater than the specified
+     * value.
+     *
+     * @param value the value
+     * @param <T> the value type
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("gtExt")
+    public infix fun <@OnlyInputTypes T> KProperty<T>.gt(value: T): Bson = Filters.gt(path(), value)
+
+    /**
+     * Creates a filter that matches all documents where the value of the given property is greater than the specified
+     * value.
+     *
+     * @param property the data class property
+     * @param value the value
+     * @param <T> the value type
+     * @return the filter
+     */
+    public fun <@OnlyInputTypes T> gt(property: KProperty<T>, value: T): Bson = property.gt(value)
+
+    /**
+     * Creates a filter that matches all documents where the value of the given property is greater than or equal to the
+     * specified value.
+     *
+     * @param value the value
+     * @param <T> the value type
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("gteExt")
+    public infix fun <@OnlyInputTypes T> KProperty<T>.gte(value: T): Bson = Filters.gte(path(), value)
+
+    /**
+     * Creates a filter that matches all documents where the value of the given property is greater than or equal to the
+     * specified value.
+     *
+     * @param property the data class property
+     * @param value the value
+     * @param <T> the value type
+     * @return the filter
+     */
+    public fun <@OnlyInputTypes T> gte(property: KProperty<T>, value: T): Bson = property.gte(value)
+
+    /**
+     * Creates a filter that matches all documents where the value of a property equals any value in the list of
+     * specified values.
+     *
+     * @param values the list of values
+     * @param <T> the value type
+     * @return the filter
+     */
+    @Suppress("FunctionNaming")
+    @JvmSynthetic
+    @JvmName("inExt")
+    public infix fun <@OnlyInputTypes T> KProperty<T?>.`in`(values: Iterable<T?>): Bson = Filters.`in`(path(), values)
+
+    /**
+     * Creates a filter that matches all documents where the value of a property equals any value in the list of
+     * specified values.
+     *
+     * @param property the data class property
+     * @param values the list of values
+     * @param <T> the value type
+     * @return the filter
+     */
+    @Suppress("FunctionNaming")
+    public fun <@OnlyInputTypes T> `in`(property: KProperty<T?>, values: Iterable<T?>): Bson = property.`in`(values)
+
+    /**
+     * Creates a filter that matches all documents where the value of a property equals any value in the list of
+     * specified values.
+     *
+     * @param values the list of values
+     * @param <T> the value type
+     * @return the filter
+     */
+    @Suppress("FunctionNaming")
+    @JvmSynthetic
+    @JvmName("inIterableExt")
+    public infix fun <@OnlyInputTypes T> KProperty<Iterable<T>?>.`in`(values: Iterable<T?>): Bson =
+        Filters.`in`(path(), values)
+
+    /**
+     * Creates a filter that matches all documents where the value of a property equals any value in the list of
+     * specified values.
+     *
+     * @param property the data class property
+     * @param values the list of values
+     * @param <T> the value type
+     * @return the filter
+     */
+    @Suppress("FunctionNaming")
+    @JvmSynthetic
+    @JvmName("inIterable")
+    public fun <@OnlyInputTypes T> `in`(property: KProperty<Iterable<T>?>, values: Iterable<T?>): Bson =
+        property.`in`(values)
+
+    /**
+     * Creates a filter that matches all documents where the value of a property does not equal any of the specified
+     * values or does not exist.
+     *
+     * @param values the list of values
+     * @param <T> the value type
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("ninExt")
+    public infix fun <@OnlyInputTypes T> KProperty<T?>.nin(values: Iterable<T?>): Bson = Filters.nin(path(), values)
+
+    /**
+     * Creates a filter that matches all documents where the value of a property does not equal any of the specified
+     * values or does not exist.
+     *
+     * @param property the data class property
+     * @param values the list of values
+     * @param <T> the value type
+     * @return the filter
+     */
+    public fun <@OnlyInputTypes T> nin(property: KProperty<T?>, values: Iterable<T?>): Bson = property.nin(values)
+
+    /**
+     * Creates a filter that matches all documents where the value of a property does not equal any of the specified
+     * values or does not exist.
+     *
+     * @param values the list of values
+     * @param <T> the value type
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("ninIterableExt")
+    public infix fun <@OnlyInputTypes T> KProperty<Iterable<T>?>.nin(values: Iterable<T?>): Bson =
+        Filters.nin(path(), values)
+
+    /**
+     * Creates a filter that matches all documents where the value of a property does not equal any of the specified
+     * values or does not exist.
+     *
+     * @param property the data class property
+     * @param values the list of values
+     * @param <T> the value type
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("ninIterable")
+    public fun <@OnlyInputTypes T> nin(property: KProperty<Iterable<T>?>, values: Iterable<T?>): Bson =
+        property.nin(values)
+
+    /**
+     * Creates a filter that performs a logical AND of the provided list of filters. Note that this will only generate
+     * an "$and" operator if absolutely necessary, as the query language implicitly ands together all the keys. In other
+     * words, a query expression like:
+     * ```and(eq("x", 1), lt("y", 3))```
+     *
+     * will generate a MongoDB query like: `{x : 1, y : {$lt : 3}}``
+     *
+     * @param filters the list of filters to and together
+     * @return the filter
+     */
+    public fun and(filters: Iterable<Bson?>): Bson = Filters.and(filters)
+
+    /**
+     * Creates a filter that performs a logical AND of the provided list of filters. Note that this will only generate
+     * an "$and" operator if absolutely necessary, as the query language implicitly ands together all the keys. In other
+     * words, a query expression like:
+     * ```and(eq("x", 1), lt("y", 3))```
+     *
+     * will generate a MongoDB query like: `{x : 1, y : {$lt : 3}}``
+     *
+     * @param filters the list of filters to and together
+     * @return the filter
+     */
+    public fun and(vararg filters: Bson?): Bson = and(filters.toList())
+
+    /**
+     * Creates a filter that preforms a logical OR of the provided list of filters.
+     *
+     * @param filters the list of filters to and together
+     * @return the filter
+     */
+    public fun or(filters: Iterable<Bson?>): Bson = Filters.or(filters)
+
+    /**
+     * Creates a filter that preforms a logical OR of the provided list of filters.
+     *
+     * @param filters the list of filters to and together
+     * @return the filter
+     */
+    public fun or(vararg filters: Bson?): Bson = or(filters.toList())
+
+    /**
+     * Creates a filter that matches all documents that do not match the passed in filter. Requires the property to
+     * passed as part of the value passed in and lifts it to create a valid "$not" query:
+     * ```not(eq("x", 1))```
+     *
+     * will generate a MongoDB query like: `{x : $not: {$eq : 1}}`
+     *
+     * @param filter the value
+     * @return the filter
+     */
+    public fun not(filter: Bson): Bson = Filters.not(filter)
+
+    /**
+     * Creates a filter that performs a logical NOR operation on all the specified filters.
+     *
+     * @param filters the list of values
+     * @return the filter
+     */
+    public fun nor(vararg filters: Bson): Bson = Filters.nor(*filters)
+
+    /**
+     * Creates a filter that performs a logical NOR operation on all the specified filters.
+     *
+     * @param filters the list of values
+     * @return the filter
+     */
+    public fun nor(filters: Iterable<Bson>): Bson = Filters.nor(filters)
+
+    /**
+     * Creates a filter that matches all documents that contain the given property.
+     *
+     * @return the filter
+     */
+    @JvmSynthetic @JvmName("existsExt") public fun <T> KProperty<T?>.exists(): Bson = Filters.exists(path())
+
+    /**
+     * Creates a filter that matches all documents that contain the given property.
+     *
+     * @param property the data class property
+     * @return the filter
+     */
+    public fun <T> exists(property: KProperty<T?>): Bson = Filters.exists(property.path())
+
+    /**
+     * Creates a filter that matches all documents that either contain or do not contain the given property, depending
+     * on the value of the exists parameter.
+     *
+     * @param exists true to check for existence, false to check for absence
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("existsExt")
+    public infix fun <T> KProperty<T?>.exists(exists: Boolean): Bson = Filters.exists(path(), exists)
+
+    /**
+     * Creates a filter that matches all documents that either contain or do not contain the given property, depending
+     * on the value of the exists parameter.
+     *
+     * @param property the data class property
+     * @param exists true to check for existence, false to check for absence
+     * @return the filter
+     */
+    public fun <T> exists(property: KProperty<T?>, exists: Boolean): Bson = property.exists(exists)
+
+    /**
+     * Creates a filter that matches all documents where the value of the property is of the specified BSON type.
+     *
+     * @param type the BSON type
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("typeExt")
+    public infix fun <T> KProperty<T?>.type(type: BsonType): Bson = Filters.type(path(), type)
+
+    /**
+     * Creates a filter that matches all documents where the value of the property is of the specified BSON type.
+     *
+     * @param property the data class property
+     * @param type the BSON type
+     * @return the filter
+     */
+    public fun <T> type(property: KProperty<T?>, type: BsonType): Bson = property.type(type)
+
+    /**
+     * Creates a filter that matches all documents where the value of a property divided by a divisor has the specified
+     * remainder (i.e. perform a modulo operation to select documents).
+     *
+     * @param divisor the modulus
+     * @param remainder the remainder
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("modExt")
+    public fun <T> KProperty<T?>.mod(divisor: Long, remainder: Long): Bson = Filters.mod(path(), divisor, remainder)
+
+    /**
+     * Creates a filter that matches all documents where the value of a property divided by a divisor has the specified
+     * remainder (i.e. perform a modulo operation to select documents).
+     *
+     * @param property the data class property
+     * @param divisor the modulus
+     * @param remainder the remainder
+     * @return the filter
+     */
+    public fun <T> mod(property: KProperty<T?>, divisor: Long, remainder: Long): Bson = property.mod(divisor, remainder)
+
+    /**
+     * Creates a filter that matches all documents where the value of the property matches the given regular expression
+     * pattern.
+     *
+     * @param pattern the pattern
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("regexExt")
+    public infix fun KProperty<String?>.regex(pattern: String): Bson = Filters.regex(path(), pattern)
+
+    /**
+     * Creates a filter that matches all documents where the value of the property matches the given regular expression
+     * pattern.
+     *
+     * @param property the data class property
+     * @param pattern the pattern
+     * @return the filter
+     */
+    public fun regex(property: KProperty<String?>, pattern: String): Bson = property.regex(pattern)
+
+    /**
+     * Creates a filter that matches all documents where the value of the property matches the given regular expression
+     * pattern.
+     *
+     * @param pattern the pattern
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("regexExt")
+    public infix fun KProperty<String?>.regex(pattern: Pattern): Bson = Filters.regex(path(), pattern)
+
+    /**
+     * Creates a filter that matches all documents where the value of the property matches the given regular expression
+     * pattern.
+     *
+     * @param property the data class property
+     * @param pattern the pattern
+     * @return the filter
+     */
+    public fun regex(property: KProperty<String?>, pattern: Pattern): Bson = property.regex(pattern)
+
+    /**
+     * Creates a filter that matches all documents where the value of the option matches the given regular expression
+     * pattern with the given options applied.
+     *
+     * @param pattern the pattern
+     * @param options the options
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("regexExt")
+    public fun KProperty<String?>.regex(pattern: String, options: String): Bson =
+        Filters.regex(path(), pattern, options)
+
+    /**
+     * Creates a filter that matches all documents where the value of the option matches the given regular expression
+     * pattern with the given options applied.
+     *
+     * @param property the data class property
+     * @param pattern the pattern
+     * @param options the options
+     * @return the filter
+     */
+    public fun regex(property: KProperty<String?>, pattern: String, options: String): Bson =
+        property.regex(pattern, options)
+
+    /**
+     * Creates a filter that matches all documents where the value of the property matches the given regular expression
+     * pattern.
+     *
+     * @param regex the regex
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("regexExt")
+    public infix fun KProperty<String?>.regex(regex: Regex): Bson = Filters.regex(path(), regex.toPattern())
+
+    /**
+     * Creates a filter that matches all documents where the value of the property matches the given regular expression
+     * pattern.
+     *
+     * @param property the data class property
+     * @param regex the regex
+     * @return the filter
+     */
+    public fun regex(property: KProperty<String?>, regex: Regex): Bson = property.regex(regex.toPattern())
+
+    /**
+     * Creates a filter that matches all documents where the value of the property matches the given regular expression
+     * pattern.
+     *
+     * @param pattern the pattern
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("regexIterableExt")
+    public infix fun KProperty<Iterable<String?>>.regex(pattern: String): Bson = Filters.regex(path(), pattern)
+
+    /**
+     * Creates a filter that matches all documents where the value of the property matches the given regular expression
+     * pattern.
+     *
+     * @param property the data class property
+     * @param pattern the pattern
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("regexIterable")
+    public fun regex(property: KProperty<Iterable<String?>>, pattern: String): Bson = property.regex(pattern)
+
+    /**
+     * Creates a filter that matches all documents where the value of the property matches the given regular expression
+     * pattern.
+     *
+     * @param pattern the pattern
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("regexIterableExt")
+    public infix fun KProperty<Iterable<String?>>.regex(pattern: Pattern): Bson = Filters.regex(path(), pattern)
+
+    /**
+     * Creates a filter that matches all documents where the value of the property matches the given regular expression
+     * pattern.
+     *
+     * @param property the data class property
+     * @param pattern the pattern
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("regexIterable")
+    public fun regex(property: KProperty<Iterable<String?>>, pattern: Pattern): Bson = property.regex(pattern)
+
+    /**
+     * Creates a filter that matches all documents where the value of the option matches the given regular expression
+     * pattern with the given options applied.
+     *
+     * @param regex the regex pattern
+     * @param options the options
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("regexIterableExt")
+    public fun KProperty<Iterable<String?>>.regex(regex: String, options: String): Bson =
+        Filters.regex(path(), regex, options)
+
+    /**
+     * Creates a filter that matches all documents where the value of the option matches the given regular expression
+     * pattern with the given options applied.
+     *
+     * @param property the data class property
+     * @param regex the regex pattern
+     * @param options the options
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("regexIterable")
+    public fun regex(property: KProperty<Iterable<String?>>, regex: String, options: String): Bson =
+        property.regex(regex, options)
+
+    /**
+     * Creates a filter that matches all documents where the value of the property matches the given regular expression
+     * pattern.
+     *
+     * @param regex the regex
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("regexIterableExt")
+    public infix fun KProperty<Iterable<String?>>.regex(regex: Regex): Bson = Filters.regex(path(), regex.toPattern())
+
+    /**
+     * Creates a filter that matches all documents where the value of the property matches the given regular expression
+     * pattern.
+     *
+     * @param property the data class property
+     * @param regex the regex
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("regexIterable")
+    public fun regex(property: KProperty<Iterable<String?>>, regex: Regex): Bson = property.regex(regex.toPattern())
+
+    /**
+     * Creates a filter that matches all documents matching the given the search term with the given text search
+     * options.
+     *
+     * @param search the search term
+     * @param textSearchOptions the text search options to use
+     * @return the filter
+     */
+    public fun text(search: String, textSearchOptions: TextSearchOptions = TextSearchOptions()): Bson =
+        Filters.text(search, textSearchOptions)
+
+    /**
+     * Creates a filter that matches all documents for which the given expression is true.
+     *
+     * @param javaScriptExpression the JavaScript expression
+     * @return the filter
+     */
+    public fun where(javaScriptExpression: String): Bson = Filters.where(javaScriptExpression)
+
+    /**
+     * Creates a filter that matches all documents that validate against the given JSON schema document.
+     *
+     * @param expression the aggregation expression
+     * @param <T> the expression type
+     * @return the filter
+     */
+    public fun <T> expr(expression: T): Bson = Filters.expr(expression)
+
+    /**
+     * Creates a filter that matches all documents where the value of a property is an array that contains all the
+     * specified values.
+     *
+     * @param values the list of values
+     * @param <T> the value type
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("allExt")
+    public infix fun <@OnlyInputTypes T> KProperty<Iterable<T>?>.all(values: Iterable<T>): Bson =
+        Filters.all(path(), values)
+
+    /**
+     * Creates a filter that matches all documents where the value of a property is an array that contains all the
+     * specified values.
+     *
+     * @param property the data class property
+     * @param values the list of values
+     * @param <T> the value type
+     * @return the filter
+     */
+    public fun <@OnlyInputTypes T> all(property: KProperty<Iterable<T>?>, values: Iterable<T>): Bson =
+        property.all(values)
+
+    /**
+     * Creates a filter that matches all documents where the value of a property is an array that contains all the
+     * specified values.
+     *
+     * @param values the list of values
+     * @param <T> the value type
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("allvargsExt")
+    public fun <@OnlyInputTypes T> KProperty<Iterable<T>?>.all(vararg values: T): Bson = Filters.all(path(), *values)
+
+    /**
+     * Creates a filter that matches all documents where the value of a property is an array that contains all the
+     * specified values.
+     *
+     * @param property the data class property
+     * @param values the list of values
+     * @param <T> the value type
+     * @return the filter
+     */
+    public fun <@OnlyInputTypes T> all(property: KProperty<Iterable<T>?>, vararg values: T): Bson =
+        property.all(*values)
+
+    /**
+     * Creates a filter that matches all documents containing a property that is an array where at least one member of
+     * the array matches the given filter.
+     *
+     * @param filter the filter to apply to each element
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("elemMatchExt")
+    public infix fun <T> KProperty<Iterable<T>?>.elemMatch(filter: Bson): Bson = Filters.elemMatch(path(), filter)
+
+    /**
+     * Creates a filter that matches all documents containing a property that is an array where at least one member of
+     * the array matches the given filter.
+     *
+     * @param property the data class property
+     * @param filter the filter to apply to each element
+     * @return the filter
+     */
+    public fun <T> elemMatch(property: KProperty<Iterable<T>?>, filter: Bson): Bson = property.elemMatch(filter)
+
+    /**
+     * Creates a filter that matches all documents where the value of a property is an array of the specified size.
+     *
+     * @param size the size of the array
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("sizeExt")
+    public infix fun <T> KProperty<T?>.size(size: Int): Bson = Filters.size(path(), size)
+
+    /**
+     * Creates a filter that matches all documents where the value of a property is an array of the specified size.
+     *
+     * @param property the data class property
+     * @param size the size of the array
+     * @return the filter
+     */
+    public fun <T> size(property: KProperty<T?>, size: Int): Bson = property.size(size)
+
+    /**
+     * Creates a filter that matches all documents where all of the bit positions are clear in the property.
+     *
+     * @param bitmask the bitmask
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("bitsAllClearExt")
+    public infix fun <T> KProperty<T?>.bitsAllClear(bitmask: Long): Bson = Filters.bitsAllClear(path(), bitmask)
+
+    /**
+     * Creates a filter that matches all documents where all of the bit positions are clear in the property.
+     *
+     * @param property the data class property
+     * @param bitmask the bitmask
+     * @return the filter
+     */
+    public fun <T> bitsAllClear(property: KProperty<T?>, bitmask: Long): Bson = property.bitsAllClear(bitmask)
+
+    /**
+     * Creates a filter that matches all documents where all of the bit positions are set in the property.
+     *
+     * @param bitmask the bitmask
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("bitsAllSetExt")
+    public infix fun <T> KProperty<T?>.bitsAllSet(bitmask: Long): Bson = Filters.bitsAllSet(path(), bitmask)
+
+    /**
+     * Creates a filter that matches all documents where all of the bit positions are set in the property.
+     *
+     * @param property the data class property
+     * @param bitmask the bitmask
+     * @return the filter
+     */
+    public fun <T> bitsAllSet(property: KProperty<T?>, bitmask: Long): Bson = property.bitsAllSet(bitmask)
+
+    /**
+     * Creates a filter that matches all documents where any of the bit positions are clear in the property.
+     *
+     * @param bitmask the bitmask
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("bitsAnyClearExt")
+    public infix fun <T> KProperty<T?>.bitsAnyClear(bitmask: Long): Bson = Filters.bitsAnyClear(path(), bitmask)
+
+    /**
+     * Creates a filter that matches all documents where any of the bit positions are clear in the property.
+     *
+     * @param property the data class property
+     * @param bitmask the bitmask
+     * @return the filter
+     */
+    public fun <T> bitsAnyClear(property: KProperty<T?>, bitmask: Long): Bson = property.bitsAnyClear(bitmask)
+
+    /**
+     * Creates a filter that matches all documents where any of the bit positions are set in the property.
+     *
+     * @param bitmask the bitmask
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("bitsAnySetExt")
+    public infix fun <T> KProperty<T?>.bitsAnySet(bitmask: Long): Bson = Filters.bitsAnySet(path(), bitmask)
+
+    /**
+     * Creates a filter that matches all documents where any of the bit positions are set in the property.
+     *
+     * @param property the data class property
+     * @param bitmask the bitmask
+     * @return the filter
+     */
+    public fun <T> bitsAnySet(property: KProperty<T?>, bitmask: Long): Bson = property.bitsAnySet(bitmask)
+
+    /**
+     * Creates a filter that matches all documents containing a property with geospatial data that exists entirely
+     * within the specified shape.
+     *
+     * @param geometry the bounding GeoJSON geometry object
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("geoWithinExt")
+    public infix fun <T> KProperty<T?>.geoWithin(geometry: Geometry): Bson = Filters.geoWithin(path(), geometry)
+
+    /**
+     * Creates a filter that matches all documents containing a property with geospatial data that exists entirely
+     * within the specified shape.
+     *
+     * @param property the data class property
+     * @param geometry the bounding GeoJSON geometry object
+     * @return the filter
+     */
+    public fun <T> geoWithin(property: KProperty<T?>, geometry: Geometry): Bson = property.geoWithin(geometry)
+
+    /**
+     * Creates a filter that matches all documents containing a property with geospatial data that exists entirely
+     * within the specified shape.
+     *
+     * @param geometry the bounding GeoJSON geometry object
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("geoWithinExt")
+    public infix fun <T> KProperty<T?>.geoWithin(geometry: Bson): Bson = Filters.geoWithin(path(), geometry)
+
+    /**
+     * Creates a filter that matches all documents containing a property with geospatial data that exists entirely
+     * within the specified shape.
+     *
+     * @param property the data class property
+     * @param geometry the bounding GeoJSON geometry object
+     * @return the filter
+     */
+    public fun <T> geoWithin(property: KProperty<T?>, geometry: Bson): Bson = property.geoWithin(geometry)
+
+    /**
+     * Creates a filter that matches all documents containing a property with grid coordinates data that exist entirely
+     * within the specified box.
+     *
+     * @param lowerLeftX the lower left x coordinate of the box
+     * @param lowerLeftY the lower left y coordinate of the box
+     * @param upperRightX the upper left x coordinate of the box
+     * @param upperRightY the upper left y coordinate of the box
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("geoWithinBoxExt")
+    public fun <T> KProperty<T?>.geoWithinBox(
+        lowerLeftX: Double,
+        lowerLeftY: Double,
+        upperRightX: Double,
+        upperRightY: Double
+    ): Bson = Filters.geoWithinBox(path(), lowerLeftX, lowerLeftY, upperRightX, upperRightY)
+
+    /**
+     * Creates a filter that matches all documents containing a property with grid coordinates data that exist entirely
+     * within the specified box.
+     *
+     * @param property the data class property
+     * @param lowerLeftX the lower left x coordinate of the box
+     * @param lowerLeftY the lower left y coordinate of the box
+     * @param upperRightX the upper left x coordinate of the box
+     * @param upperRightY the upper left y coordinate of the box
+     * @return the filter
+     */
+    public fun <T> geoWithinBox(
+        property: KProperty<T?>,
+        lowerLeftX: Double,
+        lowerLeftY: Double,
+        upperRightX: Double,
+        upperRightY: Double
+    ): Bson = property.geoWithinBox(lowerLeftX, lowerLeftY, upperRightX, upperRightY)
+
+    /**
+     * Creates a filter that matches all documents containing a property with grid coordinates data that exist entirely
+     * within the specified polygon.
+     *
+     * @param points a list of pairs of x, y coordinates. Any extra dimensions are ignored
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("geoWithinPolygonExt")
+    public infix fun <T> KProperty<T?>.geoWithinPolygon(points: List<List<Double>>): Bson =
+        Filters.geoWithinPolygon(path(), points)
+
+    /**
+     * Creates a filter that matches all documents containing a property with grid coordinates data that exist entirely
+     * within the specified polygon.
+     *
+     * @param property the data class property
+     * @param points a list of pairs of x, y coordinates. Any extra dimensions are ignored
+     * @return the filter
+     */
+    public fun <T> geoWithinPolygon(property: KProperty<T?>, points: List<List<Double>>): Bson =
+        property.geoWithinPolygon(points)
+
+    /**
+     * Creates a filter that matches all documents containing a property with grid coordinates data that exist entirely
+     * within the specified circle.
+     *
+     * @param x the x coordinate of the circle
+     * @param y the y coordinate of the circle
+     * @param radius the radius of the circle, as measured in the units used by the coordinate system
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("geoWithinCenterExt")
+    public fun <T> KProperty<T?>.geoWithinCenter(x: Double, y: Double, radius: Double): Bson =
+        Filters.geoWithinCenter(path(), x, y, radius)
+
+    /**
+     * Creates a filter that matches all documents containing a property with grid coordinates data that exist entirely
+     * within the specified circle.
+     *
+     * @param property the data class property
+     * @param x the x coordinate of the circle
+     * @param y the y coordinate of the circle
+     * @param radius the radius of the circle, as measured in the units used by the coordinate system
+     * @return the filter
+     */
+    public fun <T> geoWithinCenter(property: KProperty<T?>, x: Double, y: Double, radius: Double): Bson =
+        property.geoWithinCenter(x, y, radius)
+
+    /**
+     * Creates a filter that matches all documents containing a property with geospatial data (GeoJSON or legacy
+     * coordinate pairs) that exist entirely within the specified circle, using spherical geometry. If using longitude
+     * and latitude, specify longitude first.
+     *
+     * @param x the x coordinate of the circle
+     * @param y the y coordinate of the circle
+     * @param radius the radius of the circle, in radians
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("geoWithinCenterSphereExt")
+    public fun <T> KProperty<T?>.geoWithinCenterSphere(x: Double, y: Double, radius: Double): Bson =
+        Filters.geoWithinCenterSphere(path(), x, y, radius)
+
+    /**
+     * Creates a filter that matches all documents containing a property with geospatial data (GeoJSON or legacy
+     * coordinate pairs) that exist entirely within the specified circle, using spherical geometry. If using longitude
+     * and latitude, specify longitude first.
+     *
+     * @param property the data class property
+     * @param x the x coordinate of the circle
+     * @param y the y coordinate of the circle
+     * @param radius the radius of the circle, in radians
+     * @return the filter
+     */
+    public fun <T> geoWithinCenterSphere(property: KProperty<T?>, x: Double, y: Double, radius: Double): Bson =
+        property.geoWithinCenterSphere(x, y, radius)
+
+    /**
+     * Creates a filter that matches all documents containing a property with geospatial data that intersects with the
+     * specified shape.
+     *
+     * @param geometry the bounding GeoJSON geometry object
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("geoIntersectsExt")
+    public infix fun <T> KProperty<T?>.geoIntersects(geometry: Geometry): Bson = Filters.geoIntersects(path(), geometry)
+
+    /**
+     * Creates a filter that matches all documents containing a property with geospatial data that intersects with the
+     * specified shape.
+     *
+     * @param property the data class property
+     * @param geometry the bounding GeoJSON geometry object
+     * @return the filter
+     */
+    public fun <T> geoIntersects(property: KProperty<T?>, geometry: Geometry): Bson = property.geoIntersects(geometry)
+
+    /**
+     * Creates a filter that matches all documents containing a property with geospatial data that intersects with the
+     * specified shape.
+     *
+     * @param geometry the bounding GeoJSON geometry object
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("geoIntersectsExt")
+    public infix fun <T> KProperty<T?>.geoIntersects(geometry: Bson): Bson = Filters.geoIntersects(path(), geometry)
+
+    /**
+     * Creates a filter that matches all documents containing a property with geospatial data that intersects with the
+     * specified shape.
+     *
+     * @param property the data class property
+     * @param geometry the bounding GeoJSON geometry object
+     * @return the filter
+     */
+    public fun <T> geoIntersects(property: KProperty<T?>, geometry: Bson): Bson = property.geoIntersects(geometry)
+
+    /**
+     * Creates a filter that matches all documents containing a property with geospatial data that is near the specified
+     * GeoJSON point.
+     *
+     * @param geometry the bounding GeoJSON geometry object
+     * @param maxDistance the maximum distance from the point, in meters
+     * @param minDistance the minimum distance from the point, in meters
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("nearExt")
+    public fun <T> KProperty<T?>.near(geometry: Point, maxDistance: Double? = null, minDistance: Double? = null): Bson =
+        Filters.near(path(), geometry, maxDistance, minDistance)
+
+    /**
+     * Creates a filter that matches all documents containing a property with geospatial data that is near the specified
+     * GeoJSON point.
+     *
+     * @param property the data class property
+     * @param geometry the bounding GeoJSON geometry object
+     * @param maxDistance the maximum distance from the point, in meters
+     * @param minDistance the minimum distance from the point, in meters
+     * @return the filter
+     */
+    public fun <T> near(
+        property: KProperty<T?>,
+        geometry: Point,
+        maxDistance: Double? = null,
+        minDistance: Double? = null
+    ): Bson = property.near(geometry, maxDistance, minDistance)
+
+    /**
+     * Creates a filter that matches all documents containing a property with geospatial data that is near the specified
+     * GeoJSON point.
+     *
+     * @param geometry the bounding GeoJSON geometry object
+     * @param maxDistance the maximum distance from the point, in meters
+     * @param minDistance the minimum distance from the point, in meters
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("nearExt")
+    public fun <T> KProperty<T?>.near(geometry: Bson, maxDistance: Double? = null, minDistance: Double? = null): Bson =
+        Filters.near(path(), geometry, maxDistance, minDistance)
+
+    /**
+     * Creates a filter that matches all documents containing a property with geospatial data that is near the specified
+     * GeoJSON point.
+     *
+     * @param property the data class property
+     * @param geometry the bounding GeoJSON geometry object
+     * @param maxDistance the maximum distance from the point, in meters
+     * @param minDistance the minimum distance from the point, in meters
+     * @return the filter
+     */
+    public fun <T> near(
+        property: KProperty<T?>,
+        geometry: Bson,
+        maxDistance: Double? = null,
+        minDistance: Double? = null
+    ): Bson = property.near(geometry, maxDistance, minDistance)
+
+    /**
+     * Creates a filter that matches all documents containing a property with geospatial data that is near the specified
+     * point.
+     *
+     * @param x the x coordinate
+     * @param y the y coordinate
+     * @param maxDistance the maximum distance from the point, in radians
+     * @param minDistance the minimum distance from the point, in radians
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("nearExt")
+    public fun <T> KProperty<T?>.near(
+        x: Double,
+        y: Double,
+        maxDistance: Double? = null,
+        minDistance: Double? = null
+    ): Bson = Filters.near(path(), x, y, maxDistance, minDistance)
+
+    /**
+     * Creates a filter that matches all documents containing a property with geospatial data that is near the specified
+     * point.
+     *
+     * @param property the data class property
+     * @param x the x coordinate
+     * @param y the y coordinate
+     * @param maxDistance the maximum distance from the point, in radians
+     * @param minDistance the minimum distance from the point, in radians
+     * @return the filter
+     */
+    public fun <T> near(
+        property: KProperty<T?>,
+        x: Double,
+        y: Double,
+        maxDistance: Double? = null,
+        minDistance: Double? = null
+    ): Bson = property.near(x, y, maxDistance, minDistance)
+
+    /**
+     * Creates a filter that matches all documents containing a property with geospatial data that is near the specified
+     * GeoJSON point using spherical geometry.
+     *
+     * @param geometry the bounding GeoJSON geometry object
+     * @param maxDistance the maximum distance from the point, in meters
+     * @param minDistance the minimum distance from the point, in meters
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("nearSphereExt")
+    public fun <T> KProperty<T?>.nearSphere(
+        geometry: Bson,
+        maxDistance: Double? = null,
+        minDistance: Double? = null
+    ): Bson = Filters.nearSphere(path(), geometry, maxDistance, minDistance)
+
+    /**
+     * Creates a filter that matches all documents containing a property with geospatial data that is near the specified
+     * GeoJSON point using spherical geometry.
+     *
+     * @param property the data class property
+     * @param geometry the bounding GeoJSON geometry object
+     * @param maxDistance the maximum distance from the point, in meters
+     * @param minDistance the minimum distance from the point, in meters
+     * @return the filter
+     */
+    public fun <T> nearSphere(
+        property: KProperty<T?>,
+        geometry: Bson,
+        maxDistance: Double? = null,
+        minDistance: Double? = null
+    ): Bson = property.nearSphere(geometry, maxDistance, minDistance)
+
+    /**
+     * Creates a filter that matches all documents containing a property with geospatial data that is near the specified
+     * GeoJSON point using spherical geometry.
+     *
+     * @param geometry the bounding GeoJSON geometry object
+     * @param maxDistance the maximum distance from the point, in meters
+     * @param minDistance the minimum distance from the point, in meters
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("nearSphereExt")
+    public fun <T> KProperty<T?>.nearSphere(
+        geometry: Point,
+        maxDistance: Double? = null,
+        minDistance: Double? = null
+    ): Bson = Filters.nearSphere(path(), geometry, maxDistance, minDistance)
+
+    /**
+     * Creates a filter that matches all documents containing a property with geospatial data that is near the specified
+     * GeoJSON point using spherical geometry.
+     *
+     * @param property the data class property
+     * @param geometry the bounding GeoJSON geometry object
+     * @param maxDistance the maximum distance from the point, in meters
+     * @param minDistance the minimum distance from the point, in meters
+     * @return the filter
+     */
+    public fun <T> nearSphere(
+        property: KProperty<T?>,
+        geometry: Point,
+        maxDistance: Double? = null,
+        minDistance: Double? = null
+    ): Bson = property.nearSphere(geometry, maxDistance, minDistance)
+
+    /**
+     * Creates a filter that matches all documents containing a property with geospatial data that is near the specified
+     * point using spherical geometry.
+     *
+     * @param x the x coordinate
+     * @param y the y coordinate
+     * @param maxDistance the maximum distance from the point, in radians
+     * @param minDistance the minimum distance from the point, in radians
+     * @return the filter
+     */
+    @JvmSynthetic
+    @JvmName("nearSphereExt")
+    public fun <T> KProperty<T?>.nearSphere(
+        x: Double,
+        y: Double,
+        maxDistance: Double? = null,
+        minDistance: Double? = null
+    ): Bson = Filters.nearSphere(path(), x, y, maxDistance, minDistance)
+
+    /**
+     * Creates a filter that matches all documents containing a property with geospatial data that is near the specified
+     * point using spherical geometry.
+     *
+     * @param property the data class property
+     * @param x the x coordinate
+     * @param y the y coordinate
+     * @param maxDistance the maximum distance from the point, in radians
+     * @param minDistance the minimum distance from the point, in radians
+     * @return the filter
+     */
+    public fun <T> nearSphere(
+        property: KProperty<T?>,
+        x: Double,
+        y: Double,
+        maxDistance: Double? = null,
+        minDistance: Double? = null
+    ): Bson = property.nearSphere(x, y, maxDistance, minDistance)
+
+    /**
+     * Creates a filter that matches all documents that validate against the given JSON schema document.
+     *
+     * @param schema the JSON schema to validate against
+     * @return the filter
+     */
+    public fun jsonSchema(schema: Bson): Bson = Filters.jsonSchema(schema)
+}
diff --git a/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Indexes.kt b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Indexes.kt
new file mode 100644
index 00000000000..e87dad6400c
--- /dev/null
+++ b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Indexes.kt
@@ -0,0 +1,106 @@
+/*
+ * 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.Indexes
+import kotlin.reflect.KProperty
+import org.bson.conversions.Bson
+
+/**
+ * Indexes extension methods to improve Kotlin interop
+ *
+ * @since 5.3
+ */
+public object Indexes {
+    /**
+     * Create an index key for an ascending index on the given fields.
+     *
+     * @param properties the properties, which must contain at least one
+     * @return the index specification @mongodb.driver.manual core/indexes indexes
+     */
+    public fun ascending(vararg properties: KProperty<*>): Bson = Indexes.ascending(properties.map { it.path() })
+
+    /**
+     * Create an index key for an ascending index on the given fields.
+     *
+     * @param properties the properties, which must contain at least one
+     * @return the index specification @mongodb.driver.manual core/indexes indexes
+     */
+    public fun ascending(properties: Iterable<KProperty<*>>): Bson = Indexes.ascending(properties.map { it.path() })
+
+    /**
+     * Create an index key for a descending index on the given fields.
+     *
+     * @param properties the properties, which must contain at least one
+     * @return the index specification @mongodb.driver.manual core/indexes indexes
+     */
+    public fun descending(vararg properties: KProperty<*>): Bson = Indexes.descending(properties.map { it.path() })
+
+    /**
+     * Create an index key for a descending index on the given fields.
+     *
+     * @param properties the properties, which must contain at least one
+     * @return the index specification @mongodb.driver.manual core/indexes indexes
+     */
+    public fun descending(properties: Iterable<KProperty<*>>): Bson = Indexes.descending(properties.map { it.path() })
+
+    /**
+     * Create an index key for an 2dsphere index on the given fields.
+     *
+     * @param properties the properties, which must contain at least one
+     * @return the index specification @mongodb.driver.manual core/2dsphere 2dsphere Index
+     */
+    public fun geo2dsphere(vararg properties: KProperty<*>): Bson = Indexes.geo2dsphere(properties.map { it.path() })
+
+    /**
+     * Create an index key for an 2dsphere index on the given fields.
+     *
+     * @param properties the properties, which must contain at least one
+     * @return the index specification @mongodb.driver.manual core/2dsphere 2dsphere Index
+     */
+    public fun geo2dsphere(properties: Iterable<KProperty<*>>): Bson = Indexes.geo2dsphere(properties.map { it.path() })
+
+    /**
+     * Create an index key for a text index on the given property.
+     *
+     * @param property the property to create a text index on
+     * @return the index specification @mongodb.driver.manual core/text text index
+     */
+    public fun <T> text(property: KProperty<T>): Bson = Indexes.text(property.path())
+
+    /**
+     * Create an index key for a hashed index on the given property.
+     *
+     * @param property the property to create a hashed index on
+     * @return the index specification @mongodb.driver.manual core/hashed hashed index
+     */
+    public fun <T> hashed(property: KProperty<T>): Bson = Indexes.hashed(property.path())
+
+    /**
+     * Create an index key for a 2d index on the given field.
+     *
+     * <p>
+     * <strong>Note: </strong>A 2d index is for data stored as points on a two-dimensional plane. The 2d index is
+     * intended for legacy coordinate pairs used in MongoDB 2.2 and earlier. </p>
+     *
+     * @param property the property to create a 2d index on
+     * @return the index specification @mongodb.driver.manual core/2d 2d index
+     */
+    public fun <T> geo2d(property: KProperty<T>): Bson = Indexes.geo2d(property.path())
+}
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
new file mode 100644
index 00000000000..b35b44d4d93
--- /dev/null
+++ b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Properties.kt
@@ -0,0 +1,140 @@
+/*
+ * 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.kotlin.client.property.KCollectionSimplePropertyPath
+import com.mongodb.kotlin.client.property.KMapSimplePropertyPath
+import com.mongodb.kotlin.client.property.KPropertyPath
+import com.mongodb.kotlin.client.property.KPropertyPath.Companion.CustomProperty
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.reflect.KProperty
+import kotlin.reflect.KProperty1
+import kotlin.reflect.full.findParameterByName
+import kotlin.reflect.full.primaryConstructor
+import kotlin.reflect.jvm.internal.ReflectProperties.lazySoft
+import kotlin.reflect.jvm.javaField
+import org.bson.codecs.pojo.annotations.BsonId
+import org.bson.codecs.pojo.annotations.BsonProperty
+
+private val pathCache: MutableMap<String, String> by lazySoft { ConcurrentHashMap<String, String>() }
+
+/** Returns a composed property. For example Friend::address / Address::postalCode = "address.postalCode". */
+public operator fun <T0, T1, T2> KProperty1<T0, T1?>.div(p2: KProperty1<T1, T2?>): KProperty1<T0, T2?> =
+    KPropertyPath(this, p2)
+
+/**
+ * Returns a composed property without type checks. For example Friend::address % Address::postalCode =
+ * "address.postalCode".
+ */
+public operator fun <T0, T1, T2> KProperty1<T0, T1?>.rem(p2: KProperty1<out T1, T2?>): KProperty1<T0, T2?> =
+    KPropertyPath(this, p2)
+
+/**
+ * Returns a collection composed property. For example Friend::addresses / Address::postalCode = "addresses.postalCode".
+ */
+@JvmName("divCol")
+public operator fun <T0, T1, T2> KProperty1<T0, Iterable<T1>?>.div(p2: KProperty1<out T1, T2?>): KProperty1<T0, T2?> =
+    KPropertyPath(this, p2)
+
+/** Returns a map composed property. For example Friend::addresses / Address::postalCode = "addresses.postalCode". */
+@JvmName("divMap")
+public operator fun <T0, K, T1, T2> KProperty1<T0, Map<out K, T1>?>.div(
+    p2: KProperty1<out T1, T2?>
+): KProperty1<T0, T2?> = KPropertyPath(this, p2)
+
+/**
+ * Returns a mongo path of a property.
+ *
+ * The path name is computed by checking the following and picking the first value to exist:
+ * - SerialName annotation value
+ * - BsonId annotation use '_id'
+ * - BsonProperty annotation
+ * - Property name
+ */
+internal fun <T> KProperty<T>.path(): String {
+    return if (this is KPropertyPath<*, T>) {
+        this.name
+    } else {
+        pathCache.computeIfAbsent(this.toString()) {
+
+            // Check serial name - Note kotlinx.serialization.SerialName may not be on the class
+            // path
+            val serialName =
+                annotations.firstOrNull { it.annotationClass.qualifiedName == "kotlinx.serialization.SerialName" }
+            var path =
+                serialName?.annotationClass?.members?.firstOrNull { it.name == "value" }?.call(serialName) as String?
+
+            // If no path (serialName) then check for BsonId / BsonProperty
+            if (path == null) {
+                val originator = if (this is CustomProperty<*, *>) this.previous.property else this
+                // 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
+        }
+    }
+}
+
+/** Returns a collection property. */
+public val <T> KProperty1<out Any?, Iterable<T>?>.colProperty: KCollectionSimplePropertyPath<out Any?, T>
+    get() = KCollectionSimplePropertyPath(null, this)
+
+/** In order to write array indexed expressions (like `accesses.0.timestamp`). */
+public fun <T> KProperty1<out Any?, Iterable<T>?>.pos(position: Int): KPropertyPath<out Any?, T?> =
+    colProperty.pos(position)
+
+/** Returns a map property. */
+public val <K, T> KProperty1<out Any?, Map<out K, T>?>.mapProperty: KMapSimplePropertyPath<out Any?, K, T>
+    get() = KMapSimplePropertyPath(null, this)
+
+@Suppress("MaxLineLength")
+/**
+ * [The positional array operator $ (projection or update)](https://docs.mongodb.com/manual/reference/operator/update/positional/)
+ */
+public val <T> KProperty1<out Any?, Iterable<T>?>.posOp: KPropertyPath<out Any?, T?>
+    get() = colProperty.posOp
+
+@Suppress("MaxLineLength")
+/** [The all positional operator $[]](https://docs.mongodb.com/manual/reference/operator/update/positional-all/) */
+public val <T> KProperty1<out Any?, Iterable<T>?>.allPosOp: KPropertyPath<out Any?, T?>
+    get() = colProperty.allPosOp
+
+@Suppress("MaxLineLength")
+/**
+ * [The filtered positional operator $[\<identifier\>]](https://docs.mongodb.com/manual/reference/operator/update/positional-filtered/)
+ */
+public fun <T> KProperty1<out Any?, Iterable<T>?>.filteredPosOp(identifier: String): KPropertyPath<out Any?, T?> =
+    colProperty.filteredPosOp(identifier)
+
+/** Key projection of map. Sample: `p.keyProjection(Locale.ENGLISH) / Gift::amount` */
+@Suppress("UNCHECKED_CAST")
+public fun <K, T> KProperty1<out Any?, Map<out K, T>?>.keyProjection(key: K): KPropertyPath<Any?, T?> =
+    mapProperty.keyProjection(key) as KPropertyPath<Any?, T?>
diff --git a/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Sorts.kt b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Sorts.kt
new file mode 100644
index 00000000000..4464026d39e
--- /dev/null
+++ b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Sorts.kt
@@ -0,0 +1,71 @@
+/*
+ * 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.Sorts
+import kotlin.reflect.KProperty
+import org.bson.conversions.Bson
+
+/**
+ * Sorts extension methods to improve Kotlin interop
+ *
+ * @since 5.3
+ */
+public object Sorts {
+
+    /**
+     * Create a sort specification for an ascending sort on the given properties.
+     *
+     * @param properties the properties, which must contain at least one
+     * @return the sort specification @mongodb.driver.manual reference/operator/meta/orderby Sort
+     */
+    public fun ascending(vararg properties: KProperty<*>): Bson = ascending(properties.asList())
+
+    /**
+     * Create a sort specification for an ascending sort on the given properties.
+     *
+     * @param properties the properties, which must contain at least one
+     * @return the sort specification @mongodb.driver.manual reference/operator/meta/orderby Sort
+     */
+    public fun ascending(properties: List<KProperty<*>>): Bson = Sorts.ascending(properties.map { it.path() })
+
+    /**
+     * Create a sort specification for a descending sort on the given properties.
+     *
+     * @param properties the properties, which must contain at least one
+     * @return the sort specification @mongodb.driver.manual reference/operator/meta/orderby Sort
+     */
+    public fun descending(vararg properties: KProperty<*>): Bson = descending(properties.asList())
+
+    /**
+     * Create a sort specification for a descending sort on the given properties.
+     *
+     * @param properties the properties, which must contain at least one
+     * @return the sort specification @mongodb.driver.manual reference/operator/meta/orderby Sort
+     */
+    public fun descending(properties: List<KProperty<*>>): Bson = Sorts.descending(properties.map { it.path() })
+
+    /**
+     * Create a sort specification for the text score meta projection on the given property.
+     *
+     * @param property the data class property
+     * @return the sort specification @mongodb.driver.manual reference/operator/getProjection/meta/#sort textScore
+     */
+    public fun <T> metaTextScore(property: KProperty<T>): Bson = Sorts.metaTextScore(property.path())
+}
diff --git a/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Updates.kt b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Updates.kt
new file mode 100644
index 00000000000..4bb272b9fb5
--- /dev/null
+++ b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Updates.kt
@@ -0,0 +1,506 @@
+/*
+ * 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.PushOptions
+import com.mongodb.client.model.UpdateOptions
+import com.mongodb.client.model.Updates
+import kotlin.internal.OnlyInputTypes
+import kotlin.reflect.KProperty
+import org.bson.conversions.Bson
+
+/**
+ * Updates extension methods to improve Kotlin interop
+ *
+ * @since 5.3
+ */
+@Suppress("TooManyFunctions")
+public object Updates {
+
+    /**
+     * Creates an update that sets the value of the property to the given value.
+     *
+     * @param value the value
+     * @param <T> the value type
+     * @return the update @mongodb.driver.manual reference/operator/update/set/ $set
+     */
+    @JvmSynthetic
+    @JvmName("setExt")
+    public infix fun <@OnlyInputTypes T> KProperty<T>.set(value: T?): Bson = Updates.set(path(), value)
+
+    /**
+     * Creates an update that sets the value of the property to the given value.
+     *
+     * @param property the data class property
+     * @param value the value
+     * @param <T> the value type
+     * @return the update @mongodb.driver.manual reference/operator/update/set/ $set
+     */
+    public fun <@OnlyInputTypes T> set(property: KProperty<T?>, value: T?): Bson = property.set(value)
+
+    /**
+     * Combine a list of updates into a single update.
+     *
+     * @param updates the list of updates
+     * @return a combined update
+     */
+    public fun combine(vararg updates: Bson): Bson = Updates.combine(*updates)
+
+    /**
+     * Combine a list of updates into a single update.
+     *
+     * @param updates the list of updates
+     * @return a combined update
+     */
+    public fun combine(updates: List<Bson>): Bson = Updates.combine(updates)
+
+    /**
+     * Creates an update that deletes the property with the given name.
+     *
+     * @param property the property
+     * @return the update @mongodb.driver.manual reference/operator/update/unset/ $unset
+     */
+    public fun <T> unset(property: KProperty<T>): Bson = Updates.unset(property.path())
+
+    /**
+     * Creates an update that sets the value of the property to the given value, but only if the update is an upsert
+     * that results in an insert of a document.
+     *
+     * @param value the value
+     * @param <TItem> the value type
+     * @return the update @mongodb.driver.manual reference/operator/update/setOnInsert/ $setOnInsert
+     * @see UpdateOptions#upsert(boolean)
+     */
+    @JvmSynthetic
+    @JvmName("setOnInsertExt")
+    public infix fun <@OnlyInputTypes T> KProperty<T?>.setOnInsert(value: T?): Bson = Updates.setOnInsert(path(), value)
+
+    /**
+     * Creates an update that sets the value of the property to the given value, but only if the update is an upsert
+     * that results in an insert of a document.
+     *
+     * @param property the property
+     * @param value the value
+     * @param <TItem> the value type
+     * @return the update @mongodb.driver.manual reference/operator/update/setOnInsert/ $setOnInsert
+     * @see UpdateOptions#upsert(boolean)
+     */
+    public fun <@OnlyInputTypes T> setOnInsert(property: KProperty<T?>, value: T?): Bson = property.setOnInsert(value)
+
+    /**
+     * Creates an update that renames a field.
+     *
+     * @param newProperty the new property
+     * @return the update @mongodb.driver.manual reference/operator/update/rename/ $rename
+     */
+    @JvmSynthetic
+    @JvmName("renameExt")
+    public infix fun <@OnlyInputTypes T> KProperty<T?>.rename(newProperty: KProperty<T?>): Bson =
+        Updates.rename(path(), newProperty.path())
+
+    /**
+     * Creates an update that renames a field.
+     *
+     * @param property the property
+     * @param newProperty the new property
+     * @return the update @mongodb.driver.manual reference/operator/update/rename/ $rename
+     */
+    public fun <@OnlyInputTypes T> rename(property: KProperty<T?>, newProperty: KProperty<T?>): Bson =
+        property.rename(newProperty)
+
+    /**
+     * Creates an update that increments the value of the property by the given value.
+     *
+     * @param number the value
+     * @return the update @mongodb.driver.manual reference/operator/update/inc/ $inc
+     */
+    @JvmSynthetic
+    @JvmName("incExt")
+    public infix fun <T : Number?> KProperty<T>.inc(number: Number): Bson = Updates.inc(path(), number)
+
+    /**
+     * Creates an update that increments the value of the property by the given value.
+     *
+     * @param property the property
+     * @param number the value
+     * @return the update @mongodb.driver.manual reference/operator/update/inc/ $inc
+     */
+    public fun <T : Number?> inc(property: KProperty<T>, number: Number): Bson = property.inc(number)
+
+    /**
+     * Creates an update that multiplies the value of the property by the given number.
+     *
+     * @param number the non-null number
+     * @return the update @mongodb.driver.manual reference/operator/update/mul/ $mul
+     */
+    @JvmSynthetic
+    @JvmName("mulExt")
+    public infix fun <T : Number?> KProperty<T>.mul(number: Number): Bson = Updates.mul(path(), number)
+
+    /**
+     * Creates an update that multiplies the value of the property by the given number.
+     *
+     * @param property the property
+     * @param number the non-null number
+     * @return the update @mongodb.driver.manual reference/operator/update/mul/ $mul
+     */
+    public fun <T : Number?> mul(property: KProperty<T>, number: Number): Bson = property.mul(number)
+
+    /**
+     * Creates an update that sets the value of the property if the given value is less than the current value of the
+     * property.
+     *
+     * @param value the value
+     * @param <TItem> the value type
+     * @return the update @mongodb.driver.manual reference/operator/update/min/ $min
+     */
+    @JvmSynthetic
+    @JvmName("minExt")
+    public infix fun <@OnlyInputTypes T> KProperty<T>.min(value: T): Bson = Updates.min(path(), value)
+
+    /**
+     * Creates an update that sets the value of the property if the given value is less than the current value of the
+     * property.
+     *
+     * @param property the property
+     * @param value the value
+     * @param <TItem> the value type
+     * @return the update @mongodb.driver.manual reference/operator/update/min/ $min
+     */
+    public fun <@OnlyInputTypes T> min(property: KProperty<T>, value: T): Bson = property.min(value)
+
+    /**
+     * Creates an update that sets the value of the property if the given value is greater than the current value of the
+     * property.
+     *
+     * @param value the value
+     * @param <TItem> the value type
+     * @return the update @mongodb.driver.manual reference/operator/update/min/ $min
+     */
+    @JvmSynthetic
+    @JvmName("maxExt")
+    public infix fun <@OnlyInputTypes T> KProperty<T>.max(value: T): Bson = Updates.max(path(), value)
+
+    /**
+     * Creates an update that sets the value of the property if the given value is greater than the current value of the
+     * property.
+     *
+     * @param property the property
+     * @param value the value
+     * @param <TItem> the value type
+     * @return the update @mongodb.driver.manual reference/operator/update/min/ $min
+     */
+    public fun <@OnlyInputTypes T> max(property: KProperty<T>, value: T): Bson = property.max(value)
+
+    /**
+     * Creates an update that sets the value of the property to the current date as a BSON date.
+     *
+     * @param property the property
+     * @return the update @mongodb.driver.manual reference/operator/update/currentDate/
+     *   $currentDate @mongodb.driver.manual reference/bson-types/#date Date
+     */
+    public fun <T> currentDate(property: KProperty<T>): Bson = Updates.currentDate(property.path())
+
+    /**
+     * Creates an update that sets the value of the property to the current date as a BSON timestamp.
+     *
+     * @param property the property
+     * @return the update @mongodb.driver.manual reference/operator/update/currentDate/
+     *   $currentDate @mongodb.driver.manual reference/bson-types/#document-bson-type-timestamp Timestamp
+     */
+    public fun <T> currentTimestamp(property: KProperty<T>): Bson = Updates.currentTimestamp(property.path())
+
+    /**
+     * Creates an update that adds the given value to the array value of the property, unless the value is already
+     * present, in which case it does nothing
+     *
+     * @param value the value
+     * @param <TItem> the value type
+     * @return the update @mongodb.driver.manual reference/operator/update/addToSet/ $addToSet
+     */
+    @JvmSynthetic
+    @JvmName("addToSetExt")
+    public infix fun <@OnlyInputTypes T> KProperty<Iterable<T>?>.addToSet(value: T): Bson =
+        Updates.addToSet(path(), value)
+
+    /**
+     * Creates an update that adds the given value to the array value of the property, unless the value is already
+     * present, in which case it does nothing
+     *
+     * @param property the property
+     * @param value the value
+     * @param <TItem> the value type
+     * @return the update @mongodb.driver.manual reference/operator/update/addToSet/ $addToSet
+     */
+    public fun <@OnlyInputTypes T> addToSet(property: KProperty<Iterable<T>?>, value: T): Bson =
+        property.addToSet(value)
+
+    /**
+     * Creates an update that adds each of the given values to the array value of the property, unless the value is
+     * already present, in which case it does nothing
+     *
+     * @param property the property
+     * @param values the values
+     * @param <TItem> the value type
+     * @return the update @mongodb.driver.manual reference/operator/update/addToSet/ $addToSet
+     */
+    public fun <@OnlyInputTypes T> addEachToSet(property: KProperty<Iterable<T>?>, values: List<T>): Bson =
+        Updates.addEachToSet(property.path(), values)
+
+    /**
+     * Creates an update that adds the given value to the array value of the property.
+     *
+     * @param property the property
+     * @param value the value
+     * @param <TItem> the value type
+     * @return the update @mongodb.driver.manual reference/operator/update/push/ $push
+     */
+    public fun <@OnlyInputTypes T> push(property: KProperty<Iterable<T>?>, value: T): Bson =
+        Updates.push(property.path(), value)
+
+    /**
+     * Creates an update that adds each of the given values to the array value of the property, applying the given
+     * options for positioning the pushed values, and then slicing and/or sorting the array.
+     *
+     * @param property the property
+     * @param values the values
+     * @param options the non-null push options
+     * @param <TItem> the value type
+     * @return the update @mongodb.driver.manual reference/operator/update/push/ $push
+     */
+    public fun <@OnlyInputTypes T> pushEach(
+        property: KProperty<Iterable<T>?>,
+        values: List<T?>,
+        options: PushOptions = PushOptions()
+    ): Bson = Updates.pushEach(property.path(), values, options)
+
+    /**
+     * Creates an update that removes all instances of the given value from the array value of the property.
+     *
+     * @param value the value
+     * @param <T> the value type
+     * @return the update @mongodb.driver.manual reference/operator/update/pull/ $pull
+     */
+    @JvmSynthetic
+    @JvmName("pullExt")
+    public infix fun <@OnlyInputTypes T> KProperty<Iterable<T?>?>.pull(value: T?): Bson = Updates.pull(path(), value)
+
+    /**
+     * Creates an update that removes all instances of the given value from the array value of the property.
+     *
+     * @param property the property
+     * @param value the value
+     * @param <T> the value type
+     * @return the update @mongodb.driver.manual reference/operator/update/pull/ $pull
+     */
+    public fun <@OnlyInputTypes T> pull(property: KProperty<Iterable<T?>?>, value: T?): Bson = property.pull(value)
+
+    /**
+     * Creates an update that removes all instances of the given value from the array value of the property.
+     *
+     * @param filter the value
+     * @return the update @mongodb.driver.manual reference/operator/update/pull/ $pull
+     */
+    @JvmSynthetic
+    @JvmName("pullByFilterExt")
+    public infix fun KProperty<*>.pullByFilter(filter: Bson): Bson = Updates.pull(path(), filter)
+
+    /**
+     * Creates an update that removes all instances of the given value from the array value of the property.
+     *
+     * @param property the property
+     * @param filter the value
+     * @return the update @mongodb.driver.manual reference/operator/update/pull/ $pull
+     */
+    public fun pullByFilter(property: KProperty<*>, filter: Bson): Bson = property.pullByFilter(filter)
+
+    /**
+     * Creates an update that removes from an array all elements that match the given filter.
+     *
+     * @param filter the query filter
+     * @return the update @mongodb.driver.manual reference/operator/update/pull/ $pull
+     */
+    public fun pullByFilter(filter: Bson): Bson = Updates.pullByFilter(filter)
+
+    /**
+     * Creates an update that removes all instances of the given values from the array value of the property.
+     *
+     * @param values the values
+     * @param <TItem> the value type
+     * @return the update @mongodb.driver.manual reference/operator/update/pull/ $pull
+     */
+    @JvmSynthetic
+    @JvmName("pullAllExt")
+    public infix fun <@OnlyInputTypes T> KProperty<Iterable<T>?>.pullAll(values: List<T?>?): Bson =
+        Updates.pullAll(path(), values ?: emptyList())
+
+    /**
+     * Creates an update that removes all instances of the given values from the array value of the property.
+     *
+     * @param property the property
+     * @param values the values
+     * @param <TItem> the value type
+     * @return the update @mongodb.driver.manual reference/operator/update/pull/ $pull
+     */
+    public fun <@OnlyInputTypes T> pullAll(property: KProperty<Iterable<T>?>, values: List<T?>?): Bson =
+        property.pullAll(values ?: emptyList())
+
+    /**
+     * Creates an update that pops the first element of an array that is the value of the property.
+     *
+     * @param property the property
+     * @return the update @mongodb.driver.manual reference/operator/update/pop/ $pop
+     */
+    public fun <T> popFirst(property: KProperty<T>): Bson = Updates.popFirst(property.path())
+
+    /**
+     * Creates an update that pops the last element of an array that is the value of the property.
+     *
+     * @param property the property
+     * @return the update @mongodb.driver.manual reference/operator/update/pop/ $pop
+     */
+    public fun <T> popLast(property: KProperty<T>): Bson = Updates.popLast(property.path())
+
+    /**
+     * Creates an update that performs a bitwise and between the given integer value and the integral value of the
+     * property.
+     *
+     * @param value the value
+     * @return the update
+     */
+    @JvmSynthetic
+    @JvmName("bitwiseAndExt")
+    public infix fun <T : Number?> KProperty<T>.bitwiseAnd(value: Int): Bson = Updates.bitwiseAnd(path(), value)
+
+    /**
+     * Creates an update that performs a bitwise and between the given integer value and the integral value of the
+     * property.
+     *
+     * @param property the property
+     * @param value the value
+     * @return the update
+     */
+    public fun <T : Number?> bitwiseAnd(property: KProperty<T>, value: Int): Bson = property.bitwiseAnd(value)
+
+    /**
+     * Creates an update that performs a bitwise and between the given long value and the integral value of the
+     * property.
+     *
+     * @param value the value
+     * @return the update @mongodb.driver.manual reference/operator/update/bit/ $bit
+     */
+    @JvmSynthetic
+    @JvmName("bitwiseAndExt")
+    public infix fun <T : Number?> KProperty<T>.bitwiseAnd(value: Long): Bson = Updates.bitwiseAnd(path(), value)
+
+    /**
+     * Creates an update that performs a bitwise and between the given long value and the integral value of the
+     * property.
+     *
+     * @param property the property
+     * @param value the value
+     * @return the update @mongodb.driver.manual reference/operator/update/bit/ $bit
+     */
+    public fun <T : Number?> bitwiseAnd(property: KProperty<T>, value: Long): Bson = property.bitwiseAnd(value)
+
+    /**
+     * Creates an update that performs a bitwise or between the given integer value and the integral value of the
+     * property.
+     *
+     * @param value the value
+     * @return the update @mongodb.driver.manual reference/operator/update/bit/ $bit
+     */
+    @JvmSynthetic
+    @JvmName("bitwiseOrExt")
+    public infix fun <T : Number?> KProperty<T>.bitwiseOr(value: Int): Bson = Updates.bitwiseOr(path(), value)
+
+    /**
+     * Creates an update that performs a bitwise or between the given integer value and the integral value of the
+     * property.
+     *
+     * @param property the property
+     * @param value the value
+     * @return the update @mongodb.driver.manual reference/operator/update/bit/ $bit
+     */
+    public fun <T : Number?> bitwiseOr(property: KProperty<T>, value: Int): Bson =
+        Updates.bitwiseOr(property.path(), value)
+
+    /**
+     * Creates an update that performs a bitwise or between the given long value and the integral value of the property.
+     *
+     * @param value the value
+     * @return the update @mongodb.driver.manual reference/operator/update/bit/ $bit
+     */
+    @JvmSynthetic
+    @JvmName("bitwiseOrExt")
+    public infix fun <T : Number?> KProperty<T>.bitwiseOr(value: Long): Bson = Updates.bitwiseOr(path(), value)
+
+    /**
+     * Creates an update that performs a bitwise or between the given long value and the integral value of the property.
+     *
+     * @param property the property
+     * @param value the value
+     * @return the update @mongodb.driver.manual reference/operator/update/bit/ $bit
+     */
+    public fun <T : Number?> bitwiseOr(property: KProperty<T>, value: Long): Bson = property.bitwiseOr(value)
+
+    /**
+     * Creates an update that performs a bitwise xor between the given integer value and the integral value of the
+     * property.
+     *
+     * @param value the value
+     * @return the update
+     */
+    @JvmSynthetic
+    @JvmName("bitwiseXorExt")
+    public infix fun <T : Number?> KProperty<T>.bitwiseXor(value: Int): Bson = Updates.bitwiseXor(path(), value)
+
+    /**
+     * Creates an update that performs a bitwise xor between the given integer value and the integral value of the
+     * property.
+     *
+     * @param property the property
+     * @param value the value
+     * @return the update
+     */
+    public fun <T : Number?> bitwiseXor(property: KProperty<T>, value: Int): Bson =
+        Updates.bitwiseXor(property.path(), value)
+
+    /**
+     * Creates an update that performs a bitwise xor between the given long value and the integral value of the
+     * property.
+     *
+     * @param value the value
+     * @return the update
+     */
+    @JvmSynthetic
+    @JvmName("addToSetExt")
+    public infix fun <T : Number?> KProperty<T>.bitwiseXor(value: Long): Bson = Updates.bitwiseXor(path(), value)
+
+    /**
+     * Creates an update that performs a bitwise xor between the given long value and the integral value of the
+     * property.
+     *
+     * @param property the property
+     * @param value the value
+     * @return the update
+     */
+    public fun <T : Number?> bitwiseXor(property: KProperty<T>, value: Long): Bson =
+        Updates.bitwiseXor(property.path(), value)
+}
diff --git a/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/property/KPropertyPath.kt b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/property/KPropertyPath.kt
new file mode 100644
index 00000000000..a460266f098
--- /dev/null
+++ b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/property/KPropertyPath.kt
@@ -0,0 +1,188 @@
+/*
+ * 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.property
+
+import com.mongodb.annotations.Sealed
+import com.mongodb.kotlin.client.model.path
+import kotlin.reflect.KParameter
+import kotlin.reflect.KProperty1
+import kotlin.reflect.KType
+import kotlin.reflect.KTypeParameter
+import kotlin.reflect.KVisibility
+
+/**
+ * A property path, operations on which take one receiver as a parameter.
+ *
+ * @param T the type of the receiver which should be used to obtain the value of the property.
+ * @param R the type of the property.
+ */
+@Sealed
+public open class KPropertyPath<T, R>(
+    private val previous: KPropertyPath<T, *>?,
+    internal val property: KProperty1<*, R?>
+) : KProperty1<T, R> {
+
+    @Suppress("UNCHECKED_CAST")
+    internal constructor(
+        previous: KProperty1<*, Any?>,
+        property: KProperty1<*, R?>
+    ) : this(
+        if (previous is KPropertyPath<*, *>) {
+            previous as KPropertyPath<T, *>?
+        } else {
+            KPropertyPath<T, Any?>(null as (KPropertyPath<T, *>?), previous)
+        },
+        property)
+
+    private val path: String by lazy { "${previous?.path?.let { "$it." } ?: ""}${property.path()}" }
+
+    override val name: String
+        get() = path
+
+    override val annotations: List<Annotation>
+        get() = unSupportedOperation()
+    override val getter: KProperty1.Getter<T, R>
+        get() = unSupportedOperation()
+    override val isAbstract: Boolean
+        get() = unSupportedOperation()
+    override val isConst: Boolean
+        get() = unSupportedOperation()
+    override val isFinal: Boolean
+        get() = unSupportedOperation()
+    override val isLateinit: Boolean
+        get() = unSupportedOperation()
+    override val isOpen: Boolean
+        get() = unSupportedOperation()
+    override val isSuspend: Boolean
+        get() = unSupportedOperation()
+    override val parameters: List<KParameter>
+        get() = unSupportedOperation()
+    override val returnType: KType
+        get() = unSupportedOperation()
+    override val typeParameters: List<KTypeParameter>
+        get() = unSupportedOperation()
+    override val visibility: KVisibility?
+        get() = unSupportedOperation()
+    override fun invoke(p1: T): R = unSupportedOperation()
+    override fun call(vararg args: Any?): R = unSupportedOperation()
+    override fun callBy(args: Map<KParameter, Any?>): R = unSupportedOperation()
+    override fun get(receiver: T): R = unSupportedOperation()
+    override fun getDelegate(receiver: T): Any? = unSupportedOperation()
+
+    public companion object {
+
+        private fun unSupportedOperation(): Nothing = throw UnsupportedOperationException()
+
+        internal class CustomProperty<T, R>(val previous: KPropertyPath<*, T>, path: String) : KProperty1<T, R> {
+            override val annotations: List<Annotation>
+                get() = emptyList()
+
+            override val getter: KProperty1.Getter<T, R>
+                get() = unSupportedOperation()
+            override val isAbstract: Boolean
+                get() = previous.isAbstract
+            override val isConst: Boolean
+                get() = previous.isConst
+            override val isFinal: Boolean
+                get() = previous.isFinal
+            override val isLateinit: Boolean
+                get() = previous.isLateinit
+            override val isOpen: Boolean
+                get() = previous.isOpen
+            override val isSuspend: Boolean
+                get() = previous.isSuspend
+            override val name: String = path
+            override val parameters: List<KParameter>
+                get() = previous.parameters
+            override val returnType: KType
+                get() = unSupportedOperation()
+            override val typeParameters: List<KTypeParameter>
+                get() = previous.typeParameters
+            override val visibility: KVisibility?
+                get() = previous.visibility
+            override fun call(vararg args: Any?): R = unSupportedOperation()
+            override fun callBy(args: Map<KParameter, Any?>): R = unSupportedOperation()
+            override fun get(receiver: T): R = unSupportedOperation()
+            override fun getDelegate(receiver: T): Any? = unSupportedOperation()
+            override fun invoke(p1: T): R = unSupportedOperation()
+        }
+
+        /** Provides "fake" property with custom name. */
+        public fun <T, R> customProperty(previous: KPropertyPath<*, T>, path: String): KProperty1<T, R?> =
+            CustomProperty(previous, path)
+    }
+}
+
+/** Base class for collection property path. */
+public open class KCollectionPropertyPath<T, R, MEMBER : KPropertyPath<T, R?>>(
+    previous: KPropertyPath<T, *>?,
+    property: KProperty1<*, Iterable<R>?>
+) : KPropertyPath<T, Iterable<R>?>(previous, property) {
+
+    /** To be overridden to return the right type. */
+    @Suppress("UNCHECKED_CAST")
+    public open fun memberWithAdditionalPath(additionalPath: String): MEMBER =
+        KPropertyPath<T, R>(
+            this as KProperty1<T, Collection<R>?>, customProperty(this as KPropertyPath<*, T>, additionalPath))
+            as MEMBER
+
+    /** [The positional array operator $](https://docs.mongodb.com/manual/reference/operator/update/positional/) */
+    public val posOp: MEMBER
+        get() = memberWithAdditionalPath("\$")
+
+    /** [The all positional operator $[]](https://docs.mongodb.com/manual/reference/operator/update/positional-all/) */
+    public val allPosOp: MEMBER
+        get() = memberWithAdditionalPath("\$[]")
+
+    /**
+     * [The filtered positional operator $[\<identifier\>]]
+     * (https://docs.mongodb.com/manual/reference/operator/update/positional-filtered/)
+     */
+    public fun filteredPosOp(identifier: String): MEMBER = memberWithAdditionalPath("\$[$identifier]")
+
+    /** In order to write array indexed expressions (like `accesses.0.timestamp`) */
+    public fun pos(position: Int): MEMBER = memberWithAdditionalPath(position.toString())
+}
+
+/** A property path for a collection property. */
+public class KCollectionSimplePropertyPath<T, R>(
+    previous: KPropertyPath<T, *>?,
+    property: KProperty1<*, Iterable<R>?>
+) : KCollectionPropertyPath<T, R, KPropertyPath<T, R?>>(previous, property)
+
+/** Base class for map property path. */
+public open class KMapPropertyPath<T, K, R, MEMBER : KPropertyPath<T, R?>>(
+    previous: KPropertyPath<T, *>?,
+    property: KProperty1<*, Map<out K, R>?>
+) : KPropertyPath<T, Map<out K?, R>?>(previous, property) {
+
+    /** To be overridden to returns the right type. */
+    @Suppress("UNCHECKED_CAST")
+    public open fun memberWithAdditionalPath(additionalPath: String): MEMBER =
+        KPropertyPath<T, R>(
+            this as KProperty1<T, Collection<R>?>, customProperty(this as KPropertyPath<*, T>, additionalPath))
+            as MEMBER
+
+    /** Key projection of map. Sample: `Restaurant::localeMap.keyProjection(Locale.ENGLISH).path()` */
+    public fun keyProjection(key: K): MEMBER = memberWithAdditionalPath(key.toString())
+}
+
+/** A property path for a map property. */
+public class KMapSimplePropertyPath<T, K, R>(previous: KPropertyPath<T, *>?, property: KProperty1<*, Map<out K, R>?>) :
+    KMapPropertyPath<T, K, R, KPropertyPath<T, R?>>(previous, property)
diff --git a/driver-kotlin-extensions/src/main/kotlin/kotlin/internal/OnlyInputTypes.kt b/driver-kotlin-extensions/src/main/kotlin/kotlin/internal/OnlyInputTypes.kt
new file mode 100644
index 00000000000..7526cd9c370
--- /dev/null
+++ b/driver-kotlin-extensions/src/main/kotlin/kotlin/internal/OnlyInputTypes.kt
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2008-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.
+ */
+package kotlin.internal
+
+/**
+ * Work around to expose `kotlin.internal` OnlyInputTypes
+ *
+ * Enables compile time type checking, so that captured types cannot be expanded.
+ *
+ * See: https://youtrack.jetbrains.com/issue/KT-13198/
+ */
+@Target(AnnotationTarget.TYPE_PARAMETER)
+@Retention(AnnotationRetention.BINARY)
+internal annotation class OnlyInputTypes
diff --git a/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/AggregatesTest.kt b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/AggregatesTest.kt
new file mode 100644
index 00000000000..50f369e50ec
--- /dev/null
+++ b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/AggregatesTest.kt
@@ -0,0 +1,355 @@
+/*
+ * 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.MongoNamespace
+import com.mongodb.client.model.Aggregates
+import com.mongodb.client.model.Aggregates.project
+import com.mongodb.client.model.GraphLookupOptions
+import com.mongodb.client.model.MergeOptions
+import com.mongodb.client.model.QuantileMethod
+import com.mongodb.client.model.UnwindOptions
+import com.mongodb.client.model.densify.DensifyOptions
+import com.mongodb.client.model.densify.DensifyRange
+import com.mongodb.kotlin.client.MongoCollection
+import com.mongodb.kotlin.client.model.Accumulators.accumulator
+import com.mongodb.kotlin.client.model.Accumulators.addToSet
+import com.mongodb.kotlin.client.model.Accumulators.avg
+import com.mongodb.kotlin.client.model.Accumulators.bottom
+import com.mongodb.kotlin.client.model.Accumulators.bottomN
+import com.mongodb.kotlin.client.model.Accumulators.first
+import com.mongodb.kotlin.client.model.Accumulators.firstN
+import com.mongodb.kotlin.client.model.Accumulators.last
+import com.mongodb.kotlin.client.model.Accumulators.lastN
+import com.mongodb.kotlin.client.model.Accumulators.max
+import com.mongodb.kotlin.client.model.Accumulators.maxN
+import com.mongodb.kotlin.client.model.Accumulators.median
+import com.mongodb.kotlin.client.model.Accumulators.mergeObjects
+import com.mongodb.kotlin.client.model.Accumulators.min
+import com.mongodb.kotlin.client.model.Accumulators.minN
+import com.mongodb.kotlin.client.model.Accumulators.percentile
+import com.mongodb.kotlin.client.model.Accumulators.push
+import com.mongodb.kotlin.client.model.Accumulators.stdDevPop
+import com.mongodb.kotlin.client.model.Accumulators.stdDevSamp
+import com.mongodb.kotlin.client.model.Accumulators.sum
+import com.mongodb.kotlin.client.model.Accumulators.top
+import com.mongodb.kotlin.client.model.Accumulators.topN
+import com.mongodb.kotlin.client.model.Aggregates.count
+import com.mongodb.kotlin.client.model.Aggregates.densify
+import com.mongodb.kotlin.client.model.Aggregates.graphLookup
+import com.mongodb.kotlin.client.model.Aggregates.lookup
+import com.mongodb.kotlin.client.model.Aggregates.merge
+import com.mongodb.kotlin.client.model.Aggregates.out
+import com.mongodb.kotlin.client.model.Aggregates.unionWith
+import com.mongodb.kotlin.client.model.Aggregates.unwind
+import com.mongodb.kotlin.client.model.Projections.excludeId
+import com.mongodb.kotlin.client.model.Projections.projection
+import com.mongodb.kotlin.client.model.Sorts.ascending
+import kotlin.test.assertEquals
+import org.bson.BsonDocument
+import org.bson.conversions.Bson
+import org.junit.jupiter.api.BeforeAll
+import org.junit.jupiter.api.Test
+import org.mockito.Mock
+import org.mockito.Mockito.verify
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.whenever
+
+class AggregatesTest {
+
+    companion object {
+        @Mock internal val wrappedEmployee: com.mongodb.client.MongoCollection<Employee> = mock()
+        @Mock
+        internal val wrappedEmployeeCoroutine: com.mongodb.reactivestreams.client.MongoCollection<Employee> = mock()
+        @Mock internal val wrappedCustomer: com.mongodb.client.MongoCollection<Customer> = mock()
+        @Mock
+        internal val wrappedCustomerCoroutine: com.mongodb.reactivestreams.client.MongoCollection<Customer> = mock()
+
+        lateinit var employeeCollection: MongoCollection<Employee>
+        lateinit var employeeCollectionCoroutine: com.mongodb.kotlin.client.coroutine.MongoCollection<Employee>
+        lateinit var customerCollection: MongoCollection<Customer>
+        lateinit var customerCollectionCoroutine: com.mongodb.kotlin.client.coroutine.MongoCollection<Customer>
+
+        @JvmStatic
+        @BeforeAll
+        internal fun setUpMocks() {
+            employeeCollection = MongoCollection(wrappedEmployee)
+            employeeCollectionCoroutine = com.mongodb.kotlin.client.coroutine.MongoCollection(wrappedEmployeeCoroutine)
+
+            customerCollection = MongoCollection(wrappedCustomer)
+            customerCollectionCoroutine = com.mongodb.kotlin.client.coroutine.MongoCollection(wrappedCustomerCoroutine)
+
+            whenever(wrappedEmployee.namespace).doReturn(MongoNamespace("db", Employee::class.simpleName!!))
+            whenever(wrappedEmployeeCoroutine.namespace).doReturn(MongoNamespace("db", Employee::class.simpleName!!))
+            whenever(wrappedCustomer.namespace).doReturn(MongoNamespace("db", Customer::class.simpleName!!))
+            whenever(wrappedCustomerCoroutine.namespace).doReturn(MongoNamespace("db", Customer::class.simpleName!!))
+
+            employeeCollection.namespace
+            verify(wrappedEmployee).namespace
+            assertEquals(Employee::class.simpleName, employeeCollection.namespace.collectionName)
+
+            employeeCollectionCoroutine.namespace
+            verify(wrappedEmployeeCoroutine).namespace
+            assertEquals(Employee::class.simpleName, employeeCollectionCoroutine.namespace.collectionName)
+
+            customerCollection.namespace
+            verify(wrappedCustomer).namespace
+            assertEquals(Customer::class.simpleName, customerCollection.namespace.collectionName)
+
+            customerCollectionCoroutine.namespace
+            verify(wrappedCustomerCoroutine).namespace
+            assertEquals(Customer::class.simpleName, customerCollectionCoroutine.namespace.collectionName)
+        }
+    }
+
+    @Test
+    fun count() {
+        assertEquals(""" {${'$'}count: "name"}""", count(Person::name))
+    }
+
+    @Test
+    fun lookup() {
+        assertEquals(
+            """ {"${'$'}lookup":
+                {"from": "Customer", "localField": "customerId", "foreignField": "customerId", "as": "invoice"}}""",
+            lookup(customerCollection, Order::customerId, Customer::customerId, "invoice"))
+        assertEquals(
+            Aggregates.lookup("Customer", "customerId", "customerId", "invoice"),
+            lookup(customerCollection, Order::customerId, Customer::customerId, "invoice"))
+
+        assertEquals(
+            """ {"${'$'}lookup":
+                {"from": "Customer", "localField": "customerId", "foreignField": "customerId", "as": "invoice"}}""",
+            lookup(customerCollectionCoroutine, Order::customerId, Customer::customerId, "invoice"))
+        assertEquals(
+            Aggregates.lookup("Customer", "customerId", "customerId", "invoice"),
+            lookup(customerCollectionCoroutine, Order::customerId, Customer::customerId, "invoice"))
+    }
+
+    @Test
+    fun graphLookup() {
+        assertEquals(
+            """ {"${'$'}graphLookup":
+                 {"from": "Employee", "startWith": "${'$'}id", "connectFromField": "id", "connectToField":
+            "reportsTo", "as": "subordinates", "maxDepth": 1}} """,
+            graphLookup(
+                from = employeeCollection,
+                startWith = Employee::id.projection,
+                connectFromField = Employee::id,
+                connectToField = Employee::reportsTo,
+                fieldAs = "subordinates",
+                options = GraphLookupOptions().maxDepth(1)))
+
+        assertEquals(
+            """ {"${'$'}graphLookup":
+                 {"from": "Employee", "startWith": "${'$'}id", "connectFromField": "id", "connectToField":
+            "reportsTo", "as": "subordinates", "maxDepth": 1}} """,
+            graphLookup(
+                from = employeeCollectionCoroutine,
+                startWith = Employee::id.projection,
+                connectFromField = Employee::id,
+                connectToField = Employee::reportsTo,
+                fieldAs = "subordinates",
+                options = GraphLookupOptions().maxDepth(1)))
+    }
+
+    @Test
+    fun unionWith() {
+        assertEquals(
+            """  {"${'$'}unionWith": {"coll": "Customer", "pipeline": [{"${'$'}project": {"_id": 0}}]}} """,
+            unionWith(collection = customerCollection, pipeline = listOf(project(excludeId()))))
+
+        assertEquals(
+            """  {"${'$'}unionWith": {"coll": "Customer", "pipeline": [{"${'$'}project": {"_id": 0}}]}} """,
+            unionWith(collection = customerCollectionCoroutine, pipeline = listOf(project(excludeId()))))
+    }
+
+    @Test
+    fun unwind() {
+        assertEquals(UnwindOptions(), UnwindOptions())
+        assertEquals("""  {"${'$'}unwind": "${'$'}address"} """, unwind(Person::address))
+
+        assertEquals(
+            """ {"${'$'}unwind":
+                {"path": "${'$'}address", "preserveNullAndEmptyArrays": true, "includeArrayIndex": "idx"}} """,
+            unwind(Person::address, UnwindOptions().includeArrayIndex("idx").preserveNullAndEmptyArrays(true)))
+    }
+
+    @Test
+    fun out() {
+        assertEquals(""" {"${'$'}out": "Employee"}  """, out(employeeCollection))
+        assertEquals(""" {"${'$'}out": "Employee"}  """, out(employeeCollectionCoroutine))
+    }
+
+    @Test
+    fun merge() {
+        assertEquals(""" {"${'$'}merge": {"into": "Customer"}} """, merge(customerCollection))
+        assertEquals(""" {"${'$'}merge": {"into": "Customer"}} """, merge(customerCollectionCoroutine))
+
+        assertEquals(
+            """ {"${'$'}merge": {"into": "Customer", "on": "ssn"}} """,
+            merge(customerCollection, MergeOptions().uniqueIdentifier("ssn")))
+        assertEquals(
+            """ {"${'$'}merge": {"into": "Customer", "on": "ssn"}} """,
+            merge(customerCollectionCoroutine, MergeOptions().uniqueIdentifier("ssn")))
+    }
+
+    @Test
+    fun densify() {
+        assertEquals(
+            """  {"${'$'}densify": {
+                    "field": "email",
+                    "range": { "bounds": "full", "step": 1 }
+                }} """,
+            densify(Customer::email, DensifyRange.fullRangeWithStep(1)))
+
+        assertEquals(
+            """  {"${'$'}densify": {
+                    "field": "email",
+                    "range": { "bounds": "full", "step": 1 },
+                    "partitionByFields": ["foo"]
+                }} """,
+            densify(
+                Customer::email,
+                range = DensifyRange.fullRangeWithStep(1),
+                options = DensifyOptions.densifyOptions().partitionByFields("foo")))
+    }
+
+    @Test
+    @Suppress("LongMethod")
+    fun accumulators() {
+        assertEquals(com.mongodb.client.model.Accumulators.sum("age", 1), sum(Person::age, 1))
+
+        assertEquals(com.mongodb.client.model.Accumulators.avg("age", 1), avg(Person::age, 1))
+
+        assertEquals(
+            com.mongodb.client.model.Accumulators.percentile("age", 1, 2, QuantileMethod.approximate()),
+            percentile(Person::age, 1, 2, QuantileMethod.approximate()))
+
+        assertEquals(
+            com.mongodb.client.model.Accumulators.median("age", 1, QuantileMethod.approximate()),
+            median(Person::age, 1, QuantileMethod.approximate()))
+
+        assertEquals(com.mongodb.client.model.Accumulators.first("age", 1), first(Person::age, 1))
+
+        assertEquals(com.mongodb.client.model.Accumulators.firstN("age", 1, 2), firstN(Person::age, 1, 2))
+
+        assertEquals(
+            com.mongodb.client.model.Accumulators.top("age", com.mongodb.client.model.Sorts.ascending("name"), 1),
+            top(Person::age, ascending(Person::name), 1))
+
+        assertEquals(
+            com.mongodb.client.model.Accumulators.topN("age", com.mongodb.client.model.Sorts.ascending("name"), 1, 2),
+            topN(Person::age, ascending(Person::name), 1, 2))
+
+        assertEquals(com.mongodb.client.model.Accumulators.last("age", 1), last(Person::age, 1))
+
+        assertEquals(com.mongodb.client.model.Accumulators.lastN("age", 1, 2), lastN(Person::age, 1, 2))
+
+        assertEquals(
+            com.mongodb.client.model.Accumulators.bottom("age", com.mongodb.client.model.Sorts.ascending("name"), 1),
+            bottom(Person::age, ascending(Person::name), 1))
+
+        assertEquals(
+            com.mongodb.client.model.Accumulators.bottomN(
+                "age", com.mongodb.client.model.Sorts.ascending("name"), 1, 2),
+            bottomN(Person::age, ascending(Person::name), 1, 2))
+
+        assertEquals(com.mongodb.client.model.Accumulators.max("age", 1), max(Person::age, 1))
+
+        assertEquals(com.mongodb.client.model.Accumulators.maxN("age", 1, 2), maxN(Person::age, 1, 2))
+
+        assertEquals(com.mongodb.client.model.Accumulators.min("age", 1), min(Person::age, 1))
+
+        assertEquals(com.mongodb.client.model.Accumulators.minN("age", 1, 2), minN(Person::age, 1, 2))
+
+        assertEquals(com.mongodb.client.model.Accumulators.push("age", 1), push(Person::age, 1))
+
+        assertEquals(com.mongodb.client.model.Accumulators.addToSet("age", 1), addToSet(Person::age, 1))
+
+        assertEquals(com.mongodb.client.model.Accumulators.mergeObjects("age", 1), mergeObjects(Person::age, 1))
+
+        assertEquals(
+            com.mongodb.client.model.Accumulators.accumulator(
+                "age", "initFunction", "accumulateFunction", "mergeFunction"),
+            accumulator(Person::age, "initFunction", "accumulateFunction", "mergeFunction"))
+
+        assertEquals(
+            com.mongodb.client.model.Accumulators.accumulator(
+                "age", "initFunction", "accumulateFunction", "mergeFunction", "finalizeFunction"),
+            accumulator(Person::age, "initFunction", "accumulateFunction", "mergeFunction", "finalizeFunction"))
+
+        assertEquals(
+            com.mongodb.client.model.Accumulators.accumulator(
+                "age",
+                "initFunction",
+                listOf("a", "b"),
+                "accumulateFunction",
+                listOf("c", "d"),
+                "mergeFunction",
+                "finalizeFunction"),
+            accumulator(
+                Person::age,
+                "initFunction",
+                listOf("a", "b"),
+                "accumulateFunction",
+                listOf("c", "d"),
+                "mergeFunction",
+                "finalizeFunction"))
+
+        assertEquals(
+            com.mongodb.client.model.Accumulators.accumulator(
+                "age", "initFunction", "accumulateFunction", "mergeFunction", "finalizeFunction", "Kotlin"),
+            accumulator(
+                Person::age, "initFunction", "accumulateFunction", "mergeFunction", "finalizeFunction", "Kotlin"))
+
+        assertEquals(
+            com.mongodb.client.model.Accumulators.accumulator(
+                "age",
+                "initFunction",
+                listOf("a", "b"),
+                "accumulateFunction",
+                listOf("c", "d"),
+                "mergeFunction",
+                "finalizeFunction",
+                "Kotlin"),
+            accumulator(
+                Person::age,
+                "initFunction",
+                listOf("a", "b"),
+                "accumulateFunction",
+                listOf("c", "d"),
+                "mergeFunction",
+                "finalizeFunction",
+                "Kotlin"))
+
+        assertEquals(com.mongodb.client.model.Accumulators.stdDevPop("age", 1), stdDevPop(Person::age, 1))
+
+        assertEquals(com.mongodb.client.model.Accumulators.stdDevSamp("age", 1), stdDevSamp(Person::age, 1))
+    }
+
+    data class Person(val name: String, val age: Int, val address: List<String>?, val results: List<Int>)
+    data class Employee(val id: String, val name: String, val reportsTo: String)
+    data class Order(val id: String, val orderId: String, val customerId: Int, val amount: Int)
+    data class Customer(val id: String, val customerId: Int, val name: String, val email: String?)
+
+    private fun assertEquals(expected: String, result: Bson) =
+        assertEquals(BsonDocument.parse(expected), result.toBsonDocument())
+}
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
new file mode 100644
index 00000000000..e4455f9cfc6
--- /dev/null
+++ b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/ExtensionsApiTest.kt
@@ -0,0 +1,121 @@
+/*
+ * Copyright 2008-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.
+ */
+package com.mongodb.kotlin.client.model
+
+import io.github.classgraph.ClassGraph
+import kotlin.test.assertTrue
+import org.junit.jupiter.api.Test
+
+class ExtensionsApiTest {
+
+    @Test
+    fun shouldHaveAllFiltersExtensions() {
+        val kotlinExtensions: Set<String> = getKotlinExtensions("Filters")
+        val javaMethods: Set<String> = getJavaMethods("Filters")
+
+        val notImplemented = javaMethods subtract kotlinExtensions
+        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")
+    }
+
+    @Test
+    fun shouldHaveAllUpdatesExtensions() {
+        val kotlinExtensions: Set<String> = getKotlinExtensions("Updates")
+        val javaMethods: Set<String> = getJavaMethods("Updates")
+
+        val notImplemented = javaMethods subtract kotlinExtensions
+        assertTrue(notImplemented.isEmpty(), "Some possible Updates were not implemented: $notImplemented")
+    }
+
+    @Test
+    fun shouldHaveAllIndexesExtensions() {
+        val kotlinExtensions: Set<String> = getKotlinExtensions("Indexes")
+        val javaMethods: Set<String> = getJavaMethods("Indexes")
+        val notImplemented = javaMethods subtract kotlinExtensions
+        assertTrue(notImplemented.isEmpty(), "Some possible Indexes were not implemented: $notImplemented")
+    }
+
+    @Test
+    fun shouldHaveAllSortsExtensions() {
+        val kotlinExtensions: Set<String> = getKotlinExtensions("Sorts")
+        val javaMethods: Set<String> = getJavaMethods("Sorts")
+
+        val notImplemented = javaMethods subtract kotlinExtensions
+        assertTrue(notImplemented.isEmpty(), "Some possible Sorts were not implemented: $notImplemented")
+    }
+
+    @Test
+    fun shouldHaveAllAggregatesExtensions() {
+        val kotlinExtensions: Set<String> = getKotlinExtensions("Aggregates")
+        val javaMethods: Set<String> = getJavaMethods("Aggregates")
+
+        val notImplemented = javaMethods subtract kotlinExtensions
+        assertTrue(notImplemented.isEmpty(), "Some possible Aggregates were not implemented: $notImplemented")
+    }
+
+    @Test
+    fun shouldHaveAllAccumulatorsExtensions() {
+        val kotlinExtensions: Set<String> = getKotlinExtensions("Accumulators")
+        val javaMethods: Set<String> = getJavaMethods("Accumulators")
+
+        val notImplemented = javaMethods subtract kotlinExtensions
+        assertTrue(notImplemented.isEmpty(), "Some possible Accumulators were not implemented: $notImplemented")
+    }
+
+    private fun getKotlinExtensions(className: String): Set<String> {
+        return ClassGraph()
+            .enableClassInfo()
+            .enableMethodInfo()
+            .acceptPackages("com.mongodb.kotlin.client.model")
+            .scan()
+            .use { result ->
+                result.allClasses
+                    .filter { it.simpleName == className }
+                    .asSequence()
+                    .flatMap { it.methodInfo }
+                    .filter { it.isPublic }
+                    .map { it.name }
+                    .filter { !it.contains("$") }
+                    .toSet()
+            }
+    }
+
+    private fun getJavaMethods(className: String): Set<String> {
+        return ClassGraph().enableClassInfo().enableMethodInfo().acceptPackages("com.mongodb.client.model").scan().use {
+            it.getClassInfo("com.mongodb.client.model.$className")
+                .methodInfo
+                .filter { methodInfo ->
+                    methodInfo.isPublic &&
+                        methodInfo.parameterInfo.isNotEmpty() &&
+                        methodInfo.parameterInfo[0]
+                            .typeDescriptor
+                            .toStringWithSimpleNames()
+                            .equals("String") // only method starting
+                    // with a String (property name)
+                }
+                .map { m -> m.name }
+                .toSet()
+        }
+    }
+}
diff --git a/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/FiltersTest.kt b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/FiltersTest.kt
new file mode 100644
index 00000000000..da15d6ee5af
--- /dev/null
+++ b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/FiltersTest.kt
@@ -0,0 +1,667 @@
+/*
+ * 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.MongoClientSettings
+import com.mongodb.client.model.TextSearchOptions
+import com.mongodb.client.model.geojson.Point
+import com.mongodb.client.model.geojson.Polygon
+import com.mongodb.client.model.geojson.Position
+import com.mongodb.kotlin.client.model.Filters.all
+import com.mongodb.kotlin.client.model.Filters.and
+import com.mongodb.kotlin.client.model.Filters.bitsAllClear
+import com.mongodb.kotlin.client.model.Filters.bitsAllSet
+import com.mongodb.kotlin.client.model.Filters.bitsAnyClear
+import com.mongodb.kotlin.client.model.Filters.bitsAnySet
+import com.mongodb.kotlin.client.model.Filters.elemMatch
+import com.mongodb.kotlin.client.model.Filters.eq
+import com.mongodb.kotlin.client.model.Filters.exists
+import com.mongodb.kotlin.client.model.Filters.expr
+import com.mongodb.kotlin.client.model.Filters.geoIntersects
+import com.mongodb.kotlin.client.model.Filters.geoWithin
+import com.mongodb.kotlin.client.model.Filters.geoWithinBox
+import com.mongodb.kotlin.client.model.Filters.geoWithinCenter
+import com.mongodb.kotlin.client.model.Filters.geoWithinCenterSphere
+import com.mongodb.kotlin.client.model.Filters.geoWithinPolygon
+import com.mongodb.kotlin.client.model.Filters.gt
+import com.mongodb.kotlin.client.model.Filters.gte
+import com.mongodb.kotlin.client.model.Filters.`in`
+import com.mongodb.kotlin.client.model.Filters.jsonSchema
+import com.mongodb.kotlin.client.model.Filters.lt
+import com.mongodb.kotlin.client.model.Filters.lte
+import com.mongodb.kotlin.client.model.Filters.mod
+import com.mongodb.kotlin.client.model.Filters.ne
+import com.mongodb.kotlin.client.model.Filters.near
+import com.mongodb.kotlin.client.model.Filters.nearSphere
+import com.mongodb.kotlin.client.model.Filters.nin
+import com.mongodb.kotlin.client.model.Filters.nor
+import com.mongodb.kotlin.client.model.Filters.not
+import com.mongodb.kotlin.client.model.Filters.or
+import com.mongodb.kotlin.client.model.Filters.regex
+import com.mongodb.kotlin.client.model.Filters.size
+import com.mongodb.kotlin.client.model.Filters.text
+import com.mongodb.kotlin.client.model.Filters.type
+import com.mongodb.kotlin.client.model.Filters.where
+import kotlin.test.assertEquals
+import org.bson.BsonDocument
+import org.bson.BsonType
+import org.bson.conversions.Bson
+import org.junit.Test
+
+class FiltersTest {
+
+    data class Person(val name: String, val age: Int, val address: List<String>, val results: List<Int>)
+    val person = Person("Ada", 20, listOf("St James Square", "London", "W1"), listOf(1, 2, 3))
+
+    @Test
+    fun testEqSupport() {
+        val expected = BsonDocument.parse("""{"name": "Ada"}""")
+        val bson = eq(Person::name, person.name)
+        assertEquals(expected, bson.document)
+
+        val kmongoDsl = Person::name eq person.name
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testNeSupport() {
+        val expected = BsonDocument.parse("""{"age": {"${'$'}ne": 20 }}""")
+        val bson = ne(Person::age, person.age)
+        assertEquals(expected, bson.document)
+
+        val kmongoDsl = Person::age ne person.age
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testNotSupport() {
+        val expected = BsonDocument.parse("""{"age": {${'$'}not: {${'$'}eq: 20 }}}""")
+        val bson = not(eq(Person::age, person.age))
+        assertEquals(expected, bson.document)
+
+        val kmongoDsl = not(Person::age eq person.age)
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testGtSupport() {
+        val expected = BsonDocument.parse("""{"age": {"${'$'}gt": 20}}""")
+        val bson = gt(Person::age, person.age)
+        assertEquals(expected, bson.document)
+
+        val kmongoDsl = Person::age gt 20
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testGteSupport() {
+        val expected = BsonDocument.parse("""{"age": {"${'$'}gte": 20}}""")
+        val bson = gte(Person::age, person.age)
+        assertEquals(expected, bson.document)
+
+        val kmongoDsl = Person::age gte 20
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testLtSupport() {
+        val expected = BsonDocument.parse("""{"age": {"${'$'}lt": 20}}""")
+        val bson = lt(Person::age, person.age)
+        assertEquals(expected, bson.document)
+
+        val kmongoDsl = Person::age lt 20
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testLteSupport() {
+        val expected = BsonDocument.parse("""{"age": {"${'$'}lte": 20}}""")
+        val bson = lte(Person::age, person.age)
+        assertEquals(expected, bson.document)
+
+        val kmongoDsl = Person::age lte 20
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testExistsSupport() {
+        val expected = BsonDocument.parse("""{"age": {"${'$'}exists": true}}""")
+
+        var bson = exists(Person::age)
+        assertEquals(expected, bson.document)
+
+        var kmongoDsl = Person::age.exists()
+        assertEquals(expected, kmongoDsl.document)
+
+        bson = exists(Person::age, true)
+        assertEquals(expected, bson.document)
+
+        kmongoDsl = Person::age exists true
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testOrSupport() {
+        val expected = BsonDocument.parse("""{${'$'}or: [{"name": "Ada"}, {"age": 20 }]}""")
+        val bson = or(eq(Person::name, person.name), eq(Person::age, person.age))
+        assertEquals(expected, bson.document)
+
+        val kmongoDsl = or(Person::name eq person.name, Person::age eq person.age)
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testNorSupport() {
+        val expected = BsonDocument.parse("""{${'$'}nor: [{"name": "Ada"}, {"age": 20 }]}""")
+        var bson = nor(eq(Person::name, person.name), eq(Person::age, person.age))
+        assertEquals(expected, bson.document)
+
+        var kmongoDsl = nor(Person::name eq person.name, Person::age eq person.age)
+        assertEquals(expected, kmongoDsl.document)
+
+        // List api
+        bson = nor(listOf(eq(Person::name, person.name), eq(Person::age, person.age)))
+        assertEquals(expected, bson.document)
+
+        kmongoDsl = nor(listOf(Person::name eq person.name, Person::age eq person.age))
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testAndSupport() {
+        val expected = BsonDocument.parse("""{${'$'}and: [{"name": "Ada"}, {"age": 20 }]}""")
+        val bson = and(eq(Person::name, person.name), eq(Person::age, person.age))
+        assertEquals(expected, bson.document)
+
+        val kmongoDsl = and(Person::name.eq(person.name), Person::age.eq(person.age))
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testAllSupport() {
+        val expected = BsonDocument.parse("""{"address": {${'$'}all: ["a", "b", "c"]}}""")
+        var bson = all(Person::address, "a", "b", "c")
+        assertEquals(expected, bson.document)
+
+        var kmongoDsl = Person::address.all("a", "b", "c")
+        assertEquals(expected, kmongoDsl.document)
+
+        bson = all(Person::address, listOf("a", "b", "c"))
+        assertEquals(expected, bson.document)
+
+        kmongoDsl = Person::address.all(listOf("a", "b", "c"))
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testElemMatchSupport() {
+        val expected =
+            BsonDocument.parse(
+                """{"results": {"${'$'}elemMatch":
+            |{"${'$'}and": [{"age": {"${'$'}gt": 1}}, {"age": {"${'$'}lt": 10}}]}}}"""
+                    .trimMargin())
+        val bson = elemMatch(Person::results, and(gt(Person::age, 1), lt(Person::age, 10)))
+        assertEquals(expected, bson.document)
+
+        val kmongoDsl = Person::results elemMatch and(gt(Person::age, 1), lt(Person::age, 10))
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testInSupport() {
+        // List of values
+        var expected = BsonDocument.parse("""{"results": {"${'$'}in": [1, 2, 3]}}""")
+        var bson = `in`(Person::results, person.results)
+        assertEquals(expected, bson.document)
+
+        var kmongoDsl = Person::results.`in`(person.results)
+        assertEquals(expected, kmongoDsl.document)
+
+        // Alternative implementations
+        expected = BsonDocument.parse("""{"name": {"${'$'}in": ["Abe", "Ada", "Asda"]}}""")
+        bson = `in`(Person::name, listOf("Abe", "Ada", "Asda"))
+        assertEquals(expected, bson.document)
+
+        kmongoDsl = Person::name.`in`(listOf("Abe", "Ada", "Asda"))
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testNinSupport() {
+        // List of values
+        var expected = BsonDocument.parse("""{"results": {"${'$'}nin": [1, 2, 3]}}""")
+        var bson = nin(Person::results, person.results)
+        assertEquals(expected, bson.document)
+
+        var kmongoDsl = Person::results.nin(person.results)
+        assertEquals(expected, kmongoDsl.document)
+
+        // Alternative implementations
+        expected = BsonDocument.parse("""{"name": {"${'$'}nin": ["Abe", "Ada", "Asda"]}}""")
+        bson = nin(Person::name, listOf("Abe", "Ada", "Asda"))
+        assertEquals(expected, bson.document)
+
+        kmongoDsl = Person::name.nin(listOf("Abe", "Ada", "Asda"))
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testModSupport() {
+        val expected =
+            BsonDocument.parse(
+                """{"age": {"${'$'}mod": [{ "${'$'}numberLong" : "20" }, { "${'$'}numberLong" : "0" }]}}""")
+        val bson = mod(Person::age, person.age.toLong(), 0)
+        assertEquals(expected, bson.document)
+
+        val kmongoDsl = Person::age.mod(person.age.toLong(), 0)
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testSizeSupport() {
+        val expected = BsonDocument.parse("""{"results": {"${'$'}size": 3}}""")
+        val bson = size(Person::results, 3)
+        assertEquals(expected, bson.document)
+
+        val kmongoDsl = Person::results.size(3)
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testBitsAllClearSupport() {
+        val expected = BsonDocument.parse("""{"results": {"${'$'}bitsAllClear":  { "${'$'}numberLong" : "3" }}}""")
+        val bson = bitsAllClear(Person::results, 3)
+        assertEquals(expected, bson.document)
+
+        val kmongoDsl = Person::results bitsAllClear 3
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testBitsSetClearSupport() {
+        // List of values
+        val expected = BsonDocument.parse("""{"results": {"${'$'}bitsAllSet":  { "${'$'}numberLong" : "3" }}}""")
+        val bson = bitsAllSet(Person::results, 3)
+        assertEquals(expected, bson.document)
+
+        val kmongoDsl = Person::results bitsAllSet 3
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testBitsAnyClearSupport() {
+        val expected = BsonDocument.parse("""{"results": {"${'$'}bitsAnyClear":  { "${'$'}numberLong" : "3" }}}""")
+        val bson = bitsAnyClear(Person::results, 3)
+        assertEquals(expected, bson.document)
+
+        val kmongoDsl = Person::results bitsAnyClear 3
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testBitsAnySetSupport() {
+        val expected = BsonDocument.parse("""{"results": {"${'$'}bitsAnySet":  { "${'$'}numberLong" : "3" }}}""")
+        val bson = bitsAnySet(Person::results, 3)
+        assertEquals(expected, bson.document)
+
+        val kmongoDsl = Person::results bitsAnySet 3
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testTypeSupport() {
+        val expected = BsonDocument.parse("""{"results": {"${'$'}type":  5}}""")
+        val bson = type(Person::results, BsonType.BINARY)
+        assertEquals(expected, bson.document)
+
+        val kmongoDsl = Person::results type BsonType.BINARY
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testTextSupport() {
+        var expected = BsonDocument.parse("""{${'$'}text: {${'$'}search: "mongoDB for GIANT ideas"}}""")
+        var bson = text("mongoDB for GIANT ideas")
+        assertEquals(expected, bson.document)
+
+        expected =
+            BsonDocument.parse("""{${'$'}text: {${'$'}search: "mongoDB for GIANT ideas", ${'$'}language: "english"}}""")
+        bson = text("mongoDB for GIANT ideas", TextSearchOptions().language("english"))
+        assertEquals(expected, bson.document)
+    }
+
+    @Test
+    fun testRegexSupport() {
+        val pattern = "acme.*corp"
+        var expected = BsonDocument.parse("""{"name": {"${'$'}regex": "$pattern", ${'$'}options : ""}}}""")
+        var bson = regex(Person::name, pattern)
+        assertEquals(expected, bson.document)
+
+        bson = regex(Person::name, pattern.toRegex())
+        assertEquals(expected, bson.document)
+
+        bson = regex(Person::name, pattern.toRegex().toPattern())
+        assertEquals(expected, bson.document)
+
+        var kmongoDsl = Person::name.regex(pattern)
+        assertEquals(expected, kmongoDsl.document)
+
+        kmongoDsl = Person::name.regex(pattern.toRegex())
+        assertEquals(expected, kmongoDsl.document)
+
+        kmongoDsl = Person::name.regex(pattern.toRegex().toPattern())
+        assertEquals(expected, kmongoDsl.document)
+
+        // With options
+        val options = "iu"
+        expected = BsonDocument.parse("""{"name": {"${'$'}regex": "$pattern", ${'$'}options : "$options"}}}""")
+        bson = regex(Person::name, pattern, options)
+        assertEquals(expected, bson.document)
+
+        bson = regex(Person::name, pattern.toRegex(RegexOption.IGNORE_CASE))
+        assertEquals(expected, bson.document)
+
+        bson = regex(Person::name, pattern.toRegex(RegexOption.IGNORE_CASE).toPattern())
+        assertEquals(expected, bson.document)
+
+        kmongoDsl = Person::name.regex(pattern, options)
+        assertEquals(expected, kmongoDsl.document)
+
+        kmongoDsl = Person::name.regex(pattern.toRegex(RegexOption.IGNORE_CASE))
+        assertEquals(expected, kmongoDsl.document)
+
+        kmongoDsl = Person::name.regex(pattern.toRegex(RegexOption.IGNORE_CASE).toPattern())
+        assertEquals(expected, kmongoDsl.document)
+
+        // Iterable<String?>
+        expected = BsonDocument.parse("""{"address": {"${'$'}regex": "$pattern", ${'$'}options : ""}}}""")
+        bson = regex(Person::address, pattern)
+        assertEquals(expected, bson.document)
+
+        bson = regex(Person::address, pattern.toRegex())
+        assertEquals(expected, bson.document)
+
+        bson = regex(Person::address, pattern.toRegex().toPattern())
+        assertEquals(expected, bson.document)
+
+        kmongoDsl = Person::address.regex(pattern)
+        assertEquals(expected, kmongoDsl.document)
+
+        kmongoDsl = Person::address.regex(pattern.toRegex())
+        assertEquals(expected, kmongoDsl.document)
+
+        kmongoDsl = Person::address.regex(pattern.toRegex().toPattern())
+        assertEquals(expected, kmongoDsl.document)
+
+        expected = BsonDocument.parse("""{"address": {"${'$'}regex": "$pattern", ${'$'}options : "$options"}}}""")
+        bson = regex(Person::address, pattern, options)
+        assertEquals(expected, bson.document)
+
+        bson = regex(Person::address, pattern.toRegex(RegexOption.IGNORE_CASE))
+        assertEquals(expected, bson.document)
+
+        bson = regex(Person::address, pattern.toRegex(RegexOption.IGNORE_CASE).toPattern())
+        assertEquals(expected, bson.document)
+
+        kmongoDsl = Person::address.regex(pattern, options)
+        assertEquals(expected, kmongoDsl.document)
+
+        kmongoDsl = Person::address.regex(pattern.toRegex(RegexOption.IGNORE_CASE))
+        assertEquals(expected, kmongoDsl.document)
+
+        kmongoDsl = Person::address.regex(pattern.toRegex(RegexOption.IGNORE_CASE).toPattern())
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testWhereSupport() {
+        val expected = BsonDocument.parse("""{${'$'}where: "this.address.0 == this.address.1"}""")
+        val bson = where("this.address.0 == this.address.1")
+
+        assertEquals(expected, bson.document)
+    }
+
+    @Test
+    fun testExprSupport() {
+        val expected = BsonDocument.parse("""{${'$'}expr: {"name": "Ada"}}""")
+        val bson = expr(Person::name eq person.name)
+
+        assertEquals(expected, bson.document)
+    }
+
+    @Test
+    fun testGeoWithinSupport() {
+        val geometry =
+            """{"${'$'}geometry":  {"type": "Polygon",
+                | "coordinates": [[[1.0, 2.0], [2.0, 3.0], [3.0, 4.0], [1.0, 2.0]]]}}"""
+                .trimMargin()
+        val expected = BsonDocument.parse("""{"address": {"${'$'}geoWithin": $geometry}}""")
+        val polygon = Polygon(listOf(Position(1.0, 2.0), Position(2.0, 3.0), Position(3.0, 4.0), Position(1.0, 2.0)))
+        var bson = geoWithin(Person::address, polygon)
+        assertEquals(expected, bson.document)
+
+        var kmongoDsl = Person::address geoWithin polygon
+        assertEquals(expected, kmongoDsl.document)
+
+        // Using Bson
+        val bsonGeometry = BsonDocument.parse(geometry).getDocument("${'$'}geometry")
+        bson = geoWithin(Person::address, bsonGeometry)
+        assertEquals(expected, bson.document)
+
+        kmongoDsl = Person::address geoWithin bsonGeometry
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testGeoWithinBoxSupport() {
+        val expected =
+            BsonDocument.parse("""{"address": {"${'$'}geoWithin": {"${'$'}box":  [[1.0, 2.0], [3.0, 4.0]]}}}}""")
+        val bson = geoWithinBox(Person::address, 1.0, 2.0, 3.0, 4.0)
+        assertEquals(expected, bson.document)
+
+        val kmongoDsl = Person::address.geoWithinBox(1.0, 2.0, 3.0, 4.0)
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testGeoWithinPolygonSupport() {
+        val expected =
+            BsonDocument.parse(
+                """{"address": {"${'$'}geoWithin": {"${'$'}polygon":  [[0.0, 0.0], [1.0, 2.0], [2.0, 0.0]]}}}}""")
+        val bson = geoWithinPolygon(Person::address, listOf(listOf(0.0, 0.0), listOf(1.0, 2.0), listOf(2.0, 0.0)))
+        assertEquals(expected, bson.document)
+
+        val kmongoDsl = Person::address.geoWithinPolygon(listOf(listOf(0.0, 0.0), listOf(1.0, 2.0), listOf(2.0, 0.0)))
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testGeoWithinCenterSupport() {
+        val expected =
+            BsonDocument.parse("""{"address": {"${'$'}geoWithin": {"${'$'}center":  [[1.0, 2.0], 30.0]}}}}""")
+        val bson = geoWithinCenter(Person::address, 1.0, 2.0, 30.0)
+        assertEquals(expected, bson.document)
+
+        val kmongoDsl = Person::address.geoWithinCenter(1.0, 2.0, 30.0)
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testGeoWithinCenterSphereSupport() {
+        val expected =
+            BsonDocument.parse("""{"address": {"${'$'}geoWithin": {"${'$'}centerSphere":  [[1.0, 2.0], 30.0]}}}}""")
+        val bson = geoWithinCenterSphere(Person::address, 1.0, 2.0, 30.0)
+        assertEquals(expected, bson.document)
+
+        val kmongoDsl = Person::address.geoWithinCenterSphere(1.0, 2.0, 30.0)
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testGeoIntersectsSupport() {
+        val geometry =
+            """{"${'$'}geometry":  {"type": "Polygon",
+                | "coordinates": [[[1.0, 2.0], [2.0, 3.0], [3.0, 4.0], [1.0, 2.0]]]}}"""
+                .trimMargin()
+        val expected = BsonDocument.parse("""{"address": {"${'$'}geoIntersects": $geometry}}""")
+        val polygon = Polygon(listOf(Position(1.0, 2.0), Position(2.0, 3.0), Position(3.0, 4.0), Position(1.0, 2.0)))
+        var bson = geoIntersects(Person::address, polygon)
+        assertEquals(expected, bson.document)
+
+        var kmongoDsl = Person::address.geoIntersects(polygon)
+        assertEquals(expected, kmongoDsl.document)
+
+        // Using Bson
+        val bsonGeometry = BsonDocument.parse(geometry).getDocument("${'$'}geometry")
+        bson = geoIntersects(Person::address, bsonGeometry)
+        assertEquals(expected, bson.document)
+
+        kmongoDsl = Person::address.geoIntersects(bsonGeometry)
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testNearSupport() {
+        var geometry = """{"${'$'}geometry":  {"type": "Point", "coordinates": [1.0, 2.0]}}}"""
+        var expected = BsonDocument.parse("""{"address": {"${'$'}near": $geometry}}""")
+        val point = Point(Position(1.0, 2.0))
+        var bson = near(Person::address, point)
+        assertEquals(expected, bson.document)
+
+        var kmongoDsl = Person::address.near(point)
+        assertEquals(expected, kmongoDsl.document)
+
+        // Using Bson
+        var bsonGeometry = BsonDocument.parse(geometry).getDocument("${'$'}geometry")
+        bson = near(Person::address, bsonGeometry)
+        assertEquals(expected, bson.document)
+
+        kmongoDsl = Person::address.near(bsonGeometry)
+        assertEquals(expected, kmongoDsl.document)
+
+        // Using short api
+        expected = BsonDocument.parse("""{"address": {"${'$'}near": [1.0, 2.0]}}""")
+        bson = near(Person::address, 1.0, 2.0)
+        assertEquals(expected, bson.document)
+
+        kmongoDsl = Person::address.near(1.0, 2.0)
+        assertEquals(expected, kmongoDsl.document)
+
+        // With optionals
+        geometry =
+            """{"${'$'}geometry":  {"type": "Point", "coordinates": [1.0, 2.0]},
+                |"${'$'}maxDistance": 10.0, "${'$'}minDistance": 1.0}"""
+                .trimMargin()
+        expected = BsonDocument.parse("""{"address": {"${'$'}near": $geometry}}""")
+        bson = near(Person::address, point, 10.0, 1.0)
+        assertEquals(expected, bson.document)
+
+        kmongoDsl = Person::address.near(point, 10.0, 1.0)
+        assertEquals(expected, kmongoDsl.document)
+
+        // Using Bson
+        bsonGeometry = BsonDocument.parse(geometry).getDocument("${'$'}geometry")
+        bson = near(Person::address, bsonGeometry, 10.0, 1.0)
+        assertEquals(expected, bson.document)
+
+        kmongoDsl = Person::address.near(bsonGeometry, 10.0, 1.0)
+        assertEquals(expected, kmongoDsl.document)
+
+        // Using short api
+        expected =
+            BsonDocument.parse(
+                """{"address": {"${'$'}near": [1.0, 2.0], "${'$'}maxDistance": 10.0, "${'$'}minDistance": 1.0}}""")
+        bson = near(Person::address, 1.0, 2.0, 10.0, 1.0)
+        assertEquals(expected, bson.document)
+
+        kmongoDsl = Person::address.near(1.0, 2.0, 10.0, 1.0)
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testNearSphereSupport() {
+        var geometry = """{"${'$'}geometry":  {"type": "Point", "coordinates": [1.0, 2.0]}}}"""
+        var expected = BsonDocument.parse("""{"address": {"${'$'}nearSphere": $geometry}}""")
+        val point = Point(Position(1.0, 2.0))
+        var bson = nearSphere(Person::address, point)
+        assertEquals(expected, bson.document)
+
+        var kmongoDsl = Person::address.nearSphere(point)
+        assertEquals(expected, kmongoDsl.document)
+
+        // Using Bson
+        var bsonGeometry = BsonDocument.parse(geometry).getDocument("${'$'}geometry")
+        bson = nearSphere(Person::address, bsonGeometry)
+        assertEquals(expected, bson.document)
+
+        kmongoDsl = Person::address.nearSphere(point)
+        assertEquals(expected, kmongoDsl.document)
+
+        // Using short api
+        expected = BsonDocument.parse("""{"address": {"${'$'}nearSphere": [1.0, 2.0]}}""")
+        bson = nearSphere(Person::address, 1.0, 2.0)
+        assertEquals(expected, bson.document)
+
+        kmongoDsl = Person::address.nearSphere(1.0, 2.0)
+        assertEquals(expected, kmongoDsl.document)
+
+        // With optionals
+        geometry =
+            """{"${'$'}geometry":  {"type": "Point", "coordinates": [1.0, 2.0]},
+                |"${'$'}maxDistance": 10.0, "${'$'}minDistance": 1.0}"""
+                .trimMargin()
+        expected = BsonDocument.parse("""{"address": {"${'$'}nearSphere": $geometry}}""")
+        bson = nearSphere(Person::address, point, 10.0, 1.0)
+        assertEquals(expected, bson.document)
+
+        kmongoDsl = Person::address.nearSphere(point, 10.0, 1.0)
+        assertEquals(expected, kmongoDsl.document)
+
+        // Using Bson
+        bsonGeometry = BsonDocument.parse(geometry).getDocument("${'$'}geometry")
+        bson = nearSphere(Person::address, bsonGeometry, 10.0, 1.0)
+        assertEquals(expected, bson.document)
+
+        kmongoDsl = Person::address.nearSphere(point, 10.0, 1.0)
+        assertEquals(expected, kmongoDsl.document)
+
+        // Using short api
+        expected =
+            BsonDocument.parse(
+                """{"address": {"${'$'}nearSphere": [1.0, 2.0],
+                    |"${'$'}maxDistance": 10.0, "${'$'}minDistance": 1.0}}"""
+                    .trimMargin())
+        bson = nearSphere(Person::address, 1.0, 2.0, 10.0, 1.0)
+        assertEquals(expected, bson.document)
+
+        kmongoDsl = Person::address.nearSphere(1.0, 2.0, 10.0, 1.0)
+        assertEquals(expected, kmongoDsl.document)
+    }
+
+    @Test
+    fun testJsonSchemaSupport() {
+        val expected = BsonDocument.parse("""{"${'$'}jsonSchema": {"bsonType": "object"}}""")
+
+        val bson = jsonSchema(BsonDocument.parse("""{"bsonType": "object"}"""))
+        assertEquals(expected, bson.document)
+    }
+
+    private val Bson.document: BsonDocument
+        get() = toBsonDocument(BsonDocument::class.java, MongoClientSettings.getDefaultCodecRegistry())
+}
diff --git a/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/IndexesTest.kt b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/IndexesTest.kt
new file mode 100644
index 00000000000..00a819810fe
--- /dev/null
+++ b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/IndexesTest.kt
@@ -0,0 +1,94 @@
+/*
+ * 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.Indexes
+import com.mongodb.client.model.Indexes.compoundIndex
+import com.mongodb.kotlin.client.model.Indexes.ascending
+import com.mongodb.kotlin.client.model.Indexes.descending
+import com.mongodb.kotlin.client.model.Indexes.geo2d
+import com.mongodb.kotlin.client.model.Indexes.geo2dsphere
+import com.mongodb.kotlin.client.model.Indexes.hashed
+import com.mongodb.kotlin.client.model.Indexes.text
+import kotlin.test.assertEquals
+import org.bson.BsonDocument
+import org.bson.conversions.Bson
+import org.junit.Test
+
+class IndexesTest {
+
+    @Test
+    fun `ascending index`() {
+        assertEquals(""" {name: 1} """, ascending(Person::name))
+        assertEquals(""" {name: 1, age: 1} """, ascending(Person::name, Person::age))
+        assertEquals(""" {name: 1, age: 1} """, ascending(listOf(Person::name, Person::age)))
+    }
+
+    @Test
+    fun `descending index`() {
+        assertEquals(""" {name: -1} """, descending(Person::name))
+        assertEquals(""" {name: -1, age: -1} """, descending(Person::name, Person::age))
+        assertEquals(""" {name: -1, age: -1} """, descending(listOf(Person::name, Person::age)))
+    }
+
+    @Test
+    fun `geo2dsphere index`() {
+        assertEquals(""" {name: "2dsphere"} """, geo2dsphere(Person::name))
+        assertEquals(""" {name: "2dsphere", age: "2dsphere"} """, geo2dsphere(Person::name, Person::age))
+        assertEquals(""" {name: "2dsphere", age: "2dsphere"} """, geo2dsphere(listOf(Person::name, Person::age)))
+    }
+
+    @Test
+    fun `geo2d index`() {
+        assertEquals(""" {name: "2d"} """, geo2d(Person::name))
+    }
+
+    @Test
+    fun `text helper`() {
+        assertEquals(""" {name: "text"} """, text(Person::name))
+        assertEquals(""" { "${'$'}**" : "text"} """, Indexes.text())
+    }
+
+    @Test
+    fun `hashed index`() {
+        assertEquals(""" {name: "hashed"} """, hashed(Person::name))
+    }
+
+    @Test
+    fun `compound index`() {
+        assertEquals(""" {name : 1, age : -1}  """, compoundIndex(ascending(Person::name), descending(Person::age)))
+    }
+
+    @Test
+    fun `should test equals on CompoundIndex`() {
+        assertEquals(
+            compoundIndex(ascending(Person::name), descending(Person::age)),
+            compoundIndex(ascending(Person::name), descending(Person::age)))
+
+        assertEquals(
+            compoundIndex(listOf(ascending(Person::name), descending(Person::age))),
+            compoundIndex(listOf(ascending(Person::name), descending(Person::age))))
+    }
+
+    // Utils
+    private data class Person(val name: String, val age: Int)
+
+    private fun assertEquals(expected: String, result: Bson) =
+        assertEquals(BsonDocument.parse(expected), result.toBsonDocument())
+}
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
new file mode 100644
index 00000000000..9d27b86c7ef
--- /dev/null
+++ b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/KPropertiesTest.kt
@@ -0,0 +1,142 @@
+/*
+ * 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.
+ */
+package com.mongodb.kotlin.client.model
+
+import java.util.Locale
+import kotlin.test.assertEquals
+import kotlinx.serialization.SerialName
+import org.bson.codecs.pojo.annotations.BsonId
+import org.bson.codecs.pojo.annotations.BsonProperty
+import org.junit.Test
+import org.junit.jupiter.api.assertThrows
+
+class KPropertiesTest {
+
+    data class Restaurant(
+        @BsonId val a: String,
+        @BsonProperty("b") val bsonProperty: String,
+        @SerialName("c") val serialName: String,
+        val name: String,
+        val stringList: List<String>,
+        val localeMap: Map<Locale, Review>,
+        val reviews: List<Review>,
+        @BsonProperty("nested") val subDocument: Restaurant?
+    )
+
+    data class Review(
+        @BsonProperty("prop") val bsonProperty: String,
+        @SerialName("rating") val score: String,
+        val name: String,
+        @BsonProperty("old") val previous: Review?,
+        @BsonProperty("nested") val misc: List<String>
+    )
+
+    @Test
+    fun testPath() {
+        assertEquals("_id", Restaurant::a.path())
+        assertEquals("b", Restaurant::bsonProperty.path())
+        assertEquals("c", Restaurant::serialName.path())
+        assertEquals("name", Restaurant::name.path())
+        assertEquals("stringList", Restaurant::stringList.path())
+        assertEquals("localeMap", Restaurant::localeMap.path())
+        assertEquals("nested", Restaurant::subDocument.path())
+        assertEquals("reviews", Restaurant::reviews.path())
+
+        assertEquals("prop", Review::bsonProperty.path())
+        assertEquals("rating", Review::score.path())
+        assertEquals("name", Review::name.path())
+        assertEquals("old", Review::previous.path())
+    }
+
+    @Test
+    fun testDivOperator() {
+        assertEquals("nested._id", (Restaurant::subDocument / Restaurant::a).path())
+        assertEquals("nested.b", (Restaurant::subDocument / Restaurant::bsonProperty).path())
+        assertEquals("nested.c", (Restaurant::subDocument / Restaurant::serialName).path())
+        assertEquals("nested.name", (Restaurant::subDocument / Restaurant::name).path())
+        assertEquals("nested.stringList", (Restaurant::subDocument / Restaurant::stringList).path())
+        assertEquals("nested.localeMap", (Restaurant::subDocument / Restaurant::localeMap).path())
+        assertEquals("nested.nested", (Restaurant::subDocument / Restaurant::subDocument).path())
+    }
+
+    @Test
+    fun testRemOperator() {
+        assertEquals("nested.prop", (Restaurant::subDocument % Review::bsonProperty).path())
+        assertEquals("nested.rating", (Restaurant::subDocument % Review::score).path())
+        assertEquals("nested.name", (Restaurant::subDocument % Review::name).path())
+        assertEquals("nested.old", (Restaurant::subDocument % Review::previous).path())
+    }
+
+    @Test
+    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())
+    }
+
+    @Test
+    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
+    fun testArrayFilteredPositionalOperator() {
+        assertEquals("reviews.\$[elem]", Restaurant::reviews.filteredPosOp("elem").path())
+        assertEquals("reviews.\$[elem].rating", (Restaurant::reviews.filteredPosOp("elem") / Review::score).path())
+    }
+
+    @Test
+    fun testMapProjection() {
+        assertEquals("localeMap", Restaurant::localeMap.path())
+        assertEquals("localeMap.rating", (Restaurant::localeMap / Review::score).path())
+        assertEquals("localeMap.en", Restaurant::localeMap.keyProjection(Locale.ENGLISH).path())
+        assertEquals(
+            "localeMap.en.rating", (Restaurant::localeMap.keyProjection(Locale.ENGLISH) / Review::score).path())
+    }
+
+    @Test
+    fun testArrayIndexProperty() {
+        assertEquals("reviews.1.rating", (Restaurant::reviews.pos(1) / Review::score).path())
+    }
+
+    @Test
+    fun testKPropertyPath() {
+        val property = (Restaurant::subDocument / Restaurant::a)
+        assertThrows<UnsupportedOperationException> { property.annotations }
+        assertThrows<UnsupportedOperationException> { property.isAbstract }
+        assertThrows<UnsupportedOperationException> { property.isConst }
+        assertThrows<UnsupportedOperationException> { property.isFinal }
+        assertThrows<UnsupportedOperationException> { property.isLateinit }
+        assertThrows<UnsupportedOperationException> { property.isOpen }
+        assertThrows<UnsupportedOperationException> { property.isSuspend }
+        assertThrows<UnsupportedOperationException> { property.parameters }
+        assertThrows<UnsupportedOperationException> { property.returnType }
+        assertThrows<UnsupportedOperationException> { property.typeParameters }
+        assertThrows<UnsupportedOperationException> { property.visibility }
+
+        val restaurant = Restaurant("a", "b", "c", "name", listOf(), mapOf(), listOf(), null)
+        assertThrows<UnsupportedOperationException> { property.getter }
+        assertThrows<UnsupportedOperationException> { property.invoke(restaurant) }
+        assertThrows<UnsupportedOperationException> { property.call() }
+        assertThrows<UnsupportedOperationException> { property.callBy(mapOf()) }
+        assertThrows<UnsupportedOperationException> { property.get(restaurant) }
+        assertThrows<UnsupportedOperationException> { property.getDelegate(restaurant) }
+    }
+}
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())
+}
diff --git a/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/SortsTest.kt b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/SortsTest.kt
new file mode 100644
index 00000000000..f3740ede352
--- /dev/null
+++ b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/SortsTest.kt
@@ -0,0 +1,73 @@
+/*
+ * 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.Sorts.orderBy
+import com.mongodb.kotlin.client.model.Sorts.ascending
+import com.mongodb.kotlin.client.model.Sorts.descending
+import com.mongodb.kotlin.client.model.Sorts.metaTextScore
+import kotlin.test.assertEquals
+import org.bson.BsonDocument
+import org.bson.conversions.Bson
+import org.junit.Test
+
+class SortsTest {
+
+    @Test
+    fun ascending() {
+        assertEquals(""" {name : 1}  """, ascending(Person::name))
+        assertEquals(""" {name : 1, age: 1}  """, ascending(Person::name, Person::age))
+        assertEquals(""" {name : 1, age: 1}  """, ascending(listOf(Person::name, Person::age)))
+    }
+
+    @Test
+    fun descending() {
+        assertEquals(""" {name : -1}  """, descending(Person::name))
+        assertEquals(""" {name : -1, age: -1}  """, descending(Person::name, Person::age))
+        assertEquals(""" {name : -1, age: -1}  """, descending(listOf(Person::name, Person::age)))
+    }
+
+    @Test
+    fun metaTextScore() {
+        assertEquals(""" {name : {${'$'}meta : "textScore"}}  """, metaTextScore(Person::name))
+    }
+
+    @Test
+    fun orderBy() {
+        assertEquals(""" {name : 1, age : -1}  """, orderBy(ascending(Person::name), descending(Person::age)))
+        assertEquals(""" {name : 1, age : -1}  """, orderBy(listOf(ascending(Person::name), descending(Person::age))))
+        assertEquals(
+            """ {name : -1, age : -1}  """,
+            orderBy(ascending(Person::name), descending(Person::age), descending(Person::name)))
+        assertEquals(
+            """ {name : 1, age : 1, results: -1, address: -1}  """,
+            orderBy(ascending(Person::name, Person::age), descending(Person::results, Person::address)))
+    }
+
+    @Test
+    fun `should create string representation for compound sorts`() {
+        assertEquals(
+            """Compound Sort{sorts=[{"name": 1, "age": 1}, {"results": -1, "address": -1}]}""",
+            orderBy(ascending(Person::name, Person::age), descending(Person::results, Person::address)).toString())
+    }
+
+    private data class Person(val name: String, val age: Int, val address: List<String>, val results: List<Int>)
+    private fun assertEquals(expected: String, result: Bson) =
+        assertEquals(BsonDocument.parse(expected), result.toBsonDocument())
+}
diff --git a/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/UpdatesTest.kt b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/UpdatesTest.kt
new file mode 100644
index 00000000000..aa51bc98921
--- /dev/null
+++ b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/UpdatesTest.kt
@@ -0,0 +1,287 @@
+/*
+ * 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.PushOptions
+import com.mongodb.kotlin.client.model.Filters.gte
+import com.mongodb.kotlin.client.model.Updates.addEachToSet
+import com.mongodb.kotlin.client.model.Updates.addToSet
+import com.mongodb.kotlin.client.model.Updates.bitwiseAnd
+import com.mongodb.kotlin.client.model.Updates.bitwiseOr
+import com.mongodb.kotlin.client.model.Updates.bitwiseXor
+import com.mongodb.kotlin.client.model.Updates.combine
+import com.mongodb.kotlin.client.model.Updates.currentDate
+import com.mongodb.kotlin.client.model.Updates.currentTimestamp
+import com.mongodb.kotlin.client.model.Updates.inc
+import com.mongodb.kotlin.client.model.Updates.max
+import com.mongodb.kotlin.client.model.Updates.min
+import com.mongodb.kotlin.client.model.Updates.mul
+import com.mongodb.kotlin.client.model.Updates.popFirst
+import com.mongodb.kotlin.client.model.Updates.popLast
+import com.mongodb.kotlin.client.model.Updates.pull
+import com.mongodb.kotlin.client.model.Updates.pullAll
+import com.mongodb.kotlin.client.model.Updates.pullByFilter
+import com.mongodb.kotlin.client.model.Updates.push
+import com.mongodb.kotlin.client.model.Updates.pushEach
+import com.mongodb.kotlin.client.model.Updates.rename
+import com.mongodb.kotlin.client.model.Updates.set
+import com.mongodb.kotlin.client.model.Updates.setOnInsert
+import com.mongodb.kotlin.client.model.Updates.unset
+import java.time.Instant
+import java.util.Date
+import kotlin.test.assertEquals
+import org.bson.BsonDocument
+import org.bson.Document
+import org.bson.codecs.configuration.CodecRegistries
+import org.bson.codecs.configuration.CodecRegistries.fromProviders
+import org.bson.codecs.configuration.CodecRegistry
+import org.bson.codecs.pojo.PojoCodecProvider
+import org.bson.conversions.Bson
+import org.junit.Test
+
+class UpdatesTest {
+    @Test
+    fun `should render $set`() {
+        assertEquals(""" {"${'$'}set": {"name": "foo"}} """, set(Person::name, "foo"))
+        assertEquals(""" {"${'$'}set": {"name": null}} """, set(Person::name, null))
+
+        assertEquals(set(Person::name, "foo"), Person::name set "foo")
+        assertEquals(set(Person::name, null), Person::name set null)
+    }
+
+    @Test
+    fun `should render $setOnInsert`() {
+        assertEquals(""" {${'$'}setOnInsert : { age : 42} } """, setOnInsert(Person::age, 42))
+        assertEquals(setOnInsert(Person::age, 42), Person::age setOnInsert 42)
+
+        assertEquals(""" {${'$'}setOnInsert : { age : null} } """, setOnInsert(Person::age, null))
+        assertEquals(setOnInsert(Person::age, null), Person::age setOnInsert null)
+
+        assertEquals(
+            """ {"${'$'}setOnInsert": {"name": "foo", "age": 42}}""",
+            combine(listOf(setOnInsert(Person::name, "foo"), setOnInsert(Person::age, 42))))
+    }
+
+    @Test
+    fun `should render $unset`() {
+        assertEquals(""" {"${'$'}unset": {"name": ""}} """, unset(Person::name))
+    }
+
+    @Test
+    fun `should render $rename`() {
+        assertEquals(""" {${'$'}rename : { "age" : "score"} } """, rename(Person::age, Grade::score))
+    }
+
+    @Test
+    fun `should render $inc`() {
+        assertEquals(""" {${'$'}inc : { age : 1} } """, inc(Person::age, 1))
+        assertEquals(inc(Person::age, 1), Person::age inc 1)
+
+        assertEquals(""" {${'$'}inc : { age : {${'$'}numberLong : "42"}} } """, inc(Person::age, 42L))
+        assertEquals(""" {${'$'}inc : { age :  3.14 } } """, inc(Person::age, 3.14))
+    }
+
+    @Test
+    fun `should render $mul`() {
+        assertEquals(""" {${'$'}mul : { "age" : 1} }  """, mul(Person::age, 1))
+        assertEquals(""" {${'$'}mul : { "age" : 1} }  """, Person::age mul 1)
+
+        assertEquals(""" {${'$'}mul : { "age" : {${'$'}numberLong : "5"}} }  """, mul(Person::age, 5L))
+        assertEquals(""" {${'$'}mul : { "age" : 3.14} }  """, mul(Person::age, 3.14))
+    }
+
+    @Test
+    fun `should render $min`() {
+        assertEquals(""" {${'$'}min : { age : 42} }  """, min(Person::age, 42))
+        assertEquals(""" {${'$'}min : { age : 42} }  """, Person::age min 42)
+    }
+
+    @Test
+    fun `should render max`() {
+        assertEquals(""" {${'$'}max : { age : 42} }  """, max(Person::age, 42))
+        assertEquals(""" {${'$'}max : { age : 42} }  """, Person::age max 42)
+    }
+
+    @Test
+    fun `should render $currentDate`() {
+        assertEquals("""  {${'$'}currentDate : { date : true} } """, currentDate(Person::date))
+        assertEquals(
+            """  {${'$'}currentDate : { date : {${'$'}type : "timestamp"}} } """, currentTimestamp(Person::date))
+    }
+
+    @Test
+    fun `should render $addToSet`() {
+        assertEquals(""" {${'$'}addToSet : { results : 1} } """, addToSet(Person::results, 1))
+        assertEquals(""" {${'$'}addToSet : { results : 1} } """, Person::results addToSet 1)
+        assertEquals(
+            """ {"${'$'}addToSet": {"results": {"${'$'}each": [1, 2, 3]}}} """,
+            addEachToSet(Person::results, listOf(1, 2, 3)))
+    }
+
+    @Test
+    fun `should render $push`() {
+        assertEquals(""" {${'$'}push : { results : 1} } """, push(Person::results, 1))
+        assertEquals(
+            """ {"${'$'}push": {"results": {"${'$'}each": [1, 2, 3]}}} """,
+            pushEach(Person::results, listOf(1, 2, 3), options = PushOptions()))
+
+        assertEquals(
+            """ {"${'$'}push": {"grades": {"${'$'}each":
+                |[{"comments": [], "score": 11, "subject": "Science"}],
+                | "${'$'}position": 0, "${'$'}slice": 3, "${'$'}sort": {"score": -1}}}} """
+                .trimMargin(),
+            pushEach(
+                Student::grades,
+                listOf(Grade("Science", 11, emptyList())),
+                options = PushOptions().position(0).slice(3).sortDocument(Document("score", -1))))
+
+        assertEquals(
+            """ {${'$'}push : { results : { ${'$'}each :
+                |[89, 65], ${'$'}position : 0, ${'$'}slice : 3, ${'$'}sort : -1 } } } """
+                .trimMargin(),
+            pushEach(Person::results, listOf(89, 65), options = PushOptions().position(0).slice(3).sort(-1)))
+    }
+
+    @Test
+    fun `should render $pull`() {
+        assertEquals(""" {${'$'}pull : { address : "foo"} } """, pull(Person::address, "foo"))
+        assertEquals(""" {${'$'}pull : { address : "foo"} } """, Person::address pull "foo")
+
+        assertEquals(""" {${'$'}pull : { score : { ${'$'}gte : 5 }} } """, pullByFilter(Grade::score gte 5))
+        assertEquals(
+            """ {"${'$'}pull": {"grades": {"score": {"${'$'}gte": 5}}}} """,
+            pullByFilter(Student::grades, Grade::score gte 5))
+        assertEquals(
+            """ {"${'$'}pull": {"grades": {"score": {"${'$'}gte": 5}}}} """,
+            Student::grades pullByFilter (Grade::score gte 5))
+    }
+
+    @Test
+    fun `should render $pullAll`() {
+        assertEquals(""" {${'$'}pullAll : { results : []} }  """, pullAll(Person::results, emptyList()))
+        assertEquals(""" {${'$'}pullAll : { results : []} }  """, Person::results pullAll emptyList())
+        assertEquals(""" {${'$'}pullAll : { results : [1,2,3]} }  """, pullAll(Person::results, listOf(1, 2, 3)))
+    }
+
+    @Test
+    fun `should render $pop`() {
+        assertEquals(""" {${'$'}pop : { address : -1} } """, popFirst(Person::address))
+        assertEquals(""" {${'$'}pop : { address : 1} } """, popLast(Person::address))
+    }
+
+    @Test
+    fun `should render $bit`() {
+        assertEquals("""  {${'$'}bit : { "score" : {and : 5} } } """, bitwiseAnd(Grade::score, 5))
+        assertEquals("""  {${'$'}bit : { "score" : {and : 5} } } """, Grade::score bitwiseAnd 5)
+        assertEquals(
+            """  {${'$'}bit : { "score" : {and : {${'$'}numberLong : "5"}} } } """, bitwiseAnd(Grade::score, 5L))
+        assertEquals(
+            """  {${'$'}bit : { "score" : {and : {${'$'}numberLong : "5"}} } } """, Grade::score bitwiseAnd (5L))
+        assertEquals("""  {${'$'}bit : { "score" : {or : 5} } } """, bitwiseOr(Grade::score, 5))
+        assertEquals("""  {${'$'}bit : { "score" : {or : 5} } } """, Grade::score bitwiseOr 5)
+        assertEquals("""  {${'$'}bit : { "score" : {or : {${'$'}numberLong : "5"}} } } """, bitwiseOr(Grade::score, 5L))
+        assertEquals("""  {${'$'}bit : { "score" : {or : {${'$'}numberLong : "5"}} } } """, Grade::score bitwiseOr 5L)
+        assertEquals("""  {${'$'}bit : { "score" : {xor : 5} } } """, bitwiseXor(Grade::score, 5))
+        assertEquals("""  {${'$'}bit : { "score" : {xor : 5} } } """, Grade::score bitwiseXor 5)
+        assertEquals("""  {${'$'}bit : { "score" : {xor : {${'$'}numberLong : "5"}} } } """, Grade::score bitwiseXor 5L)
+        assertEquals(
+            """  {${'$'}bit : { "score" : {xor : {${'$'}numberLong : "5"}} } } """, bitwiseXor(Grade::score, 5L))
+    }
+
+    @Test
+    fun `should combine updates`() {
+        assertEquals(""" {${'$'}set : { name : "foo"} } """, combine(set(Person::name, "foo")))
+        assertEquals(
+            """ {${'$'}set : { name : "foo", age: 42} } """, combine(set(Person::name, "foo"), set(Person::age, 42)))
+        assertEquals(
+            """ {${'$'}set : { name : "bar"} } """, combine(set(Person::name, "foo"), set(Person::name, "bar")))
+        assertEquals(
+            """ {"${'$'}set": {"name": "foo", "date": {"${'$'}date": "1970-01-01T00:00:00Z"}},
+                | "${'$'}inc": {"age": 3, "floatField": 3.14}} """
+                .trimMargin(),
+            combine(
+                set(Person::name, "foo"),
+                inc(Person::age, 3),
+                set(Person::date, Date.from(Instant.EPOCH)),
+                inc(Person::floatField, 3.14)))
+
+        assertEquals(""" {${'$'}set : { "name" : "foo"} } """, combine(combine(set(Person::name, "foo"))))
+        assertEquals(
+            """ {${'$'}set : { "name" : "foo", "age": 42} } """,
+            combine(combine(set(Person::name, "foo"), set(Person::age, 42))))
+        assertEquals(
+            """ {${'$'}set : { "name" : "bar"} } """,
+            combine(combine(set(Person::name, "foo"), set(Person::name, "bar"))))
+
+        assertEquals(
+            """ {"${'$'}set": {"name": "bar"}, "${'$'}inc": {"age": 3, "floatField": 3.14}}  """,
+            combine(
+                combine(
+                    set(Person::name, "foo"),
+                    inc(Person::age, 3),
+                    set(Person::name, "bar"),
+                    inc(Person::floatField, 3.14))))
+    }
+
+    @Test
+    fun `should create string representation for simple updates`() {
+        assertEquals(
+            """Update{fieldName='name', operator='${'$'}set', value=foo}""", set(Person::name, "foo").toString())
+    }
+
+    @Test
+    fun `should create string representation for with each update`() {
+        assertEquals(
+            """Each Update{fieldName='results', operator='${'$'}addToSet', values=[1, 2, 3]}""",
+            addEachToSet(Person::results, listOf(1, 2, 3)).toString())
+    }
+
+    @Test
+    fun `should test equals for SimpleBsonKeyValue`() {
+        assertEquals(setOnInsert(Person::name, "foo"), setOnInsert(Person::name, "foo"))
+        assertEquals(setOnInsert(Person::name, null), setOnInsert(Person::name, null))
+    }
+
+    @Test
+    fun `should test hashCode for SimpleBsonKeyValue`() {
+        assertEquals(setOnInsert(Person::name, "foo").hashCode(), setOnInsert(Person::name, "foo").hashCode())
+        assertEquals(setOnInsert(Person::name, null).hashCode(), setOnInsert(Person::name, null).hashCode())
+    }
+
+    // Utils
+    private data class Person(
+        val name: String,
+        val age: Int,
+        val address: List<String>,
+        val results: List<Int>,
+        val date: Date,
+        val floatField: Float
+    )
+
+    private data class Student(val name: String, val grade: Int, val grades: List<Grade>)
+    data class Grade(val subject: String, val score: Int?, val comments: List<String>)
+
+    private val defaultsAndPojoCodecRegistry: CodecRegistry =
+        CodecRegistries.fromRegistries(
+            Bson.DEFAULT_CODEC_REGISTRY, fromProviders(PojoCodecProvider.builder().automatic(true).build()))
+
+    private fun assertEquals(expected: String, result: Bson) =
+        assertEquals(
+            BsonDocument.parse(expected), result.toBsonDocument(BsonDocument::class.java, defaultsAndPojoCodecRegistry))
+}
diff --git a/driver-kotlin-sync/build.gradle.kts b/driver-kotlin-sync/build.gradle.kts
index 05b20b4803b..e7fb132cb36 100644
--- a/driver-kotlin-sync/build.gradle.kts
+++ b/driver-kotlin-sync/build.gradle.kts
@@ -150,15 +150,6 @@ val integrationTest =
         classpath = sourceSets["integrationTest"].runtimeClasspath
     }
 
-tasks.create("kotlinCheck") {
-    description = "Runs all the kotlin checks"
-    group = "verification"
-
-    dependsOn("clean", "check", integrationTest)
-    tasks.findByName("check")?.mustRunAfter("clean")
-    tasks.findByName("integrationTest")?.mustRunAfter("check")
-}
-
 tasks.test { useJUnitPlatform() }
 
 // ===========================
diff --git a/driver-sync/src/test/functional/com/mongodb/client/csot/AbstractClientSideOperationsEncryptionTimeoutProseTest.java b/driver-sync/src/test/functional/com/mongodb/client/csot/AbstractClientSideOperationsEncryptionTimeoutProseTest.java
index 31f72ca4332..f874ae2042e 100644
--- a/driver-sync/src/test/functional/com/mongodb/client/csot/AbstractClientSideOperationsEncryptionTimeoutProseTest.java
+++ b/driver-sync/src/test/functional/com/mongodb/client/csot/AbstractClientSideOperationsEncryptionTimeoutProseTest.java
@@ -71,7 +71,7 @@
 
 /**
  * See
- * <a href="https://github.com/mongodb/specifications/blob/master/source/client-side-operations-timeout/tests/README.rst#clientencryption">Prose Tests</a>.
+ * <a href="https://github.com/mongodb/specifications/blob/master/source/client-side-operations-timeout/tests/README.md#3-clientencryption">Prose Tests</a>.
  */
 public abstract class AbstractClientSideOperationsEncryptionTimeoutProseTest {
 
diff --git a/settings.gradle b/settings.gradle
index 4ebbb10c4e0..c8a32bd7df5 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -25,6 +25,7 @@ include ':driver-sync'
 include ':driver-reactive-streams'
 include ':bson-kotlin'
 include ':bson-kotlinx'
+include ':driver-kotlin-extensions'
 include ':driver-kotlin-sync'
 include ':driver-kotlin-coroutine'
 include ':bson-scala'