From 9fe3bd14e811baad66861c64379aad388ddd8a1c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?J=C3=A9r=C3=B4me=20Tamarelle?= <jerome@tamarelle.net>
Date: Tue, 3 Dec 2024 20:10:22 +0100
Subject: [PATCH] Add generated files

---
 psalm-baseline.xml                            |    8 -
 src/Builder/Search/AutocompleteOperator.php   |   76 +
 src/Builder/Search/CompoundOperator.php       |   84 +
 .../Search/EmbeddedDocumentOperator.php       |   57 +
 src/Builder/Search/EqualsOperator.php         |   59 +
 src/Builder/Search/ExistsOperator.php         |   48 +
 src/Builder/Search/FacetOperator.php          |   49 +
 src/Builder/Search/FactoryTrait.php           |  345 ++
 src/Builder/Search/GeoShapeOperator.php       |   62 +
 src/Builder/Search/GeoWithinOperator.php      |   76 +
 src/Builder/Search/InOperator.php             |   65 +
 src/Builder/Search/MoreLikeThisOperator.php   |   52 +
 src/Builder/Search/NearOperator.php           |   64 +
 src/Builder/Search/PhraseOperator.php         |   83 +
 src/Builder/Search/QueryStringOperator.php    |   40 +
 src/Builder/Search/RangeOperator.php          |   85 +
 src/Builder/Search/RegexOperator.php          |   67 +
 src/Builder/Search/TextOperator.php           |   81 +
 src/Builder/Search/WildcardOperator.php       |   66 +
 src/Builder/Stage/FactoryTrait.php            |   77 +-
 src/Builder/Stage/FluentFactoryTrait.php      |   79 +-
 src/Builder/Stage/SearchMetaStage.php         |   35 +-
 src/Builder/Stage/SearchStage.php             |  102 +-
 tests/Builder/Search/Pipelines.php            | 2814 +++++++++++++++++
 24 files changed, 4530 insertions(+), 44 deletions(-)
 create mode 100644 src/Builder/Search/AutocompleteOperator.php
 create mode 100644 src/Builder/Search/CompoundOperator.php
 create mode 100644 src/Builder/Search/EmbeddedDocumentOperator.php
 create mode 100644 src/Builder/Search/EqualsOperator.php
 create mode 100644 src/Builder/Search/ExistsOperator.php
 create mode 100644 src/Builder/Search/FacetOperator.php
 create mode 100644 src/Builder/Search/FactoryTrait.php
 create mode 100644 src/Builder/Search/GeoShapeOperator.php
 create mode 100644 src/Builder/Search/GeoWithinOperator.php
 create mode 100644 src/Builder/Search/InOperator.php
 create mode 100644 src/Builder/Search/MoreLikeThisOperator.php
 create mode 100644 src/Builder/Search/NearOperator.php
 create mode 100644 src/Builder/Search/PhraseOperator.php
 create mode 100644 src/Builder/Search/QueryStringOperator.php
 create mode 100644 src/Builder/Search/RangeOperator.php
 create mode 100644 src/Builder/Search/RegexOperator.php
 create mode 100644 src/Builder/Search/TextOperator.php
 create mode 100644 src/Builder/Search/WildcardOperator.php
 create mode 100644 tests/Builder/Search/Pipelines.php

diff --git a/psalm-baseline.xml b/psalm-baseline.xml
index a06d5df23..321bbc05a 100644
--- a/psalm-baseline.xml
+++ b/psalm-baseline.xml
@@ -60,9 +60,6 @@
     </NoInterfaceProperties>
   </file>
   <file src="src/Builder/Encoder/OperatorEncoder.php">
-    <MixedArgument>
-      <code><![CDATA[$this->recursiveEncode($val)]]></code>
-    </MixedArgument>
     <MixedAssignment>
       <code><![CDATA[$k]]></code>
       <code><![CDATA[$name]]></code>
@@ -73,19 +70,14 @@
       <code><![CDATA[$prop]]></code>
       <code><![CDATA[$result]]></code>
       <code><![CDATA[$result[]]]></code>
-      <code><![CDATA[$subval]]></code>
       <code><![CDATA[$v]]></code>
       <code><![CDATA[$val]]></code>
       <code><![CDATA[$val]]></code>
       <code><![CDATA[$val]]></code>
-      <code><![CDATA[$val]]></code>
     </MixedAssignment>
     <PossibleRawObjectIteration>
       <code><![CDATA[$val]]></code>
     </PossibleRawObjectIteration>
-    <PossiblyInvalidArgument>
-      <code><![CDATA[$this->recursiveEncode($val)]]></code>
-    </PossiblyInvalidArgument>
   </file>
   <file src="src/Builder/Encoder/OutputWindowEncoder.php">
     <MixedArgument>
diff --git a/src/Builder/Search/AutocompleteOperator.php b/src/Builder/Search/AutocompleteOperator.php
new file mode 100644
index 000000000..19bdbf92d
--- /dev/null
+++ b/src/Builder/Search/AutocompleteOperator.php
@@ -0,0 +1,76 @@
+<?php
+
+/**
+ * THIS FILE IS AUTO-GENERATED. ANY CHANGES WILL BE LOST!
+ */
+
+declare(strict_types=1);
+
+namespace MongoDB\Builder\Search;
+
+use MongoDB\BSON\Document;
+use MongoDB\BSON\Serializable;
+use MongoDB\Builder\Type\Encode;
+use MongoDB\Builder\Type\OperatorInterface;
+use MongoDB\Builder\Type\Optional;
+use MongoDB\Builder\Type\SearchOperatorInterface;
+use stdClass;
+
+/**
+ * The autocomplete operator performs a search for a word or phrase that
+ * contains a sequence of characters from an incomplete input string. The
+ * fields that you intend to query with the autocomplete operator must be
+ * indexed with the autocomplete data type in the collection's index definition.
+ *
+ * @see https://www.mongodb.com/docs/atlas/atlas-search/autocomplete/
+ * @internal
+ */
+final class AutocompleteOperator implements SearchOperatorInterface, OperatorInterface
+{
+    public const ENCODE = Encode::Object;
+    public const NAME = 'autocomplete';
+
+    public const PROPERTIES = [
+        'path' => 'path',
+        'query' => 'query',
+        'tokenOrder' => 'tokenOrder',
+        'fuzzy' => 'fuzzy',
+        'score' => 'score',
+    ];
+
+    /** @var array|string $path */
+    public readonly array|string $path;
+
+    /** @var string $query */
+    public readonly string $query;
+
+    /** @var Optional|string $tokenOrder */
+    public readonly Optional|string $tokenOrder;
+
+    /** @var Optional|Document|Serializable|array|stdClass $fuzzy */
+    public readonly Optional|Document|Serializable|stdClass|array $fuzzy;
+
+    /** @var Optional|Document|Serializable|array|stdClass $score */
+    public readonly Optional|Document|Serializable|stdClass|array $score;
+
+    /**
+     * @param array|string $path
+     * @param string $query
+     * @param Optional|string $tokenOrder
+     * @param Optional|Document|Serializable|array|stdClass $fuzzy
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public function __construct(
+        array|string $path,
+        string $query,
+        Optional|string $tokenOrder = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $fuzzy = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ) {
+        $this->path = $path;
+        $this->query = $query;
+        $this->tokenOrder = $tokenOrder;
+        $this->fuzzy = $fuzzy;
+        $this->score = $score;
+    }
+}
diff --git a/src/Builder/Search/CompoundOperator.php b/src/Builder/Search/CompoundOperator.php
new file mode 100644
index 000000000..27b8c2aeb
--- /dev/null
+++ b/src/Builder/Search/CompoundOperator.php
@@ -0,0 +1,84 @@
+<?php
+
+/**
+ * THIS FILE IS AUTO-GENERATED. ANY CHANGES WILL BE LOST!
+ */
+
+declare(strict_types=1);
+
+namespace MongoDB\Builder\Search;
+
+use MongoDB\BSON\Document;
+use MongoDB\BSON\PackedArray;
+use MongoDB\BSON\Serializable;
+use MongoDB\Builder\Type\Encode;
+use MongoDB\Builder\Type\OperatorInterface;
+use MongoDB\Builder\Type\Optional;
+use MongoDB\Builder\Type\SearchOperatorInterface;
+use MongoDB\Model\BSONArray;
+use stdClass;
+
+/**
+ * The compound operator combines two or more operators into a single query.
+ * Each element of a compound query is called a clause, and each clause
+ * consists of one or more sub-queries.
+ *
+ * @see https://www.mongodb.com/docs/atlas/atlas-search/compound/
+ * @internal
+ */
+final class CompoundOperator implements SearchOperatorInterface, OperatorInterface
+{
+    public const ENCODE = Encode::Object;
+    public const NAME = 'compound';
+
+    public const PROPERTIES = [
+        'must' => 'must',
+        'mustNot' => 'mustNot',
+        'should' => 'should',
+        'filter' => 'filter',
+        'minimumShouldMatch' => 'minimumShouldMatch',
+        'score' => 'score',
+    ];
+
+    /** @var Optional|BSONArray|Document|PackedArray|SearchOperatorInterface|Serializable|array|stdClass $must */
+    public readonly Optional|Document|PackedArray|Serializable|SearchOperatorInterface|BSONArray|stdClass|array $must;
+
+    /** @var Optional|BSONArray|Document|PackedArray|SearchOperatorInterface|Serializable|array|stdClass $mustNot */
+    public readonly Optional|Document|PackedArray|Serializable|SearchOperatorInterface|BSONArray|stdClass|array $mustNot;
+
+    /** @var Optional|BSONArray|Document|PackedArray|SearchOperatorInterface|Serializable|array|stdClass $should */
+    public readonly Optional|Document|PackedArray|Serializable|SearchOperatorInterface|BSONArray|stdClass|array $should;
+
+    /** @var Optional|BSONArray|Document|PackedArray|SearchOperatorInterface|Serializable|array|stdClass $filter */
+    public readonly Optional|Document|PackedArray|Serializable|SearchOperatorInterface|BSONArray|stdClass|array $filter;
+
+    /** @var Optional|int $minimumShouldMatch */
+    public readonly Optional|int $minimumShouldMatch;
+
+    /** @var Optional|Document|Serializable|array|stdClass $score */
+    public readonly Optional|Document|Serializable|stdClass|array $score;
+
+    /**
+     * @param Optional|BSONArray|Document|PackedArray|SearchOperatorInterface|Serializable|array|stdClass $must
+     * @param Optional|BSONArray|Document|PackedArray|SearchOperatorInterface|Serializable|array|stdClass $mustNot
+     * @param Optional|BSONArray|Document|PackedArray|SearchOperatorInterface|Serializable|array|stdClass $should
+     * @param Optional|BSONArray|Document|PackedArray|SearchOperatorInterface|Serializable|array|stdClass $filter
+     * @param Optional|int $minimumShouldMatch
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public function __construct(
+        Optional|Document|PackedArray|Serializable|SearchOperatorInterface|BSONArray|stdClass|array $must = Optional::Undefined,
+        Optional|Document|PackedArray|Serializable|SearchOperatorInterface|BSONArray|stdClass|array $mustNot = Optional::Undefined,
+        Optional|Document|PackedArray|Serializable|SearchOperatorInterface|BSONArray|stdClass|array $should = Optional::Undefined,
+        Optional|Document|PackedArray|Serializable|SearchOperatorInterface|BSONArray|stdClass|array $filter = Optional::Undefined,
+        Optional|int $minimumShouldMatch = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ) {
+        $this->must = $must;
+        $this->mustNot = $mustNot;
+        $this->should = $should;
+        $this->filter = $filter;
+        $this->minimumShouldMatch = $minimumShouldMatch;
+        $this->score = $score;
+    }
+}
diff --git a/src/Builder/Search/EmbeddedDocumentOperator.php b/src/Builder/Search/EmbeddedDocumentOperator.php
new file mode 100644
index 000000000..91f6c1f96
--- /dev/null
+++ b/src/Builder/Search/EmbeddedDocumentOperator.php
@@ -0,0 +1,57 @@
+<?php
+
+/**
+ * THIS FILE IS AUTO-GENERATED. ANY CHANGES WILL BE LOST!
+ */
+
+declare(strict_types=1);
+
+namespace MongoDB\Builder\Search;
+
+use MongoDB\BSON\Document;
+use MongoDB\BSON\Serializable;
+use MongoDB\Builder\Type\Encode;
+use MongoDB\Builder\Type\OperatorInterface;
+use MongoDB\Builder\Type\Optional;
+use MongoDB\Builder\Type\SearchOperatorInterface;
+use stdClass;
+
+/**
+ * The embeddedDocument operator is similar to $elemMatch operator.
+ * It constrains multiple query predicates to be satisfied from a single
+ * element of an array of embedded documents. embeddedDocument can be used only
+ * for queries over fields of the embeddedDocuments
+ *
+ * @see https://www.mongodb.com/docs/atlas/atlas-search/embedded-document/
+ * @internal
+ */
+final class EmbeddedDocumentOperator implements SearchOperatorInterface, OperatorInterface
+{
+    public const ENCODE = Encode::Object;
+    public const NAME = 'embeddedDocument';
+    public const PROPERTIES = ['path' => 'path', 'operator' => 'operator', 'score' => 'score'];
+
+    /** @var array|string $path */
+    public readonly array|string $path;
+
+    /** @var Document|SearchOperatorInterface|Serializable|array|stdClass $operator */
+    public readonly Document|Serializable|SearchOperatorInterface|stdClass|array $operator;
+
+    /** @var Optional|Document|Serializable|array|stdClass $score */
+    public readonly Optional|Document|Serializable|stdClass|array $score;
+
+    /**
+     * @param array|string $path
+     * @param Document|SearchOperatorInterface|Serializable|array|stdClass $operator
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public function __construct(
+        array|string $path,
+        Document|Serializable|SearchOperatorInterface|stdClass|array $operator,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ) {
+        $this->path = $path;
+        $this->operator = $operator;
+        $this->score = $score;
+    }
+}
diff --git a/src/Builder/Search/EqualsOperator.php b/src/Builder/Search/EqualsOperator.php
new file mode 100644
index 000000000..bbfe75b8e
--- /dev/null
+++ b/src/Builder/Search/EqualsOperator.php
@@ -0,0 +1,59 @@
+<?php
+
+/**
+ * THIS FILE IS AUTO-GENERATED. ANY CHANGES WILL BE LOST!
+ */
+
+declare(strict_types=1);
+
+namespace MongoDB\Builder\Search;
+
+use MongoDB\BSON\Binary;
+use MongoDB\BSON\Decimal128;
+use MongoDB\BSON\Document;
+use MongoDB\BSON\Int64;
+use MongoDB\BSON\ObjectId;
+use MongoDB\BSON\Serializable;
+use MongoDB\BSON\UTCDateTime;
+use MongoDB\Builder\Type\Encode;
+use MongoDB\Builder\Type\OperatorInterface;
+use MongoDB\Builder\Type\Optional;
+use MongoDB\Builder\Type\SearchOperatorInterface;
+use stdClass;
+
+/**
+ * The equals operator checks whether a field matches a value you specify.
+ *
+ * @see https://www.mongodb.com/docs/atlas/atlas-search/equals/
+ * @internal
+ */
+final class EqualsOperator implements SearchOperatorInterface, OperatorInterface
+{
+    public const ENCODE = Encode::Object;
+    public const NAME = 'equals';
+    public const PROPERTIES = ['path' => 'path', 'value' => 'value', 'score' => 'score'];
+
+    /** @var array|string $path */
+    public readonly array|string $path;
+
+    /** @var Binary|Decimal128|Int64|ObjectId|UTCDateTime|bool|float|int|null|string $value */
+    public readonly Binary|Decimal128|Int64|ObjectId|UTCDateTime|bool|float|int|null|string $value;
+
+    /** @var Optional|Document|Serializable|array|stdClass $score */
+    public readonly Optional|Document|Serializable|stdClass|array $score;
+
+    /**
+     * @param array|string $path
+     * @param Binary|Decimal128|Int64|ObjectId|UTCDateTime|bool|float|int|null|string $value
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public function __construct(
+        array|string $path,
+        Binary|Decimal128|Int64|ObjectId|UTCDateTime|bool|float|int|null|string $value,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ) {
+        $this->path = $path;
+        $this->value = $value;
+        $this->score = $score;
+    }
+}
diff --git a/src/Builder/Search/ExistsOperator.php b/src/Builder/Search/ExistsOperator.php
new file mode 100644
index 000000000..4330f130f
--- /dev/null
+++ b/src/Builder/Search/ExistsOperator.php
@@ -0,0 +1,48 @@
+<?php
+
+/**
+ * THIS FILE IS AUTO-GENERATED. ANY CHANGES WILL BE LOST!
+ */
+
+declare(strict_types=1);
+
+namespace MongoDB\Builder\Search;
+
+use MongoDB\BSON\Document;
+use MongoDB\BSON\Serializable;
+use MongoDB\Builder\Type\Encode;
+use MongoDB\Builder\Type\OperatorInterface;
+use MongoDB\Builder\Type\Optional;
+use MongoDB\Builder\Type\SearchOperatorInterface;
+use stdClass;
+
+/**
+ * The exists operator tests if a path to a specified indexed field name exists in a document.
+ *
+ * @see https://www.mongodb.com/docs/atlas/atlas-search/exists/
+ * @internal
+ */
+final class ExistsOperator implements SearchOperatorInterface, OperatorInterface
+{
+    public const ENCODE = Encode::Object;
+    public const NAME = 'exists';
+    public const PROPERTIES = ['path' => 'path', 'score' => 'score'];
+
+    /** @var array|string $path */
+    public readonly array|string $path;
+
+    /** @var Optional|Document|Serializable|array|stdClass $score */
+    public readonly Optional|Document|Serializable|stdClass|array $score;
+
+    /**
+     * @param array|string $path
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public function __construct(
+        array|string $path,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ) {
+        $this->path = $path;
+        $this->score = $score;
+    }
+}
diff --git a/src/Builder/Search/FacetOperator.php b/src/Builder/Search/FacetOperator.php
new file mode 100644
index 000000000..15fc10830
--- /dev/null
+++ b/src/Builder/Search/FacetOperator.php
@@ -0,0 +1,49 @@
+<?php
+
+/**
+ * THIS FILE IS AUTO-GENERATED. ANY CHANGES WILL BE LOST!
+ */
+
+declare(strict_types=1);
+
+namespace MongoDB\Builder\Search;
+
+use MongoDB\BSON\Document;
+use MongoDB\BSON\Serializable;
+use MongoDB\Builder\Type\Encode;
+use MongoDB\Builder\Type\OperatorInterface;
+use MongoDB\Builder\Type\Optional;
+use MongoDB\Builder\Type\SearchOperatorInterface;
+use stdClass;
+
+/**
+ * The facet collector groups results by values or ranges in the specified
+ * faceted fields and returns the count for each of those groups.
+ *
+ * @see https://www.mongodb.com/docs/atlas/atlas-search/facet/
+ * @internal
+ */
+final class FacetOperator implements SearchOperatorInterface, OperatorInterface
+{
+    public const ENCODE = Encode::Object;
+    public const NAME = 'facet';
+    public const PROPERTIES = ['facets' => 'facets', 'operator' => 'operator'];
+
+    /** @var Document|Serializable|array|stdClass $facets */
+    public readonly Document|Serializable|stdClass|array $facets;
+
+    /** @var Optional|Document|SearchOperatorInterface|Serializable|array|stdClass $operator */
+    public readonly Optional|Document|Serializable|SearchOperatorInterface|stdClass|array $operator;
+
+    /**
+     * @param Document|Serializable|array|stdClass $facets
+     * @param Optional|Document|SearchOperatorInterface|Serializable|array|stdClass $operator
+     */
+    public function __construct(
+        Document|Serializable|stdClass|array $facets,
+        Optional|Document|Serializable|SearchOperatorInterface|stdClass|array $operator = Optional::Undefined,
+    ) {
+        $this->facets = $facets;
+        $this->operator = $operator;
+    }
+}
diff --git a/src/Builder/Search/FactoryTrait.php b/src/Builder/Search/FactoryTrait.php
new file mode 100644
index 000000000..3a7762521
--- /dev/null
+++ b/src/Builder/Search/FactoryTrait.php
@@ -0,0 +1,345 @@
+<?php
+
+/**
+ * THIS FILE IS AUTO-GENERATED. ANY CHANGES WILL BE LOST!
+ */
+
+declare(strict_types=1);
+
+namespace MongoDB\Builder\Search;
+
+use MongoDB\BSON\Binary;
+use MongoDB\BSON\Decimal128;
+use MongoDB\BSON\Document;
+use MongoDB\BSON\Int64;
+use MongoDB\BSON\ObjectId;
+use MongoDB\BSON\PackedArray;
+use MongoDB\BSON\Serializable;
+use MongoDB\BSON\Type;
+use MongoDB\BSON\UTCDateTime;
+use MongoDB\Builder\Type\GeometryInterface;
+use MongoDB\Builder\Type\Optional;
+use MongoDB\Builder\Type\SearchOperatorInterface;
+use MongoDB\Model\BSONArray;
+use stdClass;
+
+/**
+ * @internal
+ */
+trait FactoryTrait
+{
+    /**
+     * The autocomplete operator performs a search for a word or phrase that
+     * contains a sequence of characters from an incomplete input string. The
+     * fields that you intend to query with the autocomplete operator must be
+     * indexed with the autocomplete data type in the collection's index definition.
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/autocomplete/
+     * @param array|string $path
+     * @param string $query
+     * @param Optional|string $tokenOrder
+     * @param Optional|Document|Serializable|array|stdClass $fuzzy
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public static function autocomplete(
+        array|string $path,
+        string $query,
+        Optional|string $tokenOrder = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $fuzzy = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ): AutocompleteOperator {
+        return new AutocompleteOperator($path, $query, $tokenOrder, $fuzzy, $score);
+    }
+
+    /**
+     * The compound operator combines two or more operators into a single query.
+     * Each element of a compound query is called a clause, and each clause
+     * consists of one or more sub-queries.
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/compound/
+     * @param Optional|BSONArray|Document|PackedArray|SearchOperatorInterface|Serializable|array|stdClass $must
+     * @param Optional|BSONArray|Document|PackedArray|SearchOperatorInterface|Serializable|array|stdClass $mustNot
+     * @param Optional|BSONArray|Document|PackedArray|SearchOperatorInterface|Serializable|array|stdClass $should
+     * @param Optional|BSONArray|Document|PackedArray|SearchOperatorInterface|Serializable|array|stdClass $filter
+     * @param Optional|int $minimumShouldMatch
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public static function compound(
+        Optional|Document|PackedArray|Serializable|SearchOperatorInterface|BSONArray|stdClass|array $must = Optional::Undefined,
+        Optional|Document|PackedArray|Serializable|SearchOperatorInterface|BSONArray|stdClass|array $mustNot = Optional::Undefined,
+        Optional|Document|PackedArray|Serializable|SearchOperatorInterface|BSONArray|stdClass|array $should = Optional::Undefined,
+        Optional|Document|PackedArray|Serializable|SearchOperatorInterface|BSONArray|stdClass|array $filter = Optional::Undefined,
+        Optional|int $minimumShouldMatch = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ): CompoundOperator {
+        return new CompoundOperator($must, $mustNot, $should, $filter, $minimumShouldMatch, $score);
+    }
+
+    /**
+     * The embeddedDocument operator is similar to $elemMatch operator.
+     * It constrains multiple query predicates to be satisfied from a single
+     * element of an array of embedded documents. embeddedDocument can be used only
+     * for queries over fields of the embeddedDocuments
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/embedded-document/
+     * @param array|string $path
+     * @param Document|SearchOperatorInterface|Serializable|array|stdClass $operator
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public static function embeddedDocument(
+        array|string $path,
+        Document|Serializable|SearchOperatorInterface|stdClass|array $operator,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ): EmbeddedDocumentOperator {
+        return new EmbeddedDocumentOperator($path, $operator, $score);
+    }
+
+    /**
+     * The equals operator checks whether a field matches a value you specify.
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/equals/
+     * @param array|string $path
+     * @param Binary|Decimal128|Int64|ObjectId|UTCDateTime|bool|float|int|null|string $value
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public static function equals(
+        array|string $path,
+        Binary|Decimal128|Int64|ObjectId|UTCDateTime|bool|float|int|null|string $value,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ): EqualsOperator {
+        return new EqualsOperator($path, $value, $score);
+    }
+
+    /**
+     * The exists operator tests if a path to a specified indexed field name exists in a document.
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/exists/
+     * @param array|string $path
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public static function exists(
+        array|string $path,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ): ExistsOperator {
+        return new ExistsOperator($path, $score);
+    }
+
+    /**
+     * The facet collector groups results by values or ranges in the specified
+     * faceted fields and returns the count for each of those groups.
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/facet/
+     * @param Document|Serializable|array|stdClass $facets
+     * @param Optional|Document|SearchOperatorInterface|Serializable|array|stdClass $operator
+     */
+    public static function facet(
+        Document|Serializable|stdClass|array $facets,
+        Optional|Document|Serializable|SearchOperatorInterface|stdClass|array $operator = Optional::Undefined,
+    ): FacetOperator {
+        return new FacetOperator($facets, $operator);
+    }
+
+    /**
+     * The geoShape operator supports querying shapes with a relation to a given
+     * geometry if indexShapes is set to true in the index definition.
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/geoShape/
+     * @param array|string $path
+     * @param string $relation
+     * @param Document|GeometryInterface|Serializable|array|stdClass $geometry
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public static function geoShape(
+        array|string $path,
+        string $relation,
+        Document|Serializable|GeometryInterface|stdClass|array $geometry,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ): GeoShapeOperator {
+        return new GeoShapeOperator($path, $relation, $geometry, $score);
+    }
+
+    /**
+     * The geoWithin operator supports querying geographic points within a given
+     * geometry. Only points are returned, even if indexShapes value is true in
+     * the index definition.
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/geoWithin/
+     * @param array|string $path
+     * @param Optional|Document|Serializable|array|stdClass $box
+     * @param Optional|Document|Serializable|array|stdClass $circle
+     * @param Optional|Document|GeometryInterface|Serializable|array|stdClass $geometry
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public static function geoWithin(
+        array|string $path,
+        Optional|Document|Serializable|stdClass|array $box = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $circle = Optional::Undefined,
+        Optional|Document|Serializable|GeometryInterface|stdClass|array $geometry = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ): GeoWithinOperator {
+        return new GeoWithinOperator($path, $box, $circle, $geometry, $score);
+    }
+
+    /**
+     * The in operator performs a search for an array of BSON values in a field.
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/in/
+     * @param array|string $path
+     * @param BSONArray|PackedArray|Type|array|bool|float|int|null|stdClass|string $value
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public static function in(
+        array|string $path,
+        PackedArray|Type|BSONArray|stdClass|array|bool|float|int|null|string $value,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ): InOperator {
+        return new InOperator($path, $value, $score);
+    }
+
+    /**
+     * The moreLikeThis operator returns documents similar to input documents.
+     * The moreLikeThis operator allows you to build features for your applications
+     * that display similar or alternative results based on one or more given documents.
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/moreLikeThis/
+     * @param BSONArray|Document|PackedArray|Serializable|array|stdClass $like
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public static function moreLikeThis(
+        Document|PackedArray|Serializable|BSONArray|stdClass|array $like,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ): MoreLikeThisOperator {
+        return new MoreLikeThisOperator($like, $score);
+    }
+
+    /**
+     * The near operator supports querying and scoring numeric, date, and GeoJSON point values.
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/near/
+     * @param array|string $path
+     * @param Decimal128|Document|GeometryInterface|Int64|Serializable|UTCDateTime|array|float|int|stdClass $origin
+     * @param Decimal128|Int64|float|int $pivot
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public static function near(
+        array|string $path,
+        Decimal128|Document|Int64|Serializable|UTCDateTime|GeometryInterface|stdClass|array|float|int $origin,
+        Decimal128|Int64|float|int $pivot,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ): NearOperator {
+        return new NearOperator($path, $origin, $pivot, $score);
+    }
+
+    /**
+     * The phrase operator performs search for documents containing an ordered sequence of terms using the analyzer specified in the index configuration.
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/phrase/
+     * @param array|string $path
+     * @param BSONArray|PackedArray|array|string $query
+     * @param Optional|int $slop
+     * @param Optional|string $synonyms
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public static function phrase(
+        array|string $path,
+        PackedArray|BSONArray|array|string $query,
+        Optional|int $slop = Optional::Undefined,
+        Optional|string $synonyms = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ): PhraseOperator {
+        return new PhraseOperator($path, $query, $slop, $synonyms, $score);
+    }
+
+    /**
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/queryString/
+     * @param array|string $defaultPath
+     * @param string $query
+     */
+    public static function queryString(array|string $defaultPath, string $query): QueryStringOperator
+    {
+        return new QueryStringOperator($defaultPath, $query);
+    }
+
+    /**
+     * The range operator supports querying and scoring numeric, date, and string values.
+     * You can use this operator to find results that are within a given numeric, date, objectId, or letter (from the English alphabet) range.
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/range/
+     * @param array|string $path
+     * @param Optional|Decimal128|Int64|ObjectId|UTCDateTime|float|int|string $gt
+     * @param Optional|Decimal128|Int64|ObjectId|UTCDateTime|float|int|string $gte
+     * @param Optional|Decimal128|Int64|ObjectId|UTCDateTime|float|int|string $lt
+     * @param Optional|Decimal128|Int64|ObjectId|UTCDateTime|float|int|string $lte
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public static function range(
+        array|string $path,
+        Optional|Decimal128|Int64|ObjectId|UTCDateTime|float|int|string $gt = Optional::Undefined,
+        Optional|Decimal128|Int64|ObjectId|UTCDateTime|float|int|string $gte = Optional::Undefined,
+        Optional|Decimal128|Int64|ObjectId|UTCDateTime|float|int|string $lt = Optional::Undefined,
+        Optional|Decimal128|Int64|ObjectId|UTCDateTime|float|int|string $lte = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ): RangeOperator {
+        return new RangeOperator($path, $gt, $gte, $lt, $lte, $score);
+    }
+
+    /**
+     * regex interprets the query field as a regular expression.
+     * regex is a term-level operator, meaning that the query field isn't analyzed.
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/regex/
+     * @param array|string $path
+     * @param string $query
+     * @param Optional|bool $allowAnalyzedField
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public static function regex(
+        array|string $path,
+        string $query,
+        Optional|bool $allowAnalyzedField = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ): RegexOperator {
+        return new RegexOperator($path, $query, $allowAnalyzedField, $score);
+    }
+
+    /**
+     * The text operator performs a full-text search using the analyzer that you specify in the index configuration.
+     * If you omit an analyzer, the text operator uses the default standard analyzer.
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/text/
+     * @param array|string $path
+     * @param string $query
+     * @param Optional|Document|Serializable|array|stdClass $fuzzy
+     * @param Optional|string $matchCriteria
+     * @param Optional|string $synonyms
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public static function text(
+        array|string $path,
+        string $query,
+        Optional|Document|Serializable|stdClass|array $fuzzy = Optional::Undefined,
+        Optional|string $matchCriteria = Optional::Undefined,
+        Optional|string $synonyms = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ): TextOperator {
+        return new TextOperator($path, $query, $fuzzy, $matchCriteria, $synonyms, $score);
+    }
+
+    /**
+     * The wildcard operator enables queries which use special characters in the search string that can match any character.
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/wildcard/
+     * @param array|string $path
+     * @param string $query
+     * @param Optional|bool $allowAnalyzedField
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public static function wildcard(
+        array|string $path,
+        string $query,
+        Optional|bool $allowAnalyzedField = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ): WildcardOperator {
+        return new WildcardOperator($path, $query, $allowAnalyzedField, $score);
+    }
+}
diff --git a/src/Builder/Search/GeoShapeOperator.php b/src/Builder/Search/GeoShapeOperator.php
new file mode 100644
index 000000000..d8cefbb1c
--- /dev/null
+++ b/src/Builder/Search/GeoShapeOperator.php
@@ -0,0 +1,62 @@
+<?php
+
+/**
+ * THIS FILE IS AUTO-GENERATED. ANY CHANGES WILL BE LOST!
+ */
+
+declare(strict_types=1);
+
+namespace MongoDB\Builder\Search;
+
+use MongoDB\BSON\Document;
+use MongoDB\BSON\Serializable;
+use MongoDB\Builder\Type\Encode;
+use MongoDB\Builder\Type\GeometryInterface;
+use MongoDB\Builder\Type\OperatorInterface;
+use MongoDB\Builder\Type\Optional;
+use MongoDB\Builder\Type\SearchOperatorInterface;
+use stdClass;
+
+/**
+ * The geoShape operator supports querying shapes with a relation to a given
+ * geometry if indexShapes is set to true in the index definition.
+ *
+ * @see https://www.mongodb.com/docs/atlas/atlas-search/geoShape/
+ * @internal
+ */
+final class GeoShapeOperator implements SearchOperatorInterface, OperatorInterface
+{
+    public const ENCODE = Encode::Object;
+    public const NAME = 'geoShape';
+    public const PROPERTIES = ['path' => 'path', 'relation' => 'relation', 'geometry' => 'geometry', 'score' => 'score'];
+
+    /** @var array|string $path */
+    public readonly array|string $path;
+
+    /** @var string $relation */
+    public readonly string $relation;
+
+    /** @var Document|GeometryInterface|Serializable|array|stdClass $geometry */
+    public readonly Document|Serializable|GeometryInterface|stdClass|array $geometry;
+
+    /** @var Optional|Document|Serializable|array|stdClass $score */
+    public readonly Optional|Document|Serializable|stdClass|array $score;
+
+    /**
+     * @param array|string $path
+     * @param string $relation
+     * @param Document|GeometryInterface|Serializable|array|stdClass $geometry
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public function __construct(
+        array|string $path,
+        string $relation,
+        Document|Serializable|GeometryInterface|stdClass|array $geometry,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ) {
+        $this->path = $path;
+        $this->relation = $relation;
+        $this->geometry = $geometry;
+        $this->score = $score;
+    }
+}
diff --git a/src/Builder/Search/GeoWithinOperator.php b/src/Builder/Search/GeoWithinOperator.php
new file mode 100644
index 000000000..dcf605697
--- /dev/null
+++ b/src/Builder/Search/GeoWithinOperator.php
@@ -0,0 +1,76 @@
+<?php
+
+/**
+ * THIS FILE IS AUTO-GENERATED. ANY CHANGES WILL BE LOST!
+ */
+
+declare(strict_types=1);
+
+namespace MongoDB\Builder\Search;
+
+use MongoDB\BSON\Document;
+use MongoDB\BSON\Serializable;
+use MongoDB\Builder\Type\Encode;
+use MongoDB\Builder\Type\GeometryInterface;
+use MongoDB\Builder\Type\OperatorInterface;
+use MongoDB\Builder\Type\Optional;
+use MongoDB\Builder\Type\SearchOperatorInterface;
+use stdClass;
+
+/**
+ * The geoWithin operator supports querying geographic points within a given
+ * geometry. Only points are returned, even if indexShapes value is true in
+ * the index definition.
+ *
+ * @see https://www.mongodb.com/docs/atlas/atlas-search/geoWithin/
+ * @internal
+ */
+final class GeoWithinOperator implements SearchOperatorInterface, OperatorInterface
+{
+    public const ENCODE = Encode::Object;
+    public const NAME = 'geoWithin';
+
+    public const PROPERTIES = [
+        'path' => 'path',
+        'box' => 'box',
+        'circle' => 'circle',
+        'geometry' => 'geometry',
+        'score' => 'score',
+    ];
+
+    /** @var array|string $path */
+    public readonly array|string $path;
+
+    /** @var Optional|Document|Serializable|array|stdClass $box */
+    public readonly Optional|Document|Serializable|stdClass|array $box;
+
+    /** @var Optional|Document|Serializable|array|stdClass $circle */
+    public readonly Optional|Document|Serializable|stdClass|array $circle;
+
+    /** @var Optional|Document|GeometryInterface|Serializable|array|stdClass $geometry */
+    public readonly Optional|Document|Serializable|GeometryInterface|stdClass|array $geometry;
+
+    /** @var Optional|Document|Serializable|array|stdClass $score */
+    public readonly Optional|Document|Serializable|stdClass|array $score;
+
+    /**
+     * @param array|string $path
+     * @param Optional|Document|Serializable|array|stdClass $box
+     * @param Optional|Document|Serializable|array|stdClass $circle
+     * @param Optional|Document|GeometryInterface|Serializable|array|stdClass $geometry
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public function __construct(
+        array|string $path,
+        Optional|Document|Serializable|stdClass|array $box = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $circle = Optional::Undefined,
+        Optional|Document|Serializable|GeometryInterface|stdClass|array $geometry = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ) {
+        $this->path = $path;
+        $this->box = $box;
+        $this->circle = $circle;
+        $this->geometry = $geometry;
+        $this->score = $score;
+    }
+}
diff --git a/src/Builder/Search/InOperator.php b/src/Builder/Search/InOperator.php
new file mode 100644
index 000000000..f050a1679
--- /dev/null
+++ b/src/Builder/Search/InOperator.php
@@ -0,0 +1,65 @@
+<?php
+
+/**
+ * THIS FILE IS AUTO-GENERATED. ANY CHANGES WILL BE LOST!
+ */
+
+declare(strict_types=1);
+
+namespace MongoDB\Builder\Search;
+
+use MongoDB\BSON\Document;
+use MongoDB\BSON\PackedArray;
+use MongoDB\BSON\Serializable;
+use MongoDB\BSON\Type;
+use MongoDB\Builder\Type\Encode;
+use MongoDB\Builder\Type\OperatorInterface;
+use MongoDB\Builder\Type\Optional;
+use MongoDB\Builder\Type\SearchOperatorInterface;
+use MongoDB\Exception\InvalidArgumentException;
+use MongoDB\Model\BSONArray;
+use stdClass;
+
+use function array_is_list;
+use function is_array;
+
+/**
+ * The in operator performs a search for an array of BSON values in a field.
+ *
+ * @see https://www.mongodb.com/docs/atlas/atlas-search/in/
+ * @internal
+ */
+final class InOperator implements SearchOperatorInterface, OperatorInterface
+{
+    public const ENCODE = Encode::Object;
+    public const NAME = 'in';
+    public const PROPERTIES = ['path' => 'path', 'value' => 'value', 'score' => 'score'];
+
+    /** @var array|string $path */
+    public readonly array|string $path;
+
+    /** @var BSONArray|PackedArray|Type|array|bool|float|int|null|stdClass|string $value */
+    public readonly PackedArray|Type|BSONArray|stdClass|array|bool|float|int|null|string $value;
+
+    /** @var Optional|Document|Serializable|array|stdClass $score */
+    public readonly Optional|Document|Serializable|stdClass|array $score;
+
+    /**
+     * @param array|string $path
+     * @param BSONArray|PackedArray|Type|array|bool|float|int|null|stdClass|string $value
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public function __construct(
+        array|string $path,
+        PackedArray|Type|BSONArray|stdClass|array|bool|float|int|null|string $value,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ) {
+        $this->path = $path;
+        if (is_array($value) && ! array_is_list($value)) {
+            throw new InvalidArgumentException('Expected $value argument to be a list, got an associative array.');
+        }
+
+        $this->value = $value;
+        $this->score = $score;
+    }
+}
diff --git a/src/Builder/Search/MoreLikeThisOperator.php b/src/Builder/Search/MoreLikeThisOperator.php
new file mode 100644
index 000000000..689508d53
--- /dev/null
+++ b/src/Builder/Search/MoreLikeThisOperator.php
@@ -0,0 +1,52 @@
+<?php
+
+/**
+ * THIS FILE IS AUTO-GENERATED. ANY CHANGES WILL BE LOST!
+ */
+
+declare(strict_types=1);
+
+namespace MongoDB\Builder\Search;
+
+use MongoDB\BSON\Document;
+use MongoDB\BSON\PackedArray;
+use MongoDB\BSON\Serializable;
+use MongoDB\Builder\Type\Encode;
+use MongoDB\Builder\Type\OperatorInterface;
+use MongoDB\Builder\Type\Optional;
+use MongoDB\Builder\Type\SearchOperatorInterface;
+use MongoDB\Model\BSONArray;
+use stdClass;
+
+/**
+ * The moreLikeThis operator returns documents similar to input documents.
+ * The moreLikeThis operator allows you to build features for your applications
+ * that display similar or alternative results based on one or more given documents.
+ *
+ * @see https://www.mongodb.com/docs/atlas/atlas-search/moreLikeThis/
+ * @internal
+ */
+final class MoreLikeThisOperator implements SearchOperatorInterface, OperatorInterface
+{
+    public const ENCODE = Encode::Object;
+    public const NAME = 'moreLikeThis';
+    public const PROPERTIES = ['like' => 'like', 'score' => 'score'];
+
+    /** @var BSONArray|Document|PackedArray|Serializable|array|stdClass $like */
+    public readonly Document|PackedArray|Serializable|BSONArray|stdClass|array $like;
+
+    /** @var Optional|Document|Serializable|array|stdClass $score */
+    public readonly Optional|Document|Serializable|stdClass|array $score;
+
+    /**
+     * @param BSONArray|Document|PackedArray|Serializable|array|stdClass $like
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public function __construct(
+        Document|PackedArray|Serializable|BSONArray|stdClass|array $like,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ) {
+        $this->like = $like;
+        $this->score = $score;
+    }
+}
diff --git a/src/Builder/Search/NearOperator.php b/src/Builder/Search/NearOperator.php
new file mode 100644
index 000000000..ab1b9b0c1
--- /dev/null
+++ b/src/Builder/Search/NearOperator.php
@@ -0,0 +1,64 @@
+<?php
+
+/**
+ * THIS FILE IS AUTO-GENERATED. ANY CHANGES WILL BE LOST!
+ */
+
+declare(strict_types=1);
+
+namespace MongoDB\Builder\Search;
+
+use MongoDB\BSON\Decimal128;
+use MongoDB\BSON\Document;
+use MongoDB\BSON\Int64;
+use MongoDB\BSON\Serializable;
+use MongoDB\BSON\UTCDateTime;
+use MongoDB\Builder\Type\Encode;
+use MongoDB\Builder\Type\GeometryInterface;
+use MongoDB\Builder\Type\OperatorInterface;
+use MongoDB\Builder\Type\Optional;
+use MongoDB\Builder\Type\SearchOperatorInterface;
+use stdClass;
+
+/**
+ * The near operator supports querying and scoring numeric, date, and GeoJSON point values.
+ *
+ * @see https://www.mongodb.com/docs/atlas/atlas-search/near/
+ * @internal
+ */
+final class NearOperator implements SearchOperatorInterface, OperatorInterface
+{
+    public const ENCODE = Encode::Object;
+    public const NAME = 'near';
+    public const PROPERTIES = ['path' => 'path', 'origin' => 'origin', 'pivot' => 'pivot', 'score' => 'score'];
+
+    /** @var array|string $path */
+    public readonly array|string $path;
+
+    /** @var Decimal128|Document|GeometryInterface|Int64|Serializable|UTCDateTime|array|float|int|stdClass $origin */
+    public readonly Decimal128|Document|Int64|Serializable|UTCDateTime|GeometryInterface|stdClass|array|float|int $origin;
+
+    /** @var Decimal128|Int64|float|int $pivot */
+    public readonly Decimal128|Int64|float|int $pivot;
+
+    /** @var Optional|Document|Serializable|array|stdClass $score */
+    public readonly Optional|Document|Serializable|stdClass|array $score;
+
+    /**
+     * @param array|string $path
+     * @param Decimal128|Document|GeometryInterface|Int64|Serializable|UTCDateTime|array|float|int|stdClass $origin
+     * @param Decimal128|Int64|float|int $pivot
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public function __construct(
+        array|string $path,
+        Decimal128|Document|Int64|Serializable|UTCDateTime|GeometryInterface|stdClass|array|float|int $origin,
+        Decimal128|Int64|float|int $pivot,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ) {
+        $this->path = $path;
+        $this->origin = $origin;
+        $this->pivot = $pivot;
+        $this->score = $score;
+    }
+}
diff --git a/src/Builder/Search/PhraseOperator.php b/src/Builder/Search/PhraseOperator.php
new file mode 100644
index 000000000..2bbb707a9
--- /dev/null
+++ b/src/Builder/Search/PhraseOperator.php
@@ -0,0 +1,83 @@
+<?php
+
+/**
+ * THIS FILE IS AUTO-GENERATED. ANY CHANGES WILL BE LOST!
+ */
+
+declare(strict_types=1);
+
+namespace MongoDB\Builder\Search;
+
+use MongoDB\BSON\Document;
+use MongoDB\BSON\PackedArray;
+use MongoDB\BSON\Serializable;
+use MongoDB\Builder\Type\Encode;
+use MongoDB\Builder\Type\OperatorInterface;
+use MongoDB\Builder\Type\Optional;
+use MongoDB\Builder\Type\SearchOperatorInterface;
+use MongoDB\Exception\InvalidArgumentException;
+use MongoDB\Model\BSONArray;
+use stdClass;
+
+use function array_is_list;
+use function is_array;
+
+/**
+ * The phrase operator performs search for documents containing an ordered sequence of terms using the analyzer specified in the index configuration.
+ *
+ * @see https://www.mongodb.com/docs/atlas/atlas-search/phrase/
+ * @internal
+ */
+final class PhraseOperator implements SearchOperatorInterface, OperatorInterface
+{
+    public const ENCODE = Encode::Object;
+    public const NAME = 'phrase';
+
+    public const PROPERTIES = [
+        'path' => 'path',
+        'query' => 'query',
+        'slop' => 'slop',
+        'synonyms' => 'synonyms',
+        'score' => 'score',
+    ];
+
+    /** @var array|string $path */
+    public readonly array|string $path;
+
+    /** @var BSONArray|PackedArray|array|string $query */
+    public readonly PackedArray|BSONArray|array|string $query;
+
+    /** @var Optional|int $slop */
+    public readonly Optional|int $slop;
+
+    /** @var Optional|string $synonyms */
+    public readonly Optional|string $synonyms;
+
+    /** @var Optional|Document|Serializable|array|stdClass $score */
+    public readonly Optional|Document|Serializable|stdClass|array $score;
+
+    /**
+     * @param array|string $path
+     * @param BSONArray|PackedArray|array|string $query
+     * @param Optional|int $slop
+     * @param Optional|string $synonyms
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public function __construct(
+        array|string $path,
+        PackedArray|BSONArray|array|string $query,
+        Optional|int $slop = Optional::Undefined,
+        Optional|string $synonyms = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ) {
+        $this->path = $path;
+        if (is_array($query) && ! array_is_list($query)) {
+            throw new InvalidArgumentException('Expected $query argument to be a list, got an associative array.');
+        }
+
+        $this->query = $query;
+        $this->slop = $slop;
+        $this->synonyms = $synonyms;
+        $this->score = $score;
+    }
+}
diff --git a/src/Builder/Search/QueryStringOperator.php b/src/Builder/Search/QueryStringOperator.php
new file mode 100644
index 000000000..edc4d3471
--- /dev/null
+++ b/src/Builder/Search/QueryStringOperator.php
@@ -0,0 +1,40 @@
+<?php
+
+/**
+ * THIS FILE IS AUTO-GENERATED. ANY CHANGES WILL BE LOST!
+ */
+
+declare(strict_types=1);
+
+namespace MongoDB\Builder\Search;
+
+use MongoDB\Builder\Type\Encode;
+use MongoDB\Builder\Type\OperatorInterface;
+use MongoDB\Builder\Type\SearchOperatorInterface;
+
+/**
+ * @see https://www.mongodb.com/docs/atlas/atlas-search/queryString/
+ * @internal
+ */
+final class QueryStringOperator implements SearchOperatorInterface, OperatorInterface
+{
+    public const ENCODE = Encode::Object;
+    public const NAME = 'queryString';
+    public const PROPERTIES = ['defaultPath' => 'defaultPath', 'query' => 'query'];
+
+    /** @var array|string $defaultPath */
+    public readonly array|string $defaultPath;
+
+    /** @var string $query */
+    public readonly string $query;
+
+    /**
+     * @param array|string $defaultPath
+     * @param string $query
+     */
+    public function __construct(array|string $defaultPath, string $query)
+    {
+        $this->defaultPath = $defaultPath;
+        $this->query = $query;
+    }
+}
diff --git a/src/Builder/Search/RangeOperator.php b/src/Builder/Search/RangeOperator.php
new file mode 100644
index 000000000..a728d7477
--- /dev/null
+++ b/src/Builder/Search/RangeOperator.php
@@ -0,0 +1,85 @@
+<?php
+
+/**
+ * THIS FILE IS AUTO-GENERATED. ANY CHANGES WILL BE LOST!
+ */
+
+declare(strict_types=1);
+
+namespace MongoDB\Builder\Search;
+
+use MongoDB\BSON\Decimal128;
+use MongoDB\BSON\Document;
+use MongoDB\BSON\Int64;
+use MongoDB\BSON\ObjectId;
+use MongoDB\BSON\Serializable;
+use MongoDB\BSON\UTCDateTime;
+use MongoDB\Builder\Type\Encode;
+use MongoDB\Builder\Type\OperatorInterface;
+use MongoDB\Builder\Type\Optional;
+use MongoDB\Builder\Type\SearchOperatorInterface;
+use stdClass;
+
+/**
+ * The range operator supports querying and scoring numeric, date, and string values.
+ * You can use this operator to find results that are within a given numeric, date, objectId, or letter (from the English alphabet) range.
+ *
+ * @see https://www.mongodb.com/docs/atlas/atlas-search/range/
+ * @internal
+ */
+final class RangeOperator implements SearchOperatorInterface, OperatorInterface
+{
+    public const ENCODE = Encode::Object;
+    public const NAME = 'range';
+
+    public const PROPERTIES = [
+        'path' => 'path',
+        'gt' => 'gt',
+        'gte' => 'gte',
+        'lt' => 'lt',
+        'lte' => 'lte',
+        'score' => 'score',
+    ];
+
+    /** @var array|string $path */
+    public readonly array|string $path;
+
+    /** @var Optional|Decimal128|Int64|ObjectId|UTCDateTime|float|int|string $gt */
+    public readonly Optional|Decimal128|Int64|ObjectId|UTCDateTime|float|int|string $gt;
+
+    /** @var Optional|Decimal128|Int64|ObjectId|UTCDateTime|float|int|string $gte */
+    public readonly Optional|Decimal128|Int64|ObjectId|UTCDateTime|float|int|string $gte;
+
+    /** @var Optional|Decimal128|Int64|ObjectId|UTCDateTime|float|int|string $lt */
+    public readonly Optional|Decimal128|Int64|ObjectId|UTCDateTime|float|int|string $lt;
+
+    /** @var Optional|Decimal128|Int64|ObjectId|UTCDateTime|float|int|string $lte */
+    public readonly Optional|Decimal128|Int64|ObjectId|UTCDateTime|float|int|string $lte;
+
+    /** @var Optional|Document|Serializable|array|stdClass $score */
+    public readonly Optional|Document|Serializable|stdClass|array $score;
+
+    /**
+     * @param array|string $path
+     * @param Optional|Decimal128|Int64|ObjectId|UTCDateTime|float|int|string $gt
+     * @param Optional|Decimal128|Int64|ObjectId|UTCDateTime|float|int|string $gte
+     * @param Optional|Decimal128|Int64|ObjectId|UTCDateTime|float|int|string $lt
+     * @param Optional|Decimal128|Int64|ObjectId|UTCDateTime|float|int|string $lte
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public function __construct(
+        array|string $path,
+        Optional|Decimal128|Int64|ObjectId|UTCDateTime|float|int|string $gt = Optional::Undefined,
+        Optional|Decimal128|Int64|ObjectId|UTCDateTime|float|int|string $gte = Optional::Undefined,
+        Optional|Decimal128|Int64|ObjectId|UTCDateTime|float|int|string $lt = Optional::Undefined,
+        Optional|Decimal128|Int64|ObjectId|UTCDateTime|float|int|string $lte = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ) {
+        $this->path = $path;
+        $this->gt = $gt;
+        $this->gte = $gte;
+        $this->lt = $lt;
+        $this->lte = $lte;
+        $this->score = $score;
+    }
+}
diff --git a/src/Builder/Search/RegexOperator.php b/src/Builder/Search/RegexOperator.php
new file mode 100644
index 000000000..6b2c2d63a
--- /dev/null
+++ b/src/Builder/Search/RegexOperator.php
@@ -0,0 +1,67 @@
+<?php
+
+/**
+ * THIS FILE IS AUTO-GENERATED. ANY CHANGES WILL BE LOST!
+ */
+
+declare(strict_types=1);
+
+namespace MongoDB\Builder\Search;
+
+use MongoDB\BSON\Document;
+use MongoDB\BSON\Serializable;
+use MongoDB\Builder\Type\Encode;
+use MongoDB\Builder\Type\OperatorInterface;
+use MongoDB\Builder\Type\Optional;
+use MongoDB\Builder\Type\SearchOperatorInterface;
+use stdClass;
+
+/**
+ * regex interprets the query field as a regular expression.
+ * regex is a term-level operator, meaning that the query field isn't analyzed.
+ *
+ * @see https://www.mongodb.com/docs/atlas/atlas-search/regex/
+ * @internal
+ */
+final class RegexOperator implements SearchOperatorInterface, OperatorInterface
+{
+    public const ENCODE = Encode::Object;
+    public const NAME = 'regex';
+
+    public const PROPERTIES = [
+        'path' => 'path',
+        'query' => 'query',
+        'allowAnalyzedField' => 'allowAnalyzedField',
+        'score' => 'score',
+    ];
+
+    /** @var array|string $path */
+    public readonly array|string $path;
+
+    /** @var string $query */
+    public readonly string $query;
+
+    /** @var Optional|bool $allowAnalyzedField */
+    public readonly Optional|bool $allowAnalyzedField;
+
+    /** @var Optional|Document|Serializable|array|stdClass $score */
+    public readonly Optional|Document|Serializable|stdClass|array $score;
+
+    /**
+     * @param array|string $path
+     * @param string $query
+     * @param Optional|bool $allowAnalyzedField
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public function __construct(
+        array|string $path,
+        string $query,
+        Optional|bool $allowAnalyzedField = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ) {
+        $this->path = $path;
+        $this->query = $query;
+        $this->allowAnalyzedField = $allowAnalyzedField;
+        $this->score = $score;
+    }
+}
diff --git a/src/Builder/Search/TextOperator.php b/src/Builder/Search/TextOperator.php
new file mode 100644
index 000000000..4ade6b434
--- /dev/null
+++ b/src/Builder/Search/TextOperator.php
@@ -0,0 +1,81 @@
+<?php
+
+/**
+ * THIS FILE IS AUTO-GENERATED. ANY CHANGES WILL BE LOST!
+ */
+
+declare(strict_types=1);
+
+namespace MongoDB\Builder\Search;
+
+use MongoDB\BSON\Document;
+use MongoDB\BSON\Serializable;
+use MongoDB\Builder\Type\Encode;
+use MongoDB\Builder\Type\OperatorInterface;
+use MongoDB\Builder\Type\Optional;
+use MongoDB\Builder\Type\SearchOperatorInterface;
+use stdClass;
+
+/**
+ * The text operator performs a full-text search using the analyzer that you specify in the index configuration.
+ * If you omit an analyzer, the text operator uses the default standard analyzer.
+ *
+ * @see https://www.mongodb.com/docs/atlas/atlas-search/text/
+ * @internal
+ */
+final class TextOperator implements SearchOperatorInterface, OperatorInterface
+{
+    public const ENCODE = Encode::Object;
+    public const NAME = 'text';
+
+    public const PROPERTIES = [
+        'path' => 'path',
+        'query' => 'query',
+        'fuzzy' => 'fuzzy',
+        'matchCriteria' => 'matchCriteria',
+        'synonyms' => 'synonyms',
+        'score' => 'score',
+    ];
+
+    /** @var array|string $path */
+    public readonly array|string $path;
+
+    /** @var string $query */
+    public readonly string $query;
+
+    /** @var Optional|Document|Serializable|array|stdClass $fuzzy */
+    public readonly Optional|Document|Serializable|stdClass|array $fuzzy;
+
+    /** @var Optional|string $matchCriteria */
+    public readonly Optional|string $matchCriteria;
+
+    /** @var Optional|string $synonyms */
+    public readonly Optional|string $synonyms;
+
+    /** @var Optional|Document|Serializable|array|stdClass $score */
+    public readonly Optional|Document|Serializable|stdClass|array $score;
+
+    /**
+     * @param array|string $path
+     * @param string $query
+     * @param Optional|Document|Serializable|array|stdClass $fuzzy
+     * @param Optional|string $matchCriteria
+     * @param Optional|string $synonyms
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public function __construct(
+        array|string $path,
+        string $query,
+        Optional|Document|Serializable|stdClass|array $fuzzy = Optional::Undefined,
+        Optional|string $matchCriteria = Optional::Undefined,
+        Optional|string $synonyms = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ) {
+        $this->path = $path;
+        $this->query = $query;
+        $this->fuzzy = $fuzzy;
+        $this->matchCriteria = $matchCriteria;
+        $this->synonyms = $synonyms;
+        $this->score = $score;
+    }
+}
diff --git a/src/Builder/Search/WildcardOperator.php b/src/Builder/Search/WildcardOperator.php
new file mode 100644
index 000000000..ee481910e
--- /dev/null
+++ b/src/Builder/Search/WildcardOperator.php
@@ -0,0 +1,66 @@
+<?php
+
+/**
+ * THIS FILE IS AUTO-GENERATED. ANY CHANGES WILL BE LOST!
+ */
+
+declare(strict_types=1);
+
+namespace MongoDB\Builder\Search;
+
+use MongoDB\BSON\Document;
+use MongoDB\BSON\Serializable;
+use MongoDB\Builder\Type\Encode;
+use MongoDB\Builder\Type\OperatorInterface;
+use MongoDB\Builder\Type\Optional;
+use MongoDB\Builder\Type\SearchOperatorInterface;
+use stdClass;
+
+/**
+ * The wildcard operator enables queries which use special characters in the search string that can match any character.
+ *
+ * @see https://www.mongodb.com/docs/atlas/atlas-search/wildcard/
+ * @internal
+ */
+final class WildcardOperator implements SearchOperatorInterface, OperatorInterface
+{
+    public const ENCODE = Encode::Object;
+    public const NAME = 'wildcard';
+
+    public const PROPERTIES = [
+        'path' => 'path',
+        'query' => 'query',
+        'allowAnalyzedField' => 'allowAnalyzedField',
+        'score' => 'score',
+    ];
+
+    /** @var array|string $path */
+    public readonly array|string $path;
+
+    /** @var string $query */
+    public readonly string $query;
+
+    /** @var Optional|bool $allowAnalyzedField */
+    public readonly Optional|bool $allowAnalyzedField;
+
+    /** @var Optional|Document|Serializable|array|stdClass $score */
+    public readonly Optional|Document|Serializable|stdClass|array $score;
+
+    /**
+     * @param array|string $path
+     * @param string $query
+     * @param Optional|bool $allowAnalyzedField
+     * @param Optional|Document|Serializable|array|stdClass $score
+     */
+    public function __construct(
+        array|string $path,
+        string $query,
+        Optional|bool $allowAnalyzedField = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $score = Optional::Undefined,
+    ) {
+        $this->path = $path;
+        $this->query = $query;
+        $this->allowAnalyzedField = $allowAnalyzedField;
+        $this->score = $score;
+    }
+}
diff --git a/src/Builder/Stage/FactoryTrait.php b/src/Builder/Stage/FactoryTrait.php
index 199cf64ef..5b1f47a8c 100644
--- a/src/Builder/Stage/FactoryTrait.php
+++ b/src/Builder/Stage/FactoryTrait.php
@@ -24,6 +24,7 @@
 use MongoDB\Builder\Type\ExpressionInterface;
 use MongoDB\Builder\Type\Optional;
 use MongoDB\Builder\Type\QueryInterface;
+use MongoDB\Builder\Type\SearchOperatorInterface;
 use MongoDB\Builder\Type\Sort;
 use MongoDB\Model\BSONArray;
 use stdClass;
@@ -537,11 +538,35 @@ public static function sample(int $size): SampleStage
      * NOTE: $search is only available for MongoDB Atlas clusters, and is not available for self-managed deployments.
      *
      * @see https://www.mongodb.com/docs/manual/reference/operator/aggregation/search/
-     * @param Document|Serializable|array|stdClass $search
-     */
-    public static function search(Document|Serializable|stdClass|array $search): SearchStage
-    {
-        return new SearchStage($search);
+     * @param Document|SearchOperatorInterface|Serializable|array|stdClass $operator Operator to search with.  You can provide a specific operator or use
+     * the compound operator to run a compound query with multiple operators.
+     * @param Optional|string $index Name of the Atlas Search index to use. If omitted, defaults to "default".
+     * @param Optional|Document|Serializable|array|stdClass $highlight Specifies the highlighting options for displaying search terms in their original context.
+     * @param Optional|bool $concurrent Parallelize search across segments on dedicated search nodes.
+     * If you don't have separate search nodes on your cluster,
+     * Atlas Search ignores this flag. If omitted, defaults to false.
+     * @param Optional|string $count Document that specifies the count options for retrieving a count of the results.
+     * @param Optional|string $searchAfter Reference point for retrieving results. searchAfter returns documents starting immediately following the specified reference point.
+     * @param Optional|string $searchBefore Reference point for retrieving results. searchBefore returns documents starting immediately following the specified reference point.
+     * @param Optional|bool $scoreDetails Flag that specifies whether to retrieve a detailed breakdown of the score for the documents in the results. If omitted, defaults to false.
+     * @param Optional|Document|Serializable|array|stdClass $sort Document that specifies the fields to sort the Atlas Search results by in ascending or descending order.
+     * @param Optional|bool $returnStoredSource Flag that specifies whether to return the stored source document in the search results. If omitted, defaults to false.Flag that specifies whether to perform a full document lookup on the backend database or return only stored source fields directly from Atlas Search.
+     * @param Optional|Document|Serializable|array|stdClass $tracking Document that specifies the tracking option to retrieve analytics information on the search terms.
+     */
+    public static function search(
+        Document|Serializable|SearchOperatorInterface|stdClass|array $operator,
+        Optional|string $index = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $highlight = Optional::Undefined,
+        Optional|bool $concurrent = Optional::Undefined,
+        Optional|string $count = Optional::Undefined,
+        Optional|string $searchAfter = Optional::Undefined,
+        Optional|string $searchBefore = Optional::Undefined,
+        Optional|bool $scoreDetails = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $sort = Optional::Undefined,
+        Optional|bool $returnStoredSource = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $tracking = Optional::Undefined,
+    ): SearchStage {
+        return new SearchStage($operator, $index, $highlight, $concurrent, $count, $searchAfter, $searchBefore, $scoreDetails, $sort, $returnStoredSource, $tracking);
     }
 
     /**
@@ -549,11 +574,17 @@ public static function search(Document|Serializable|stdClass|array $search): Sea
      * NOTE: $searchMeta is only available for MongoDB Atlas clusters running MongoDB v4.4.9 or higher, and is not available for self-managed deployments.
      *
      * @see https://www.mongodb.com/docs/manual/reference/operator/aggregation/searchMeta/
-     * @param Document|Serializable|array|stdClass $meta
-     */
-    public static function searchMeta(Document|Serializable|stdClass|array $meta): SearchMetaStage
-    {
-        return new SearchMetaStage($meta);
+     * @param Document|SearchOperatorInterface|Serializable|array|stdClass $operator Operator to search with.  You can provide a specific operator or use
+     * the compound operator to run a compound query with multiple operators.
+     * @param Optional|string $index Name of the Atlas Search index to use. If omitted, defaults to default.
+     * @param Optional|Document|Serializable|array|stdClass $count Document that specifies the count options for retrieving a count of the results.
+     */
+    public static function searchMeta(
+        Document|Serializable|SearchOperatorInterface|stdClass|array $operator,
+        Optional|string $index = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $count = Optional::Undefined,
+    ): SearchMetaStage {
+        return new SearchMetaStage($operator, $index, $count);
     }
 
     /**
@@ -678,4 +709,30 @@ public static function unwind(
     ): UnwindStage {
         return new UnwindStage($path, $includeArrayIndex, $preserveNullAndEmptyArrays);
     }
+
+    /**
+     * The $vectorSearch stage performs an ANN or ENN search on a vector in the specified field.
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-vector-search/vector-search-stage/
+     * @param string $index Name of the Atlas Vector Search index to use.
+     * @param int $limit Number of documents to return in the results. This value can't exceed the value of numCandidates if you specify numCandidates.
+     * @param array|string $path Indexed vector type field to search.
+     * @param BSONArray|PackedArray|array $queryVector Array of numbers that represent the query vector. The number type must match the indexed field value type.
+     * @param Optional|bool $exact This is required if numCandidates is omitted.
+     * - false to run ANN search
+     * - true to run ENN search
+     * @param Optional|QueryInterface|array $filter
+     * @param Optional|int $numCandidates
+     */
+    public static function vectorSearch(
+        string $index,
+        int $limit,
+        array|string $path,
+        PackedArray|BSONArray|array $queryVector,
+        Optional|bool $exact = Optional::Undefined,
+        Optional|QueryInterface|array $filter = Optional::Undefined,
+        Optional|int $numCandidates = Optional::Undefined,
+    ): VectorSearchStage {
+        return new VectorSearchStage($index, $limit, $path, $queryVector, $exact, $filter, $numCandidates);
+    }
 }
diff --git a/src/Builder/Stage/FluentFactoryTrait.php b/src/Builder/Stage/FluentFactoryTrait.php
index 6f468322d..e2858bdde 100644
--- a/src/Builder/Stage/FluentFactoryTrait.php
+++ b/src/Builder/Stage/FluentFactoryTrait.php
@@ -26,6 +26,7 @@
 use MongoDB\Builder\Type\FieldQueryInterface;
 use MongoDB\Builder\Type\Optional;
 use MongoDB\Builder\Type\QueryInterface;
+use MongoDB\Builder\Type\SearchOperatorInterface;
 use MongoDB\Builder\Type\Sort;
 use MongoDB\Builder\Type\StageInterface;
 use MongoDB\Model\BSONArray;
@@ -605,11 +606,35 @@ public function sample(int $size): static
      * NOTE: $search is only available for MongoDB Atlas clusters, and is not available for self-managed deployments.
      *
      * @see https://www.mongodb.com/docs/manual/reference/operator/aggregation/search/
-     * @param Document|Serializable|array|stdClass $search
-     */
-    public function search(Document|Serializable|stdClass|array $search): static
-    {
-        $this->pipeline[] = Stage::search($search);
+     * @param Document|SearchOperatorInterface|Serializable|array|stdClass $operator Operator to search with.  You can provide a specific operator or use
+     * the compound operator to run a compound query with multiple operators.
+     * @param Optional|string $index Name of the Atlas Search index to use. If omitted, defaults to "default".
+     * @param Optional|Document|Serializable|array|stdClass $highlight Specifies the highlighting options for displaying search terms in their original context.
+     * @param Optional|bool $concurrent Parallelize search across segments on dedicated search nodes.
+     * If you don't have separate search nodes on your cluster,
+     * Atlas Search ignores this flag. If omitted, defaults to false.
+     * @param Optional|string $count Document that specifies the count options for retrieving a count of the results.
+     * @param Optional|string $searchAfter Reference point for retrieving results. searchAfter returns documents starting immediately following the specified reference point.
+     * @param Optional|string $searchBefore Reference point for retrieving results. searchBefore returns documents starting immediately following the specified reference point.
+     * @param Optional|bool $scoreDetails Flag that specifies whether to retrieve a detailed breakdown of the score for the documents in the results. If omitted, defaults to false.
+     * @param Optional|Document|Serializable|array|stdClass $sort Document that specifies the fields to sort the Atlas Search results by in ascending or descending order.
+     * @param Optional|bool $returnStoredSource Flag that specifies whether to return the stored source document in the search results. If omitted, defaults to false.Flag that specifies whether to perform a full document lookup on the backend database or return only stored source fields directly from Atlas Search.
+     * @param Optional|Document|Serializable|array|stdClass $tracking Document that specifies the tracking option to retrieve analytics information on the search terms.
+     */
+    public function search(
+        Document|Serializable|SearchOperatorInterface|stdClass|array $operator,
+        Optional|string $index = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $highlight = Optional::Undefined,
+        Optional|bool $concurrent = Optional::Undefined,
+        Optional|string $count = Optional::Undefined,
+        Optional|string $searchAfter = Optional::Undefined,
+        Optional|string $searchBefore = Optional::Undefined,
+        Optional|bool $scoreDetails = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $sort = Optional::Undefined,
+        Optional|bool $returnStoredSource = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $tracking = Optional::Undefined,
+    ): static {
+        $this->pipeline[] = Stage::search($operator, $index, $highlight, $concurrent, $count, $searchAfter, $searchBefore, $scoreDetails, $sort, $returnStoredSource, $tracking);
 
         return $this;
     }
@@ -619,11 +644,17 @@ public function search(Document|Serializable|stdClass|array $search): static
      * NOTE: $searchMeta is only available for MongoDB Atlas clusters running MongoDB v4.4.9 or higher, and is not available for self-managed deployments.
      *
      * @see https://www.mongodb.com/docs/manual/reference/operator/aggregation/searchMeta/
-     * @param Document|Serializable|array|stdClass $meta
-     */
-    public function searchMeta(Document|Serializable|stdClass|array $meta): static
-    {
-        $this->pipeline[] = Stage::searchMeta($meta);
+     * @param Document|SearchOperatorInterface|Serializable|array|stdClass $operator Operator to search with.  You can provide a specific operator or use
+     * the compound operator to run a compound query with multiple operators.
+     * @param Optional|string $index Name of the Atlas Search index to use. If omitted, defaults to default.
+     * @param Optional|Document|Serializable|array|stdClass $count Document that specifies the count options for retrieving a count of the results.
+     */
+    public function searchMeta(
+        Document|Serializable|SearchOperatorInterface|stdClass|array $operator,
+        Optional|string $index = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $count = Optional::Undefined,
+    ): static {
+        $this->pipeline[] = Stage::searchMeta($operator, $index, $count);
 
         return $this;
     }
@@ -767,4 +798,32 @@ public function unwind(
 
         return $this;
     }
+
+    /**
+     * The $vectorSearch stage performs an ANN or ENN search on a vector in the specified field.
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-vector-search/vector-search-stage/
+     * @param string $index Name of the Atlas Vector Search index to use.
+     * @param int $limit Number of documents to return in the results. This value can't exceed the value of numCandidates if you specify numCandidates.
+     * @param array|string $path Indexed vector type field to search.
+     * @param BSONArray|PackedArray|array $queryVector Array of numbers that represent the query vector. The number type must match the indexed field value type.
+     * @param Optional|bool $exact This is required if numCandidates is omitted.
+     * - false to run ANN search
+     * - true to run ENN search
+     * @param Optional|QueryInterface|array $filter
+     * @param Optional|int $numCandidates
+     */
+    public function vectorSearch(
+        string $index,
+        int $limit,
+        array|string $path,
+        PackedArray|BSONArray|array $queryVector,
+        Optional|bool $exact = Optional::Undefined,
+        Optional|QueryInterface|array $filter = Optional::Undefined,
+        Optional|int $numCandidates = Optional::Undefined,
+    ): static {
+        $this->pipeline[] = Stage::vectorSearch($index, $limit, $path, $queryVector, $exact, $filter, $numCandidates);
+
+        return $this;
+    }
 }
diff --git a/src/Builder/Stage/SearchMetaStage.php b/src/Builder/Stage/SearchMetaStage.php
index 88f05bec1..14687161b 100644
--- a/src/Builder/Stage/SearchMetaStage.php
+++ b/src/Builder/Stage/SearchMetaStage.php
@@ -12,6 +12,8 @@
 use MongoDB\BSON\Serializable;
 use MongoDB\Builder\Type\Encode;
 use MongoDB\Builder\Type\OperatorInterface;
+use MongoDB\Builder\Type\Optional;
+use MongoDB\Builder\Type\SearchOperatorInterface;
 use MongoDB\Builder\Type\StageInterface;
 use stdClass;
 
@@ -24,18 +26,35 @@
  */
 final class SearchMetaStage implements StageInterface, OperatorInterface
 {
-    public const ENCODE = Encode::Single;
+    public const ENCODE = Encode::Object;
     public const NAME = '$searchMeta';
-    public const PROPERTIES = ['meta' => 'meta'];
+    public const PROPERTIES = ['operator' => null, 'index' => 'index', 'count' => 'count'];
 
-    /** @var Document|Serializable|array|stdClass $meta */
-    public readonly Document|Serializable|stdClass|array $meta;
+    /**
+     * @var Document|SearchOperatorInterface|Serializable|array|stdClass $operator Operator to search with.  You can provide a specific operator or use
+     * the compound operator to run a compound query with multiple operators.
+     */
+    public readonly Document|Serializable|SearchOperatorInterface|stdClass|array $operator;
+
+    /** @var Optional|string $index Name of the Atlas Search index to use. If omitted, defaults to default. */
+    public readonly Optional|string $index;
+
+    /** @var Optional|Document|Serializable|array|stdClass $count Document that specifies the count options for retrieving a count of the results. */
+    public readonly Optional|Document|Serializable|stdClass|array $count;
 
     /**
-     * @param Document|Serializable|array|stdClass $meta
+     * @param Document|SearchOperatorInterface|Serializable|array|stdClass $operator Operator to search with.  You can provide a specific operator or use
+     * the compound operator to run a compound query with multiple operators.
+     * @param Optional|string $index Name of the Atlas Search index to use. If omitted, defaults to default.
+     * @param Optional|Document|Serializable|array|stdClass $count Document that specifies the count options for retrieving a count of the results.
      */
-    public function __construct(Document|Serializable|stdClass|array $meta)
-    {
-        $this->meta = $meta;
+    public function __construct(
+        Document|Serializable|SearchOperatorInterface|stdClass|array $operator,
+        Optional|string $index = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $count = Optional::Undefined,
+    ) {
+        $this->operator = $operator;
+        $this->index = $index;
+        $this->count = $count;
     }
 }
diff --git a/src/Builder/Stage/SearchStage.php b/src/Builder/Stage/SearchStage.php
index 188a2ece4..ec1ae8030 100644
--- a/src/Builder/Stage/SearchStage.php
+++ b/src/Builder/Stage/SearchStage.php
@@ -12,6 +12,8 @@
 use MongoDB\BSON\Serializable;
 use MongoDB\Builder\Type\Encode;
 use MongoDB\Builder\Type\OperatorInterface;
+use MongoDB\Builder\Type\Optional;
+use MongoDB\Builder\Type\SearchOperatorInterface;
 use MongoDB\Builder\Type\StageInterface;
 use stdClass;
 
@@ -24,18 +26,102 @@
  */
 final class SearchStage implements StageInterface, OperatorInterface
 {
-    public const ENCODE = Encode::Single;
+    public const ENCODE = Encode::Object;
     public const NAME = '$search';
-    public const PROPERTIES = ['search' => 'search'];
 
-    /** @var Document|Serializable|array|stdClass $search */
-    public readonly Document|Serializable|stdClass|array $search;
+    public const PROPERTIES = [
+        'operator' => null,
+        'index' => 'index',
+        'highlight' => 'highlight',
+        'concurrent' => 'concurrent',
+        'count' => 'count',
+        'searchAfter' => 'searchAfter',
+        'searchBefore' => 'searchBefore',
+        'scoreDetails' => 'scoreDetails',
+        'sort' => 'sort',
+        'returnStoredSource' => 'returnStoredSource',
+        'tracking' => 'tracking',
+    ];
 
     /**
-     * @param Document|Serializable|array|stdClass $search
+     * @var Document|SearchOperatorInterface|Serializable|array|stdClass $operator Operator to search with.  You can provide a specific operator or use
+     * the compound operator to run a compound query with multiple operators.
      */
-    public function __construct(Document|Serializable|stdClass|array $search)
-    {
-        $this->search = $search;
+    public readonly Document|Serializable|SearchOperatorInterface|stdClass|array $operator;
+
+    /** @var Optional|string $index Name of the Atlas Search index to use. If omitted, defaults to "default". */
+    public readonly Optional|string $index;
+
+    /** @var Optional|Document|Serializable|array|stdClass $highlight Specifies the highlighting options for displaying search terms in their original context. */
+    public readonly Optional|Document|Serializable|stdClass|array $highlight;
+
+    /**
+     * @var Optional|bool $concurrent Parallelize search across segments on dedicated search nodes.
+     * If you don't have separate search nodes on your cluster,
+     * Atlas Search ignores this flag. If omitted, defaults to false.
+     */
+    public readonly Optional|bool $concurrent;
+
+    /** @var Optional|string $count Document that specifies the count options for retrieving a count of the results. */
+    public readonly Optional|string $count;
+
+    /** @var Optional|string $searchAfter Reference point for retrieving results. searchAfter returns documents starting immediately following the specified reference point. */
+    public readonly Optional|string $searchAfter;
+
+    /** @var Optional|string $searchBefore Reference point for retrieving results. searchBefore returns documents starting immediately following the specified reference point. */
+    public readonly Optional|string $searchBefore;
+
+    /** @var Optional|bool $scoreDetails Flag that specifies whether to retrieve a detailed breakdown of the score for the documents in the results. If omitted, defaults to false. */
+    public readonly Optional|bool $scoreDetails;
+
+    /** @var Optional|Document|Serializable|array|stdClass $sort Document that specifies the fields to sort the Atlas Search results by in ascending or descending order. */
+    public readonly Optional|Document|Serializable|stdClass|array $sort;
+
+    /** @var Optional|bool $returnStoredSource Flag that specifies whether to return the stored source document in the search results. If omitted, defaults to false.Flag that specifies whether to perform a full document lookup on the backend database or return only stored source fields directly from Atlas Search. */
+    public readonly Optional|bool $returnStoredSource;
+
+    /** @var Optional|Document|Serializable|array|stdClass $tracking Document that specifies the tracking option to retrieve analytics information on the search terms. */
+    public readonly Optional|Document|Serializable|stdClass|array $tracking;
+
+    /**
+     * @param Document|SearchOperatorInterface|Serializable|array|stdClass $operator Operator to search with.  You can provide a specific operator or use
+     * the compound operator to run a compound query with multiple operators.
+     * @param Optional|string $index Name of the Atlas Search index to use. If omitted, defaults to "default".
+     * @param Optional|Document|Serializable|array|stdClass $highlight Specifies the highlighting options for displaying search terms in their original context.
+     * @param Optional|bool $concurrent Parallelize search across segments on dedicated search nodes.
+     * If you don't have separate search nodes on your cluster,
+     * Atlas Search ignores this flag. If omitted, defaults to false.
+     * @param Optional|string $count Document that specifies the count options for retrieving a count of the results.
+     * @param Optional|string $searchAfter Reference point for retrieving results. searchAfter returns documents starting immediately following the specified reference point.
+     * @param Optional|string $searchBefore Reference point for retrieving results. searchBefore returns documents starting immediately following the specified reference point.
+     * @param Optional|bool $scoreDetails Flag that specifies whether to retrieve a detailed breakdown of the score for the documents in the results. If omitted, defaults to false.
+     * @param Optional|Document|Serializable|array|stdClass $sort Document that specifies the fields to sort the Atlas Search results by in ascending or descending order.
+     * @param Optional|bool $returnStoredSource Flag that specifies whether to return the stored source document in the search results. If omitted, defaults to false.Flag that specifies whether to perform a full document lookup on the backend database or return only stored source fields directly from Atlas Search.
+     * @param Optional|Document|Serializable|array|stdClass $tracking Document that specifies the tracking option to retrieve analytics information on the search terms.
+     */
+    public function __construct(
+        Document|Serializable|SearchOperatorInterface|stdClass|array $operator,
+        Optional|string $index = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $highlight = Optional::Undefined,
+        Optional|bool $concurrent = Optional::Undefined,
+        Optional|string $count = Optional::Undefined,
+        Optional|string $searchAfter = Optional::Undefined,
+        Optional|string $searchBefore = Optional::Undefined,
+        Optional|bool $scoreDetails = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $sort = Optional::Undefined,
+        Optional|bool $returnStoredSource = Optional::Undefined,
+        Optional|Document|Serializable|stdClass|array $tracking = Optional::Undefined,
+    ) {
+        $this->operator = $operator;
+        $this->index = $index;
+        $this->highlight = $highlight;
+        $this->concurrent = $concurrent;
+        $this->count = $count;
+        $this->searchAfter = $searchAfter;
+        $this->searchBefore = $searchBefore;
+        $this->scoreDetails = $scoreDetails;
+        $this->sort = $sort;
+        $this->returnStoredSource = $returnStoredSource;
+        $this->tracking = $tracking;
     }
 }
diff --git a/tests/Builder/Search/Pipelines.php b/tests/Builder/Search/Pipelines.php
new file mode 100644
index 000000000..fa94f8c9a
--- /dev/null
+++ b/tests/Builder/Search/Pipelines.php
@@ -0,0 +1,2814 @@
+<?php
+
+/**
+ * THIS FILE IS AUTO-GENERATED. ANY CHANGES WILL BE LOST!
+ */
+
+declare(strict_types=1);
+
+namespace MongoDB\Tests\Builder\Search;
+
+enum Pipelines: string
+{
+    /**
+     * Basic
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/autocomplete/#basic-example
+     */
+    case AutocompleteBasic = <<<'JSON'
+    [
+        {
+            "$search": {
+                "autocomplete": {
+                    "query": "off",
+                    "path": "title"
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "10"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "title": {
+                    "$numberInt": "1"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Fuzzy
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/autocomplete/#fuzzy-example
+     */
+    case AutocompleteFuzzy = <<<'JSON'
+    [
+        {
+            "$search": {
+                "autocomplete": {
+                    "query": "pre",
+                    "path": "title",
+                    "fuzzy": {
+                        "maxEdits": {
+                            "$numberInt": "1"
+                        },
+                        "prefixLength": {
+                            "$numberInt": "1"
+                        },
+                        "maxExpansions": {
+                            "$numberInt": "256"
+                        }
+                    }
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "10"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "title": {
+                    "$numberInt": "1"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Token Order any
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/autocomplete/#simple-any-example
+     */
+    case AutocompleteTokenOrderAny = <<<'JSON'
+    [
+        {
+            "$search": {
+                "autocomplete": {
+                    "query": "men with",
+                    "path": "title",
+                    "tokenOrder": "any"
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "4"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "title": {
+                    "$numberInt": "1"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Token Order sequential
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/autocomplete/#simple-sequential-example
+     */
+    case AutocompleteTokenOrderSequential = <<<'JSON'
+    [
+        {
+            "$search": {
+                "autocomplete": {
+                    "query": "men with",
+                    "path": "title",
+                    "tokenOrder": "sequential"
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "4"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "title": {
+                    "$numberInt": "1"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Highlighting
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/autocomplete/#highlighting-example
+     */
+    case AutocompleteHighlighting = <<<'JSON'
+    [
+        {
+            "$search": {
+                "autocomplete": {
+                    "query": "ger",
+                    "path": "title"
+                },
+                "highlight": {
+                    "path": "title"
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "5"
+            }
+        },
+        {
+            "$project": {
+                "score": {
+                    "$meta": "searchScore"
+                },
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "title": {
+                    "$numberInt": "1"
+                },
+                "highlights": {
+                    "$meta": "searchHighlights"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Across Multiple Fields
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/autocomplete/#search-across-multiple-fields
+     */
+    case AutocompleteAcrossMultipleFields = <<<'JSON'
+    [
+        {
+            "$search": {
+                "compound": {
+                    "should": [
+                        {
+                            "autocomplete": {
+                                "query": "inter",
+                                "path": "title"
+                            }
+                        },
+                        {
+                            "autocomplete": {
+                                "query": "inter",
+                                "path": "plot"
+                            }
+                        }
+                    ],
+                    "minimumShouldMatch": {
+                        "$numberInt": "1"
+                    }
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "10"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "title": {
+                    "$numberInt": "1"
+                },
+                "plot": {
+                    "$numberInt": "1"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * must and mustNot
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/compound/#must-and-mustnot-example
+     */
+    case CompoundMustAndMustNot = <<<'JSON'
+    [
+        {
+            "$search": {
+                "compound": {
+                    "must": [
+                        {
+                            "text": {
+                                "query": "varieties",
+                                "path": "description"
+                            }
+                        }
+                    ],
+                    "mustNot": [
+                        {
+                            "text": {
+                                "query": "apples",
+                                "path": "description"
+                            }
+                        }
+                    ]
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * must and should
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/compound/#must-and-should-example
+     */
+    case CompoundMustAndShould = <<<'JSON'
+    [
+        {
+            "$search": {
+                "compound": {
+                    "must": [
+                        {
+                            "text": {
+                                "query": "varieties",
+                                "path": "description"
+                            }
+                        }
+                    ],
+                    "should": [
+                        {
+                            "text": {
+                                "query": "Fuji",
+                                "path": "description"
+                            }
+                        }
+                    ]
+                }
+            }
+        },
+        {
+            "$project": {
+                "score": {
+                    "$meta": "searchScore"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * minimumShouldMatch
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/compound/#minimumshouldmatch-example
+     */
+    case CompoundMinimumShouldMatch = <<<'JSON'
+    [
+        {
+            "$search": {
+                "compound": {
+                    "must": [
+                        {
+                            "text": {
+                                "query": "varieties",
+                                "path": "description"
+                            }
+                        }
+                    ],
+                    "should": [
+                        {
+                            "text": {
+                                "query": "Fuji",
+                                "path": "description"
+                            }
+                        },
+                        {
+                            "text": {
+                                "query": "Golden Delicious",
+                                "path": "description"
+                            }
+                        }
+                    ],
+                    "minimumShouldMatch": {
+                        "$numberInt": "1"
+                    }
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Filter
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/compound/#filter-examples
+     */
+    case CompoundFilter = <<<'JSON'
+    [
+        {
+            "$search": {
+                "compound": {
+                    "must": [
+                        {
+                            "text": {
+                                "query": "varieties",
+                                "path": "description"
+                            }
+                        }
+                    ],
+                    "should": [
+                        {
+                            "text": {
+                                "query": "banana",
+                                "path": "description"
+                            }
+                        }
+                    ],
+                    "filter": [
+                        {
+                            "text": {
+                                "query": "granny",
+                                "path": "description"
+                            }
+                        }
+                    ]
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Nested
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/compound/#nested-example
+     */
+    case CompoundNested = <<<'JSON'
+    [
+        {
+            "$search": {
+                "compound": {
+                    "should": [
+                        {
+                            "text": {
+                                "query": "apple",
+                                "path": "type"
+                            }
+                        },
+                        {
+                            "compound": {
+                                "must": [
+                                    {
+                                        "text": {
+                                            "query": "organic",
+                                            "path": "category"
+                                        }
+                                    },
+                                    {
+                                        "equals": {
+                                            "value": true,
+                                            "path": "in_stock"
+                                        }
+                                    }
+                                ]
+                            }
+                        }
+                    ],
+                    "minimumShouldMatch": {
+                        "$numberInt": "1"
+                    }
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Basic
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/embedded-document/#index-definition
+     */
+    case EmbeddedDocumentBasic = <<<'JSON'
+    [
+        {
+            "$search": {
+                "embeddedDocument": {
+                    "path": "items",
+                    "operator": {
+                        "compound": {
+                            "must": [
+                                {
+                                    "text": {
+                                        "path": "items.tags",
+                                        "query": "school"
+                                    }
+                                }
+                            ],
+                            "should": [
+                                {
+                                    "text": {
+                                        "path": "items.name",
+                                        "query": "backpack"
+                                    }
+                                }
+                            ]
+                        }
+                    },
+                    "score": {
+                        "embedded": {
+                            "aggregate": "mean"
+                        }
+                    }
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "5"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "items.name": {
+                    "$numberInt": "1"
+                },
+                "items.tags": {
+                    "$numberInt": "1"
+                },
+                "score": {
+                    "$meta": "searchScore"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Facet
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/embedded-document/#facet-query
+     */
+    case EmbeddedDocumentFacet = <<<'JSON'
+    [
+        {
+            "$searchMeta": {
+                "facet": {
+                    "operator": {
+                        "embeddedDocument": {
+                            "path": "items",
+                            "operator": {
+                                "compound": {
+                                    "must": [
+                                        {
+                                            "text": {
+                                                "path": "items.tags",
+                                                "query": "school"
+                                            }
+                                        }
+                                    ],
+                                    "should": [
+                                        {
+                                            "text": {
+                                                "path": "items.name",
+                                                "query": "backpack"
+                                            }
+                                        }
+                                    ]
+                                }
+                            }
+                        }
+                    },
+                    "facets": {
+                        "purchaseMethodFacet": {
+                            "type": "string",
+                            "path": "purchaseMethod"
+                        }
+                    }
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Query and Sort
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/embedded-document/#query-and-sort
+     */
+    case EmbeddedDocumentQueryAndSort = <<<'JSON'
+    [
+        {
+            "$search": {
+                "embeddedDocument": {
+                    "path": "items",
+                    "operator": {
+                        "text": {
+                            "path": "items.name",
+                            "query": "laptop"
+                        }
+                    }
+                },
+                "sort": {
+                    "items.tags": {
+                        "$numberInt": "1"
+                    }
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "5"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "items.name": {
+                    "$numberInt": "1"
+                },
+                "items.tags": {
+                    "$numberInt": "1"
+                },
+                "score": {
+                    "$meta": "searchScore"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Query for Matching Embedded Documents Only
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/embedded-document/#query-for-matching-embedded-documents-only
+     */
+    case EmbeddedDocumentQueryForMatchingEmbeddedDocumentsOnly = <<<'JSON'
+    [
+        {
+            "$search": {
+                "embeddedDocument": {
+                    "path": "items",
+                    "operator": {
+                        "compound": {
+                            "must": [
+                                {
+                                    "range": {
+                                        "path": "items.quantity",
+                                        "gt": {
+                                            "$numberInt": "2"
+                                        }
+                                    }
+                                },
+                                {
+                                    "exists": {
+                                        "path": "items.price"
+                                    }
+                                },
+                                {
+                                    "text": {
+                                        "path": "items.tags",
+                                        "query": "school"
+                                    }
+                                }
+                            ]
+                        }
+                    }
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "2"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "storeLocation": {
+                    "$numberInt": "1"
+                },
+                "items": {
+                    "$filter": {
+                        "input": "$items",
+                        "cond": {
+                            "$and": [
+                                {
+                                    "$ifNull": [
+                                        "$$this.price",
+                                        "false"
+                                    ]
+                                },
+                                {
+                                    "$gt": [
+                                        "$$this.quantity",
+                                        {
+                                            "$numberInt": "2"
+                                        }
+                                    ]
+                                },
+                                {
+                                    "$in": [
+                                        "office",
+                                        "$$this.tags"
+                                    ]
+                                }
+                            ]
+                        }
+                    }
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Boolean
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/equals/#boolean-examples
+     */
+    case EqualsBoolean = <<<'JSON'
+    [
+        {
+            "$search": {
+                "equals": {
+                    "path": "verified_user",
+                    "value": true
+                }
+            }
+        },
+        {
+            "$project": {
+                "name": {
+                    "$numberInt": "1"
+                },
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "score": {
+                    "$meta": "searchScore"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * ObjectId
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/equals/#objectid-example
+     */
+    case EqualsObjectId = <<<'JSON'
+    [
+        {
+            "$search": {
+                "equals": {
+                    "path": "teammates",
+                    "value": {
+                        "$oid": "5a9427648b0beebeb69589a1"
+                    }
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Date
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/equals/#date-example
+     */
+    case EqualsDate = <<<'JSON'
+    [
+        {
+            "$search": {
+                "equals": {
+                    "path": "account_created",
+                    "value": {
+                        "$date": {
+                            "$numberLong": "1651640468000"
+                        }
+                    }
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Number
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/equals/#number-example
+     */
+    case EqualsNumber = <<<'JSON'
+    [
+        {
+            "$search": {
+                "equals": {
+                    "path": "employee_number",
+                    "value": {
+                        "$numberInt": "259"
+                    }
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * String
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/equals/#string-example
+     */
+    case EqualsString = <<<'JSON'
+    [
+        {
+            "$search": {
+                "equals": {
+                    "path": "name",
+                    "value": "jim hall"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * UUID
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/equals/#uuid-example
+     */
+    case EqualsUUID = <<<'JSON'
+    [
+        {
+            "$search": {
+                "equals": {
+                    "path": "uuid",
+                    "value": {
+                        "$binary": {
+                            "base64": "+sMiYLURTGmEhaK+W33ang==",
+                            "subType": "04"
+                        }
+                    }
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Null
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/equals/#null-example
+     */
+    case EqualsNull = <<<'JSON'
+    [
+        {
+            "$search": {
+                "equals": {
+                    "path": "job_title",
+                    "value": null
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Basic
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/exists/#basic-example
+     */
+    case ExistsBasic = <<<'JSON'
+    [
+        {
+            "$search": {
+                "exists": {
+                    "path": "type"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Embedded
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/exists/#embedded-example
+     */
+    case ExistsEmbedded = <<<'JSON'
+    [
+        {
+            "$search": {
+                "exists": {
+                    "path": "quantities.lemons"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Compound
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/exists/#compound-example
+     */
+    case ExistsCompound = <<<'JSON'
+    [
+        {
+            "$search": {
+                "compound": {
+                    "must": [
+                        {
+                            "exists": {
+                                "path": "type"
+                            }
+                        },
+                        {
+                            "text": {
+                                "query": "apple",
+                                "path": "type"
+                            }
+                        }
+                    ],
+                    "should": {
+                        "text": {
+                            "query": "fuji",
+                            "path": "description"
+                        }
+                    }
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Facet
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/facet/#examples
+     */
+    case FacetFacet = <<<'JSON'
+    [
+        {
+            "$search": {
+                "facet": {
+                    "operator": {
+                        "near": {
+                            "path": "released",
+                            "origin": {
+                                "$date": {
+                                    "$numberLong": "930787200000"
+                                }
+                            },
+                            "pivot": {
+                                "$numberLong": "7776000000"
+                            }
+                        }
+                    },
+                    "facets": {
+                        "genresFacet": {
+                            "type": "string",
+                            "path": "genres"
+                        }
+                    }
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "2"
+            }
+        },
+        {
+            "$facet": {
+                "docs": [
+                    {
+                        "$project": {
+                            "title": {
+                                "$numberInt": "1"
+                            },
+                            "released": {
+                                "$numberInt": "1"
+                            }
+                        }
+                    }
+                ],
+                "meta": [
+                    {
+                        "$replaceWith": "$$SEARCH_META"
+                    },
+                    {
+                        "$limit": {
+                            "$numberInt": "1"
+                        }
+                    }
+                ]
+            }
+        },
+        {
+            "$set": {
+                "meta": {
+                    "$arrayElemAt": [
+                        "$meta",
+                        {
+                            "$numberInt": "0"
+                        }
+                    ]
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Disjoint
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/geoShape/#disjoint-example
+     */
+    case GeoShapeDisjoint = <<<'JSON'
+    [
+        {
+            "$search": {
+                "geoShape": {
+                    "relation": "disjoint",
+                    "geometry": {
+                        "type": "Polygon",
+                        "coordinates": [
+                            [
+                                [
+                                    {
+                                        "$numberDouble": "-161.32324199999999337"
+                                    },
+                                    {
+                                        "$numberDouble": "22.51255700000000104"
+                                    }
+                                ],
+                                [
+                                    {
+                                        "$numberDouble": "-152.44628900000000726"
+                                    },
+                                    {
+                                        "$numberDouble": "22.065277999999999281"
+                                    }
+                                ],
+                                [
+                                    {
+                                        "$numberDouble": "-156.09375"
+                                    },
+                                    {
+                                        "$numberDouble": "17.811455999999999733"
+                                    }
+                                ],
+                                [
+                                    {
+                                        "$numberDouble": "-161.32324199999999337"
+                                    },
+                                    {
+                                        "$numberDouble": "22.51255700000000104"
+                                    }
+                                ]
+                            ]
+                        ]
+                    },
+                    "path": "address.location"
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "3"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "name": {
+                    "$numberInt": "1"
+                },
+                "address": {
+                    "$numberInt": "1"
+                },
+                "score": {
+                    "$meta": "searchScore"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Intersect
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/geoShape/#intersects-example
+     */
+    case GeoShapeIntersect = <<<'JSON'
+    [
+        {
+            "$search": {
+                "geoShape": {
+                    "relation": "intersects",
+                    "geometry": {
+                        "type": "MultiPolygon",
+                        "coordinates": [
+                            [
+                                [
+                                    [
+                                        {
+                                            "$numberDouble": "2.1694200000000001261"
+                                        },
+                                        {
+                                            "$numberDouble": "41.400820000000003063"
+                                        }
+                                    ],
+                                    [
+                                        {
+                                            "$numberDouble": "2.1796299999999999564"
+                                        },
+                                        {
+                                            "$numberDouble": "41.400869999999997617"
+                                        }
+                                    ],
+                                    [
+                                        {
+                                            "$numberDouble": "2.1814599999999999547"
+                                        },
+                                        {
+                                            "$numberDouble": "41.397159999999999513"
+                                        }
+                                    ],
+                                    [
+                                        {
+                                            "$numberDouble": "2.1553300000000001901"
+                                        },
+                                        {
+                                            "$numberDouble": "41.406860000000001776"
+                                        }
+                                    ],
+                                    [
+                                        {
+                                            "$numberDouble": "2.1459600000000000897"
+                                        },
+                                        {
+                                            "$numberDouble": "41.384749999999996817"
+                                        }
+                                    ],
+                                    [
+                                        {
+                                            "$numberDouble": "2.1751900000000001789"
+                                        },
+                                        {
+                                            "$numberDouble": "41.410350000000001103"
+                                        }
+                                    ],
+                                    [
+                                        {
+                                            "$numberDouble": "2.1694200000000001261"
+                                        },
+                                        {
+                                            "$numberDouble": "41.400820000000003063"
+                                        }
+                                    ]
+                                ]
+                            ],
+                            [
+                                [
+                                    [
+                                        {
+                                            "$numberDouble": "2.1636500000000000732"
+                                        },
+                                        {
+                                            "$numberDouble": "41.3941599999999994"
+                                        }
+                                    ],
+                                    [
+                                        {
+                                            "$numberDouble": "2.1696300000000001695"
+                                        },
+                                        {
+                                            "$numberDouble": "41.397260000000002833"
+                                        }
+                                    ],
+                                    [
+                                        {
+                                            "$numberDouble": "2.1539500000000000313"
+                                        },
+                                        {
+                                            "$numberDouble": "41.380049999999997112"
+                                        }
+                                    ],
+                                    [
+                                        {
+                                            "$numberDouble": "2.1793499999999998984"
+                                        },
+                                        {
+                                            "$numberDouble": "41.430379999999999541"
+                                        }
+                                    ],
+                                    [
+                                        {
+                                            "$numberDouble": "2.1636500000000000732"
+                                        },
+                                        {
+                                            "$numberDouble": "41.3941599999999994"
+                                        }
+                                    ]
+                                ]
+                            ]
+                        ]
+                    },
+                    "path": "address.location"
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "3"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "name": {
+                    "$numberInt": "1"
+                },
+                "address": {
+                    "$numberInt": "1"
+                },
+                "score": {
+                    "$meta": "searchScore"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Within
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/geoShape/#within-example
+     */
+    case GeoShapeWithin = <<<'JSON'
+    [
+        {
+            "$search": {
+                "geoShape": {
+                    "relation": "within",
+                    "geometry": {
+                        "type": "Polygon",
+                        "coordinates": [
+                            [
+                                [
+                                    {
+                                        "$numberDouble": "-74.3994140625"
+                                    },
+                                    {
+                                        "$numberDouble": "40.530501775700003009"
+                                    }
+                                ],
+                                [
+                                    {
+                                        "$numberDouble": "-74.729003906299993787"
+                                    },
+                                    {
+                                        "$numberDouble": "40.580584664100001646"
+                                    }
+                                ],
+                                [
+                                    {
+                                        "$numberDouble": "-74.772949218799993787"
+                                    },
+                                    {
+                                        "$numberDouble": "40.946713665099998991"
+                                    }
+                                ],
+                                [
+                                    {
+                                        "$numberDouble": "-74.069824218799993787"
+                                    },
+                                    {
+                                        "$numberDouble": "41.129021347500000161"
+                                    }
+                                ],
+                                [
+                                    {
+                                        "$numberDouble": "-73.65234375"
+                                    },
+                                    {
+                                        "$numberDouble": "40.996484014399996454"
+                                    }
+                                ],
+                                [
+                                    {
+                                        "$numberDouble": "-72.6416015625"
+                                    },
+                                    {
+                                        "$numberDouble": "40.946713665099998991"
+                                    }
+                                ],
+                                [
+                                    {
+                                        "$numberDouble": "-72.355957031299993787"
+                                    },
+                                    {
+                                        "$numberDouble": "40.797177415199996631"
+                                    }
+                                ],
+                                [
+                                    {
+                                        "$numberDouble": "-74.3994140625"
+                                    },
+                                    {
+                                        "$numberDouble": "40.530501775700003009"
+                                    }
+                                ]
+                            ]
+                        ]
+                    },
+                    "path": "address.location"
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "3"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "name": {
+                    "$numberInt": "1"
+                },
+                "address": {
+                    "$numberInt": "1"
+                },
+                "score": {
+                    "$meta": "searchScore"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * box
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/geoWithin/#box-example
+     */
+    case GeoWithinBox = <<<'JSON'
+    [
+        {
+            "$search": {
+                "geoWithin": {
+                    "path": "address.location",
+                    "box": {
+                        "bottomLeft": {
+                            "type": "Point",
+                            "coordinates": [
+                                {
+                                    "$numberDouble": "112.46699999999999875"
+                                },
+                                {
+                                    "$numberDouble": "-55.049999999999997158"
+                                }
+                            ]
+                        },
+                        "topRight": {
+                            "type": "Point",
+                            "coordinates": [
+                                {
+                                    "$numberInt": "168"
+                                },
+                                {
+                                    "$numberDouble": "-9.1329999999999991189"
+                                }
+                            ]
+                        }
+                    }
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "3"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "name": {
+                    "$numberInt": "1"
+                },
+                "address": {
+                    "$numberInt": "1"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * circle
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/geoWithin/#circle-example
+     */
+    case GeoWithinCircle = <<<'JSON'
+    [
+        {
+            "$search": {
+                "geoWithin": {
+                    "circle": {
+                        "center": {
+                            "type": "Point",
+                            "coordinates": [
+                                {
+                                    "$numberDouble": "-73.540000000000006253"
+                                },
+                                {
+                                    "$numberDouble": "45.539999999999999147"
+                                }
+                            ]
+                        },
+                        "radius": {
+                            "$numberInt": "1600"
+                        }
+                    },
+                    "path": "address.location"
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "3"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "name": {
+                    "$numberInt": "1"
+                },
+                "address": {
+                    "$numberInt": "1"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * geometry
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/geoWithin/#geometry-examples
+     */
+    case GeoWithinGeometry = <<<'JSON'
+    [
+        {
+            "$search": {
+                "geoWithin": {
+                    "geometry": {
+                        "type": "Polygon",
+                        "coordinates": [
+                            [
+                                [
+                                    {
+                                        "$numberDouble": "-161.32324199999999337"
+                                    },
+                                    {
+                                        "$numberDouble": "22.51255700000000104"
+                                    }
+                                ],
+                                [
+                                    {
+                                        "$numberDouble": "-152.44628900000000726"
+                                    },
+                                    {
+                                        "$numberDouble": "22.065277999999999281"
+                                    }
+                                ],
+                                [
+                                    {
+                                        "$numberDouble": "-156.09375"
+                                    },
+                                    {
+                                        "$numberDouble": "17.811455999999999733"
+                                    }
+                                ],
+                                [
+                                    {
+                                        "$numberDouble": "-161.32324199999999337"
+                                    },
+                                    {
+                                        "$numberDouble": "22.51255700000000104"
+                                    }
+                                ]
+                            ]
+                        ]
+                    },
+                    "path": "address.location"
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "3"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "name": {
+                    "$numberInt": "1"
+                },
+                "address": {
+                    "$numberInt": "1"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Single Value Field Match
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/in/#examples
+     */
+    case InSingleValueFieldMatch = <<<'JSON'
+    [
+        {
+            "$search": {
+                "in": {
+                    "path": "birthdate",
+                    "value": [
+                        {
+                            "$date": {
+                                "$numberLong": "226117231000"
+                            }
+                        },
+                        {
+                            "$date": {
+                                "$numberLong": "226022400000"
+                            }
+                        },
+                        {
+                            "$date": {
+                                "$numberLong": "231803855000"
+                            }
+                        }
+                    ]
+                }
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "name": {
+                    "$numberInt": "1"
+                },
+                "birthdate": {
+                    "$numberInt": "1"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Array Value Field Match
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/in/#examples
+     */
+    case InArrayValueFieldMatch = <<<'JSON'
+    [
+        {
+            "$search": {
+                "in": {
+                    "path": "accounts",
+                    "value": [
+                        {
+                            "$numberInt": "371138"
+                        },
+                        {
+                            "$numberInt": "371139"
+                        },
+                        {
+                            "$numberInt": "371140"
+                        }
+                    ]
+                }
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "name": {
+                    "$numberInt": "1"
+                },
+                "accounts": {
+                    "$numberInt": "1"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Compound Query Match
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/in/#examples
+     */
+    case InCompoundQueryMatch = <<<'JSON'
+    [
+        {
+            "$search": {
+                "compound": {
+                    "must": [
+                        {
+                            "in": {
+                                "path": "name",
+                                "value": [
+                                    "james sanchez",
+                                    "jennifer lawrence"
+                                ]
+                            }
+                        }
+                    ],
+                    "should": [
+                        {
+                            "in": {
+                                "path": "_id",
+                                "value": [
+                                    {
+                                        "$oid": "5ca4bbcea2dd94ee58162a72"
+                                    },
+                                    {
+                                        "$oid": "5ca4bbcea2dd94ee58162a91"
+                                    }
+                                ]
+                            }
+                        }
+                    ]
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "5"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "1"
+                },
+                "name": {
+                    "$numberInt": "1"
+                },
+                "score": {
+                    "$meta": "searchScore"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Single Document with Multiple Fields
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/morelikethis/#example-1--single-document-with-multiple-fields
+     */
+    case MoreLikeThisSingleDocumentWithMultipleFields = <<<'JSON'
+    [
+        {
+            "$search": {
+                "moreLikeThis": {
+                    "like": {
+                        "title": "The Godfather",
+                        "genres": "action"
+                    }
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "5"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "title": {
+                    "$numberInt": "1"
+                },
+                "released": {
+                    "$numberInt": "1"
+                },
+                "genres": {
+                    "$numberInt": "1"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Input Document Excluded in Results
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/morelikethis/#example-2--input-document-excluded-in-results
+     */
+    case MoreLikeThisInputDocumentExcludedInResults = <<<'JSON'
+    [
+        {
+            "$search": {
+                "compound": {
+                    "must": [
+                        {
+                            "moreLikeThis": {
+                                "like": {
+                                    "_id": {
+                                        "$oid": "573a1396f29313caabce4a9a"
+                                    },
+                                    "genres": [
+                                        "Crime",
+                                        "Drama"
+                                    ],
+                                    "title": "The Godfather"
+                                }
+                            }
+                        }
+                    ],
+                    "mustNot": [
+                        {
+                            "equals": {
+                                "path": "_id",
+                                "value": {
+                                    "$oid": "573a1396f29313caabce4a9a"
+                                }
+                            }
+                        }
+                    ]
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "5"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "1"
+                },
+                "title": {
+                    "$numberInt": "1"
+                },
+                "released": {
+                    "$numberInt": "1"
+                },
+                "genres": {
+                    "$numberInt": "1"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Multiple Analyzers
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/morelikethis/#example-3--multiple-analyzers
+     */
+    case MoreLikeThisMultipleAnalyzers = <<<'JSON'
+    [
+        {
+            "$search": {
+                "compound": {
+                    "should": [
+                        {
+                            "moreLikeThis": {
+                                "like": {
+                                    "_id": {
+                                        "$oid": "573a1396f29313caabce4a9a"
+                                    },
+                                    "genres": [
+                                        "Crime",
+                                        "Drama"
+                                    ],
+                                    "title": "The Godfather"
+                                }
+                            }
+                        }
+                    ],
+                    "mustNot": [
+                        {
+                            "equals": {
+                                "path": "_id",
+                                "value": {
+                                    "$oid": "573a1394f29313caabcde9ef"
+                                }
+                            }
+                        }
+                    ]
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "10"
+            }
+        },
+        {
+            "$project": {
+                "title": {
+                    "$numberInt": "1"
+                },
+                "genres": {
+                    "$numberInt": "1"
+                },
+                "_id": {
+                    "$numberInt": "1"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Number
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/near/#number-example
+     */
+    case NearNumber = <<<'JSON'
+    [
+        {
+            "$search": {
+                "index": "runtimes",
+                "near": {
+                    "path": "runtime",
+                    "origin": {
+                        "$numberInt": "279"
+                    },
+                    "pivot": {
+                        "$numberInt": "2"
+                    }
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "7"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "title": {
+                    "$numberInt": "1"
+                },
+                "runtime": {
+                    "$numberInt": "1"
+                },
+                "score": {
+                    "$meta": "searchScore"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Date
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/near/#date-example
+     */
+    case NearDate = <<<'JSON'
+    [
+        {
+            "$search": {
+                "index": "releaseddate",
+                "near": {
+                    "path": "released",
+                    "origin": {
+                        "$date": {
+                            "$numberLong": "-1713657600000"
+                        }
+                    },
+                    "pivot": {
+                        "$numberLong": "7776000000"
+                    }
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "3"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "title": {
+                    "$numberInt": "1"
+                },
+                "released": {
+                    "$numberInt": "1"
+                },
+                "score": {
+                    "$meta": "searchScore"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * GeoJSON Point
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/near/#geojson-point-examples
+     */
+    case NearGeoJSONPoint = <<<'JSON'
+    [
+        {
+            "$search": {
+                "near": {
+                    "origin": {
+                        "type": "Point",
+                        "coordinates": [
+                            {
+                                "$numberDouble": "-8.6130800000000000693"
+                            },
+                            {
+                                "$numberDouble": "41.141300000000001091"
+                            }
+                        ]
+                    },
+                    "pivot": {
+                        "$numberInt": "1000"
+                    },
+                    "path": "address.location"
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "3"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "name": {
+                    "$numberInt": "1"
+                },
+                "address": {
+                    "$numberInt": "1"
+                },
+                "score": {
+                    "$meta": "searchScore"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Compound
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/near/#compound-example
+     */
+    case NearCompound = <<<'JSON'
+    [
+        {
+            "$search": {
+                "compound": {
+                    "must": {
+                        "text": {
+                            "query": "Apartment",
+                            "path": "property_type"
+                        }
+                    },
+                    "should": {
+                        "near": {
+                            "origin": {
+                                "type": "Point",
+                                "coordinates": [
+                                    {
+                                        "$numberDouble": "114.15027000000000612"
+                                    },
+                                    {
+                                        "$numberDouble": "22.281580000000001718"
+                                    }
+                                ]
+                            },
+                            "pivot": {
+                                "$numberInt": "1000"
+                            },
+                            "path": "address.location"
+                        }
+                    }
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "3"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "property_type": {
+                    "$numberInt": "1"
+                },
+                "address": {
+                    "$numberInt": "1"
+                },
+                "score": {
+                    "$meta": "searchScore"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Single Phrase
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/phrase/#single-phrase-example
+     */
+    case PhraseSinglePhrase = <<<'JSON'
+    [
+        {
+            "$search": {
+                "phrase": {
+                    "path": "title",
+                    "query": "new york"
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "10"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "title": {
+                    "$numberInt": "1"
+                },
+                "score": {
+                    "$meta": "searchScore"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Multiple Phrase
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/phrase/#multiple-phrases-example
+     */
+    case PhraseMultiplePhrase = <<<'JSON'
+    [
+        {
+            "$search": {
+                "phrase": {
+                    "path": "title",
+                    "query": [
+                        "the man",
+                        "the moon"
+                    ]
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "10"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "title": {
+                    "$numberInt": "1"
+                },
+                "score": {
+                    "$meta": "searchScore"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Phrase Slop
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/phrase/#slop-example
+     */
+    case PhrasePhraseSlop = <<<'JSON'
+    [
+        {
+            "$search": {
+                "phrase": {
+                    "path": "title",
+                    "query": "men women",
+                    "slop": {
+                        "$numberInt": "5"
+                    }
+                }
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "title": {
+                    "$numberInt": "1"
+                },
+                "score": {
+                    "$meta": "searchScore"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Phrase Synonyms
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/phrase/#synonyms-example
+     */
+    case PhrasePhraseSynonyms = <<<'JSON'
+    [
+        {
+            "$search": {
+                "phrase": {
+                    "path": "plot",
+                    "query": "automobile race",
+                    "slop": {
+                        "$numberInt": "5"
+                    },
+                    "synonyms": "my_synonyms"
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "5"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "plot": {
+                    "$numberInt": "1"
+                },
+                "title": {
+                    "$numberInt": "1"
+                },
+                "score": {
+                    "$meta": "searchScore"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Boolean Operator Queries
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/queryString/#boolean-operator-queries
+     */
+    case QueryStringBooleanOperatorQueries = <<<'JSON'
+    [
+        {
+            "$search": {
+                "queryString": {
+                    "defaultPath": "title",
+                    "query": "Rocky AND (IV OR 4 OR Four)"
+                }
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "title": {
+                    "$numberInt": "1"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Number gte lte
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/range/#number-example
+     */
+    case RangeNumberGteLte = <<<'JSON'
+    [
+        {
+            "$search": {
+                "range": {
+                    "path": "runtime",
+                    "gte": {
+                        "$numberInt": "2"
+                    },
+                    "lte": {
+                        "$numberInt": "3"
+                    }
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "5"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "title": {
+                    "$numberInt": "1"
+                },
+                "runtime": {
+                    "$numberInt": "1"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Number lte
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/range/#number-example
+     */
+    case RangeNumberLte = <<<'JSON'
+    [
+        {
+            "$search": {
+                "range": {
+                    "path": "runtime",
+                    "lte": {
+                        "$numberInt": "2"
+                    }
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "5"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "title": {
+                    "$numberInt": "1"
+                },
+                "runtime": {
+                    "$numberInt": "1"
+                },
+                "score": {
+                    "$meta": "searchScore"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Date
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/range/#date-example
+     */
+    case RangeDate = <<<'JSON'
+    [
+        {
+            "$search": {
+                "range": {
+                    "path": "released",
+                    "gt": {
+                        "$date": {
+                            "$numberLong": "1262304000000"
+                        }
+                    },
+                    "lt": {
+                        "$date": {
+                            "$numberLong": "1420070400000"
+                        }
+                    }
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "5"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "title": {
+                    "$numberInt": "1"
+                },
+                "released": {
+                    "$numberInt": "1"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * ObjectId
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/range/#objectid-example
+     */
+    case RangeObjectId = <<<'JSON'
+    [
+        {
+            "$search": {
+                "range": {
+                    "path": "_id",
+                    "gte": {
+                        "$oid": "573a1396f29313caabce4a9a"
+                    },
+                    "lte": {
+                        "$oid": "573a1396f29313caabce4ae7"
+                    }
+                }
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "1"
+                },
+                "title": {
+                    "$numberInt": "1"
+                },
+                "released": {
+                    "$numberInt": "1"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * String
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/range/#string-example
+     */
+    case RangeString = <<<'JSON'
+    [
+        {
+            "$search": {
+                "range": {
+                    "path": "title",
+                    "gt": "city",
+                    "lt": "country"
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "5"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "title": {
+                    "$numberInt": "1"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Regex
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/regex/#examples
+     */
+    case RegexRegex = <<<'JSON'
+    [
+        {
+            "$search": {
+                "regex": {
+                    "path": "title",
+                    "query": "[0-9]{2} (.){4}s"
+                }
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "title": {
+                    "$numberInt": "1"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Basic
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/text/#basic-example
+     */
+    case TextBasic = <<<'JSON'
+    [
+        {
+            "$search": {
+                "text": {
+                    "path": "title",
+                    "query": "surfer"
+                }
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "title": {
+                    "$numberInt": "1"
+                },
+                "score": {
+                    "$meta": "searchScore"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Fuzzy Default
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/text/#fuzzy-examples
+     */
+    case TextFuzzyDefault = <<<'JSON'
+    [
+        {
+            "$search": {
+                "text": {
+                    "path": "title",
+                    "query": "naw yark",
+                    "fuzzy": {}
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "10"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "title": {
+                    "$numberInt": "1"
+                },
+                "score": {
+                    "$meta": "searchScore"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Fuzzy maxExpansions
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/text/#fuzzy-examples
+     */
+    case TextFuzzyMaxExpansions = <<<'JSON'
+    [
+        {
+            "$search": {
+                "text": {
+                    "path": "title",
+                    "query": "naw yark",
+                    "fuzzy": {
+                        "maxEdits": {
+                            "$numberInt": "1"
+                        },
+                        "maxExpansions": {
+                            "$numberInt": "100"
+                        }
+                    }
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "10"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "title": {
+                    "$numberInt": "1"
+                },
+                "score": {
+                    "$meta": "searchScore"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Fuzzy prefixLength
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/text/#fuzzy-examples
+     */
+    case TextFuzzyPrefixLength = <<<'JSON'
+    [
+        {
+            "$search": {
+                "text": {
+                    "path": "title",
+                    "query": "naw yark",
+                    "fuzzy": {
+                        "maxEdits": {
+                            "$numberInt": "1"
+                        },
+                        "prefixLength": {
+                            "$numberInt": "2"
+                        }
+                    }
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "8"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "1"
+                },
+                "title": {
+                    "$numberInt": "1"
+                },
+                "score": {
+                    "$meta": "searchScore"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Match any Using equivalent Mapping
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/text/#match-any-using-equivalent-mapping
+     */
+    case TextMatchAnyUsingEquivalentMapping = <<<'JSON'
+    [
+        {
+            "$search": {
+                "text": {
+                    "path": "plot",
+                    "query": "attire",
+                    "synonyms": "my_synonyms",
+                    "matchCriteria": "any"
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "5"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "plot": {
+                    "$numberInt": "1"
+                },
+                "title": {
+                    "$numberInt": "1"
+                },
+                "score": {
+                    "$meta": "searchScore"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Match any Using explicit Mapping
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/text/#match-any-using-explicit-mapping
+     */
+    case TextMatchAnyUsingExplicitMapping = <<<'JSON'
+    [
+        {
+            "$search": {
+                "text": {
+                    "path": "plot",
+                    "query": "boat race",
+                    "synonyms": "my_synonyms",
+                    "matchCriteria": "any"
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "10"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "plot": {
+                    "$numberInt": "1"
+                },
+                "title": {
+                    "$numberInt": "1"
+                },
+                "score": {
+                    "$meta": "searchScore"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Match all Using Synonyms
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/text/#match-all-using-synonyms
+     */
+    case TextMatchAllUsingSynonyms = <<<'JSON'
+    [
+        {
+            "$search": {
+                "text": {
+                    "path": "plot",
+                    "query": "automobile race",
+                    "matchCriteria": "all",
+                    "synonyms": "my_synonyms"
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "20"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "plot": {
+                    "$numberInt": "1"
+                },
+                "title": {
+                    "$numberInt": "1"
+                },
+                "score": {
+                    "$meta": "searchScore"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Wildcard Path
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/text/
+     */
+    case TextWildcardPath = <<<'JSON'
+    [
+        {
+            "$search": {
+                "text": {
+                    "path": {
+                        "wildcard": "*"
+                    },
+                    "query": "surfer"
+                }
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "title": {
+                    "$numberInt": "1"
+                },
+                "score": {
+                    "$meta": "searchScore"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Wildcard Path
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/wildcard/#index-definition
+     */
+    case WildcardWildcardPath = <<<'JSON'
+    [
+        {
+            "$search": {
+                "wildcard": {
+                    "query": "Wom?n *",
+                    "path": {
+                        "wildcard": "*"
+                    }
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "5"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "title": {
+                    "$numberInt": "1"
+                }
+            }
+        }
+    ]
+    JSON;
+
+    /**
+     * Escape Character Example
+     *
+     * @see https://www.mongodb.com/docs/atlas/atlas-search/wildcard/#escape-character-example
+     */
+    case WildcardEscapeCharacterExample = <<<'JSON'
+    [
+        {
+            "$search": {
+                "wildcard": {
+                    "query": "*\\?",
+                    "path": "title"
+                }
+            }
+        },
+        {
+            "$limit": {
+                "$numberInt": "5"
+            }
+        },
+        {
+            "$project": {
+                "_id": {
+                    "$numberInt": "0"
+                },
+                "title": {
+                    "$numberInt": "1"
+                }
+            }
+        }
+    ]
+    JSON;
+}