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/config/spotbugs/exclude.xml b/config/spotbugs/exclude.xml
index fedf0c72566..f5522c8f271 100644
--- a/config/spotbugs/exclude.xml
+++ b/config/spotbugs/exclude.xml
@@ -223,6 +223,12 @@
         <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>
 
     <!-- Spotbugs reports false positives for suspendable operations with default params
          see: https://github.com/Kotlin/kotlinx.coroutines/issues/3099
diff --git a/driver-kotlin-extensions/build.gradle.kts b/driver-kotlin-extensions/build.gradle.kts
new file mode 100644
index 00000000000..36b2562522b
--- /dev/null
+++ b/driver-kotlin-extensions/build.gradle.kts
@@ -0,0 +1,163 @@
+/*
+ * 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")
+
+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"))
+
+    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")
+}
+
+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("^(?!Copyright .*? Litote).*\$")
+    }
+
+    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) }
+
+// ===========================
+//     Test Configuration
+// ===========================
+
+tasks.create("kotlinCheck") {
+    description = "Runs all the kotlin checks"
+    group = "verification"
+
+    dependsOn("clean", "check")
+    tasks.findByName("check")?.mustRunAfter("clean")
+}
+
+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/Filters.kt b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Filters.kt
new file mode 100644
index 00000000000..1e53faa7c13
--- /dev/null
+++ b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Filters.kt
@@ -0,0 +1,1215 @@
+/*
+ * 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 */
+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/Properties.kt b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Properties.kt
new file mode 100644
index 00000000000..2c5cf956b94
--- /dev/null
+++ b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Properties.kt
@@ -0,0 +1,134 @@
+/*
+ * 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
+ */
+@SuppressWarnings("BC_BAD_CAST_TO_ABSTRACT_COLLECTION")
+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
+                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/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/ExtensionsApiTest.kt b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/ExtensionsApiTest.kt
new file mode 100644
index 00000000000..e2c4e945adb
--- /dev/null
+++ b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/ExtensionsApiTest.kt
@@ -0,0 +1,63 @@
+/*
+ * 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")
+    }
+
+    private fun getKotlinExtensions(className: String): Set<String> {
+        return ClassGraph()
+            .enableClassInfo()
+            .enableMethodInfo()
+            .acceptPackages("com.mongodb.kotlin.client.model")
+            .scan()
+            .use {
+                it.allClasses
+                    .filter { it.simpleName == "${className}" }
+                    .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 {
+                    it.isPublic &&
+                        it.parameterInfo.isNotEmpty() &&
+                        it.parameterInfo[0].typeDescriptor.toStringWithSimpleNames().equals("String")
+                }
+                .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/KPropertiesTest.kt b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/KPropertiesTest.kt
new file mode 100644
index 00000000000..80b835e0042
--- /dev/null
+++ b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/KPropertiesTest.kt
@@ -0,0 +1,139 @@
+/*
+ * 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?
+    )
+
+    @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.\$.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())
+    }
+
+    @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/settings.gradle b/settings.gradle
index ab252727079..a232d5f739b 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'