@classytic/mongokit 3.41.0 → 3.43.0

package/dist/derive-DRBiegRH.mjs

@@ -0,0 +1,375 @@
+//#region src/search/normalize.ts
+/**
+* Search-as-you-type text rules, shared by the WRITER (the search keys stored on
+* every document) and the READER (the query typed into a search box).
+*
+* Both sides MUST run the same function, otherwise a key written as `mohammed`
+* is never found by a query normalised to `Mohammed`. That is also why this
+* module is pure (no mongoose, no driver): a portal or mobile client imports it
+* from `@classytic/mongokit/search` to highlight matches with the exact rules
+* the server indexed with.
+*
+* Rules, in order:
+*   1. lower-case (before NFKD: `'İ'.toLowerCase()` yields a combining dot the
+*      next step removes);
+*   2. Unicode NFKD, then every combining mark (`\p{M}`) dropped: `é → e`,
+*      `fi → fi`, and Arabic tashkeel (fatha, damma, kasra, shadda, sukun,
+*      tanween, superscript alef) disappear;
+*   3. Arabic folding: tatweel removed; `أ إ آ ٱ → ا` (the hamza/madda forms
+*      decompose to bare alef in step 2, wasla is folded here); `ى → ي`;
+*      `ة → ه`; Arabic-Indic and Persian digits → ASCII digits;
+*   4. format characters (`\p{Cf}`: ZWJ, ZWNJ, bidi marks) removed so a pasted
+*      name does not split or miss;
+*   5. split on anything that is not a letter or a digit (whitespace and
+*      punctuation: `al-harbi` → `al`, `harbi`; `noura.saad@x.io` → `noura`,
+*      `saad`, `x`, `io`).
+*/
+/** Characters folded after the mark strip (step 3). */
+const FOLD = {
+	ٱ: "ا",
+	ى: "ي",
+	ة: "ه"
+};
+const MARKS = /\p{M}+/gu;
+/** Tatweel (kashida) and format characters (ZWJ/ZWNJ, bidi controls). */
+const DROPPED = /[ـ\p{Cf}]+/gu;
+const FOLDED = /[ٱىة٠-٩۰-۹]/gu;
+const SEPARATORS = /[^\p{L}\p{N}]+/u;
+function foldChar(ch) {
+	const code = ch.charCodeAt(0);
+	if (code >= 1632 && code <= 1641) return String(code - 1632);
+	if (code >= 1776 && code <= 1785) return String(code - 1776);
+	return FOLD[ch] ?? ch;
+}
+/**
+* The search tokens of `text`, in order, duplicates kept. Empty for blank text
+* or text with no letters/digits.
+*
+* @example tokenizeSearchText('  Mohammed AL-Harbi ') // ['mohammed', 'al', 'harbi']
+* @example tokenizeSearchText('مُحَمَّد أحمد')        // ['محمد', 'احمد']
+*/
+function tokenizeSearchText(text) {
+	if (typeof text !== "string" || text.length === 0) return [];
+	return text.toLowerCase().normalize("NFKD").replace(MARKS, "").replace(DROPPED, "").replace(FOLDED, foldChar).split(SEPARATORS).filter((t) => t.length > 0);
+}
+/**
+* `text` normalised to its tokens joined by single spaces: the canonical form to
+* compare or display ("what the index sees").
+*
+* @example normalizeSearchText('Café  Crème') // 'cafe creme'
+*/
+function normalizeSearchText(text) {
+	return tokenizeSearchText(text).join(" ");
+}
+/** A run of the original text that can hold a token (letters, digits, and the marks/tatweel/format chars the normaliser drops). */
+const WORD = /[\p{L}\p{N}\p{M}ـ\p{Cf}]+/gu;
+/**
+* Where `query` matches `text` under the prefix-search rules: for every word of
+* `text` whose normalised form starts with one of the query's tokens, the
+* shortest leading run of the ORIGINAL characters that covers that token.
+* Offsets index the original string, so a client wraps them in `<mark>` with no
+* re-normalisation of its own.
+*
+* @example findSearchMatches('Mohammed Al-Harbi', 'moh har')
+*          // [{ start: 0, end: 3 }, { start: 12, end: 15 }]
+*/
+function findSearchMatches(text, query) {
+	const terms = [...new Set(tokenizeSearchText(query))];
+	if (terms.length === 0 || typeof text !== "string") return [];
+	const out = [];
+	for (const m of text.matchAll(WORD)) {
+		const word = m[0];
+		const start = m.index ?? 0;
+		const normalized = tokenizeSearchText(word).join("");
+		let best = 0;
+		for (const term of terms) {
+			if (!normalized.startsWith(term)) continue;
+			for (let len = 1; len <= word.length; len += 1) if (tokenizeSearchText(word.slice(0, len)).join("").length >= term.length) {
+				while (len < word.length && tokenizeSearchText(word.slice(len, len + 1)).length === 0) len += 1;
+				best = Math.max(best, len);
+				break;
+			}
+		}
+		if (best > 0) out.push({
+			start,
+			end: start + best
+		});
+	}
+	return out;
+}
+//#endregion
+//#region src/search/prefix.ts
+/**
+* Indexed search-as-you-type (`searchMode: 'prefix'`): the stored keys, the
+* query filter, and the index/schema declarations. Pure: no mongoose import.
+*
+* ## Storage choice: word tokens + anchored regex (not edge n-grams)
+*
+* Each document stores the DISTINCT normalised word tokens of its search fields
+* in one array field (`_searchKeys` by default), covered by a multikey index. A
+* query token `moh` becomes `{ _searchKeys: { $regex: '^moh' } }`: a
+* case-sensitive regex with a literal prefix, which the planner turns into the
+* index range `["moh", "moi")` (IXSCAN, keys examined ≈ matches). Several query
+* tokens AND together, one `$and` arm each; the planner bounds one arm and
+* filters the rest on the fetched documents.
+*
+* The alternative, edge n-grams (`m, mo, moh, ..., mohammed` stored, matched by
+* an exact `$all`), gives the SAME index-range query plan, only with point
+* bounds, while storing one key per prefix length instead of one per word.
+* Measured on 2,000 two-to-three-word names (mongod 8, WiredTiger; see
+* `tests/integration/prefix-search.test.ts`): tokens 6,000 keys / 60 KiB index,
+* edge n-grams (N=20) 34,140 keys / 256 KiB index, ~5.7x the keys and ~4x the
+* index bytes. N-grams also cost a write amplification on every
+* rename, and an arbitrary cut-off N past which longer prefixes stop matching.
+* Tokens keep the index small, have no length cliff, and make the backfill a
+* pure function of the source fields. So tokens are the standard here.
+*/
+/** Default name of the field that stores the search keys. */
+const DEFAULT_SEARCH_KEYS_FIELD = "_searchKeys";
+/** Query tokens beyond this many are ignored (each one is an `$and` arm). */
+const MAX_PREFIX_SEARCH_TERMS = 8;
+/** Every value at a dotted `path` of `doc`, arrays flattened (`contacts.name` over an array of contacts). */
+function valuesAtPath(doc, path) {
+	const parts = path.split(".");
+	const out = [];
+	const walk = (value, i) => {
+		if (value === void 0 || value === null) return;
+		if (Array.isArray(value)) {
+			for (const item of value) walk(item, i);
+			return;
+		}
+		if (i === parts.length) {
+			out.push(value);
+			return;
+		}
+		if (typeof value !== "object") return;
+		walk(value[parts[i]], i + 1);
+	};
+	walk(doc, 0);
+	return out;
+}
+/**
+* Distinct tokens of `values` (arrays flattened, nested arrays too; strings and
+* numbers tokenised, every other value ignored), in first-seen order.
+*/
+function collectSearchTokens(values) {
+	const keys = /* @__PURE__ */ new Set();
+	const add = (v) => {
+		if (Array.isArray(v)) {
+			for (const item of v) add(item);
+			return;
+		}
+		const text = typeof v === "string" ? v : typeof v === "number" || typeof v === "bigint" ? String(v) : void 0;
+		if (text === void 0) return;
+		for (const token of tokenizeSearchText(text)) keys.add(token);
+	};
+	for (const v of values) add(v);
+	return [...keys];
+}
+/**
+* The search keys of `doc`: the distinct normalised tokens of every value at
+* every `fields` path (strings and numbers; arrays flattened; other values
+* ignored), in first-seen order. This is exactly what the write paths store.
+*
+* @example buildSearchKeys({ name: 'Ahmed bin Ali', email: 'a.ali@x.io' }, ['name'])
+*          // ['ahmed', 'bin', 'ali']
+*/
+function buildSearchKeys(doc, fields) {
+	return collectSearchTokens(fields.map((f) => valuesAtPath(doc, f)));
+}
+const escapeRegex = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/**
+* The MongoDB filter for a prefix search: every query token must be the start of
+* some stored key (AND across words, any order). `null` when `query` has no
+* tokens (blank or punctuation only): the caller decides whether that means "no
+* search" (the repository's choice) or "match nothing".
+*
+* Uses `{ $regex: '^…' }` strings, never RegExp objects, so the filter survives
+* JSON (cache keys, logs, wire) unchanged.
+*
+* @example prefixSearchFilter('Moh Ali')
+*          // { $and: [{ _searchKeys: { $regex: '^moh' } }, { _searchKeys: { $regex: '^ali' } }] }
+*/
+function prefixSearchFilter(query, options = {}) {
+	const field = options.keysField ?? "_searchKeys";
+	const max = options.maxTerms ?? 8;
+	const terms = [...new Set(tokenizeSearchText(query))].slice(0, Math.max(1, max));
+	if (terms.length === 0) return null;
+	const arms = terms.map((t) => ({ [field]: { $regex: `^${escapeRegex(t)}` } }));
+	return arms.length === 1 ? arms[0] : { $and: arms };
+}
+/**
+* Mongoose schema path for the keys field: an array of strings, never selected
+* by default (`select: false`), absent until written (so a backfill can find
+* rows without it).
+*
+* @example schema.add({ _searchKeys: searchKeysPath() });
+*/
+function searchKeysPath() {
+	return {
+		type: [String],
+		select: false,
+		default: void 0
+	};
+}
+/**
+* Index declaration for the keys field (multikey), in the
+* `{ fields, options }` shape `schema.index(fields, options)` and the Better
+* Auth overlay's `indexes` take. Name defaults to `<field>_1`.
+*
+* @example
+* // Serves getAll({ search }) prefix search (searchMode: 'prefix').
+* const idx = searchKeysIndex();
+* schema.index(idx.fields, idx.options);
+*/
+function searchKeysIndex(field = DEFAULT_SEARCH_KEYS_FIELD, options = {}) {
+	return {
+		fields: { [field]: 1 },
+		options: { name: options.name ?? `${field}_1` }
+	};
+}
+//#endregion
+//#region src/search/derive.ts
+/**
+* How a write changes the search fields: the pure analysis behind the
+* search-keys plugin. Given one write (a document, a replacement, or an update
+* with its filter), it says which search-field values the write determines and
+* which it leaves to the stored document, so the plugin can derive the keys in
+* the SAME write (no second round-trip, no window where keys are stale).
+*/
+/** Thrown (as `status: 400` with a `code`) for a write the keys cannot follow. */
+const SEARCH_KEYS_ERROR_CODES = {
+	/** An operator or path the plugin cannot evaluate touches a search field. */
+	UNSUPPORTED_UPDATE: "SEARCH_KEYS_UNSUPPORTED_UPDATE",
+	/** A multi-document update sets SOME search fields; the rest differ per document. */
+	PARTIAL_MULTI_UPDATE: "SEARCH_KEYS_PARTIAL_MULTI_UPDATE"
+};
+var SearchKeysWriteError = class extends Error {
+	code;
+	status = 400;
+	constructor(message, code) {
+		super(message);
+		this.code = code;
+		this.name = "SearchKeysWriteError";
+	}
+};
+const isPlainObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v) && (Object.getPrototypeOf(v) === Object.prototype || Object.getPrototypeOf(v) === null);
+/** Operators whose effect on a search field the plugin evaluates. */
+const EVALUATED = /* @__PURE__ */ new Set([
+	"$set",
+	"$setOnInsert",
+	"$unset"
+]);
+/**
+* Resolve each search field against one `path → value` bag (`$set`, a plain
+* patch): an exact key, or an ANCESTOR key (`profile` for `profile.name`). A
+* DESCENDANT key (`tags.0` for `tags`) changes part of the value the plugin
+* cannot see, so it is refused.
+*/
+function resolveBag(bag, fields, op, out, unset = false) {
+	for (const key of Object.keys(bag)) for (const field of fields) if (key === field) out[field] = unset ? void 0 : bag[key];
+	else if (field.startsWith(`${key}.`)) out[field] = unset ? void 0 : valuesAtPath(bag[key], field.slice(key.length + 1));
+	else if (key.startsWith(`${field}.`)) throw new SearchKeysWriteError(`[mongokit] search keys: '${op}' on '${key}' changes part of search field '${field}'; set the whole field ('${field}') so its search keys can be derived`, SEARCH_KEYS_ERROR_CODES.UNSUPPORTED_UPDATE);
+}
+const touches = (key, fields) => fields.some((f) => key === f || f.startsWith(`${key}.`) || key.startsWith(`${f}.`));
+/** Equalities in a filter's top level (and top-level `$and` arms) on search fields. */
+function pinnedValues(filter, fields, out) {
+	if (!isPlainObject(filter)) return;
+	for (const [key, value] of Object.entries(filter)) {
+		if (key === "$and" && Array.isArray(value)) {
+			for (const arm of value) pinnedValues(arm, fields, out);
+			continue;
+		}
+		if (!fields.includes(key)) continue;
+		if (typeof value === "string" || typeof value === "number") out[key] = value;
+		else if (isPlainObject(value) && Object.keys(value).length === 1 && "$eq" in value) {
+			const eq = value.$eq;
+			if (typeof eq === "string" || typeof eq === "number") out[key] = eq;
+		}
+	}
+}
+/**
+* Analyse an update (plain patch, operator update, or pipeline) against the
+* search fields. Strips any caller-supplied value for `keysField` (the keys
+* are derived, never client-settable). Throws {@link SearchKeysWriteError} for
+* an operator other than `$set`/`$setOnInsert`/`$unset` (or a pipeline stage)
+* that touches a search field.
+*/
+function analyzeUpdate(update, filter, fields, keysField) {
+	const effect = {
+		updated: {},
+		onInsert: {},
+		pinned: {}
+	};
+	pinnedValues(filter, fields, effect.pinned);
+	if (Array.isArray(update)) {
+		for (const stage of update) {
+			if (!isPlainObject(stage)) continue;
+			for (const [name, body] of Object.entries(stage)) {
+				const keys = name === "$unset" ? [].concat(body).map(String) : isPlainObject(body) ? Object.keys(body) : [];
+				if (name === "$replaceRoot" || name === "$replaceWith" || name === "$project" || keys.some((k) => touches(k, fields))) throw new SearchKeysWriteError(`[mongokit] search keys: pipeline stage '${name}' touches a search field (${fields.join(", ")}); use an operator update (\$set / \$unset) so the keys can be derived`, SEARCH_KEYS_ERROR_CODES.UNSUPPORTED_UPDATE);
+			}
+		}
+		return effect;
+	}
+	if (!isPlainObject(update)) return effect;
+	const keys = Object.keys(update);
+	if (!keys.some((k) => k.startsWith("$"))) {
+		delete update[keysField];
+		resolveBag(update, fields, "$set", effect.updated);
+		return effect;
+	}
+	for (const op of keys) {
+		const body = update[op];
+		if (!isPlainObject(body)) continue;
+		if (op === "$set" || op === "$setOnInsert") delete body[keysField];
+		if (op === "$unset") delete body[keysField];
+		if (!EVALUATED.has(op)) {
+			const hit = Object.keys(body).find((k) => touches(k, fields));
+			if (hit) throw new SearchKeysWriteError(`[mongokit] search keys: '${op}' on '${hit}' cannot be followed by the search keys; set the whole value with $set (or call rebuildSearchKeys afterwards)`, SEARCH_KEYS_ERROR_CODES.UNSUPPORTED_UPDATE);
+			continue;
+		}
+		if (op === "$set") resolveBag(body, fields, op, effect.updated);
+		else if (op === "$unset") resolveBag(body, fields, op, effect.updated, true);
+		else resolveBag(body, fields, op, effect.onInsert);
+	}
+	return effect;
+}
+/** Fields the effect leaves unknown for the update path (neither updated nor pinned). */
+function unresolvedForUpdate(effect, fields) {
+	return fields.filter((f) => !(f in effect.updated) && !(f in effect.pinned));
+}
+/** The full value set an INSERT through this update would store. */
+function insertValues(effect) {
+	return {
+		...effect.pinned,
+		...effect.onInsert,
+		...effect.updated
+	};
+}
+/**
+* Put `keys` into an update in place: a plain patch gets the key directly
+* (mongoose wraps it in `$set`), an operator update under `$set` (or
+* `$setOnInsert` for an insert-only derivation).
+*/
+function writeKeys(update, keysField, keys, slot = "$set") {
+	if (!Object.keys(update).some((k) => k.startsWith("$"))) {
+		update[keysField] = keys;
+		return;
+	}
+	const bag = isPlainObject(update[slot]) ? update[slot] : {};
+	bag[keysField] = keys;
+	update[slot] = bag;
+}
+/** The values of `fields` read from a stored (or to-be-inserted) document. */
+function fieldValuesOf(doc, fields) {
+	const out = {};
+	for (const f of fields) out[f] = valuesAtPath(doc, f);
+	return out;
+}
+/** The keys for a resolved value set (see {@link collectSearchTokens}), in `fields` order. */
+function keysFromValues(values, fields) {
+	return collectSearchTokens(fields.map((f) => values[f]));
+}
+//#endregion
+export { tokenizeSearchText as _, insertValues as a, writeKeys as c, buildSearchKeys as d, prefixSearchFilter as f, normalizeSearchText as g, findSearchMatches as h, fieldValuesOf as i, DEFAULT_SEARCH_KEYS_FIELD as l, searchKeysPath as m, SearchKeysWriteError as n, keysFromValues as o, searchKeysIndex as p, analyzeUpdate as r, unresolvedForUpdate as s, SEARCH_KEYS_ERROR_CODES as t, MAX_PREFIX_SEARCH_TERMS as u };

package/dist/index-C0AjVqX3.d.mts

@@ -0,0 +1,169 @@
+//#region src/search/derive.d.ts
+/**
+ * How a write changes the search fields: the pure analysis behind the
+ * search-keys plugin. Given one write (a document, a replacement, or an update
+ * with its filter), it says which search-field values the write determines and
+ * which it leaves to the stored document, so the plugin can derive the keys in
+ * the SAME write (no second round-trip, no window where keys are stale).
+ */
+/** Thrown (as `status: 400` with a `code`) for a write the keys cannot follow. */
+declare const SEARCH_KEYS_ERROR_CODES: {
+  /** An operator or path the plugin cannot evaluate touches a search field. */
+  readonly UNSUPPORTED_UPDATE: "SEARCH_KEYS_UNSUPPORTED_UPDATE";
+  /** A multi-document update sets SOME search fields; the rest differ per document. */
+  readonly PARTIAL_MULTI_UPDATE: "SEARCH_KEYS_PARTIAL_MULTI_UPDATE";
+};
+declare class SearchKeysWriteError extends Error {
+  readonly code: (typeof SEARCH_KEYS_ERROR_CODES)[keyof typeof SEARCH_KEYS_ERROR_CODES];
+  readonly status = 400;
+  constructor(message: string, code: (typeof SEARCH_KEYS_ERROR_CODES)[keyof typeof SEARCH_KEYS_ERROR_CODES]);
+}
+//#endregion
+//#region src/search/normalize.d.ts
+/**
+ * Search-as-you-type text rules, shared by the WRITER (the search keys stored on
+ * every document) and the READER (the query typed into a search box).
+ *
+ * Both sides MUST run the same function, otherwise a key written as `mohammed`
+ * is never found by a query normalised to `Mohammed`. That is also why this
+ * module is pure (no mongoose, no driver): a portal or mobile client imports it
+ * from `@classytic/mongokit/search` to highlight matches with the exact rules
+ * the server indexed with.
+ *
+ * Rules, in order:
+ *   1. lower-case (before NFKD: `'İ'.toLowerCase()` yields a combining dot the
+ *      next step removes);
+ *   2. Unicode NFKD, then every combining mark (`\p{M}`) dropped: `é → e`,
+ *      `fi → fi`, and Arabic tashkeel (fatha, damma, kasra, shadda, sukun,
+ *      tanween, superscript alef) disappear;
+ *   3. Arabic folding: tatweel removed; `أ إ آ ٱ → ا` (the hamza/madda forms
+ *      decompose to bare alef in step 2, wasla is folded here); `ى → ي`;
+ *      `ة → ه`; Arabic-Indic and Persian digits → ASCII digits;
+ *   4. format characters (`\p{Cf}`: ZWJ, ZWNJ, bidi marks) removed so a pasted
+ *      name does not split or miss;
+ *   5. split on anything that is not a letter or a digit (whitespace and
+ *      punctuation: `al-harbi` → `al`, `harbi`; `noura.saad@x.io` → `noura`,
+ *      `saad`, `x`, `io`).
+ */
+/**
+ * The search tokens of `text`, in order, duplicates kept. Empty for blank text
+ * or text with no letters/digits.
+ *
+ * @example tokenizeSearchText('  Mohammed AL-Harbi ') // ['mohammed', 'al', 'harbi']
+ * @example tokenizeSearchText('مُحَمَّد أحمد')        // ['محمد', 'احمد']
+ */
+declare function tokenizeSearchText(text: string): string[];
+/**
+ * `text` normalised to its tokens joined by single spaces: the canonical form to
+ * compare or display ("what the index sees").
+ *
+ * @example normalizeSearchText('Café  Crème') // 'cafe creme'
+ */
+declare function normalizeSearchText(text: string): string;
+/** A `[start, end)` range of the ORIGINAL text, as {@link findSearchMatches} returns. */
+interface SearchMatchRange {
+  start: number;
+  end: number;
+}
+/**
+ * Where `query` matches `text` under the prefix-search rules: for every word of
+ * `text` whose normalised form starts with one of the query's tokens, the
+ * shortest leading run of the ORIGINAL characters that covers that token.
+ * Offsets index the original string, so a client wraps them in `<mark>` with no
+ * re-normalisation of its own.
+ *
+ * @example findSearchMatches('Mohammed Al-Harbi', 'moh har')
+ *          // [{ start: 0, end: 3 }, { start: 12, end: 15 }]
+ */
+declare function findSearchMatches(text: string, query: string): SearchMatchRange[];
+//#endregion
+//#region src/search/prefix.d.ts
+/**
+ * Indexed search-as-you-type (`searchMode: 'prefix'`): the stored keys, the
+ * query filter, and the index/schema declarations. Pure: no mongoose import.
+ *
+ * ## Storage choice: word tokens + anchored regex (not edge n-grams)
+ *
+ * Each document stores the DISTINCT normalised word tokens of its search fields
+ * in one array field (`_searchKeys` by default), covered by a multikey index. A
+ * query token `moh` becomes `{ _searchKeys: { $regex: '^moh' } }`: a
+ * case-sensitive regex with a literal prefix, which the planner turns into the
+ * index range `["moh", "moi")` (IXSCAN, keys examined ≈ matches). Several query
+ * tokens AND together, one `$and` arm each; the planner bounds one arm and
+ * filters the rest on the fetched documents.
+ *
+ * The alternative, edge n-grams (`m, mo, moh, ..., mohammed` stored, matched by
+ * an exact `$all`), gives the SAME index-range query plan, only with point
+ * bounds, while storing one key per prefix length instead of one per word.
+ * Measured on 2,000 two-to-three-word names (mongod 8, WiredTiger; see
+ * `tests/integration/prefix-search.test.ts`): tokens 6,000 keys / 60 KiB index,
+ * edge n-grams (N=20) 34,140 keys / 256 KiB index, ~5.7x the keys and ~4x the
+ * index bytes. N-grams also cost a write amplification on every
+ * rename, and an arbitrary cut-off N past which longer prefixes stop matching.
+ * Tokens keep the index small, have no length cliff, and make the backfill a
+ * pure function of the source fields. So tokens are the standard here.
+ */
+/** Default name of the field that stores the search keys. */
+declare const DEFAULT_SEARCH_KEYS_FIELD = "_searchKeys";
+/** Query tokens beyond this many are ignored (each one is an `$and` arm). */
+declare const MAX_PREFIX_SEARCH_TERMS = 8;
+/**
+ * The search keys of `doc`: the distinct normalised tokens of every value at
+ * every `fields` path (strings and numbers; arrays flattened; other values
+ * ignored), in first-seen order. This is exactly what the write paths store.
+ *
+ * @example buildSearchKeys({ name: 'Ahmed bin Ali', email: 'a.ali@x.io' }, ['name'])
+ *          // ['ahmed', 'bin', 'ali']
+ */
+declare function buildSearchKeys(doc: unknown, fields: readonly string[]): string[];
+interface PrefixSearchFilterOptions {
+  /** Field holding the keys. Default {@link DEFAULT_SEARCH_KEYS_FIELD}. */
+  keysField?: string;
+  /** Cap on query tokens. Default {@link MAX_PREFIX_SEARCH_TERMS}. */
+  maxTerms?: number;
+}
+/**
+ * The MongoDB filter for a prefix search: every query token must be the start of
+ * some stored key (AND across words, any order). `null` when `query` has no
+ * tokens (blank or punctuation only): the caller decides whether that means "no
+ * search" (the repository's choice) or "match nothing".
+ *
+ * Uses `{ $regex: '^…' }` strings, never RegExp objects, so the filter survives
+ * JSON (cache keys, logs, wire) unchanged.
+ *
+ * @example prefixSearchFilter('Moh Ali')
+ *          // { $and: [{ _searchKeys: { $regex: '^moh' } }, { _searchKeys: { $regex: '^ali' } }] }
+ */
+declare function prefixSearchFilter(query: string, options?: PrefixSearchFilterOptions): Record<string, unknown> | null;
+/**
+ * Mongoose schema path for the keys field: an array of strings, never selected
+ * by default (`select: false`), absent until written (so a backfill can find
+ * rows without it).
+ *
+ * @example schema.add({ _searchKeys: searchKeysPath() });
+ */
+declare function searchKeysPath(): {
+  type: [StringConstructor];
+  select: false;
+  default: undefined;
+};
+/**
+ * Index declaration for the keys field (multikey), in the
+ * `{ fields, options }` shape `schema.index(fields, options)` and the Better
+ * Auth overlay's `indexes` take. Name defaults to `<field>_1`.
+ *
+ * @example
+ * // Serves getAll({ search }) prefix search (searchMode: 'prefix').
+ * const idx = searchKeysIndex();
+ * schema.index(idx.fields, idx.options);
+ */
+declare function searchKeysIndex(field?: string, options?: {
+  name?: string;
+}): {
+  fields: Record<string, 1>;
+  options: {
+    name: string;
+  };
+};
+//#endregion
+export { prefixSearchFilter as a, SearchMatchRange as c, tokenizeSearchText as d, SEARCH_KEYS_ERROR_CODES as f, buildSearchKeys as i, findSearchMatches as l, MAX_PREFIX_SEARCH_TERMS as n, searchKeysIndex as o, SearchKeysWriteError as p, PrefixSearchFilterOptions as r, searchKeysPath as s, DEFAULT_SEARCH_KEYS_FIELD as t, normalizeSearchText as u };

package/dist/index.d.mts

@@ -2,16 +2,17 @@ import { S as LookupOptions, _ as SessionOptions, a as ConvenientTransactionOpti
 import { A as ObjectId, C as configureQueryDefaults, D as AnyDocument, E as resolveQueryOptions, F as SortSpec$1, M as ReadPreferenceType, N as SelectSpec, O as AnyModel, P as SortDirection, S as configureAggregateDefaults, T as resetQueryDefaults, _ as QueryDefaults, a as CursorPayload, b as WriteConcernSpec, c as MongokitPageExtras, d as ValueType, f as CursorSecret, g as QUERY_DEFAULTS_ERROR_CODES, h as PerCallQueryOptions, i as CountStrategy, j as PopulateSpec, l as OffsetPaginationOptions, m as CommandKind, n as BasePaginationOptions, o as DecodedCursor, p as AggregateDefaults, r as CollationOptions, s as KeysetPaginationOptions, t as AggregatePaginationOptions, u as PaginationConfig, v as ReadConcernLevel, w as getQueryDefaults, x as assertQueryDefaultsConfigured, y as ResolvedQueryOptions } from "./pagination-D6psses0.mjs";
 import { a as CreateManyFailure, l as isCreateManyPartialError, o as CreateManyPartial, s as CreateManyPartialError, t as index_d_exports } from "./index-SYF8N28D.mjs";
 import { a as InferRawDoc, c as NonNullableFields, d as Strict, f as UpdatePatch, i as InferDocument, l as PartialBy, n as DeepPartial, o as KeysOfType, p as UpdateWithValidationResult, r as DocField, s as MongoOperatorUpdate, t as CreateInput, u as RequiredBy } from "./type-utils-CLzRFtIA.mjs";
-import { S as RepositoryPluginName, _ as RepositoryOptions, a as HookMode, b as MONGOKIT_PLUGIN_NAMES, c as MinimalRepoView, d as PluginType, f as PrioritizedHook, g as RepositoryOperation, h as RepositoryInstance, i as EventPhase, l as Plugin, m as RepositoryEvent, n as EventHandlers, o as Middleware, p as RepositoryContext, r as EventPayload, s as MiddlewareContext, t as AllPluginMethods, u as PluginFunction, v as UserContext, x as MongoKitPluginName, y as WithPlugins } from "./repository-DNHfjAZX.mjs";
-import { A as EnsureAuditTrailReadyOptions, C as AuditQueryOptions, D as AuditTrailOptions, E as AuditTrailMode, M as ensureAuditTrailReady, O as AuditTrailQuery, S as AuditOperation, T as AuditTrailMethods, _ as CacheOptions, a as DateSequentialIdOptions, b as cachePlugin, c as SequentialIdOptions, d as ensureSequenceAtLeast, f as getNextSequence, g as CacheAdapter, h as sequentialId, i as CustomIdOptions, j as auditTrailPlugin, k as AuditTrailQueryOptions, l as customIdPlugin, m as readSequence, n as adminBypass, o as IdGenerator, p as prefixedId, r as multiTenantPlugin, s as PrefixedIdOptions, t as MultiTenantOptions, u as dateSequentialId, v as RepositoryCacheHandle, w as AuditQueryResult, x as AuditEntry, y as RepositoryCachePluginOptions } from "./multi-tenant.plugin-a3UhQARj.mjs";
+import { C as RepositoryPluginName, S as MongoKitPluginName, _ as RepositoryOptions, a as HookMode, b as WithPlugins, c as MinimalRepoView, d as PluginType, f as PrioritizedHook, g as RepositoryOperation, h as RepositoryInstance, i as EventPhase, l as Plugin, m as RepositoryEvent, n as EventHandlers, o as Middleware, p as RepositoryContext, r as EventPayload, s as MiddlewareContext, t as AllPluginMethods, u as PluginFunction, v as RepositorySearchMode, x as MONGOKIT_PLUGIN_NAMES, y as UserContext } from "./repository-MqAP409e.mjs";
+import { A as EnsureAuditTrailReadyOptions, C as AuditQueryOptions, D as AuditTrailOptions, E as AuditTrailMode, M as ensureAuditTrailReady, O as AuditTrailQuery, S as AuditOperation, T as AuditTrailMethods, _ as CacheOptions, a as DateSequentialIdOptions, b as cachePlugin, c as SequentialIdOptions, d as ensureSequenceAtLeast, f as getNextSequence, g as CacheAdapter, h as sequentialId, i as CustomIdOptions, j as auditTrailPlugin, k as AuditTrailQueryOptions, l as customIdPlugin, m as readSequence, n as adminBypass, o as IdGenerator, p as prefixedId, r as multiTenantPlugin, s as PrefixedIdOptions, t as MultiTenantOptions, u as dateSequentialId, v as RepositoryCacheHandle, w as AuditQueryResult, x as AuditEntry, y as RepositoryCachePluginOptions } from "./multi-tenant.plugin-B_q9NUHc.mjs";
 import { n as PaginationEngine, t as CountMemoKey } from "./PaginationEngine-CRHyuUtw.mjs";
-import { a as AggregationBuilder, c as ProjectionSpec, d as VectorSearchOptions, i as TransitionMachine, l as SortOrder, n as HOOK_PRIORITY, o as AggregationPlan, r as Repository, s as GroupSpec, t as GetAllParams, u as SortSpec } from "./Repository-pnLw1rG5.mjs";
-import { a as SoftDeleteFilterMode, c as ValidationChainOptions, i as Logger, l as ValidatorDefinition, n as CascadeRelation, o as SoftDeleteOptions, r as FieldPreset, s as SoftDeleteRepository, t as CascadeOptions } from "./plugin-options-CRhIvSzx.mjs";
-import { n as CreateRepositoryConfig, r as createRepository, t as AuditConfig } from "./create-repository-BUx9vfG9.mjs";
-import { A as IdempotencyStoreMethods, B as batchOperationsPlugin, C as LeaseMethods, D as ImmutableStatesPluginOptions, E as ImmutableClaimView, F as elasticSearchPlugin, G as aggregateHelpersPlugin, H as AppendOnlyPluginOptions, I as cascadePlugin, L as BatchOperationsMethods, M as idempotencyStorePlugin, N as fieldFilterPlugin, O as immutableStatesPlugin, P as ElasticSearchOptions, R as BulkWriteOptions, S as methodRegistryPlugin, T as leasePlugin, U as appendOnlyPlugin, V as auditLogPlugin, W as AggregateHelpersMethods, _ as OperationMetric, a as requireField, b as mongoOperationsPlugin, c as timestampPlugin, d as createTenantContext, f as SubdocumentMethods, g as ObservabilityOptions, h as softDeletePlugin, i as immutableField, j as IdempotencyStorePluginOptions, k as IdempotencyClaim, l as TenantContext, m as SoftDeleteMethods, n as autoInject, o as uniqueField, p as subdocumentPlugin, r as blockIf, s as validationChainPlugin, t as OperationType, u as TenantStore, v as observabilityPlugin, w as LeasePluginOptions, y as MongoOperationsMethods, z as BulkWriteResult } from "./validation-chain.plugin-CTcNJCmV.mjs";
+import { a as AggregationBuilder, c as ProjectionSpec, d as VectorSearchOptions, i as TransitionMachine, l as SortOrder, n as HOOK_PRIORITY, o as AggregationPlan, r as Repository, s as GroupSpec, t as GetAllParams, u as SortSpec } from "./Repository-DnL4xk5w.mjs";
+import { a as SoftDeleteFilterMode, c as ValidationChainOptions, i as Logger, l as ValidatorDefinition, n as CascadeRelation, o as SoftDeleteOptions, r as FieldPreset, s as SoftDeleteRepository, t as CascadeOptions } from "./plugin-options-Cirmb4Kp.mjs";
+import { n as CreateRepositoryConfig, r as createRepository, t as AuditConfig } from "./create-repository-CJtVdwig.mjs";
+import { A as immutableStatesPlugin, B as BulkWriteOptions, D as leasePlugin, E as LeasePluginOptions, F as fieldFilterPlugin, G as appendOnlyPlugin, H as batchOperationsPlugin, I as ElasticSearchOptions, K as AggregateHelpersMethods, L as elasticSearchPlugin, M as IdempotencyStoreMethods, N as IdempotencyStorePluginOptions, O as ImmutableClaimView, P as idempotencyStorePlugin, R as cascadePlugin, S as mongoOperationsPlugin, T as LeaseMethods, U as auditLogPlugin, V as BulkWriteResult, W as AppendOnlyPluginOptions, _ as searchKeysPlugin, a as requireField, b as observabilityPlugin, c as timestampPlugin, d as createTenantContext, f as SubdocumentMethods, g as SearchKeysPluginOptions, h as softDeletePlugin, i as immutableField, j as IdempotencyClaim, k as ImmutableStatesPluginOptions, l as TenantContext, m as SoftDeleteMethods, n as autoInject, o as uniqueField, p as subdocumentPlugin, q as aggregateHelpersPlugin, r as blockIf, s as validationChainPlugin, t as OperationType, u as TenantStore, v as ObservabilityOptions, w as methodRegistryPlugin, x as MongoOperationsMethods, y as OperationMetric, z as BatchOperationsMethods } from "./validation-chain.plugin-BAeC5eVT.mjs";
 import { n as SchemaPathsLike, t as FieldType$1 } from "./coercion-BjdPX3YF.mjs";
 import { n as SchemaIndexes } from "./indexes-DIjMpYES.mjs";
-import { S as parseDuplicateKeyError, _ as getMongooseProjection, a as createMemoryCache, b as createError, g as getFieldsForUser, h as filterResponseData, i as buildCrudSchemasFromMongooseSchema, m as createFieldPreset, n as CrudSchemasFramework, o as LoggerConfig, r as buildCrudSchemasFromModel, s as configureLogger, t as toPlain, u as idVariants, v as CreateErrorOptions, x as isDuplicateKeyError, y as ParseDuplicateKeyOptions } from "./to-plain-CjgEInWV.mjs";
+import { a as prefixSearchFilter, c as SearchMatchRange, d as tokenizeSearchText, f as SEARCH_KEYS_ERROR_CODES, i as buildSearchKeys, l as findSearchMatches, n as MAX_PREFIX_SEARCH_TERMS, o as searchKeysIndex, p as SearchKeysWriteError, r as PrefixSearchFilterOptions, s as searchKeysPath, t as DEFAULT_SEARCH_KEYS_FIELD, u as normalizeSearchText } from "./index-C0AjVqX3.mjs";
+import { S as parseDuplicateKeyError, _ as getMongooseProjection, a as createMemoryCache, b as createError, g as getFieldsForUser, h as filterResponseData, i as buildCrudSchemasFromMongooseSchema, m as createFieldPreset, n as CrudSchemasFramework, o as LoggerConfig, r as buildCrudSchemasFromModel, s as configureLogger, t as toPlain, u as idVariants, v as CreateErrorOptions, x as isDuplicateKeyError, y as ParseDuplicateKeyOptions } from "./to-plain-o5tUY2nV.mjs";
 import { RepoCapabilities } from "@classytic/repo-core/repository";
 import { ClientSession, Connection, Model, PipelineStage, Schema } from "mongoose";
 import { HttpError } from "@classytic/repo-core/errors";
@@ -753,6 +754,34 @@ declare function declareCollectionScope(model: object, rule: CollectionScopeRule
   tenantField?: string;
 }): void;
 //#endregion
+//#region src/search/rebuild.d.ts
+/** A prefix-mode `Repository` satisfies this: `rebuildSearchKeys(repo)`. */
+interface SearchKeysSource {
+  Model: Model<any, any, any, any>;
+  searchFields?: readonly string[] | undefined;
+  searchKeysField?: string;
+}
+interface RebuildSearchKeysOptions {
+  /** Source fields. Default: the repository's `searchFields`. */
+  fields?: readonly string[];
+  /** Keys field. Default: the repository's `searchKeysField`, else `'_searchKeys'`. */
+  keysField?: string;
+  /** Only documents matching this filter. Default: all. */
+  filter?: Record<string, unknown>;
+  /** Only documents with no keys field yet (cheapest boot-time backfill). Default `false`. */
+  onlyMissing?: boolean;
+  /** Documents read and written per round-trip. Default 500. */
+  batchSize?: number;
+  session?: unknown;
+}
+interface RebuildSearchKeysResult {
+  /** Documents read. */
+  scanned: number;
+  /** Documents whose keys were missing or stale and were rewritten (server-reported). */
+  updated: number;
+}
+declare function rebuildSearchKeys(source: SearchKeysSource | Model<any, any, any, any>, options?: RebuildSearchKeysOptions): Promise<RebuildSearchKeysResult>;
+//#endregion
 //#region src/transaction.d.ts
 /** Minimal shape we need from a Mongoose connection. */
 interface SessionStarter {
@@ -1116,4 +1145,4 @@ declare function createOptionsExtractor<TCtx extends Record<string, unknown>>(fi
  */
 declare function systemContext(extra?: SessionOptions): SessionOptions;
 //#endregion
-export { ALL_OPERATIONS, type AggregateCallOptions, type AggregateDefaults, type AggregateHelpersMethods, type AggregateOptions, type AggregatePaginationOptions, AggregationBuilder, type AggregationPlan, type SortOrder as AggregationSortOrder, type SortSpec as AggregationSortSpec, type AllPluginMethods, type AnyDocument, type AnyModel, type AppendOnlyPluginOptions, type AuditConfig, type AuditEntry, type AuditOperation, type AuditQueryOptions, type AuditQueryResult, type AuditTrailMethods, type AuditTrailMode, type AuditTrailOptions, AuditTrailQuery, type AuditTrailQueryOptions, type BasePaginationOptions, type BatchOperationsMethods, type BulkWriteOptions, type BulkWriteResult, type CacheAdapter, type CacheOperationOptions, type CacheOptions, type CacheableOptions, type CapabilityConnectionLike, type CapabilityProbeOptions, type CapabilityResolution, type CascadeOptions, type CascadePurgeReferencesOptions, type CascadeRelation, type CollationOptions, type CollectionRWLike, type CollectionScopeRule, type CommandKind, type ConvenientTransactionOptions, type CountMemoKey, type CountStrategy, type CreateErrorOptions, type CreateInput, type CreateManyFailure, type CreateManyPartial, type CreateManyPartialError, type CreateOptions, type CreateRepositoryConfig, type CrudSchemasFramework, type CursorPayload, type CursorSecret, type CustomIdOptions, type DateSequentialIdOptions, type DecodedCursor, type DeepPartial, type DefineModelOptions, type DeleteResult, type DocField, type ElasticSearchOptions, type EnsureAuditTrailReadyOptions, type EventHandlers, type EventPayload, type EventPhase, type ExistingModelPolicy, type FieldPreset, type FieldType, type FilterQuery, type FindOneAndUpdateOptions, type GetAllParams, type GetByIdsOptions, type GroupResult, type GroupSpec, HOOK_PRIORITY, type HookMode, type IdGenerator, type IdempotencyClaim, type IdempotencyStoreMethods, type IdempotencyStorePluginOptions, type ImmutableClaimView, type ImmutableStatesPluginOptions, type InferDocument, type InferRawDoc, JOIN_ERROR_CODES, type KeysOfType, type KeysetPaginationOptions, type KeysetSourceOptions, type LeaseMethods, type LeasePluginOptions, type Logger, type LoggerConfig, LookupBuilder, type LookupOptions, type LookupPopulateOptions, type LookupPopulateResult, MONGOKIT_CAPABILITIES, MONGOKIT_PLUGIN_NAMES, MUTATING_OPERATIONS, type Middleware, type MiddlewareContext, type MinMaxResult, type MinimalRepoView, type ModelBlueprint, ModelCollisionError, type ModelSpec, type MongoKitPluginName, type MongoOperationsMethods, type MongoOperatorUpdate, type MongoRepoCapabilities, type MongokitPageExtras, type MultiTenantOptions, type NonNullableFields, OP_REGISTRY, type ObjectId, type ObservabilityOptions, type OffsetPaginationOptions, type OperationDescriptor, type OperationMetric, type OperationOptions, type OperationType, PAGINATION_ERROR_CODES, type PaginationConfig, type PaginationDefaults, PaginationEngine, type ParseDuplicateKeyOptions, type ParsedQuery, type PartialBy, type PerCallQueryOptions, type Plugin, type PluginFunction, type PluginType, type PolicyKey, type PopulateOption, type PopulateSpec, type PrefixedIdOptions, type PrioritizedHook, type ProjectionSpec, type PurgeMode, type PurgeableRepoLike, QUERY_DEFAULTS_ERROR_CODES, type QueryDefaults, QueryParser, type QueryParserOptions, type QuerySchema, READ_OPERATIONS, type ReadConcernLevel, type ReadOptions, type ReadPreferenceType, type ReferencePurgeResult, type ReferenceRelation, type RepoScope, Repository, Repository as default, type RepositoryCacheHandle, type RepositoryCachePluginOptions, type RepositoryContext, type RepositoryEvent, type RepositoryInstance, type RepositoryOperation, type RepositoryOptions, type RepositoryPluginName, type RequiredBy, type ResolvedQueryOptions, type SchemaLike, type SearchMode, type SelectSpec, type SequentialIdOptions, type SessionOptions, type SessionStarter, type SoftDeleteFilterMode, type SoftDeleteMethods, type SoftDeleteOptions, type SoftDeleteRepository, type SortDirection, type SortSpec$1 as SortSpec, type Strict, type SubdocumentMethods, TRANSACTION_ERROR_CODES, type TenantContext, type TenantStore, type TransactionSupport, type TransitionMachine, type UpdateManyResult, type UpdateOptions, type UpdatePatch, type UpdateWithValidationResult, type UserContext, type ValidationChainOptions, type ValidatorDefinition, type ValueType, type VectorSearchOptions, type WithPlugins, type WithTransactionOptions, type WriteConcernSpec, index_d_exports as actions, adminBypass, aggregateHelpersPlugin, appendOnlyPlugin, assertQueryDefaultsConfigured, auditLogPlugin, auditTrailPlugin, autoInject, batchOperationsPlugin, batchTransaction, blockIf, buildCrudSchemasFromModel, buildCrudSchemasFromMongooseSchema, cachePlugin, capabilitiesForSupport, cascadePlugin, cascadePurgeReferences, classifyHelloReply, compileFilterToMongo, configureAggregateDefaults, configureLogger, configurePaginationDefaults, configureQueryDefaults, createError, createFieldPreset, createMemoryCache, createOptionsExtractor, createRepository, createTenantContext, customIdPlugin, dateSequentialId, declareCollectionScope, declareTenantContextKey, defineModel, defineModels, elasticSearchPlugin, ensureAuditTrailReady, ensureSequenceAtLeast, fieldFilterPlugin, filterResponseData, forwardScope, getFieldsForUser, getMongooseProjection, getNextSequence, getPaginationDefaults, getQueryDefaults, idVariants, idempotencyStorePlugin, immutableField, immutableStatesPlugin, isCreateManyPartialError, isDuplicateKeyError, isModelRegistered, isTransactionUnsupported, keysetSource, leasePlugin, methodRegistryPlugin, mongoOperationsPlugin, multiTenantPlugin, observabilityPlugin, operationsByPolicyKey, parseDuplicateKeyError, prefixedId, probeMongoCapabilities, readSequence, repoOptionsFromCtx, requireField, resetCapabilityProbeCache, resetPaginationDefaults, resetQueryDefaults, resolveMongoCapabilities, resolveQueryOptions, resolveTransactionSupport, runTransaction, sequentialId, softDeletePlugin, subdocumentPlugin, supportsTransactions, systemContext, tenantContextKeysOf, timestampPlugin, toPlain, transactionResolutionOf, uniqueField, validationChainPlugin, withTransaction };
+export { ALL_OPERATIONS, type AggregateCallOptions, type AggregateDefaults, type AggregateHelpersMethods, type AggregateOptions, type AggregatePaginationOptions, AggregationBuilder, type AggregationPlan, type SortOrder as AggregationSortOrder, type SortSpec as AggregationSortSpec, type AllPluginMethods, type AnyDocument, type AnyModel, type AppendOnlyPluginOptions, type AuditConfig, type AuditEntry, type AuditOperation, type AuditQueryOptions, type AuditQueryResult, type AuditTrailMethods, type AuditTrailMode, type AuditTrailOptions, AuditTrailQuery, type AuditTrailQueryOptions, type BasePaginationOptions, type BatchOperationsMethods, type BulkWriteOptions, type BulkWriteResult, type CacheAdapter, type CacheOperationOptions, type CacheOptions, type CacheableOptions, type CapabilityConnectionLike, type CapabilityProbeOptions, type CapabilityResolution, type CascadeOptions, type CascadePurgeReferencesOptions, type CascadeRelation, type CollationOptions, type CollectionRWLike, type CollectionScopeRule, type CommandKind, type ConvenientTransactionOptions, type CountMemoKey, type CountStrategy, type CreateErrorOptions, type CreateInput, type CreateManyFailure, type CreateManyPartial, type CreateManyPartialError, type CreateOptions, type CreateRepositoryConfig, type CrudSchemasFramework, type CursorPayload, type CursorSecret, type CustomIdOptions, DEFAULT_SEARCH_KEYS_FIELD, type DateSequentialIdOptions, type DecodedCursor, type DeepPartial, type DefineModelOptions, type DeleteResult, type DocField, type ElasticSearchOptions, type EnsureAuditTrailReadyOptions, type EventHandlers, type EventPayload, type EventPhase, type ExistingModelPolicy, type FieldPreset, type FieldType, type FilterQuery, type FindOneAndUpdateOptions, type GetAllParams, type GetByIdsOptions, type GroupResult, type GroupSpec, HOOK_PRIORITY, type HookMode, type IdGenerator, type IdempotencyClaim, type IdempotencyStoreMethods, type IdempotencyStorePluginOptions, type ImmutableClaimView, type ImmutableStatesPluginOptions, type InferDocument, type InferRawDoc, JOIN_ERROR_CODES, type KeysOfType, type KeysetPaginationOptions, type KeysetSourceOptions, type LeaseMethods, type LeasePluginOptions, type Logger, type LoggerConfig, LookupBuilder, type LookupOptions, type LookupPopulateOptions, type LookupPopulateResult, MAX_PREFIX_SEARCH_TERMS, MONGOKIT_CAPABILITIES, MONGOKIT_PLUGIN_NAMES, MUTATING_OPERATIONS, type Middleware, type MiddlewareContext, type MinMaxResult, type MinimalRepoView, type ModelBlueprint, ModelCollisionError, type ModelSpec, type MongoKitPluginName, type MongoOperationsMethods, type MongoOperatorUpdate, type MongoRepoCapabilities, type MongokitPageExtras, type MultiTenantOptions, type NonNullableFields, OP_REGISTRY, type ObjectId, type ObservabilityOptions, type OffsetPaginationOptions, type OperationDescriptor, type OperationMetric, type OperationOptions, type OperationType, PAGINATION_ERROR_CODES, type PaginationConfig, type PaginationDefaults, PaginationEngine, type ParseDuplicateKeyOptions, type ParsedQuery, type PartialBy, type PerCallQueryOptions, type Plugin, type PluginFunction, type PluginType, type PolicyKey, type PopulateOption, type PopulateSpec, type PrefixSearchFilterOptions, type PrefixedIdOptions, type PrioritizedHook, type ProjectionSpec, type PurgeMode, type PurgeableRepoLike, QUERY_DEFAULTS_ERROR_CODES, type QueryDefaults, QueryParser, type QueryParserOptions, type QuerySchema, READ_OPERATIONS, type ReadConcernLevel, type ReadOptions, type ReadPreferenceType, type RebuildSearchKeysOptions, type RebuildSearchKeysResult, type ReferencePurgeResult, type ReferenceRelation, type RepoScope, Repository, Repository as default, type RepositoryCacheHandle, type RepositoryCachePluginOptions, type RepositoryContext, type RepositoryEvent, type RepositoryInstance, type RepositoryOperation, type RepositoryOptions, type RepositoryPluginName, type RepositorySearchMode, type RequiredBy, type ResolvedQueryOptions, SEARCH_KEYS_ERROR_CODES, type SchemaLike, type SearchKeysPluginOptions, type SearchKeysSource, SearchKeysWriteError, type SearchMatchRange, type SearchMode, type SelectSpec, type SequentialIdOptions, type SessionOptions, type SessionStarter, type SoftDeleteFilterMode, type SoftDeleteMethods, type SoftDeleteOptions, type SoftDeleteRepository, type SortDirection, type SortSpec$1 as SortSpec, type Strict, type SubdocumentMethods, TRANSACTION_ERROR_CODES, type TenantContext, type TenantStore, type TransactionSupport, type TransitionMachine, type UpdateManyResult, type UpdateOptions, type UpdatePatch, type UpdateWithValidationResult, type UserContext, type ValidationChainOptions, type ValidatorDefinition, type ValueType, type VectorSearchOptions, type WithPlugins, type WithTransactionOptions, type WriteConcernSpec, index_d_exports as actions, adminBypass, aggregateHelpersPlugin, appendOnlyPlugin, assertQueryDefaultsConfigured, auditLogPlugin, auditTrailPlugin, autoInject, batchOperationsPlugin, batchTransaction, blockIf, buildCrudSchemasFromModel, buildCrudSchemasFromMongooseSchema, buildSearchKeys, cachePlugin, capabilitiesForSupport, cascadePlugin, cascadePurgeReferences, classifyHelloReply, compileFilterToMongo, configureAggregateDefaults, configureLogger, configurePaginationDefaults, configureQueryDefaults, createError, createFieldPreset, createMemoryCache, createOptionsExtractor, createRepository, createTenantContext, customIdPlugin, dateSequentialId, declareCollectionScope, declareTenantContextKey, defineModel, defineModels, elasticSearchPlugin, ensureAuditTrailReady, ensureSequenceAtLeast, fieldFilterPlugin, filterResponseData, findSearchMatches, forwardScope, getFieldsForUser, getMongooseProjection, getNextSequence, getPaginationDefaults, getQueryDefaults, idVariants, idempotencyStorePlugin, immutableField, immutableStatesPlugin, isCreateManyPartialError, isDuplicateKeyError, isModelRegistered, isTransactionUnsupported, keysetSource, leasePlugin, methodRegistryPlugin, mongoOperationsPlugin, multiTenantPlugin, normalizeSearchText, observabilityPlugin, operationsByPolicyKey, parseDuplicateKeyError, prefixSearchFilter, prefixedId, probeMongoCapabilities, readSequence, rebuildSearchKeys, repoOptionsFromCtx, requireField, resetCapabilityProbeCache, resetPaginationDefaults, resetQueryDefaults, resolveMongoCapabilities, resolveQueryOptions, resolveTransactionSupport, runTransaction, searchKeysIndex, searchKeysPath, searchKeysPlugin, sequentialId, softDeletePlugin, subdocumentPlugin, supportsTransactions, systemContext, tenantContextKeysOf, timestampPlugin, toPlain, tokenizeSearchText, transactionResolutionOf, uniqueField, validationChainPlugin, withTransaction };