@classytic/mongokit 3.29.0 → 3.31.0

package/dist/better-auth/index.d.mts

@@ -58,6 +58,19 @@ interface RegisterBetterAuthStubsOptions {
   usePlural?: boolean;
   /** Per-collection model name override (mirrors BA's `user.modelName`). */
   modelOverrides?: Partial<Record<string, string>>;
+  /**
+   * Canonical collection names to SKIP — because something else owns their model.
+   *
+   * The normal reason is `createBetterAuthOverlay`: a host wants stubs for the collections it merely
+   * REFERENCES (`organization`, `member`) and a full overlay for the one it exposes CRUD on (`user`).
+   * Without this the two helpers collide — the stub registers `user` first, and the overlay then
+   * THROWS, correctly, because mongoose locks a schema on first `model()` and its `additionalFields`
+   * would be silently dropped.
+   *
+   * Names are CANONICAL (`'user'`, not a pluralised or overridden model name); exclusion is applied
+   * before `usePlural` / `modelOverrides`, so a caller does not have to predict the final name.
+   */
+  exclude?: string[];
 }
 /**
  * Register stub Mongoose models for Better Auth's collections so that

package/dist/better-auth/index.mjs

@@ -1,8 +1,45 @@
-import { n as Repository } from "../Repository-DThvFCaV.mjs";
-import { n as createMongooseAdapter } from "../adapter-CLvUHiTW.mjs";
+import { n as Repository } from "../Repository-BQ3FEnOa.mjs";
+import { n as createMongooseAdapter } from "../adapter-BitHg-CN.mjs";
 import { pluralizeBetterAuthCollection, resolveBetterAuthCollections } from "@classytic/repo-core/better-auth";
 //#region src/better-auth/index.ts
 /**
+* Field key with ORDER PRESERVED — a compound index is identified by its key sequence.
+* `{ organizationId: 1, createdAt: -1 }` is a DIFFERENT index from `{ createdAt: -1, organizationId: 1 }`
+* (they serve different queries), so sorting the keys here would wrongly equate them.
+*/
+function indexFieldsKey(fields) {
+	return Object.entries(fields).map(([k, v]) => `${k}:${String(v)}`).join(",");
+}
+/** Deterministic canonical form (sorted object keys, recursive) for value equality. */
+function canonical(value) {
+	if (Array.isArray(value)) return value.map(canonical);
+	if (value && typeof value === "object") {
+		const obj = value;
+		return Object.keys(obj).sort().reduce((acc, k) => {
+			acc[k] = canonical(obj[k]);
+			return acc;
+		}, {});
+	}
+	return value;
+}
+/**
+* Is every DECLARED option satisfied by the existing index's options? A subset check, not
+* equality: Mongoose augments stored index options with defaults (e.g. `background`), so the
+* existing side legitimately carries extra keys. We require each declared key to deep-equal the
+* existing value — covering ALL declared options (unique, sparse, expireAfterSeconds, collation,
+* name, weights, default_language, partialFilterExpression, …) with no hand-maintained subset.
+*/
+function declaredOptionsSatisfied(declared = {}, existing = {}) {
+	for (const [key, value] of Object.entries(declared)) if (JSON.stringify(canonical(value)) !== JSON.stringify(canonical(existing[key]))) return false;
+	return true;
+}
+/** Which declared indexes are NOT already present on the existing model's schema. */
+function missingIndexesOn(existing, declared) {
+	if (declared.length === 0) return [];
+	const existingIndexes = (existing?.schema)?.indexes?.() ?? [];
+	return declared.filter((d) => !existingIndexes.some(([fields, options]) => indexFieldsKey(fields) === indexFieldsKey(d.fields) && declaredOptionsSatisfied(d.options ?? {}, options ?? {})));
+}
+/**
 * Register stub Mongoose models for Better Auth's collections so that
 * Mongoose-based resources can `.populate()` references to BA-owned
 * documents. Idempotent — safe to call multiple times.
@@ -22,10 +59,14 @@ import { pluralizeBetterAuthCollection, resolveBetterAuthCollections } from "@cl
 *          already existed on `mongoose.models`).
 */
 function registerBetterAuthStubs(mongoose, options = {}) {
-	const names = resolveBetterAuthCollections(options);
+	const excluded = new Set(options.exclude ?? []);
+	const names = resolveBetterAuthCollections({
+		...options,
+		...excluded.size ? { exclude: [...excluded] } : {}
+	});
 	const registered = [];
 	for (const finalName of names) {
-		if (mongoose.models[finalName]) continue;
+		if (finalName in mongoose.models) continue;
 		const schema = new mongoose.Schema({}, {
 			strict: false,
 			collection: finalName,
@@ -59,8 +100,37 @@ async function createBetterAuthOverlay(options) {
 	const tableConfig = ctx.tables[collection];
 	if (!tableConfig) throw new Error(`[mongokit:better-auth] Better Auth has no table named '${collection}'. Available: ${Object.keys(ctx.tables).join(", ")}. Did you enable the right plugin in your betterAuth() config?`);
 	const finalName = usePlural ? pluralizeBetterAuthCollection(tableConfig.modelName) : tableConfig.modelName;
-	if (mongoose.models[finalName]) {
-		if (Object.keys(additionalFields).length > 0 || indexes.length > 0) throw new Error(`[mongokit:better-auth] '${finalName}' already registered on mongoose.models. Cannot apply additionalFields / indexes from this createBetterAuthOverlay() call — mongoose locks schema on first model() call. Either: (a) drop the prior registerBetterAuthStubs() call for '${finalName}', or (b) move additionalFields / indexes into the existing schema definition.`);
+	if (finalName in mongoose.models) {
+		const declared = Object.keys(additionalFields);
+		if (declared.length > 0 || indexes.length > 0) {
+			/**
+			* Distinguish "a STUB got here first" from "this same overlay already ran in this process".
+			*
+			* The guard exists because mongoose locks a schema on first `model()`, so declared
+			* `additionalFields` would be silently dropped. That danger is real when a
+			* `registerBetterAuthStubs()` call registered an EMPTY `strict: false` schema first.
+			*
+			* It is NOT real on a re-boot: a process that composes the app twice (every integration suite,
+			* and any host that recomposes) hits an existing model whose schema ALREADY carries these exact
+			* paths, because an identical overlay call put them there. Throwing then just makes the second
+			* boot impossible — which is precisely why hosts hand-rolled `models.X || model(X, schema)` and
+			* inherited the silent-drop bug this guard was written to stop.
+			*
+			* So the test is the SCHEMA, not the mere presence of a model: if every declared field is
+			* already a path, the fields are applied and reuse is safe. If any is missing, something else
+			* owns this model and the throw stands.
+			*/
+			const existing = mongoose.models[finalName];
+			const paths = existing?.schema?.paths ?? {};
+			const missing = declared.filter((f) => !(f in paths));
+			const missingIdx = missingIndexesOn(existing, indexes);
+			if (missing.length > 0 || missingIdx.length > 0) {
+				const parts = [];
+				if (missing.length > 0) parts.push(`${missing.length === 1 ? "field" : "fields"} ${missing.map((f) => `'${f}'`).join(", ")}`);
+				if (missingIdx.length > 0) parts.push(`${missingIdx.length === 1 ? "index" : "indexes"} on ${missingIdx.map((i) => `{${Object.keys(i.fields).join(",")}}`).join(", ")}`);
+				throw new Error(`[mongokit:better-auth] '${finalName}' already registered on mongoose.models WITHOUT ${parts.join(" and ")}. Cannot apply additionalFields / indexes from this createBetterAuthOverlay() call — mongoose locks schema on first model() call, so they would be SILENTLY DROPPED. Either: (a) exclude '${finalName}' from the prior registerBetterAuthStubs() call (\`exclude: ['${collection}']\`), or (b) move additionalFields / indexes there.`);
+			}
+		}
 	}
 	let Model = mongoose.models[finalName];
 	if (!Model) {

package/dist/{create-repository-uhKt_oUT.mjs → create-repository-BOTVMsIg.mjs}

@@ -1,5 +1,6 @@
-import { n as Repository } from "./Repository-DThvFCaV.mjs";
-import { a as methodRegistryPlugin, d as cachePlugin, f as batchOperationsPlugin, g as auditLogPlugin, i as multiTenantPlugin, m as auditTrailPlugin, n as softDeletePlugin, o as customIdPlugin, t as timestampPlugin } from "./timestamp.plugin-CFL6LlYZ.mjs";
+import { n as Repository } from "./Repository-BQ3FEnOa.mjs";
+import { a as customIdPlugin, f as auditTrailPlugin, i as multiTenantPlugin, m as auditLogPlugin, n as softDeletePlugin, t as timestampPlugin, u as cachePlugin } from "./timestamp.plugin-i9Qxm6kn.mjs";
+import { n as batchOperationsPlugin, t as methodRegistryPlugin } from "./method-registry.plugin-DblM7V6j.mjs";
 //#region src/create-repository.ts
 function isLoggerAudit(value) {
 	const v = value;

package/dist/create-repository-mEdfH9sz.d.mts

@@ -0,0 +1,54 @@
+import { c as PaginationConfig } from "./pagination-jSUdrACK.mjs";
+import { _ as RepositoryOptions, d as PluginType } from "./repository-Q16ErTu8.mjs";
+import { T as AuditTrailOptions, _ as RepositoryCachePluginOptions, i as CustomIdOptions, t as MultiTenantOptions } from "./multi-tenant.plugin-2VtSSm1Y.mjs";
+import { n as Repository } from "./Repository-BAzymuOz.mjs";
+import { i as Logger, o as SoftDeleteOptions } from "./plugin-options-BsFH0sTi.mjs";
+import { Model } from "mongoose";
+//#region src/create-repository.d.ts
+/**
+ * Audit config — either a `Logger` (routes to `auditLogPlugin`, which
+ * writes structured log lines through your logger) or an
+ * `AuditTrailOptions` object (routes to `auditTrailPlugin`, which
+ * persists a queryable compliance ledger in its own collection).
+ *
+ * Discrimination: a value carrying any of the `Logger` function members
+ * (`info` / `warn` / `error` / `debug`) is treated as a logger; anything
+ * else is treated as `AuditTrailOptions` (all of whose members are
+ * data-shaped except `metadata` / `onError`, which don't overlap with
+ * the logger member names).
+ */
+type AuditConfig = Logger | AuditTrailOptions;
+/**
+ * Declarative repository config. Every key is optional; a feature's
+ * plugin is installed only when its key is present. The remaining
+ * `RepositoryOptions` keys (`idField`, `hooks`, `schema`, `updateSchema`,
+ * `events`, `requirePlugins`, ...) pass through to the `Repository`
+ * constructor unchanged.
+ */
+interface CreateRepositoryConfig extends RepositoryOptions {
+  /** Multi-tenant scoping — forwarded to `multiTenantPlugin`. */
+  tenant?: MultiTenantOptions;
+  /** Soft-delete — `true` for defaults, or `SoftDeleteOptions`. */
+  softDelete?: boolean | SoftDeleteOptions;
+  /** createdAt/updatedAt stamping — `timestampPlugin` takes no options. */
+  timestamps?: boolean;
+  /** Batch ops (`updateMany`/`deleteMany`/`bulkWrite`) via `batchOperationsPlugin`. */
+  batch?: boolean;
+  /** Read-through cache — forwarded to `cachePlugin`. */
+  cache?: RepositoryCachePluginOptions;
+  /** Audit — `Logger` → `auditLogPlugin`; `AuditTrailOptions` → `auditTrailPlugin`. */
+  audit?: AuditConfig;
+  /** Custom ID generation — forwarded to `customIdPlugin`. */
+  customId?: CustomIdOptions;
+  /** Extra plugins appended AFTER the canonical stack. */
+  plugins?: PluginType[];
+  /** Pagination engine config (defaultLimit, maxLimit, ...). */
+  pagination?: PaginationConfig;
+}
+/**
+ * Build a `Repository` from a declarative config. See module JSDoc for
+ * ordering guarantees and an example.
+ */
+declare function createRepository<TDoc>(model: Model<TDoc, any, any, any>, config?: CreateRepositoryConfig): Repository<TDoc>;
+//#endregion
+export { CreateRepositoryConfig as n, createRepository as r, AuditConfig as t };

package/dist/{index-DceInCTX.d.mts → index-Beyr1r4d.d.mts}

@@ -1,4 +1,4 @@
-import { c as GroupResult, d as MinMaxResult, f as OperationOptions, g as UpdateOptions, h as UpdateManyResult, i as CreateOptions, o as DeleteResult, s as FindOneAndUpdateOptions, y as LookupOptions } from "./operations-C8IcCHF9.mjs";
+import { c as GroupResult, d as MinMaxResult, f as OperationOptions, g as UpdateOptions, h as UpdateManyResult, i as CreateOptions, o as DeleteResult, s as FindOneAndUpdateOptions, y as LookupOptions } from "./operations-CuzX9m2Z.mjs";
 import { a as PopulateSpec, i as ObjectId, l as SortSpec, o as ReadPreferenceType, s as SelectSpec, t as AnyDocument } from "./core-62oo3N1C.mjs";
 import { p as UpdateWithValidationResult } from "./type-utils-CLzRFtIA.mjs";
 import { Model, PipelineStage } from "mongoose";

package/dist/index.d.mts

@@ -1,19 +1,20 @@
-import { _ as WithTransactionOptions, c as GroupResult, d as MinMaxResult, f as OperationOptions, g as UpdateOptions, h as UpdateManyResult, i as CreateOptions, l as LookupPopulateOptions, m as SessionOptions, n as CacheOperationOptions, o as DeleteResult, p as ReadOptions, r as CacheableOptions, s as FindOneAndUpdateOptions, t as AggregateOptions, u as LookupPopulateResult, v as LookupBuilder, y as LookupOptions } from "./operations-C8IcCHF9.mjs";
-import { a as PopulateSpec, c as SortDirection, i as ObjectId, l as SortSpec, n as AnyModel, o as ReadPreferenceType, s as SelectSpec, t as AnyDocument } from "./core-62oo3N1C.mjs";
+import { _ as WithTransactionOptions, c as GroupResult, d as MinMaxResult, f as OperationOptions, g as UpdateOptions, h as UpdateManyResult, i as CreateOptions, l as LookupPopulateOptions, m as SessionOptions, n as CacheOperationOptions, o as DeleteResult, p as ReadOptions, r as CacheableOptions, s as FindOneAndUpdateOptions, t as AggregateOptions, u as LookupPopulateResult, v as LookupBuilder, y as LookupOptions } from "./operations-CuzX9m2Z.mjs";
+import { a as PopulateSpec, c as SortDirection, i as ObjectId, l as SortSpec$1, n as AnyModel, o as ReadPreferenceType, s as SelectSpec, t as AnyDocument } from "./core-62oo3N1C.mjs";
 import { a as DecodedCursor, c as PaginationConfig, i as CursorPayload, l as ValueType, n as BasePaginationOptions, o as KeysetPaginationOptions, r as CollationOptions, s as OffsetPaginationOptions, t as AggregatePaginationOptions } from "./pagination-jSUdrACK.mjs";
-import { t as index_d_exports } from "./index-DceInCTX.mjs";
+import { t as index_d_exports } from "./index-Beyr1r4d.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-DCHRWRXw.mjs";
-import { A as ensureAuditTrailReady, C as AuditTrailMethods, D as AuditTrailQueryOptions, E as AuditTrailQuery, O as EnsureAuditTrailReadyOptions, S as AuditQueryResult, T as AuditTrailOptions, _ as RepositoryCachePluginOptions, a as DateSequentialIdOptions, b as AuditOperation, c as SequentialIdOptions, d as getNextSequence, f as prefixedId, g as RepositoryCacheHandle, h as CacheOptions, i as CustomIdOptions, k as auditTrailPlugin, l as customIdPlugin, m as CacheAdapter, n as adminBypass, o as IdGenerator, p as sequentialId, r as multiTenantPlugin, s as PrefixedIdOptions, t as MultiTenantOptions, u as dateSequentialId, v as cachePlugin, w as AuditTrailMode, x as AuditQueryOptions, y as AuditEntry } from "./multi-tenant.plugin-DVyVGREb.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-Q16ErTu8.mjs";
+import { A as ensureAuditTrailReady, C as AuditTrailMethods, D as AuditTrailQueryOptions, E as AuditTrailQuery, O as EnsureAuditTrailReadyOptions, S as AuditQueryResult, T as AuditTrailOptions, _ as RepositoryCachePluginOptions, a as DateSequentialIdOptions, b as AuditOperation, c as SequentialIdOptions, d as getNextSequence, f as prefixedId, g as RepositoryCacheHandle, h as CacheOptions, i as CustomIdOptions, k as auditTrailPlugin, l as customIdPlugin, m as CacheAdapter, n as adminBypass, o as IdGenerator, p as sequentialId, r as multiTenantPlugin, s as PrefixedIdOptions, t as MultiTenantOptions, u as dateSequentialId, v as cachePlugin, w as AuditTrailMode, x as AuditQueryOptions, y as AuditEntry } from "./multi-tenant.plugin-2VtSSm1Y.mjs";
 import { t as PaginationEngine } from "./PaginationEngine-CBS1XGzp.mjs";
-import { a as Repository, i as HOOK_PRIORITY, n as CreateRepositoryConfig, o as TransitionMachine, r as createRepository, s as AggregationBuilder, t as AuditConfig } from "./create-repository-D4ZU94b3.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-vFufQZMZ.mjs";
-import { A as IdempotencyStorePluginOptions, B as AppendOnlyPluginOptions, C as LeasePluginOptions, D as immutableStatesPlugin, E as ImmutableStatesPluginOptions, F as cascadePlugin, H as AggregateHelpersMethods, I as BatchOperationsMethods, L as BulkWriteResult, M as fieldFilterPlugin, N as ElasticSearchOptions, O as IdempotencyClaim, P as elasticSearchPlugin, R as batchOperationsPlugin, S as LeaseMethods, T as ImmutableClaimView, U as aggregateHelpersPlugin, V as appendOnlyPlugin, _ as observabilityPlugin, a as uniqueField, c as TenantContext, d as SubdocumentMethods, f as subdocumentPlugin, g as OperationMetric, h as ObservabilityOptions, i as requireField, j as idempotencyStorePlugin, k as IdempotencyStoreMethods, l as TenantStore, m as softDeletePlugin, n as blockIf, o as validationChainPlugin, p as SoftDeleteMethods, r as immutableField, s as timestampPlugin, t as autoInject, u as createTenantContext, v as MongoOperationsMethods, w as leasePlugin, x as methodRegistryPlugin, y as mongoOperationsPlugin, z as auditLogPlugin } from "./validation-chain.plugin-BLecaKa0.mjs";
+import { a as AggregationPlan, c as SortOrder, i as AggregationBuilder, l as SortSpec, n as Repository, o as GroupSpec, r as TransitionMachine, s as ProjectionSpec, t as HOOK_PRIORITY, u as VectorSearchOptions } from "./Repository-BAzymuOz.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-BsFH0sTi.mjs";
+import { n as CreateRepositoryConfig, r as createRepository, t as AuditConfig } from "./create-repository-mEdfH9sz.mjs";
+import { A as IdempotencyStoreMethods, B as auditLogPlugin, C as LeaseMethods, D as ImmutableStatesPluginOptions, E as ImmutableClaimView, F as elasticSearchPlugin, H as appendOnlyPlugin, I as cascadePlugin, L as BatchOperationsMethods, M as idempotencyStorePlugin, N as fieldFilterPlugin, O as immutableStatesPlugin, P as ElasticSearchOptions, R as BulkWriteResult, S as methodRegistryPlugin, T as leasePlugin, U as AggregateHelpersMethods, V as AppendOnlyPluginOptions, W as aggregateHelpersPlugin, _ 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 batchOperationsPlugin } from "./validation-chain.plugin-BSshLJTA.mjs";
 import { n as SchemaPathsLike, t as FieldType$1 } from "./coercion-BjdPX3YF.mjs";
 import { n as SchemaIndexes } from "./indexes-DIjMpYES.mjs";
-import { _ as isDuplicateKeyError, a as configureLogger, c as idVariants, f as createFieldPreset, g as createError, h as getMongooseProjection, i as createMemoryCache, m as getFieldsForUser, n as buildCrudSchemasFromModel, p as filterResponseData, r as buildCrudSchemasFromMongooseSchema, t as toPlain, v as parseDuplicateKeyError } from "./to-plain-DkF5px0R.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-BuX1RUZV.mjs";
 import { RepoCapabilities } from "@classytic/repo-core/repository";
-import { ClientSession, PipelineStage } from "mongoose";
+import { ClientSession, Connection, Model, PipelineStage, Schema } from "mongoose";
 //#region src/actions/cascade-references.d.ts
 type PurgeMode = 'hard' | 'soft' | 'anonymize';
 /** Raw collection surface — a native MongoDB `Collection` or a Mongoose `Model`. */
@@ -93,30 +94,270 @@ interface ReferencePurgeResult {
 declare function cascadePurgeReferences(options: CascadePurgeReferencesOptions): Promise<ReferencePurgeResult[]>;
 //#endregion
 //#region src/capabilities.d.ts
-declare const MONGOKIT_CAPABILITIES: RepoCapabilities;
+/** Three-valued transaction answer. `'unknown'` is NOT `'no'` and NOT `'yes'`. */
+type TransactionSupport = 'yes' | 'no' | 'unknown';
+/**
+ * How a capability descriptor's `transactions` flag was arrived at.
+ *
+ * - `'declared'` — a static kit descriptor (sqlitekit, prismakit, or
+ *   {@link MONGOKIT_CAPABILITIES} itself). Absent field ⇒ `'declared'`, so
+ *   every existing kit stays valid without change.
+ * - `'observed'` — read off THIS connection's live deployment topology.
+ * - `'unknown'`  — could not be determined; `transactions` is reported
+ *   `false` (fail closed), which is a different fact from an observed `false`.
+ */
+type CapabilityResolution = 'declared' | 'observed' | 'unknown';
+/**
+ * Mongokit's capability descriptor: `RepoCapabilities` plus the provenance of
+ * the `transactions` flag.
+ *
+ * Structural extension rather than a repo-core change on purpose — the extra
+ * key is optional to every other consumer, and {@link transactionResolutionOf}
+ * reads it defensively so a kernel can accept ANY `RepoCapabilities` (including
+ * a non-mongo kit's) without a cast.
+ */
+interface MongoRepoCapabilities extends RepoCapabilities {
+  readonly transactionsResolution: CapabilityResolution;
+  /**
+   * `LookupOptions.coerce` — join a STRING reference against an `ObjectId` key.
+   *
+   * Declared HERE and not on repo-core's portable `RepoCapabilities` on
+   * purpose: `coerce` is a mongokit-only `LookupOptions` field with no
+   * counterpart on repo-core's `LookupSpec`, so a cross-kit caller cannot
+   * express it. A portable capability flag for a non-portable option would be
+   * decoration — and it would force a repo-core release plus a peer-floor bump
+   * on every kit for a field only one of them can honour.
+   *
+   * It is worth declaring at all because the unsupported case is INVISIBLE: a
+   * `$lookup` comparing `string` to `ObjectId` matches nothing and raises no
+   * error, so a host cannot tell "not supported here" from "no matches".
+   */
+  readonly lookupCoerce: boolean;
+}
+/**
+ * Read the provenance of a capability descriptor's `transactions` flag.
+ * A descriptor without the field is a static declaration (`'declared'`) —
+ * which is exactly right for sqlitekit / prismakit / any kit whose answer
+ * genuinely does not depend on a live deployment.
+ */
+declare function transactionResolutionOf(caps: RepoCapabilities): CapabilityResolution;
+/**
+ * What MongoDB supports through mongokit's surface, DECLARED (not observed).
+ *
+ * Deployment-dependent flags (`transactions`, `nestedTransactions`,
+ * `changeStreams` — all three need a replica set or mongos) are `true` here
+ * because they describe the product, not the server you happen to be pointed
+ * at. **Do not read this constant to decide whether a live connection can run
+ * a transaction** — that is {@link resolveMongoCapabilities}, which is what
+ * `Repository#capabilities` returns. This one is for the cross-kit conformance
+ * harness (which overrides environment-specific limits where it is
+ * constructed) and as the base every observed descriptor is derived from.
+ */
+declare const MONGOKIT_CAPABILITIES: MongoRepoCapabilities;
+interface ServerDescriptionLike {
+  readonly type?: string | undefined;
+}
+interface TopologyDescriptionLike {
+  readonly type?: string | undefined;
+  readonly servers?: ReadonlyMap<string, ServerDescriptionLike> | Record<string, ServerDescriptionLike> | undefined;
+}
+interface ClientLike {
+  readonly topology?: {
+    readonly description?: TopologyDescriptionLike | undefined;
+  } | undefined;
+}
+/**
+ * The slice of a Mongoose `Connection` this module touches. Structural on
+ * purpose — mongokit's topology helpers stay usable with a raw `MongoClient`,
+ * a `Connection`, or a test double, and never import mongoose types.
+ */
+interface CapabilityConnectionLike {
+  readyState?: number | undefined;
+  getClient?: (() => ClientLike | undefined) | undefined;
+  client?: ClientLike | undefined;
+  asPromise?: (() => Promise<unknown>) | undefined;
+  db?: {
+    admin?: (() => {
+      command: (cmd: Record<string, unknown>) => Promise<Record<string, unknown>>;
+    }) | undefined;
+  } | undefined;
+}
+/**
+ * Read whether a connection's LIVE deployment supports multi-document
+ * transactions, synchronously, from the driver's SDAM topology description.
+ *
+ * Free (a few property reads against an object the driver keeps current), so
+ * it is deliberately NOT memoized — a connection that opens after the repo was
+ * constructed upgrades its own answer with no invalidation step. What IS
+ * memoized is the async {@link probeMongoCapabilities} result, which this
+ * function consults first so an exotic deployment that answered `hello` but
+ * exposes no topology still reports definitively.
+ *
+ * @returns `'yes'` / `'no'` when the topology is conclusive, `'unknown'`
+ *   otherwise — never optimistic. See the module docblock on rule 3.
+ */
+declare function resolveTransactionSupport(connection: unknown): TransactionSupport;
+/**
+ * The capability descriptor for a LIVE connection — what
+ * `Repository#capabilities` returns.
+ *
+ * Every deployment-dependent flag reflects the observed topology; everything
+ * else comes from {@link MONGOKIT_CAPABILITIES}. Cheap enough to call per
+ * access (topology read + one frozen-object lookup).
+ */
+declare function resolveMongoCapabilities(connection: unknown): MongoRepoCapabilities;
+/** The three derived descriptors, for tests and for gates that want to compare identity. */
+declare function capabilitiesForSupport(support: TransactionSupport): MongoRepoCapabilities;
+/** Test seam — drop memoized probe answers (a reused connection object across suites). */
+declare function resetCapabilityProbeCache(connection?: unknown): void;
+/** Options for {@link probeMongoCapabilities}. */
+interface CapabilityProbeOptions {
+  /**
+   * Hard ceiling on the whole probe (waiting for the connection to open PLUS
+   * the `hello` round-trip). Exceeding it yields `'unknown'` — a bounded
+   * wrong-but-loud answer, never a hang at boot. Default 2000ms.
+   */
+  timeoutMs?: number;
+}
+/**
+ * Classify a `hello` (or legacy `isMaster`) reply.
+ *
+ * - `msg: 'isdbgrid'` ⇒ mongos ⇒ transactions (Mongo 4.2+ sharded).
+ * - `setName` ⇒ a replica-set member ⇒ transactions.
+ * - a reply that IS a hello (`isWritablePrimary` / `ismaster` present) with
+ *   neither marker ⇒ standalone ⇒ **no**. Verified: a memory-server standalone
+ *   returns `{ isWritablePrimary: true }` and nothing else.
+ * - anything unrecognised ⇒ `'unknown'`. A reply we cannot parse is not a yes.
+ */
+declare function classifyHelloReply(reply: Record<string, unknown> | undefined): TransactionSupport;
+/**
+ * Resolve a connection's real capabilities, waiting for (and if necessary
+ * asking) the deployment. Memoized per connection: N repositories and N
+ * kernels on one connection issue at most ONE `hello`.
+ *
+ * Hosts do not have to call this — `Repository#capabilities` reads the live
+ * topology synchronously, which is already conclusive once
+ * `await mongoose.connect()` has returned (the Kernel Construction Standard's
+ * Describe → **Bind** ordering guarantees that). It exists for the cases the
+ * sync read cannot cover: binding while a connection is still opening, or a
+ * deployment whose driver surfaces no topology description. Calling it makes
+ * the SUBSEQUENT synchronous reads definitive, so nothing else needs rewiring:
+ *
+ * ```ts
+ * await probeMongoCapabilities(connection);   // once, before bind
+ * const engine = defineWallet().bind(connection);  // gate now sees the truth
+ * ```
+ *
+ * Only definitive answers are cached — an `'unknown'` may be re-probed later
+ * (the deployment may simply not have been up yet).
+ */
+declare function probeMongoCapabilities(connection: unknown, options?: CapabilityProbeOptions): Promise<MongoRepoCapabilities>;
 //#endregion
 //#region src/filter/compile.d.ts
+declare function compileFilterToMongo(input: unknown,
+/**
+ * Mongoose schema for the collection being filtered. Supply it wherever it is available:
+ * without it the date coercion guesses from the value's SHAPE alone and silently breaks
+ * range filters on ISO-shaped string columns. See `CoerceFilterDatesOptions.isDateField`.
+ */
+schema?: Schema): Record<string, unknown>;
+//#endregion
+//#region src/model-blueprint.d.ts
+/**
+ * What a bind does when a model name is ALREADY registered on the connection.
+ *
+ * There is no default — the kernel chooses per model, because the three are not
+ * interchangeable and a silent choice is how schema/index contributions get dropped.
+ */
+type ExistingModelPolicy =
+/**
+ * The caller is contributing schema (fields, indexes) Mongoose cannot apply to a locked
+ * schema — reusing would silently drop it, so fail loud. The production default.
+ */
+{
+  readonly mode: 'throw';
+  readonly hint?: string;
+} |
+/** Idempotent registration — the caller adds nothing new, so an existing model is correct. */
+{
+  readonly mode: 'reuse';
+} |
+/**
+ * Clobber an existing model, then register fresh. An explicit test/development escape hatch
+ * (hot-reload, fixtures) — replacing a live model in production is a footgun and THROWS.
+ * `environment` documents intent; a bind still refuses when `NODE_ENV === 'production'`.
+ */
+{
+  readonly mode: 'replace';
+  readonly environment: 'test' | 'development';
+};
+interface ModelSpec<TDocument = unknown> {
+  readonly name: string;
+  /** Explicit collection name. Omit for Mongoose's default pluralization. */
+  readonly collection?: string;
+  /** Schema FACTORY — built at most once, only when this model is actually registered. */
+  readonly schema: () => Schema<TDocument>;
+  /** What to do if `name` is already registered on the bind connection. */
+  readonly existing: ExistingModelPolicy;
+}
+interface ModelBlueprint<TModels> {
+  /** Every model name this blueprint will register — known WITHOUT a connection. */
+  readonly modelNames: readonly string[];
+  /**
+   * Compile + register every model on `connection`, then assemble the typed model bag.
+   *
+   * Registration is connection-local (uses `connection.models`, never the global registry).
+   * On a partial failure, models THIS bind created are removed from the connection's registry
+   * (a registry rollback — it never touches database collections) and the original error is
+   * re-thrown with the names that had already bound.
+   */
+  bind(connection: Connection): TModels;
+}
 /**
- * Filter IR → MongoDB query compiler.
- *
- * Mirrors sqlitekit's `compileFilterToDrizzle`: takes a repo-core
- * `Filter` tree and emits a MongoDB query object. Used by `groupBy` /
- * `groupByPaginate` to translate the portable AggRequest's `filter`
- * + `having` into `$match` stages.
- *
- * Scope: the same operator set sqlitekit supports (`eq`, `ne`, `gt`,
- * `gte`, `lt`, `lte`, `in`, `nin`, `exists`, `like`, `regex`, `and`,
- * `or`, `not`, `raw`). Anything else throws so we fail loud instead
- * of silently dropping predicates.
- *
- * Why only this op set here and not everywhere in mongokit? Historic
- * reason: mongokit pre-dates repo-core's Filter IR, so its existing
- * policy plugins (multi-tenant, soft-delete) speak MongoDB query
- * language directly. Converting mongokit's entire filter pipeline
- * to Filter IR is out-of-scope for this change — we introduce the
- * compiler only where the new portable `groupBy` IR needs it.
+ * Describe a set of models as a connection-free blueprint. Duplicate spec names are rejected
+ * here, at describe time, before any connection is involved.
  */
-declare function compileFilterToMongo(input: unknown): Record<string, unknown>;
+declare function defineModels<TModels>(spec: {
+  readonly models: readonly ModelSpec<any>[];
+  /** Turn the bound `name -> Model` map into the kernel's typed model bag. */
+  readonly assemble: (models: ReadonlyMap<string, Model<unknown>>) => TModels;
+}): ModelBlueprint<TModels>;
+//#endregion
+//#region src/model-registry.d.ts
+/**
+ * A model name was already registered when a `throw` policy required it to be free.
+ *
+ * Typed (not a bare `Error`) so consumers — kernels wrapping their own domain collision error,
+ * tests asserting the failure — can `instanceof`-check it instead of matching a message string.
+ */
+declare class ModelCollisionError extends Error {
+  readonly modelName: string;
+  constructor(modelName: string, detail?: string);
+}
+interface DefineModelOptions {
+  /** What to do when the name is already registered. Required — see the note above. */
+  onExisting: 'reuse' | 'throw';
+  /** Register on a specific connection instead of the default mongoose instance. */
+  connection?: Connection;
+  /** Extra context appended to the `throw` message (which call site, what would be lost). */
+  throwHint?: string;
+  /**
+   * Explicit collection name — Mongoose's third `model()` argument. Omit for Mongoose's
+   * default pluralization. Passed through only on a FRESH registration (a `reuse` hit
+   * returns the existing model, whose collection is already fixed).
+   */
+  collection?: string;
+}
+/** Is this model name already registered? Prefer {@link defineModel} over asking. */
+declare function isModelRegistered(name: string, connection?: Connection): boolean;
+/**
+ * Register a model, or return the existing one, according to `onExisting`.
+ *
+ * `schema` is a FACTORY so it is never built when an existing model wins — building a
+ * schema has side effects (plugin application, index declaration) that should not run for
+ * a registration that is about to be discarded.
+ */
+declare function defineModel<TDoc>(name: string, schema: () => Schema<TDoc>, options: DefineModelOptions): Model<TDoc>;
 //#endregion
 //#region src/operations.d.ts
 /**
@@ -155,7 +396,7 @@ declare const READ_OPERATIONS: readonly RepositoryOperation[];
 declare function operationsByPolicyKey(key: PolicyKey): RepositoryOperation[];
 //#endregion
 //#region src/query/parser/types.d.ts
-type SortSpec$1 = Record<string, 1 | -1>;
+type SortSpec$2 = Record<string, 1 | -1>;
 type FilterQuery = Record<string, unknown>;
 /**
  * Mongoose-compatible populate option
@@ -177,7 +418,7 @@ interface PopulateOption {
   /** Query options (limit, sort, skip) */
   options?: {
     limit?: number;
-    sort?: SortSpec$1;
+    sort?: SortSpec$2;
     skip?: number;
   };
   /** Nested populate configuration */
@@ -188,7 +429,7 @@ interface ParsedQuery {
   /** MongoDB filter query */
   filters: FilterQuery;
   /** Sort specification */
-  sort?: SortSpec$1;
+  sort?: SortSpec$2;
   /** Fields to populate (simple comma-separated string) */
   populate?: string;
   /**
@@ -359,6 +600,19 @@ declare class QueryParser {
    * Returns `undefined` if no whitelist is set (all fields allowed).
    */
   get allowedSortFields(): string[] | undefined;
+  /**
+   * The configured page-size cap — EXPOSED so a caller does not apply a second one.
+   *
+   * A resource that constructs `new QueryParser({ maxLimit: 1000 })` has answered the
+   * question "how large may a page be?". Without a way to read it back, every layer
+   * downstream applies its own default and the LOWEST silently wins — which is exactly
+   * what happened: a resource asked for 1000, a repository was configured for 1000, and
+   * arc's `QueryResolver` capped at its own default of 100. Three caps, one winner, no
+   * signal, and an account picker that showed 100 of 696 rows.
+   *
+   * Read this instead of defaulting when a parser is supplied.
+   */
+  get maxLimit(): number;
   /**
    * Get the configured allowed operators.
    * Returns `undefined` if no whitelist is set (all built-in operators allowed).
@@ -495,15 +749,23 @@ declare function isTransactionUnsupported(error: Error): boolean;
 /**
  * PROACTIVELY report whether a connection's deployment supports multi-document
  * transactions — the read-side companion to {@link isTransactionUnsupported}
- * (which classifies a FAILED attempt). Single source of truth for the topology
- * check so callers don't hand-roll `client.topology.description.type` probing.
- *
- * Returns `false` ONLY when the topology is positively a standalone (`'Single'`)
- * server; an unknown/undefined topology (not yet connected, non-standard
- * connection object) returns `true` — optimistic, because a genuine failure is
- * still caught reactively by `isTransactionUnsupported`. Lets a caller skip a
- * doomed transaction attempt on standalone dev Mongo rather than starting one
- * just to catch the error.
+ * (which classifies a FAILED attempt). Lets a caller skip a doomed transaction
+ * attempt on standalone dev Mongo rather than starting one just to catch the
+ * error.
+ *
+ * Delegates to {@link resolveTransactionSupport} so mongokit has exactly ONE
+ * topology reader. That also fixes a false NEGATIVE this function used to
+ * have: it tested `description.type !== 'Single'`, but a single-node replica
+ * set reached with `directConnection` is `Single` with a server type of
+ * `RSPrimary` and runs transactions fine. The shared reader looks at the
+ * SERVER descriptions first.
+ *
+ * **`unknown` is optimistic HERE and pessimistic in `capabilities.ts` — the
+ * difference is deliberate.** This answers "should I bother ATTEMPTING a
+ * transaction?", where guessing yes costs one caught error (`allowFallback`
+ * still recovers). The capability descriptor answers "may this deployment be
+ * trusted with money?", where guessing yes is the bug class this repo keeps
+ * hitting (AGENTS.md FAIL LOUD rule 3). Do not "unify" them.
  *
  * Accepts a Mongoose `Connection` (or anything exposing `getClient()`/`client`
  * with a driver `topology`), so it stays decoupled from mongoose types.
@@ -709,4 +971,4 @@ declare function createOptionsExtractor<TCtx extends Record<string, unknown>>(fi
  */
 declare function systemContext(extra?: SessionOptions): SessionOptions;
 //#endregion
-export { ALL_OPERATIONS, type AggregateHelpersMethods, type AggregateOptions, type AggregatePaginationOptions, AggregationBuilder, 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 BulkWriteResult, type CacheAdapter, type CacheOperationOptions, type CacheOptions, type CacheableOptions, type CascadeOptions, type CascadePurgeReferencesOptions, type CascadeRelation, type CollationOptions, type CollectionRWLike, type CreateInput, type CreateOptions, type CreateRepositoryConfig, type CursorPayload, type CustomIdOptions, type DateSequentialIdOptions, type DecodedCursor, type DeepPartial, type DeleteResult, type DocField, type ElasticSearchOptions, type EnsureAuditTrailReadyOptions, type EventHandlers, type EventPayload, type EventPhase, type FieldPreset, type FieldType, type FilterQuery, type FindOneAndUpdateOptions, type GroupResult, HOOK_PRIORITY, type HookMode, type IdGenerator, type IdempotencyClaim, type IdempotencyStoreMethods, type IdempotencyStorePluginOptions, type ImmutableClaimView, type ImmutableStatesPluginOptions, type InferDocument, type InferRawDoc, type KeysOfType, type KeysetPaginationOptions, type LeaseMethods, type LeasePluginOptions, type Logger, LookupBuilder, type LookupOptions, type LookupPopulateOptions, type LookupPopulateResult, MONGOKIT_CAPABILITIES, MONGOKIT_PLUGIN_NAMES, MUTATING_OPERATIONS, type Middleware, type MiddlewareContext, type MinMaxResult, type MinimalRepoView, type MongoKitPluginName, type MongoOperationsMethods, type MongoOperatorUpdate, type MultiTenantOptions, type NonNullableFields, OP_REGISTRY, type ObjectId, type ObservabilityOptions, type OffsetPaginationOptions, type OperationDescriptor, type OperationMetric, type OperationOptions, type PaginationConfig, PaginationEngine, type ParsedQuery, type PartialBy, type Plugin, type PluginFunction, type PluginType, type PolicyKey, type PopulateOption, type PopulateSpec, type PrefixedIdOptions, type PrioritizedHook, type PurgeMode, type PurgeableRepoLike, QueryParser, type QueryParserOptions, READ_OPERATIONS, type ReadOptions, type ReadPreferenceType, type ReferencePurgeResult, type ReferenceRelation, Repository, Repository as default, type RepositoryCacheHandle, type RepositoryCachePluginOptions, type RepositoryContext, type RepositoryEvent, type RepositoryInstance, type RepositoryOperation, type RepositoryOptions, type RepositoryPluginName, type RequiredBy, type SchemaLike, type SearchMode, type SelectSpec, type SequentialIdOptions, type SessionOptions, type SoftDeleteFilterMode, type SoftDeleteMethods, type SoftDeleteOptions, type SoftDeleteRepository, type SortDirection, type SortSpec, type Strict, type SubdocumentMethods, type TenantContext, type TenantStore, type TransitionMachine, type UpdateManyResult, type UpdateOptions, type UpdatePatch, type UpdateWithValidationResult, type UserContext, type ValidationChainOptions, type ValidatorDefinition, type ValueType, type WithPlugins, type WithTransactionOptions, index_d_exports as actions, adminBypass, aggregateHelpersPlugin, appendOnlyPlugin, auditLogPlugin, auditTrailPlugin, autoInject, batchOperationsPlugin, batchTransaction, blockIf, buildCrudSchemasFromModel, buildCrudSchemasFromMongooseSchema, cachePlugin, cascadePlugin, cascadePurgeReferences, compileFilterToMongo, configureLogger, createError, createFieldPreset, createMemoryCache, createOptionsExtractor, createRepository, createTenantContext, customIdPlugin, dateSequentialId, elasticSearchPlugin, ensureAuditTrailReady, fieldFilterPlugin, filterResponseData, getFieldsForUser, getMongooseProjection, getNextSequence, idVariants, idempotencyStorePlugin, immutableField, immutableStatesPlugin, isDuplicateKeyError, isTransactionUnsupported, leasePlugin, methodRegistryPlugin, mongoOperationsPlugin, multiTenantPlugin, observabilityPlugin, operationsByPolicyKey, parseDuplicateKeyError, prefixedId, repoOptionsFromCtx, requireField, sequentialId, softDeletePlugin, subdocumentPlugin, supportsTransactions, systemContext, timestampPlugin, toPlain, uniqueField, validationChainPlugin, withTransaction };
+export { ALL_OPERATIONS, 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 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 CreateErrorOptions, type CreateInput, type CreateOptions, type CreateRepositoryConfig, type CrudSchemasFramework, type CursorPayload, 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 GroupResult, type GroupSpec, HOOK_PRIORITY, type HookMode, type IdGenerator, type IdempotencyClaim, type IdempotencyStoreMethods, type IdempotencyStorePluginOptions, type ImmutableClaimView, type ImmutableStatesPluginOptions, type InferDocument, type InferRawDoc, type KeysOfType, type KeysetPaginationOptions, 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 MultiTenantOptions, type NonNullableFields, OP_REGISTRY, type ObjectId, type ObservabilityOptions, type OffsetPaginationOptions, type OperationDescriptor, type OperationMetric, type OperationOptions, type OperationType, type PaginationConfig, PaginationEngine, type ParseDuplicateKeyOptions, type ParsedQuery, type PartialBy, type Plugin, type PluginFunction, type PluginType, type PolicyKey, type PopulateOption, type PopulateSpec, type PrefixedIdOptions, type PrioritizedHook, type ProjectionSpec, type PurgeMode, type PurgeableRepoLike, QueryParser, type QueryParserOptions, type QuerySchema, READ_OPERATIONS, type ReadOptions, type ReadPreferenceType, type ReferencePurgeResult, type ReferenceRelation, Repository, Repository as default, type RepositoryCacheHandle, type RepositoryCachePluginOptions, type RepositoryContext, type RepositoryEvent, type RepositoryInstance, type RepositoryOperation, type RepositoryOptions, type RepositoryPluginName, type RequiredBy, 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, 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, index_d_exports as actions, adminBypass, aggregateHelpersPlugin, appendOnlyPlugin, auditLogPlugin, auditTrailPlugin, autoInject, batchOperationsPlugin, batchTransaction, blockIf, buildCrudSchemasFromModel, buildCrudSchemasFromMongooseSchema, cachePlugin, capabilitiesForSupport, cascadePlugin, cascadePurgeReferences, classifyHelloReply, compileFilterToMongo, configureLogger, createError, createFieldPreset, createMemoryCache, createOptionsExtractor, createRepository, createTenantContext, customIdPlugin, dateSequentialId, defineModel, defineModels, elasticSearchPlugin, ensureAuditTrailReady, fieldFilterPlugin, filterResponseData, getFieldsForUser, getMongooseProjection, getNextSequence, idVariants, idempotencyStorePlugin, immutableField, immutableStatesPlugin, isDuplicateKeyError, isModelRegistered, isTransactionUnsupported, leasePlugin, methodRegistryPlugin, mongoOperationsPlugin, multiTenantPlugin, observabilityPlugin, operationsByPolicyKey, parseDuplicateKeyError, prefixedId, probeMongoCapabilities, repoOptionsFromCtx, requireField, resetCapabilityProbeCache, resolveMongoCapabilities, resolveTransactionSupport, sequentialId, softDeletePlugin, subdocumentPlugin, supportsTransactions, systemContext, timestampPlugin, toPlain, transactionResolutionOf, uniqueField, validationChainPlugin, withTransaction };