From 955c53826ff144f3c2fb8ec6f337bd248cee788d Mon Sep 17 00:00:00 2001
From: Ross Lawley <ross.lawley@gmail.com>
Date: Tue, 13 Aug 2024 14:10:52 +0100
Subject: [PATCH 1/6] Helper methods and extensions to improve kotlin interop.
 Based on kmongo-property but provides both infix and nested helpers.

Adds a new package `org.mongodb.mongodb-driver-kotlin-extensions`. Its both kotlin drivers and bson kotlin implementations agnostic.
So can be used with any combination of `bson-kotlin`, `bson-kotlinx`, `mongodb-driver-kotlin-sync` and `mongodb-driver-kotlin-coroutine`.

Initial Filters extensions support, with both inflix and nested helpers eg:

```
import com.mongodb.kotlin.client.model.Filters.eq

// infix
Person::name.eq(person.name)

// nested
val bson = eq(Person::name, person.name)
```

Also adds path based support which works with vairous annotations on the data class: `@SerialName("_id")`, `@BsonId`, `@BsonProperty("_id")`:

```
(Restaurant::reviews / Review::score).path() == "reviews.rating"
```

JAVA-5308 JAVA-5484
---
 config/spotbugs/exclude.xml                   |    6 +
 driver-kotlin-extensions/build.gradle.kts     |  158 +++
 .../kotlin/client/model/Filters/Filters.kt    | 1142 +++++++++++++++++
 .../mongodb/kotlin/client/model/Properties.kt |  121 ++
 .../kotlin/client/property/KPropertyPath.kt   |  185 +++
 .../kotlin/kotlin/internal/OnlyInputTypes.kt  |   27 +
 .../kotlin/client/model/ExtensionsApiTest.kt  |   65 +
 .../client/model/Filters/FiltersTest.kt       |  631 +++++++++
 .../kotlin/client/model/KPropertiesTest.kt    |  138 ++
 settings.gradle                               |    1 +
 10 files changed, 2474 insertions(+)
 create mode 100644 driver-kotlin-extensions/build.gradle.kts
 create mode 100644 driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Filters/Filters.kt
 create mode 100644 driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Properties.kt
 create mode 100644 driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/property/KPropertyPath.kt
 create mode 100644 driver-kotlin-extensions/src/main/kotlin/kotlin/internal/OnlyInputTypes.kt
 create mode 100644 driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/ExtensionsApiTest.kt
 create mode 100644 driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/Filters/FiltersTest.kt
 create mode 100644 driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/KPropertiesTest.kt

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..918a094a9be
--- /dev/null
+++ b/driver-kotlin-extensions/build.gradle.kts
@@ -0,0 +1,158 @@
+/*
+ * 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
+// ===========================
+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"))
+    }
+
+    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/Filters.kt b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Filters/Filters.kt
new file mode 100644
index 00000000000..44ec7ac8619
--- /dev/null
+++ b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Filters/Filters.kt
@@ -0,0 +1,1142 @@
+/*
+ * 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.
+ */
+@file:Suppress("TooManyFunctions", "PackageNaming")
+
+package com.mongodb.kotlin.client.model.Filters
+
+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 com.mongodb.kotlin.client.model.path
+import java.util.regex.Pattern
+import kotlin.internal.OnlyInputTypes
+import kotlin.reflect.KProperty
+import org.bson.BsonType
+import org.bson.conversions.Bson
+
+/**
+ * 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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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")
+@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")
+@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")
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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
+ */
+@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..dcd293baf71
--- /dev/null
+++ b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Properties.kt
@@ -0,0 +1,121 @@
+/*
+ * Copyright 2008-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.mongodb.kotlin.client.model
+
+import 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. */
+@SuppressWarnings("BC_BAD_CAST_TO_ABSTRACT_COLLECTION")
+public fun <T> KProperty<T>.path(): String {
+    return if (this is KPropertyPath<*, T>) {
+        this.name
+    } else {
+        pathCache.computeIfAbsent(this.toString()) {
+
+            // Check serial name
+            val serialName = annotations.firstOrNull { it.annotationClass.simpleName == "SerialName" }
+            var path =
+                serialName?.annotationClass?.members?.firstOrNull { it.name == "value" }?.call(serialName) as String?
+
+            // 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)
+
+                path =
+                    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..209f98e6631
--- /dev/null
+++ b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/property/KPropertyPath.kt
@@ -0,0 +1,185 @@
+/*
+ * 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.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
+        get() = "${previous?.path?.let { "$it." } ?: ""}${property.path()}"
+
+    override val annotations: List<Annotation>
+        get() = property.annotations
+    override val getter: KProperty1.Getter<T, R>
+        get() = notImplemented()
+    override val isAbstract: Boolean
+        get() = previous?.isAbstract ?: property.isAbstract
+    override val isConst: Boolean
+        get() = previous?.isConst ?: property.isConst
+    override val isFinal: Boolean
+        get() = previous?.isFinal ?: property.isFinal
+    override val isLateinit: Boolean
+        get() = previous?.isLateinit ?: property.isLateinit
+    override val isOpen: Boolean
+        get() = previous?.isOpen ?: property.isOpen
+    override val isSuspend: Boolean
+        get() = property.isSuspend
+    override val name: String
+        get() = path
+    override val parameters: List<KParameter>
+        get() = property.parameters
+    override val returnType: KType
+        get() = property.returnType
+    override val typeParameters: List<KTypeParameter>
+        get() = property.typeParameters
+    override val visibility: KVisibility?
+        get() = property.visibility
+    override fun invoke(p1: T): R = notImplemented()
+    override fun call(vararg args: Any?): R = notImplemented()
+    override fun callBy(args: Map<KParameter, Any?>): R = notImplemented()
+    override fun get(receiver: T): R = notImplemented()
+    override fun getDelegate(receiver: T): Any? = notImplemented()
+
+    public companion object {
+
+        private fun notImplemented(): Nothing = throw NotImplementedError()
+
+        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() = notImplemented()
+            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() = notImplemented()
+            override val typeParameters: List<KTypeParameter>
+                get() = previous.typeParameters
+            override val visibility: KVisibility?
+                get() = previous.visibility
+            override fun call(vararg args: Any?): R = notImplemented()
+            override fun callBy(args: Map<KParameter, Any?>): R = notImplemented()
+            override fun get(receiver: T): R = notImplemented()
+            override fun getDelegate(receiver: T): Any? = notImplemented()
+            override fun invoke(p1: T): R = notImplemented()
+        }
+
+        /** 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..d92601eafa9
--- /dev/null
+++ b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/ExtensionsApiTest.kt
@@ -0,0 +1,65 @@
+/*
+ * 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> {
+        // In the JVM extension methods in Filters.kt will become a class FiltersKt
+        return ClassGraph()
+            .enableClassInfo()
+            .enableMethodInfo()
+            .acceptPackages("com.mongodb.kotlin.client.model")
+            .scan()
+            .use {
+                it.allClasses
+                    .filter { it.simpleName == "${className}Kt" }
+                    .flatMap { it.methodInfo }
+                    .filter { it.isPublic }
+                    .map { it.name }
+                    .filter { !it.contains("$") }
+                    .toSet()
+            }
+    }
+
+    private fun getJavaMethods(className: String): Set<String> {
+        // In the JVM extension methods in Filters.kt will become a class FiltersKt
+        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/Filters/FiltersTest.kt b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/Filters/FiltersTest.kt
new file mode 100644
index 00000000000..8a367829e27
--- /dev/null
+++ b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/Filters/FiltersTest.kt
@@ -0,0 +1,631 @@
+/*
+ * 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.
+ */
+@file:Suppress("PackageNaming")
+
+package com.mongodb.kotlin.client.model.Filters
+
+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 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..40d0b7300c7
--- /dev/null
+++ b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/KPropertiesTest.kt
@@ -0,0 +1,138 @@
+/*
+ * 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 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.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)
+
+        assertEquals(property.annotations, Restaurant::a.annotations)
+        assertEquals(property.isAbstract, Restaurant::a.isAbstract)
+        assertEquals(property.isConst, Restaurant::a.isConst)
+        assertEquals(property.isFinal, Restaurant::a.isFinal)
+        assertEquals(property.isLateinit, Restaurant::a.isLateinit)
+        assertEquals(property.isOpen, Restaurant::a.isOpen)
+        assertEquals(property.isSuspend, Restaurant::a.isSuspend)
+        assertEquals(property.parameters, Restaurant::a.parameters)
+        assertEquals(property.returnType, Restaurant::a.returnType)
+        assertEquals(property.typeParameters, Restaurant::a.typeParameters)
+        assertEquals(property.visibility, Restaurant::a.visibility)
+
+        val restaurant = Restaurant("a", "b", "c", "name", listOf(), mapOf(), listOf(), null)
+        assertThrows<NotImplementedError> { property.getter }
+        assertThrows<NotImplementedError> { property.invoke(restaurant) }
+        assertThrows<NotImplementedError> { property.call() }
+        assertThrows<NotImplementedError> { property.callBy(mapOf()) }
+        assertThrows<NotImplementedError> { property.get(restaurant) }
+        assertThrows<NotImplementedError> { 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'

From 5c19eb043349f4d48bb980b8c6b7e6d0c8199768 Mon Sep 17 00:00:00 2001
From: Ross Lawley <ross.lawley@gmail.com>
Date: Thu, 29 Aug 2024 12:18:21 +0100
Subject: [PATCH 2/6] Use a companion object rather than an invalid package
 name

---
 .sdkmanrc                                     |    3 +
 .../mongodb/kotlin/client/model/Filters.kt    | 1157 +++++++++++++++++
 .../kotlin/client/model/Filters/Filters.kt    | 1142 ----------------
 .../kotlin/client/model/ExtensionsApiTest.kt  |    4 +-
 .../client/model/{Filters => }/FiltersTest.kt |   37 +-
 5 files changed, 1197 insertions(+), 1146 deletions(-)
 create mode 100644 .sdkmanrc
 create mode 100644 driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Filters.kt
 delete mode 100644 driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Filters/Filters.kt
 rename driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/{Filters => }/FiltersTest.kt (92%)

diff --git a/.sdkmanrc b/.sdkmanrc
new file mode 100644
index 00000000000..b9fe931c084
--- /dev/null
+++ b/.sdkmanrc
@@ -0,0 +1,3 @@
+# Enable auto-env through the sdkman_auto_env config
+# Add key=value pairs of SDKs to use below
+java=17.0.12-tem
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..333bb7b9c70
--- /dev/null
+++ b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Filters.kt
@@ -0,0 +1,1157 @@
+/*
+ * 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.
+ */
+@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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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")
+    @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")
+    @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")
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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
+     */
+    @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/Filters/Filters.kt b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Filters/Filters.kt
deleted file mode 100644
index 44ec7ac8619..00000000000
--- a/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Filters/Filters.kt
+++ /dev/null
@@ -1,1142 +0,0 @@
-/*
- * 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.
- */
-@file:Suppress("TooManyFunctions", "PackageNaming")
-
-package com.mongodb.kotlin.client.model.Filters
-
-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 com.mongodb.kotlin.client.model.path
-import java.util.regex.Pattern
-import kotlin.internal.OnlyInputTypes
-import kotlin.reflect.KProperty
-import org.bson.BsonType
-import org.bson.conversions.Bson
-
-/**
- * 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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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")
-@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")
-@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")
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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
- */
-@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/test/kotlin/com/mongodb/kotlin/client/model/ExtensionsApiTest.kt b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/ExtensionsApiTest.kt
index d92601eafa9..e2c4e945adb 100644
--- a/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/ExtensionsApiTest.kt
+++ b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/ExtensionsApiTest.kt
@@ -31,7 +31,6 @@ class ExtensionsApiTest {
     }
 
     private fun getKotlinExtensions(className: String): Set<String> {
-        // In the JVM extension methods in Filters.kt will become a class FiltersKt
         return ClassGraph()
             .enableClassInfo()
             .enableMethodInfo()
@@ -39,7 +38,7 @@ class ExtensionsApiTest {
             .scan()
             .use {
                 it.allClasses
-                    .filter { it.simpleName == "${className}Kt" }
+                    .filter { it.simpleName == "${className}" }
                     .flatMap { it.methodInfo }
                     .filter { it.isPublic }
                     .map { it.name }
@@ -49,7 +48,6 @@ class ExtensionsApiTest {
     }
 
     private fun getJavaMethods(className: String): Set<String> {
-        // In the JVM extension methods in Filters.kt will become a class FiltersKt
         return ClassGraph().enableClassInfo().enableMethodInfo().acceptPackages("com.mongodb.client.model").scan().use {
             it.getClassInfo("com.mongodb.client.model.$className")
                 .methodInfo
diff --git a/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/Filters/FiltersTest.kt b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/FiltersTest.kt
similarity index 92%
rename from driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/Filters/FiltersTest.kt
rename to driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/FiltersTest.kt
index 8a367829e27..610600e6002 100644
--- a/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/Filters/FiltersTest.kt
+++ b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/FiltersTest.kt
@@ -15,13 +15,48 @@
  */
 @file:Suppress("PackageNaming")
 
-package com.mongodb.kotlin.client.model.Filters
+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

From 3f520a2639920a06b5127ca0f308cde3899603ed Mon Sep 17 00:00:00 2001
From: Ross Lawley <ross.lawley@gmail.com>
Date: Thu, 29 Aug 2024 13:52:16 +0100
Subject: [PATCH 3/6] Remove temp file

---
 .sdkmanrc | 3 ---
 1 file changed, 3 deletions(-)
 delete mode 100644 .sdkmanrc

diff --git a/.sdkmanrc b/.sdkmanrc
deleted file mode 100644
index b9fe931c084..00000000000
--- a/.sdkmanrc
+++ /dev/null
@@ -1,3 +0,0 @@
-# Enable auto-env through the sdkman_auto_env config
-# Add key=value pairs of SDKs to use below
-java=17.0.12-tem

From 3a8fc1aa875c948f1c3ffa9e59085e6c0b08d73e Mon Sep 17 00:00:00 2001
From: Ross Lawley <ross.lawley@gmail.com>
Date: Tue, 3 Sep 2024 13:09:43 +0100
Subject: [PATCH 4/6] Code review updates

---
 THIRD-PARTY-NOTICES                           | 23 +++++++++++++++++++
 driver-kotlin-extensions/build.gradle.kts     |  5 ++++
 .../mongodb/kotlin/client/model/Filters.kt    |  3 +++
 .../mongodb/kotlin/client/model/Properties.kt | 13 +++++++----
 .../kotlin/client/property/KPropertyPath.kt   |  3 +++
 .../kotlin/client/model/FiltersTest.kt        |  5 ++--
 .../kotlin/client/model/KPropertiesTest.kt    |  2 ++
 7 files changed, 47 insertions(+), 7 deletions(-)

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/driver-kotlin-extensions/build.gradle.kts b/driver-kotlin-extensions/build.gradle.kts
index 918a094a9be..36b2562522b 100644
--- a/driver-kotlin-extensions/build.gradle.kts
+++ b/driver-kotlin-extensions/build.gradle.kts
@@ -66,6 +66,8 @@ tasks.withType<KotlinCompile> {
 // ===========================
 //     Code Quality checks
 // ===========================
+val customLicenseHeader = "/^(?s)(?!.*@custom-license-header).*/"
+
 spotless {
     kotlinGradle {
         ktfmt("0.39").dropboxStyle().configure { it.setMaxWidth(120) }
@@ -81,7 +83,10 @@ spotless {
         trimTrailingWhitespace()
         indentWithSpaces()
         endWithNewline()
+
         licenseHeaderFile(rootProject.file("config/mongodb.license"))
+            .named("standard")
+            .onlyIfContentMatches("^(?!Copyright .*? Litote).*\$")
     }
 
     format("extraneous") {
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
index 333bb7b9c70..b8ef2c453e1 100644
--- 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
@@ -1,5 +1,6 @@
 /*
  * 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.
@@ -12,6 +13,8 @@
  * 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")
 
diff --git a/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Properties.kt b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Properties.kt
index dcd293baf71..2990369d5d1 100644
--- a/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Properties.kt
+++ b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Properties.kt
@@ -1,5 +1,6 @@
 /*
  * 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.
@@ -12,6 +13,8 @@
  * 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
 
@@ -31,25 +34,25 @@ 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". */
+/** 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 =
+ * 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".
+ * 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". */
+/** 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?>
@@ -57,7 +60,7 @@ public operator fun <T0, K, T1, T2> KProperty1<T0, Map<out K, T1>?>.div(
 
 /** Returns a mongo path of a property. */
 @SuppressWarnings("BC_BAD_CAST_TO_ABSTRACT_COLLECTION")
-public fun <T> KProperty<T>.path(): String {
+internal fun <T> KProperty<T>.path(): String {
     return if (this is KPropertyPath<*, T>) {
         this.name
     } else {
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
index 209f98e6631..3c886134df4 100644
--- 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
@@ -1,5 +1,6 @@
 /*
  * 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.
@@ -12,6 +13,8 @@
  * 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
 
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
index 610600e6002..c5a23ffe658 100644
--- 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
@@ -1,5 +1,6 @@
 /*
  * 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.
@@ -12,9 +13,9 @@
  * 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("PackageNaming")
-
 package com.mongodb.kotlin.client.model
 
 import com.mongodb.MongoClientSettings
diff --git a/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/KPropertiesTest.kt b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/KPropertiesTest.kt
index 40d0b7300c7..5f5fefd1779 100644
--- a/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/KPropertiesTest.kt
+++ b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/KPropertiesTest.kt
@@ -1,5 +1,6 @@
 /*
  * 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.
@@ -101,6 +102,7 @@ class KPropertiesTest {
     @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())

From c7272e45f63806a6593c930d1b86b527d9a213d1 Mon Sep 17 00:00:00 2001
From: Ross Lawley <ross.lawley@gmail.com>
Date: Fri, 20 Sep 2024 14:13:08 +0100
Subject: [PATCH 5/6] PR updates

---
 .../mongodb/kotlin/client/model/Properties.kt | 24 +++++---
 .../kotlin/client/property/KPropertyPath.kt   | 60 +++++++++----------
 .../kotlin/client/model/FiltersTest.kt        |  4 +-
 .../kotlin/client/model/KPropertiesTest.kt    | 35 ++++++-----
 4 files changed, 66 insertions(+), 57 deletions(-)

diff --git a/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Properties.kt b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Properties.kt
index 2990369d5d1..2c5cf956b94 100644
--- a/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Properties.kt
+++ b/driver-kotlin-extensions/src/main/kotlin/com/mongodb/kotlin/client/model/Properties.kt
@@ -58,7 +58,15 @@ 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. */
+/**
+ * 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>) {
@@ -66,19 +74,21 @@ internal fun <T> KProperty<T>.path(): String {
     } else {
         pathCache.computeIfAbsent(this.toString()) {
 
-            // Check serial name
-            val serialName = annotations.firstOrNull { it.annotationClass.simpleName == "SerialName" }
+            // 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?
 
-            // Check for BsonId / BsonProperty
+            // 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)
 
-                path =
-                    path ?: constructorProperty?.annotations?.filterIsInstance<BsonId>()?.firstOrNull()?.let { "_id" }
+                // 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
             }
@@ -113,7 +123,7 @@ public val <T> KProperty1<out Any?, Iterable<T>?>.allPosOp: KPropertyPath<out An
 
 @Suppress("MaxLineLength")
 /**
- * [The filtered positional operator $[<identifier>]](https://docs.mongodb.com/manual/reference/operator/update/positional-filtered/)
+ * [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)
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
index 3c886134df4..a460266f098 100644
--- 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
@@ -50,51 +50,51 @@ public open class KPropertyPath<T, R>(
         },
         property)
 
-    private val path: String
-        get() = "${previous?.path?.let { "$it." } ?: ""}${property.path()}"
+    private val path: String by lazy { "${previous?.path?.let { "$it." } ?: ""}${property.path()}" }
+
+    override val name: String
+        get() = path
 
     override val annotations: List<Annotation>
-        get() = property.annotations
+        get() = unSupportedOperation()
     override val getter: KProperty1.Getter<T, R>
-        get() = notImplemented()
+        get() = unSupportedOperation()
     override val isAbstract: Boolean
-        get() = previous?.isAbstract ?: property.isAbstract
+        get() = unSupportedOperation()
     override val isConst: Boolean
-        get() = previous?.isConst ?: property.isConst
+        get() = unSupportedOperation()
     override val isFinal: Boolean
-        get() = previous?.isFinal ?: property.isFinal
+        get() = unSupportedOperation()
     override val isLateinit: Boolean
-        get() = previous?.isLateinit ?: property.isLateinit
+        get() = unSupportedOperation()
     override val isOpen: Boolean
-        get() = previous?.isOpen ?: property.isOpen
+        get() = unSupportedOperation()
     override val isSuspend: Boolean
-        get() = property.isSuspend
-    override val name: String
-        get() = path
+        get() = unSupportedOperation()
     override val parameters: List<KParameter>
-        get() = property.parameters
+        get() = unSupportedOperation()
     override val returnType: KType
-        get() = property.returnType
+        get() = unSupportedOperation()
     override val typeParameters: List<KTypeParameter>
-        get() = property.typeParameters
+        get() = unSupportedOperation()
     override val visibility: KVisibility?
-        get() = property.visibility
-    override fun invoke(p1: T): R = notImplemented()
-    override fun call(vararg args: Any?): R = notImplemented()
-    override fun callBy(args: Map<KParameter, Any?>): R = notImplemented()
-    override fun get(receiver: T): R = notImplemented()
-    override fun getDelegate(receiver: T): Any? = notImplemented()
+        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 notImplemented(): Nothing = throw NotImplementedError()
+        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() = notImplemented()
+                get() = unSupportedOperation()
             override val isAbstract: Boolean
                 get() = previous.isAbstract
             override val isConst: Boolean
@@ -111,16 +111,16 @@ public open class KPropertyPath<T, R>(
             override val parameters: List<KParameter>
                 get() = previous.parameters
             override val returnType: KType
-                get() = notImplemented()
+                get() = unSupportedOperation()
             override val typeParameters: List<KTypeParameter>
                 get() = previous.typeParameters
             override val visibility: KVisibility?
                 get() = previous.visibility
-            override fun call(vararg args: Any?): R = notImplemented()
-            override fun callBy(args: Map<KParameter, Any?>): R = notImplemented()
-            override fun get(receiver: T): R = notImplemented()
-            override fun getDelegate(receiver: T): Any? = notImplemented()
-            override fun invoke(p1: T): R = notImplemented()
+            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. */
@@ -151,7 +151,7 @@ public open class KCollectionPropertyPath<T, R, MEMBER : KPropertyPath<T, R?>>(
         get() = memberWithAdditionalPath("\$[]")
 
     /**
-     * [The filtered positional operator $[<identifier>]]
+     * [The filtered positional operator $[\<identifier\>]]
      * (https://docs.mongodb.com/manual/reference/operator/update/positional-filtered/)
      */
     public fun filteredPosOp(identifier: String): MEMBER = memberWithAdditionalPath("\$[$identifier]")
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
index c5a23ffe658..da15d6ee5af 100644
--- 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
@@ -456,7 +456,7 @@ class FiltersTest {
         var bson = geoWithin(Person::address, polygon)
         assertEquals(expected, bson.document)
 
-        var kmongoDsl = Person::address.geoWithin(polygon)
+        var kmongoDsl = Person::address geoWithin polygon
         assertEquals(expected, kmongoDsl.document)
 
         // Using Bson
@@ -464,7 +464,7 @@ class FiltersTest {
         bson = geoWithin(Person::address, bsonGeometry)
         assertEquals(expected, bson.document)
 
-        kmongoDsl = Person::address.geoWithin(bsonGeometry)
+        kmongoDsl = Person::address geoWithin bsonGeometry
         assertEquals(expected, kmongoDsl.document)
     }
 
diff --git a/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/KPropertiesTest.kt b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/KPropertiesTest.kt
index 5f5fefd1779..80b835e0042 100644
--- a/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/KPropertiesTest.kt
+++ b/driver-kotlin-extensions/src/test/kotlin/com/mongodb/kotlin/client/model/KPropertiesTest.kt
@@ -116,25 +116,24 @@ class KPropertiesTest {
     @Test
     fun testKPropertyPath() {
         val property = (Restaurant::subDocument / Restaurant::a)
-
-        assertEquals(property.annotations, Restaurant::a.annotations)
-        assertEquals(property.isAbstract, Restaurant::a.isAbstract)
-        assertEquals(property.isConst, Restaurant::a.isConst)
-        assertEquals(property.isFinal, Restaurant::a.isFinal)
-        assertEquals(property.isLateinit, Restaurant::a.isLateinit)
-        assertEquals(property.isOpen, Restaurant::a.isOpen)
-        assertEquals(property.isSuspend, Restaurant::a.isSuspend)
-        assertEquals(property.parameters, Restaurant::a.parameters)
-        assertEquals(property.returnType, Restaurant::a.returnType)
-        assertEquals(property.typeParameters, Restaurant::a.typeParameters)
-        assertEquals(property.visibility, Restaurant::a.visibility)
+        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<NotImplementedError> { property.getter }
-        assertThrows<NotImplementedError> { property.invoke(restaurant) }
-        assertThrows<NotImplementedError> { property.call() }
-        assertThrows<NotImplementedError> { property.callBy(mapOf()) }
-        assertThrows<NotImplementedError> { property.get(restaurant) }
-        assertThrows<NotImplementedError> { property.getDelegate(restaurant) }
+        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) }
     }
 }

From a500d9c5861b5d758f2b4eb72436fba08f787bf6 Mon Sep 17 00:00:00 2001
From: Ross Lawley <ross.lawley@gmail.com>
Date: Fri, 20 Sep 2024 18:27:49 +0100
Subject: [PATCH 6/6] Mark jvm methods as synthentic as well

---
 .../mongodb/kotlin/client/model/Filters.kt    | 69 +++++++++++++++++--
 1 file changed, 62 insertions(+), 7 deletions(-)

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
index b8ef2c453e1..1e53faa7c13 100644
--- 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
@@ -41,7 +41,9 @@ public object Filters {
      * @param <T> the value type
      * @return the filter
      */
-    @JvmName("eqExt") public infix fun <@OnlyInputTypes T> KProperty<T?>.eq(value: T?): Bson = Filters.eq(path(), value)
+    @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
@@ -61,7 +63,9 @@ public object Filters {
      * @param <T> the value type
      * @return the filter
      */
-    @JvmName("neExt") public infix fun <@OnlyInputTypes T> KProperty<T?>.ne(value: T?): Bson = Filters.ne(path(), value)
+    @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.
@@ -81,7 +85,9 @@ public object Filters {
      * @param <T> the value type
      * @return the filter
      */
-    @JvmName("ltExt") public infix fun <@OnlyInputTypes T> KProperty<T?>.lt(value: T): Bson = Filters.lt(path(), value)
+    @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
@@ -102,6 +108,7 @@ public object Filters {
      * @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)
 
@@ -124,7 +131,9 @@ public object Filters {
      * @param <T> the value type
      * @return the filter
      */
-    @JvmName("gtExt") public infix fun <@OnlyInputTypes T> KProperty<T>.gt(value: T): Bson = Filters.gt(path(), value)
+    @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
@@ -145,6 +154,7 @@ public object Filters {
      * @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)
 
@@ -168,6 +178,7 @@ public object Filters {
      * @return the filter
      */
     @Suppress("FunctionNaming")
+    @JvmSynthetic
     @JvmName("inExt")
     public infix fun <@OnlyInputTypes T> KProperty<T?>.`in`(values: Iterable<T?>): Bson = Filters.`in`(path(), values)
 
@@ -192,6 +203,7 @@ public object Filters {
      * @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)
@@ -206,6 +218,7 @@ public object Filters {
      * @return the filter
      */
     @Suppress("FunctionNaming")
+    @JvmSynthetic
     @JvmName("inIterable")
     public fun <@OnlyInputTypes T> `in`(property: KProperty<Iterable<T>?>, values: Iterable<T?>): Bson =
         property.`in`(values)
@@ -218,6 +231,7 @@ public object Filters {
      * @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)
 
@@ -240,6 +254,7 @@ public object Filters {
      * @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)
@@ -253,6 +268,7 @@ public object Filters {
      * @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)
@@ -332,7 +348,7 @@ public object Filters {
      *
      * @return the filter
      */
-    @JvmName("existsExt") public fun <T> KProperty<T?>.exists(): Bson = Filters.exists(path())
+    @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.
@@ -349,6 +365,7 @@ public object Filters {
      * @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)
 
@@ -368,7 +385,9 @@ public object Filters {
      * @param type the BSON type
      * @return the filter
      */
-    @JvmName("typeExt") public infix fun <T> KProperty<T?>.type(type: BsonType): Bson = Filters.type(path(), type)
+    @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.
@@ -387,6 +406,7 @@ public object Filters {
      * @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)
 
@@ -408,6 +428,7 @@ public object Filters {
      * @param pattern the pattern
      * @return the filter
      */
+    @JvmSynthetic
     @JvmName("regexExt")
     public infix fun KProperty<String?>.regex(pattern: String): Bson = Filters.regex(path(), pattern)
 
@@ -428,6 +449,7 @@ public object Filters {
      * @param pattern the pattern
      * @return the filter
      */
+    @JvmSynthetic
     @JvmName("regexExt")
     public infix fun KProperty<String?>.regex(pattern: Pattern): Bson = Filters.regex(path(), pattern)
 
@@ -449,6 +471,7 @@ public object Filters {
      * @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)
@@ -472,6 +495,7 @@ public object Filters {
      * @param regex the regex
      * @return the filter
      */
+    @JvmSynthetic
     @JvmName("regexExt")
     public infix fun KProperty<String?>.regex(regex: Regex): Bson = Filters.regex(path(), regex.toPattern())
 
@@ -492,6 +516,7 @@ public object Filters {
      * @param pattern the pattern
      * @return the filter
      */
+    @JvmSynthetic
     @JvmName("regexIterableExt")
     public infix fun KProperty<Iterable<String?>>.regex(pattern: String): Bson = Filters.regex(path(), pattern)
 
@@ -503,6 +528,7 @@ public object Filters {
      * @param pattern the pattern
      * @return the filter
      */
+    @JvmSynthetic
     @JvmName("regexIterable")
     public fun regex(property: KProperty<Iterable<String?>>, pattern: String): Bson = property.regex(pattern)
 
@@ -513,6 +539,7 @@ public object Filters {
      * @param pattern the pattern
      * @return the filter
      */
+    @JvmSynthetic
     @JvmName("regexIterableExt")
     public infix fun KProperty<Iterable<String?>>.regex(pattern: Pattern): Bson = Filters.regex(path(), pattern)
 
@@ -524,6 +551,7 @@ public object Filters {
      * @param pattern the pattern
      * @return the filter
      */
+    @JvmSynthetic
     @JvmName("regexIterable")
     public fun regex(property: KProperty<Iterable<String?>>, pattern: Pattern): Bson = property.regex(pattern)
 
@@ -535,6 +563,7 @@ public object Filters {
      * @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)
@@ -548,6 +577,7 @@ public object Filters {
      * @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)
@@ -559,6 +589,7 @@ public object Filters {
      * @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())
 
@@ -570,6 +601,7 @@ public object Filters {
      * @param regex the regex
      * @return the filter
      */
+    @JvmSynthetic
     @JvmName("regexIterable")
     public fun regex(property: KProperty<Iterable<String?>>, regex: Regex): Bson = property.regex(regex.toPattern())
 
@@ -609,6 +641,7 @@ public object Filters {
      * @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)
@@ -633,6 +666,7 @@ public object Filters {
      * @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)
 
@@ -655,6 +689,7 @@ public object Filters {
      * @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)
 
@@ -674,7 +709,9 @@ public object Filters {
      * @param size the size of the array
      * @return the filter
      */
-    @JvmName("sizeExt") public infix fun <T> KProperty<T?>.size(size: Int): Bson = Filters.size(path(), size)
+    @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.
@@ -691,6 +728,7 @@ public object Filters {
      * @param bitmask the bitmask
      * @return the filter
      */
+    @JvmSynthetic
     @JvmName("bitsAllClearExt")
     public infix fun <T> KProperty<T?>.bitsAllClear(bitmask: Long): Bson = Filters.bitsAllClear(path(), bitmask)
 
@@ -709,6 +747,7 @@ public object Filters {
      * @param bitmask the bitmask
      * @return the filter
      */
+    @JvmSynthetic
     @JvmName("bitsAllSetExt")
     public infix fun <T> KProperty<T?>.bitsAllSet(bitmask: Long): Bson = Filters.bitsAllSet(path(), bitmask)
 
@@ -727,6 +766,7 @@ public object Filters {
      * @param bitmask the bitmask
      * @return the filter
      */
+    @JvmSynthetic
     @JvmName("bitsAnyClearExt")
     public infix fun <T> KProperty<T?>.bitsAnyClear(bitmask: Long): Bson = Filters.bitsAnyClear(path(), bitmask)
 
@@ -745,6 +785,7 @@ public object Filters {
      * @param bitmask the bitmask
      * @return the filter
      */
+    @JvmSynthetic
     @JvmName("bitsAnySetExt")
     public infix fun <T> KProperty<T?>.bitsAnySet(bitmask: Long): Bson = Filters.bitsAnySet(path(), bitmask)
 
@@ -764,6 +805,7 @@ public object Filters {
      * @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)
 
@@ -784,6 +826,7 @@ public object Filters {
      * @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)
 
@@ -807,6 +850,7 @@ public object Filters {
      * @param upperRightY the upper left y coordinate of the box
      * @return the filter
      */
+    @JvmSynthetic
     @JvmName("geoWithinBoxExt")
     public fun <T> KProperty<T?>.geoWithinBox(
         lowerLeftX: Double,
@@ -841,6 +885,7 @@ public object Filters {
      * @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)
@@ -865,6 +910,7 @@ public object Filters {
      * @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)
@@ -892,6 +938,7 @@ public object Filters {
      * @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)
@@ -917,6 +964,7 @@ public object Filters {
      * @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)
 
@@ -937,6 +985,7 @@ public object Filters {
      * @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)
 
@@ -959,6 +1008,7 @@ public object Filters {
      * @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)
@@ -989,6 +1039,7 @@ public object Filters {
      * @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)
@@ -1020,6 +1071,7 @@ public object Filters {
      * @param minDistance the minimum distance from the point, in radians
      * @return the filter
      */
+    @JvmSynthetic
     @JvmName("nearExt")
     public fun <T> KProperty<T?>.near(
         x: Double,
@@ -1056,6 +1108,7 @@ public object Filters {
      * @param minDistance the minimum distance from the point, in meters
      * @return the filter
      */
+    @JvmSynthetic
     @JvmName("nearSphereExt")
     public fun <T> KProperty<T?>.nearSphere(
         geometry: Bson,
@@ -1089,6 +1142,7 @@ public object Filters {
      * @param minDistance the minimum distance from the point, in meters
      * @return the filter
      */
+    @JvmSynthetic
     @JvmName("nearSphereExt")
     public fun <T> KProperty<T?>.nearSphere(
         geometry: Point,
@@ -1123,6 +1177,7 @@ public object Filters {
      * @param minDistance the minimum distance from the point, in radians
      * @return the filter
      */
+    @JvmSynthetic
     @JvmName("nearSphereExt")
     public fun <T> KProperty<T?>.nearSphere(
         x: Double,