@atscript/db-mongo 0.1.101 → 0.1.103

package/dist/agg.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_mongo_filter = require("./mongo-filter-AihWWQXp.cjs");
+const require_mongo_filter = require("./mongo-filter-1EpqdD-T.cjs");
 let _atscript_db_agg = require("@atscript/db/agg");
 //#region src/agg.ts
 /** Simple accumulators that map directly to `{ $<fn>: '$field' }`. */

package/dist/agg.mjs

@@ -1,4 +1,4 @@
-import { t as buildMongoFilter } from "./mongo-filter-BsocUQG3.mjs";
+import { t as buildMongoFilter } from "./mongo-filter-DBYaF9aH.mjs";
 import { resolveAlias } from "@atscript/db/agg";
 //#region src/agg.ts
 /** Simple accumulators that map directly to `{ $<fn>: '$field' }`. */

package/dist/index-Bl_O47fp.d.cts

@@ -0,0 +1,6 @@
+import { TAtscriptPlugin } from "@atscript/core";
+
+//#region src/plugin/index.d.ts
+declare const MongoPlugin: () => TAtscriptPlugin;
+//#endregion
+export { MongoPlugin as t };

package/dist/index-Bl_O47fp.d.mts

@@ -0,0 +1,6 @@
+import { TAtscriptPlugin } from "@atscript/core";
+
+//#region src/plugin/index.d.ts
+declare const MongoPlugin: () => TAtscriptPlugin;
+//#endregion
+export { MongoPlugin as t };

package/dist/index.cjs

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_mongo_filter = require("./mongo-filter-AihWWQXp.cjs");
+const require_mongo_filter = require("./mongo-filter-1EpqdD-T.cjs");
+const require_plugin = require("./plugin-Bq6hZMBA.cjs");
 let _atscript_db = require("@atscript/db");
 let mongodb = require("mongodb");
 //#region src/lib/projection-dedupe.ts
@@ -72,6 +73,9 @@ function containsAggregationExpr(v) {
 * `$set` map.
 */
 var CollectionPatcher = class {
+	collection;
+	payload;
+	ops;
 	constructor(collection, payload, ops) {
 		this.collection = collection;
 		this.payload = payload;
@@ -630,13 +634,13 @@ function isVectorSearchableImpl(host) {
 }
 /** Text search via $search aggregation stage. */
 async function searchImpl(host, text, query, indexName) {
-	const plan = buildSearchStage(host, text, indexName);
+	const plan = buildSearchStage(host, text, indexName, query.controls);
 	if (!plan) throw new Error(indexName ? `Search index "${indexName}" not found` : "No search index available");
 	return runSearchPipeline(host, plan.stage, query, "search", void 0, plan.classicText);
 }
 /** Text search with faceted count. */
 async function searchWithCountImpl(host, text, query, indexName) {
-	const plan = buildSearchStage(host, text, indexName);
+	const plan = buildSearchStage(host, text, indexName, query.controls);
 	if (!plan) throw new Error(indexName ? `Search index "${indexName}" not found` : "No search index available");
 	return runSearchWithCountPipeline(host, plan.stage, query, "searchWithCount", void 0, plan.classicText);
 }
@@ -672,7 +676,7 @@ function resolveThreshold(host, controls, indexName) {
 * MongoDB the stage is unsupported entirely — even though the table reports
 * `searchable: true`. The discriminator is the resolved index's `type`.
 */
-function buildSearchStage(host, text, indexName) {
+function buildSearchStage(host, text, indexName, controls) {
 	const index = host.getMongoSearchIndex(indexName);
 	if (!index) return;
 	if (index.type === "vector") throw new Error("Vector indexes cannot be used with text search. Use vectorSearch() instead.");
@@ -680,17 +684,58 @@ function buildSearchStage(host, text, indexName) {
 		stage: { $match: { $text: { $search: text } } },
 		classicText: true
 	};
+	const searchIndex = index;
+	const fuzzy = resolveSearchFuzzy(searchIndex, controls);
+	const strategy = searchIndex.strategy ?? "compound";
+	const autocompletePaths = autocompleteFieldPaths(searchIndex);
+	const textClause = () => ({ text: {
+		query: text,
+		path: { wildcard: "*" },
+		...fuzzy ? { fuzzy } : {}
+	} });
+	const autocompleteClause = (path) => ({ autocomplete: {
+		query: text,
+		path,
+		...fuzzy ? { fuzzy } : {}
+	} });
+	let body;
+	if (strategy === "text" || autocompletePaths.length === 0) body = textClause();
+	else if (strategy === "autocomplete") {
+		const clauses = autocompletePaths.map(autocompleteClause);
+		body = clauses.length === 1 ? clauses[0] : { compound: {
+			should: clauses,
+			minimumShouldMatch: 1
+		} };
+	} else body = { compound: {
+		should: [textClause(), ...autocompletePaths.map(autocompleteClause)],
+		minimumShouldMatch: 1
+	} };
 	return {
 		stage: { $search: {
 			index: index.key,
-			text: {
-				query: text,
-				path: { wildcard: "*" }
-			}
+			...body
 		} },
 		classicText: false
 	};
 }
+/**
+* Resolves query-time fuzzy (typo tolerance): the `$fuzzy` request control
+* overrides the schema-declared `@db.mongo.search.*` fuzzy. Only an edit distance
+* of 1 or 2 is emitted (Atlas rejects 0) — anything else means "no fuzzy".
+*/
+function resolveSearchFuzzy(index, controls) {
+	const override = controls?.$fuzzy;
+	const maxEdits = override === void 0 ? index.fuzzy?.maxEdits : Number(override);
+	return maxEdits === 1 || maxEdits === 2 ? { maxEdits } : void 0;
+}
+/** Field paths in this index that carry an `autocomplete` mapping. */
+function autocompleteFieldPaths(index) {
+	const fields = index.definition.mappings?.fields;
+	if (!fields) return [];
+	const paths = [];
+	for (const [path, mapping] of Object.entries(fields)) if ((Array.isArray(mapping) ? mapping : [mapping]).some((m) => m.type === "autocomplete")) paths.push(path);
+	return paths;
+}
 /** Builds a $vectorSearch aggregation stage from a pre-computed vector. */
 function buildVectorSearchStage(host, vector, indexName, limit) {
 	let index;
@@ -1289,10 +1334,26 @@ function fieldsMatch(left, right) {
 	if (leftKeys.length !== rightKeys.length) return false;
 	for (const key of leftKeys) {
 		if (!(key in right)) return false;
-		if (left[key].type !== right[key].type || left[key].analyzer !== right[key].analyzer) return false;
+		if (!fieldMappingEqual(left[key], right[key])) return false;
 	}
 	return true;
 }
+/** Order-independent structural compare of a field's Atlas type mapping(s). */
+function fieldMappingEqual(a, b) {
+	const am = mappingsByType(a);
+	const bm = mappingsByType(b);
+	if (am.size !== bm.size) return false;
+	for (const [type, av] of am) {
+		const bv = bm.get(type);
+		if (!bv || av.analyzer !== bv.analyzer || av.tokenization !== bv.tokenization || av.minGrams !== bv.minGrams || av.maxGrams !== bv.maxGrams || av.foldDiacritics !== bv.foldDiacritics) return false;
+	}
+	return true;
+}
+function mappingsByType(m) {
+	const map = /* @__PURE__ */ new Map();
+	for (const x of Array.isArray(m) ? m : [m]) map.set(x.type, x);
+	return map;
+}
 function vectorFieldsMatch(left, right) {
 	if (left.length !== (right || []).length) return false;
 	const rightMap = /* @__PURE__ */ new Map();
@@ -1318,6 +1379,8 @@ const validateMongoIdPlugin = (ctx, def, value) => {
 //#endregion
 //#region src/lib/mongo-adapter.ts
 var MongoAdapter = class MongoAdapter extends _atscript_db.BaseDbAdapter {
+	db;
+	client;
 	_collection;
 	/** MongoDB-specific indexes (search, vector) — separate from table.indexes. */
 	_mongoIndexes = /* @__PURE__ */ new Map();
@@ -1508,13 +1571,14 @@ var MongoAdapter = class MongoAdapter extends _atscript_db.BaseDbAdapter {
 		const dynamicText = typeMeta.get("db.mongo.search.dynamic");
 		if (dynamicText) this._setSearchIndex("dynamic_text", "_", {
 			mappings: { dynamic: true },
-			analyzer: dynamicText.analyzer,
-			text: { fuzzy: { maxEdits: dynamicText.fuzzy || 0 } }
-		});
+			analyzer: dynamicText.analyzer
+		}, { fuzzy: normalizeSearchFuzzy(dynamicText.fuzzy) });
 		for (const textSearch of typeMeta.get("db.mongo.search.static") || []) this._setSearchIndex("search_text", textSearch.indexName, {
 			mappings: { fields: {} },
-			analyzer: textSearch.analyzer,
-			text: { fuzzy: { maxEdits: textSearch.fuzzy || 0 } }
+			analyzer: textSearch.analyzer
+		}, {
+			fuzzy: normalizeSearchFuzzy(textSearch.fuzzy),
+			strategy: normalizeSearchStrategy(textSearch.strategy)
 		});
 	}
 	onFieldScanned(field, _type, metadata) {
@@ -1528,7 +1592,24 @@ var MongoAdapter = class MongoAdapter extends _atscript_db.BaseDbAdapter {
 			const startValue = metadata.get("db.default.increment");
 			this._incrementFields.set(physicalName, typeof startValue === "number" ? startValue : void 0);
 		}
-		for (const index of metadata.get("db.mongo.search.text") || []) this._addFieldToSearchIndex("search_text", index.indexName, field, index.analyzer);
+		for (const index of metadata.get("db.mongo.search.text") || []) this._addFieldToSearchIndex("search_text", index.indexName, field, [index.analyzer ? {
+			type: "string",
+			analyzer: index.analyzer
+		} : { type: "string" }]);
+		for (const ac of metadata.get("db.mongo.search.autocomplete") || []) {
+			const autocomplete = {
+				type: "autocomplete",
+				tokenization: ac.tokenization || "edgeGram",
+				minGrams: ac.minGrams ?? 2,
+				maxGrams: ac.maxGrams ?? 15,
+				foldDiacritics: ac.foldDiacritics ?? true
+			};
+			const companion = ac.analyzer ? {
+				type: "string",
+				analyzer: ac.analyzer
+			} : { type: "string" };
+			this._addFieldToSearchIndex("search_text", ac.indexName, field, [autocomplete, companion]);
+		}
 		const vectorIndex = metadata.get("db.search.vector");
 		if (vectorIndex) {
 			const indexName = vectorIndex.indexName || field;
@@ -1989,32 +2070,68 @@ var MongoAdapter = class MongoAdapter extends _atscript_db.BaseDbAdapter {
 		}
 		if (weight) index.weights[field] = weight;
 	}
-	_setSearchIndex(type, name, definition) {
+	_setSearchIndex(type, name, definition, meta) {
 		const key = mongoIndexKey(type, name || "DEFAULT");
-		this._mongoIndexes.set(key, {
+		const index = {
 			key,
 			name: name || "DEFAULT",
 			type,
-			definition
-		});
+			definition,
+			fuzzy: meta?.fuzzy,
+			strategy: meta?.strategy
+		};
+		this._mongoIndexes.set(key, index);
+		return index;
 	}
-	_addFieldToSearchIndex(type, _name, fieldName, analyzer) {
+	/**
+	* Adds (and merges, by mapping `type`) one or more Atlas field-type mappings to
+	* a `search_text` index. Multiple annotations on the same field — e.g.
+	* `@db.mongo.search.text` (string) plus `@db.mongo.search.autocomplete`
+	* (autocomplete + string) — accumulate into a single multi-type mapping
+	* instead of overwriting one another.
+	*/
+	_addFieldToSearchIndex(type, _name, fieldName, mappings) {
 		const name = _name || "DEFAULT";
 		let index = this._mongoIndexes.get(mongoIndexKey(type, name));
-		if (!index && type === "search_text") {
-			this._setSearchIndex(type, name, {
-				mappings: { fields: {} },
-				text: { fuzzy: { maxEdits: 0 } }
-			});
-			index = this._mongoIndexes.get(mongoIndexKey(type, name));
-		}
+		if (!index && type === "search_text") index = this._setSearchIndex(type, name, { mappings: { fields: {} } });
 		if (index) {
-			index.definition.mappings.fields[fieldName] = { type: "string" };
-			if (analyzer) index.definition.mappings.fields[fieldName].analyzer = analyzer;
+			const fields = index.definition.mappings.fields;
+			fields[fieldName] = mergeFieldMappings(fields[fieldName], mappings);
 		}
 	}
 };
 /**
+* Normalizes a declared `fuzzy` arg (`0-2`) into the query-time metadata Atlas
+* accepts. Atlas only honors an edit distance of `1` or `2`; `0`/undefined means
+* "no fuzzy", returned as `undefined` so no `fuzzy` clause is ever emitted.
+*/
+function normalizeSearchFuzzy(fuzzy) {
+	return fuzzy === 1 || fuzzy === 2 ? { maxEdits: fuzzy } : void 0;
+}
+/** Narrows the declared `strategy` arg to a known value (undefined → query layer defaults to "compound"). */
+function normalizeSearchStrategy(strategy) {
+	return strategy === "compound" || strategy === "autocomplete" || strategy === "text" ? strategy : void 0;
+}
+/**
+* Merges incoming Atlas field-type mappings into a field's existing mapping,
+* keyed by `type` (a later mapping of the same type replaces the earlier one).
+* Collapses to a single object when one type remains, else an array (Atlas's
+* multi-type field form).
+*/
+function mergeFieldMappings(existing, incoming) {
+	const byType = /* @__PURE__ */ new Map();
+	const order = [];
+	const add = (m) => {
+		if (!byType.has(m.type)) order.push(m.type);
+		byType.set(m.type, m);
+	};
+	if (Array.isArray(existing)) existing.forEach(add);
+	else if (existing) add(existing);
+	incoming.forEach(add);
+	const merged = order.map((t) => byType.get(t));
+	return merged.length === 1 ? merged[0] : merged;
+}
+/**
 * Builds a MongoDB update document from a data object that may contain
 * field ops (`{ $inc: N }`, `{ $dec: N }`, `{ $mul: N }`).
 * Regular fields go into `$set`, ops go into `$inc` / `$mul`. When
@@ -2047,6 +2164,7 @@ function createAdapter(connection, _options) {
 //#endregion
 exports.CollectionPatcher = CollectionPatcher;
 exports.MongoAdapter = MongoAdapter;
+exports.MongoPlugin = require_plugin.MongoPlugin;
 exports.buildMongoFilter = require_mongo_filter.buildMongoFilter;
 exports.createAdapter = createAdapter;
 exports.validateMongoIdPlugin = validateMongoIdPlugin;

package/dist/index.d.cts

@@ -1,3 +1,4 @@
+import { t as MongoPlugin } from "./index-Bl_O47fp.cjs";
 import { BaseDbAdapter, DbQuery, DbSpace, FilterExpr, TColumnDiff, TDbDeleteResult, TDbFieldMeta, TDbForeignKey, TDbInsertManyResult, TDbInsertResult, TDbRelation, TDbUpdateResult, TExistingTableOption, TFieldOps, TMetadataOverrides, TSearchIndexInfo, TSyncColumnResult, TTableResolver, TableMetadata, WithRelation, getKeyProps } from "@atscript/db";
 import { AggregationCursor, ClientSession, Collection, Db, Document, Filter, MongoClient, ObjectId, UpdateFilter, UpdateOptions } from "mongodb";
 import { TAtscriptAnnotatedType, TMetadataMap, TValidatorOptions, TValidatorPlugin, Validator } from "@atscript/typescript/utils";
@@ -165,16 +166,45 @@ interface TSearchIndex {
   name: string;
   type: "dynamic_text" | "search_text" | "vector";
   definition: TMongoSearchIndexDefinition;
+  /**
+   * Query-time fuzzy (typo tolerance) declared via `@db.mongo.search.dynamic` /
+   * `@db.mongo.search.static`. Carried as index metadata — NOT part of the Atlas
+   * index `definition` (Atlas applies fuzzy at query time on the `text`/
+   * `autocomplete` operator, not in the index schema). `buildSearchStage` reads
+   * this and attaches it to the emitted operator.
+   */
+  fuzzy?: {
+    maxEdits: number;
+  };
+  /**
+   * The match strategy declared via `@db.mongo.search.static`, locking this
+   * index's query shape. `buildSearchStage` reads it; undefined → `"compound"`.
+   * - `compound` — wildcard `text` + per-field `autocomplete` (exact ranks above prefix).
+   * - `autocomplete` — autocomplete fields only (pure typeahead, no word clause).
+   * - `text` — single `text` operator over all string-mapped fields.
+   */
+  strategy?: "compound" | "autocomplete" | "text";
 }
 type TMongoIndex = TPlainIndex | TSearchIndex;
 type TVectorSimilarity = "cosine" | "euclidean" | "dotProduct";
+/**
+ * One Atlas Search field-type mapping. `type: "string"` is plain word matching;
+ * `type: "autocomplete"` enables prefix/typeahead (edgeGram) or substring (nGram).
+ * A field may carry several mappings at once (an array of these) — e.g. an
+ * autocomplete field double-mapped as `string` so exact-word hits still rank.
+ */
+interface TSearchFieldMapping {
+  type: string;
+  analyzer?: string;
+  tokenization?: "edgeGram" | "rightEdgeGram" | "nGram";
+  minGrams?: number;
+  maxGrams?: number;
+  foldDiacritics?: boolean;
+}
 interface TMongoSearchIndexDefinition {
   mappings?: {
     dynamic?: boolean;
-    fields?: Record<string, {
-      type: string;
-      analyzer?: string;
-    }>;
+    fields?: Record<string, TSearchFieldMapping | TSearchFieldMapping[]>;
   };
   fields?: Array<{
     path: string;
@@ -183,11 +213,6 @@ interface TMongoSearchIndexDefinition {
     numDimensions?: number;
   }>;
   analyzer?: string;
-  text?: {
-    fuzzy?: {
-      maxEdits: number;
-    };
-  };
 }
 //#endregion
 //#region src/lib/mongo-adapter.d.ts
@@ -351,8 +376,20 @@ declare class MongoAdapter extends BaseDbAdapter {
    */
   private _getCollationOpts;
   protected _addMongoIndexField(type: TPlainIndex["type"], name: string, field: string, weight?: number): void;
-  protected _setSearchIndex(type: TSearchIndex["type"], name: string | undefined, definition: TMongoSearchIndexDefinition): void;
-  protected _addFieldToSearchIndex(type: TSearchIndex["type"], _name: string | undefined, fieldName: string, analyzer?: string): void;
+  protected _setSearchIndex(type: TSearchIndex["type"], name: string | undefined, definition: TMongoSearchIndexDefinition, meta?: {
+    fuzzy?: {
+      maxEdits: number;
+    };
+    strategy?: TSearchIndex["strategy"];
+  }): TSearchIndex;
+  /**
+   * Adds (and merges, by mapping `type`) one or more Atlas field-type mappings to
+   * a `search_text` index. Multiple annotations on the same field — e.g.
+   * `@db.mongo.search.text` (string) plus `@db.mongo.search.autocomplete`
+   * (autocomplete + string) — accumulate into a single multi-type mapping
+   * instead of overwriting one another.
+   */
+  protected _addFieldToSearchIndex(type: TSearchIndex["type"], _name: string | undefined, fieldName: string, mappings: TSearchFieldMapping[]): void;
 }
 //#endregion
 //#region src/lib/mongo-filter.d.ts
@@ -371,4 +408,4 @@ declare const validateMongoIdPlugin: TValidatorPlugin;
 //#region src/lib/index.d.ts
 declare function createAdapter(connection: string, _options?: Record<string, unknown>): DbSpace;
 //#endregion
-export { CollectionPatcher, MongoAdapter, TCollectionPatcherContext, type TMongoIndex, type TMongoSearchIndexDefinition, type TPlainIndex, type TSearchIndex, buildMongoFilter, createAdapter, validateMongoIdPlugin };
+export { CollectionPatcher, MongoAdapter, MongoPlugin, TCollectionPatcherContext, type TMongoIndex, type TMongoSearchIndexDefinition, type TPlainIndex, type TSearchIndex, buildMongoFilter, createAdapter, validateMongoIdPlugin };

package/dist/index.d.mts

@@ -1,3 +1,4 @@
+import { t as MongoPlugin } from "./index-Bl_O47fp.mjs";
 import { BaseDbAdapter, DbQuery, DbSpace, FilterExpr, TColumnDiff, TDbDeleteResult, TDbFieldMeta, TDbForeignKey, TDbInsertManyResult, TDbInsertResult, TDbRelation, TDbUpdateResult, TExistingTableOption, TFieldOps, TMetadataOverrides, TSearchIndexInfo, TSyncColumnResult, TTableResolver, TableMetadata, WithRelation, getKeyProps } from "@atscript/db";
 import { AggregationCursor, ClientSession, Collection, Db, Document, Filter, MongoClient, ObjectId, UpdateFilter, UpdateOptions } from "mongodb";
 import { TAtscriptAnnotatedType, TMetadataMap, TValidatorOptions, TValidatorPlugin, Validator } from "@atscript/typescript/utils";
@@ -165,16 +166,45 @@ interface TSearchIndex {
   name: string;
   type: "dynamic_text" | "search_text" | "vector";
   definition: TMongoSearchIndexDefinition;
+  /**
+   * Query-time fuzzy (typo tolerance) declared via `@db.mongo.search.dynamic` /
+   * `@db.mongo.search.static`. Carried as index metadata — NOT part of the Atlas
+   * index `definition` (Atlas applies fuzzy at query time on the `text`/
+   * `autocomplete` operator, not in the index schema). `buildSearchStage` reads
+   * this and attaches it to the emitted operator.
+   */
+  fuzzy?: {
+    maxEdits: number;
+  };
+  /**
+   * The match strategy declared via `@db.mongo.search.static`, locking this
+   * index's query shape. `buildSearchStage` reads it; undefined → `"compound"`.
+   * - `compound` — wildcard `text` + per-field `autocomplete` (exact ranks above prefix).
+   * - `autocomplete` — autocomplete fields only (pure typeahead, no word clause).
+   * - `text` — single `text` operator over all string-mapped fields.
+   */
+  strategy?: "compound" | "autocomplete" | "text";
 }
 type TMongoIndex = TPlainIndex | TSearchIndex;
 type TVectorSimilarity = "cosine" | "euclidean" | "dotProduct";
+/**
+ * One Atlas Search field-type mapping. `type: "string"` is plain word matching;
+ * `type: "autocomplete"` enables prefix/typeahead (edgeGram) or substring (nGram).
+ * A field may carry several mappings at once (an array of these) — e.g. an
+ * autocomplete field double-mapped as `string` so exact-word hits still rank.
+ */
+interface TSearchFieldMapping {
+  type: string;
+  analyzer?: string;
+  tokenization?: "edgeGram" | "rightEdgeGram" | "nGram";
+  minGrams?: number;
+  maxGrams?: number;
+  foldDiacritics?: boolean;
+}
 interface TMongoSearchIndexDefinition {
   mappings?: {
     dynamic?: boolean;
-    fields?: Record<string, {
-      type: string;
-      analyzer?: string;
-    }>;
+    fields?: Record<string, TSearchFieldMapping | TSearchFieldMapping[]>;
   };
   fields?: Array<{
     path: string;
@@ -183,11 +213,6 @@ interface TMongoSearchIndexDefinition {
     numDimensions?: number;
   }>;
   analyzer?: string;
-  text?: {
-    fuzzy?: {
-      maxEdits: number;
-    };
-  };
 }
 //#endregion
 //#region src/lib/mongo-adapter.d.ts
@@ -351,8 +376,20 @@ declare class MongoAdapter extends BaseDbAdapter {
    */
   private _getCollationOpts;
   protected _addMongoIndexField(type: TPlainIndex["type"], name: string, field: string, weight?: number): void;
-  protected _setSearchIndex(type: TSearchIndex["type"], name: string | undefined, definition: TMongoSearchIndexDefinition): void;
-  protected _addFieldToSearchIndex(type: TSearchIndex["type"], _name: string | undefined, fieldName: string, analyzer?: string): void;
+  protected _setSearchIndex(type: TSearchIndex["type"], name: string | undefined, definition: TMongoSearchIndexDefinition, meta?: {
+    fuzzy?: {
+      maxEdits: number;
+    };
+    strategy?: TSearchIndex["strategy"];
+  }): TSearchIndex;
+  /**
+   * Adds (and merges, by mapping `type`) one or more Atlas field-type mappings to
+   * a `search_text` index. Multiple annotations on the same field — e.g.
+   * `@db.mongo.search.text` (string) plus `@db.mongo.search.autocomplete`
+   * (autocomplete + string) — accumulate into a single multi-type mapping
+   * instead of overwriting one another.
+   */
+  protected _addFieldToSearchIndex(type: TSearchIndex["type"], _name: string | undefined, fieldName: string, mappings: TSearchFieldMapping[]): void;
 }
 //#endregion
 //#region src/lib/mongo-filter.d.ts
@@ -371,4 +408,4 @@ declare const validateMongoIdPlugin: TValidatorPlugin;
 //#region src/lib/index.d.ts
 declare function createAdapter(connection: string, _options?: Record<string, unknown>): DbSpace;
 //#endregion
-export { CollectionPatcher, MongoAdapter, TCollectionPatcherContext, type TMongoIndex, type TMongoSearchIndexDefinition, type TPlainIndex, type TSearchIndex, buildMongoFilter, createAdapter, validateMongoIdPlugin };
+export { CollectionPatcher, MongoAdapter, MongoPlugin, TCollectionPatcherContext, type TMongoIndex, type TMongoSearchIndexDefinition, type TPlainIndex, type TSearchIndex, buildMongoFilter, createAdapter, validateMongoIdPlugin };