@classytic/mongokit 3.28.0 → 3.30.0

package/dist/{timestamp.plugin-ennbatTW.mjs → timestamp.plugin-ChFRcLRJ.mjs}

@@ -1,6 +1,5 @@
-import { c as ALL_OPERATIONS, t as HOOK_PRIORITY, u as OP_REGISTRY } from "./Repository-BFBTAMlA.mjs";
+import { c as ALL_OPERATIONS, t as HOOK_PRIORITY, u as OP_REGISTRY } from "./Repository-X7U2d0kU.mjs";
 import { n as warn } from "./logger-K7dPmu2U.mjs";
-import { t as createError } from "./error-BuByZwKU.mjs";
 import { throwIfAborted, withRetry } from "@classytic/repo-core/repository";
 import mongoose from "mongoose";
 import { cachePlugin } from "@classytic/repo-core/cache";
@@ -632,81 +631,6 @@ var AuditTrailQuery = class {
 	}
 };
 //#endregion
-//#region src/plugins/batch-operations.plugin.ts
-/**
-* Batch operations plugin.
-*
-* @example
-* const repo = new Repository(Model, [
-*   methodRegistryPlugin(),
-*   batchOperationsPlugin(),
-* ]);
-*
-* // updateMany + deleteMany are primitives on Repository — no plugin needed.
-* await repo.updateMany({ status: 'pending' }, { status: 'active' });
-* await repo.deleteMany({ status: 'deleted' });
-*
-* // bulkWrite is what this plugin contributes.
-* await repo.bulkWrite([...ops]);
-*/
-function batchOperationsPlugin() {
-	return {
-		name: "batch-operations",
-		apply(repo) {
-			if (!repo.registerMethod) throw new Error("batchOperationsPlugin requires methodRegistryPlugin");
-			/**
-			* Execute heterogeneous bulk write operations in a single database call.
-			*
-			* Supports insertOne, updateOne, updateMany, deleteOne, deleteMany, and replaceOne
-			* operations mixed together for maximum efficiency.
-			*
-			* @example
-			* await repo.bulkWrite([
-			*   { insertOne: { document: { name: 'New Item', price: 10 } } },
-			*   { updateOne: { filter: { _id: id1 }, update: { $inc: { views: 1 } } } },
-			*   { updateMany: { filter: { status: 'draft' }, update: { $set: { status: 'published' } } } },
-			*   { deleteOne: { filter: { _id: id2 } } },
-			* ]);
-			*/
-			repo.registerMethod("bulkWrite", async function(operations, options = {}) {
-				const context = await this._buildContext("bulkWrite", {
-					operations,
-					...options
-				});
-				try {
-					const finalOps = context.operations || operations;
-					if (!finalOps || finalOps.length === 0) throw createError(400, "bulkWrite requires at least one operation");
-					const result = await this.Model.bulkWrite(finalOps, {
-						ordered: options.ordered ?? true,
-						session: options.session
-					});
-					const bulkResult = {
-						ok: result.ok,
-						insertedCount: result.insertedCount,
-						upsertedCount: result.upsertedCount,
-						matchedCount: result.matchedCount,
-						modifiedCount: result.modifiedCount,
-						deletedCount: result.deletedCount,
-						insertedIds: result.insertedIds,
-						upsertedIds: result.upsertedIds
-					};
-					await this.emitAsync("after:bulkWrite", {
-						context,
-						result: bulkResult
-					});
-					return bulkResult;
-				} catch (error) {
-					this.emit("error:bulkWrite", {
-						context,
-						error
-					});
-					throw this._handleError(error);
-				}
-			});
-		}
-	};
-}
-//#endregion
 //#region src/plugins/custom-id.plugin.ts
 /**
 * Custom ID Plugin
@@ -893,7 +817,6 @@ function dateSequentialId(options) {
 			default:
 				datePart = `${year}${separator}${month}`;
 				counterKey = `${model.modelName}:${year}-${month}`;
-				break;
 		}
 		const seq = await getNextSequence(counterKey, 1, context._counterConnection, context.session);
 		return `${prefix}${separator}${datePart}${separator}${String(seq).padStart(padding, "0")}`;
@@ -972,50 +895,18 @@ function customIdPlugin(options) {
 					docsNeedingIds.push(doc);
 				}
 				if (docsNeedingIds.length === 0) return;
-				for (const doc of docsNeedingIds) doc[fieldName] = await options.generator({
-					...context,
-					data: doc
-				});
+				for (const doc of docsNeedingIds) {
+					const id = await options.generator({
+						...context,
+						data: doc
+					});
+					doc[fieldName] = id;
+				}
 			});
 		}
 	};
 }
 //#endregion
-//#region src/plugins/method-registry.plugin.ts
-/**
-* Method registry plugin that enables dynamic method registration
-*/
-function methodRegistryPlugin() {
-	return {
-		name: "method-registry",
-		apply(repo) {
-			const registeredMethods = [];
-			/**
-			* Register a new method on the repository instance
-			*/
-			repo.registerMethod = (name, fn) => {
-				if (repo[name]) throw new Error(`Cannot register method '${name}': Method already exists on repository. Choose a different name or use a plugin that doesn't conflict.`);
-				if (!name || typeof name !== "string") throw new Error("Method name must be a non-empty string");
-				if (typeof fn !== "function") throw new Error(`Method '${name}' must be a function`);
-				repo[name] = fn.bind(repo);
-				registeredMethods.push(name);
-				repo.emit("method:registered", {
-					name,
-					fn
-				});
-			};
-			/**
-			* Check if a method is registered
-			*/
-			repo.hasMethod = (name) => typeof repo[name] === "function";
-			/**
-			* Get list of all dynamically registered methods
-			*/
-			repo.getRegisteredMethods = () => [...registeredMethods];
-		}
-	};
-}
-//#endregion
 //#region src/plugins/multi-tenant.plugin.ts
 /**
 * Multi-Tenant Plugin
@@ -1147,34 +1038,32 @@ function multiTenantPlugin(options = {}) {
 								}
 							}
 							break;
-						case "operations":
-							if (context.operations) {
-								const ops = context.operations;
-								for (const subOp of ops) {
-									for (const key of [
-										"updateOne",
-										"updateMany",
-										"deleteOne",
-										"deleteMany",
-										"replaceOne"
-									]) {
-										const opBody = subOp[key];
-										if (opBody?.filter) {
-											assertTenantValue(opBody.filter[tenantField], `bulkWrite ${key}.filter`);
-											opBody.filter = {
-												...opBody.filter,
-												[tenantField]: castId
-											};
-										}
-									}
-									const insertBody = subOp.insertOne;
-									if (insertBody?.document) {
-										assertTenantValue(insertBody.document[tenantField], "bulkWrite insertOne.document");
-										insertBody.document[tenantField] = castId;
+						case "operations": if (context.operations) {
+							const ops = context.operations;
+							for (const subOp of ops) {
+								for (const key of [
+									"updateOne",
+									"updateMany",
+									"deleteOne",
+									"deleteMany",
+									"replaceOne"
+								]) {
+									const opBody = subOp[key];
+									if (opBody?.filter) {
+										assertTenantValue(opBody.filter[tenantField], `bulkWrite ${key}.filter`);
+										opBody.filter = {
+											...opBody.filter,
+											[tenantField]: castId
+										};
 									}
 								}
+								const insertBody = subOp.insertOne;
+								if (insertBody?.document) {
+									assertTenantValue(insertBody.document[tenantField], "bulkWrite insertOne.document");
+									insertBody.document[tenantField] = castId;
+								}
 							}
-							break;
+						}
 					}
 				}, { priority: HOOK_PRIORITY.POLICY });
 			}
@@ -1542,4 +1431,4 @@ function timestampPlugin() {
 	};
 }
 //#endregion
-export { methodRegistryPlugin as a, getNextSequence as c, cachePlugin as d, batchOperationsPlugin as f, auditLogPlugin as g, ensureAuditTrailReady as h, multiTenantPlugin as i, prefixedId as l, auditTrailPlugin as m, softDeletePlugin as n, customIdPlugin as o, AuditTrailQuery as p, adminBypass$1 as r, dateSequentialId as s, timestampPlugin as t, sequentialId as u };
+export { customIdPlugin as a, prefixedId as c, AuditTrailQuery as d, auditTrailPlugin as f, multiTenantPlugin as i, sequentialId as l, auditLogPlugin as m, softDeletePlugin as n, dateSequentialId as o, ensureAuditTrailReady as p, adminBypass$1 as r, getNextSequence as s, timestampPlugin as t, cachePlugin as u };

package/dist/{to-plain-DkF5px0R.d.mts → to-plain-BuX1RUZV.d.mts}

@@ -1,5 +1,5 @@
-import { v as UserContext } from "./repository-DCHRWRXw.mjs";
-import { r as FieldPreset } from "./plugin-options-vFufQZMZ.mjs";
+import { v as UserContext } from "./repository-Q16ErTu8.mjs";
+import { r as FieldPreset } from "./plugin-options-BsFH0sTi.mjs";
 import mongoose, { Schema } from "mongoose";
 import { CacheAdapter } from "@classytic/repo-core/cache";
 import { CrudSchemas, SchemaBuilderOptions } from "@classytic/repo-core/schema";
@@ -288,8 +288,16 @@ declare function buildCrudSchemasFromMongooseSchema(mongooseSchema: Schema, opti
  * field accepts this function directly with no glue. Future Mongo-shaped
  * kits implementing the same contract are interchangeable at the adapter
  * boundary.
+ *
+ * GENERIC over the document type, not fixed to `Model<unknown>`. Only
+ * `.schema` is read, so the document type is irrelevant here — but Mongoose's
+ * `Model<T>` is INVARIANT through `schema.static`, so a hard `Model<unknown>`
+ * parameter rejects every concretely-typed model a host actually has. That is
+ * not theoretical: it made `arc init`'s generated `example.schemas.ts` fail
+ * `tsc` on a brand-new project. Instantiating `TDoc = unknown` still satisfies
+ * `SchemaGenerator<Model<unknown>>`, so the contract claim above is unchanged.
  */
-declare function buildCrudSchemasFromModel(mongooseModel: mongoose.Model<unknown>, options?: SchemaBuilderOptions): CrudSchemasFramework;
+declare function buildCrudSchemasFromModel<TDoc = unknown>(mongooseModel: mongoose.Model<TDoc>, options?: SchemaBuilderOptions): CrudSchemasFramework;
 //#endregion
 //#region src/utils/to-plain.d.ts
 /**
@@ -320,4 +328,4 @@ declare function buildCrudSchemasFromModel(mongooseModel: mongoose.Model<unknown
  */
 declare function toPlain<T>(value: T): T;
 //#endregion
-export { isDuplicateKeyError as _, configureLogger as a, idVariants as c, toObjectId as d, createFieldPreset as f, createError as g, getMongooseProjection as h, createMemoryCache as i, isObjectIdInstance as l, getFieldsForUser as m, buildCrudSchemasFromModel as n, IdType as o, filterResponseData as p, buildCrudSchemasFromMongooseSchema as r, getSchemaIdType as s, toPlain as t, isValidIdForType as u, parseDuplicateKeyError as v };
+export { parseDuplicateKeyError as S, getMongooseProjection as _, createMemoryCache as a, createError as b, IdType as c, isObjectIdInstance as d, isValidIdForType as f, getFieldsForUser as g, filterResponseData as h, buildCrudSchemasFromMongooseSchema as i, getSchemaIdType as l, createFieldPreset as m, CrudSchemasFramework as n, LoggerConfig as o, toObjectId as p, buildCrudSchemasFromModel as r, configureLogger as s, toPlain as t, idVariants as u, CreateErrorOptions as v, isDuplicateKeyError as x, ParseDuplicateKeyOptions as y };

package/dist/{update-1Lq9OMD2.mjs → update-DHdXdOk_.mjs}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import { n as warn } from "./logger-K7dPmu2U.mjs";
 import { t as createError } from "./error-BuByZwKU.mjs";
-import { isFilter } from "@classytic/repo-core/filter";
+import { coerceFilterDates, isFilter } from "@classytic/repo-core/filter";
 //#region src/filter/compile.ts
 /**
 * Compile a Filter IR node to a MongoDB query object. Returns `{}`
@@ -34,47 +34,41 @@ const SHORTHAND_OPS = /* @__PURE__ */ new Set([
 	"regex",
 	"mod"
 ]);
-/** Range operators whose string values should be coerced to Date. */
-const RANGE_OPS = /* @__PURE__ */ new Set([
-	"gt",
-	"gte",
-	"lt",
-	"lte"
+/** Logical operators whose operand is an array of sub-queries to recurse into. */
+const LOGICAL_ARRAY_OPS = /* @__PURE__ */ new Set([
+	"$and",
+	"$or",
+	"$nor"
 ]);
-/** ISO-8601 date-only or datetime string pattern. */
-const ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}/;
-/**
-* Coerce a string value to a Date when it looks like an ISO-8601 date.
-* Needed because MongoDB won't match a BSON Date field against a string
-* value even when using range operators — BSON type comparison treats
-* Date (type 9) and String (type 2) as distinct, so `{ createdAt: {
-* $gte: "2026-05-01" } }` never matches a Date-typed field.
-*/
-function tryCoerceDate(value) {
-	if (typeof value === "string" && ISO_DATE_RE.test(value)) {
-		const d = new Date(value);
-		return Number.isNaN(d.getTime()) ? value : d;
-	}
-	return value;
-}
 /**
-* Expand operator shorthand values in a plain Mongo-style query object.
+* Expand operator shorthand values in a plain Mongo-style query object —
+* `$`-prefixing is the ONE Mongo-dialect concern this function owns. Date
+* coercion is delegated to `coerceFilterDates` (repo-core) so the ISO
+* pattern has a single source of truth shared with the URL-parsing boundary.
+*
 * Only expands nested objects whose keys are ALL in `SHORTHAND_OPS` — so
 * real nested documents (e.g. `address: { city: 'Dhaka' }`) pass through
 * unchanged, while `createdAt: { gte: '2026-04-01', lte: '2026-05-01' }`
-* becomes `createdAt: { $gte: Date(2026-04-01), $lte: Date(2026-05-01) }`.
-* String values on range operators are coerced to Date when they match the
-* ISO-8601 pattern, so BSON Date fields in MongoDB are compared correctly.
+* becomes `createdAt: { $gte: '2026-04-01', $lte: '2026-05-01' }` for the
+* coercion pass to type.
+*
+* Recurses `$and` / `$or` / `$nor` because a policy-scope merge conjoins the
+* caller filter under `$and`, and un-prefixed shorthand nested there would
+* otherwise reach `$match` as a literal field named `gte`.
 */
 function expandShorthands(obj) {
 	const out = {};
 	for (const [key, value] of Object.entries(obj)) {
+		if (LOGICAL_ARRAY_OPS.has(key) && Array.isArray(value)) {
+			out[key] = value.map((entry) => entry !== null && typeof entry === "object" && !Array.isArray(entry) ? expandShorthands(entry) : entry);
+			continue;
+		}
 		if (value !== null && typeof value === "object" && !Array.isArray(value)) {
 			const nested = value;
 			const keys = Object.keys(nested);
 			if (keys.length > 0 && keys.every((k) => !k.startsWith("$") && SHORTHAND_OPS.has(k))) {
 				const expanded = {};
-				for (const [op, opVal] of Object.entries(nested)) expanded[`$${op}`] = RANGE_OPS.has(op) ? tryCoerceDate(opVal) : opVal;
+				for (const [op, opVal] of Object.entries(nested)) expanded[`$${op}`] = opVal;
 				out[key] = expanded;
 				continue;
 			}
@@ -83,9 +77,28 @@ function expandShorthands(obj) {
 	}
 	return out;
 }
-function compileFilterToMongo(input) {
+/**
+* Build the schema oracle `coerceFilterDates` needs from a mongoose schema.
+*
+* A path is date-coercible only when the schema says it is a Date. Everything else — most
+* importantly a `String` path whose values are ISO-shaped, like a `civilDate` of
+* `'2026-08-02'` — keeps its operand verbatim.
+*
+* Unknown paths default to TRUE (coerce). A filter on a path the schema does not declare
+* is usually a `strict: false` extension or a nested/dynamic key, and the old
+* value-shape-only behaviour is the safer default there: coercing a genuine date string is
+* right far more often than not for an undeclared path.
+*/
+function schemaDateOracle(schema) {
+	return (field) => {
+		const path = schema.path(field);
+		if (!path) return true;
+		return path.instance === "Date";
+	};
+}
+function compileFilterToMongo(input, schema) {
 	if (!input) return {};
-	if (!isFilter(input)) return expandShorthands(input);
+	if (!isFilter(input)) return coerceFilterDates(expandShorthands(input), schema ? { isDateField: schemaDateOracle(schema) } : void 0);
 	return compile(input);
 }
 function compile(filter) {

package/dist/utils/index.d.mts

@@ -1,2 +1,2 @@
-import { a as configureLogger, d as toObjectId, f as createFieldPreset, g as createError, h as getMongooseProjection, i as createMemoryCache, l as isObjectIdInstance, m as getFieldsForUser, n as buildCrudSchemasFromModel, o as IdType, p as filterResponseData, r as buildCrudSchemasFromMongooseSchema, s as getSchemaIdType, t as toPlain, u as isValidIdForType } from "../to-plain-DkF5px0R.mjs";
-export { type IdType, buildCrudSchemasFromModel, buildCrudSchemasFromMongooseSchema, configureLogger, createError, createFieldPreset, createMemoryCache, filterResponseData, getFieldsForUser, getMongooseProjection, getSchemaIdType, isObjectIdInstance, isValidIdForType, toObjectId, toPlain };
+import { _ as getMongooseProjection, a as createMemoryCache, b as createError, c as IdType, d as isObjectIdInstance, f as isValidIdForType, g as getFieldsForUser, h as filterResponseData, i as buildCrudSchemasFromMongooseSchema, l as getSchemaIdType, m as createFieldPreset, n as CrudSchemasFramework, o as LoggerConfig, p as toObjectId, r as buildCrudSchemasFromModel, s as configureLogger, t as toPlain, v as CreateErrorOptions, y as ParseDuplicateKeyOptions } from "../to-plain-BuX1RUZV.mjs";
+export { type CreateErrorOptions, type CrudSchemasFramework, type IdType, type LoggerConfig, type ParseDuplicateKeyOptions, buildCrudSchemasFromModel, buildCrudSchemasFromMongooseSchema, configureLogger, createError, createFieldPreset, createMemoryCache, filterResponseData, getFieldsForUser, getMongooseProjection, getSchemaIdType, isObjectIdInstance, isValidIdForType, toObjectId, toPlain };

package/dist/utils/index.mjs

@@ -3,5 +3,5 @@ import { t as configureLogger } from "../logger-K7dPmu2U.mjs";
 import { t as createError } from "../error-BuByZwKU.mjs";
 import { i as getMongooseProjection, n as filterResponseData, r as getFieldsForUser, t as createFieldPreset } from "../field-selection-FSQFLpsU.mjs";
 import { n as createMemoryCache, t as toPlain } from "../to-plain-vksRrLtc.mjs";
-import { n as buildCrudSchemasFromMongooseSchema, t as buildCrudSchemasFromModel } from "../mongooseToJsonSchema-CByt1VhQ.mjs";
+import { n as buildCrudSchemasFromMongooseSchema, t as buildCrudSchemasFromModel } from "../mongooseToJsonSchema-DKbnKduN.mjs";
 export { buildCrudSchemasFromModel, buildCrudSchemasFromMongooseSchema, configureLogger, createError, createFieldPreset, createMemoryCache, filterResponseData, getFieldsForUser, getMongooseProjection, getSchemaIdType, isObjectIdInstance, isValidIdForType, toObjectId, toPlain };

package/dist/{validation-chain.plugin-Cm0Ttnd8.d.mts → validation-chain.plugin-BSshLJTA.d.mts}

@@ -1,6 +1,6 @@
 import { a as PopulateSpec, i as ObjectId, l as SortSpec, s as SelectSpec } from "./core-62oo3N1C.mjs";
-import { h as RepositoryInstance, l as Plugin, p as RepositoryContext } from "./repository-DCHRWRXw.mjs";
-import { c as ValidationChainOptions, i as Logger, l as ValidatorDefinition, o as SoftDeleteOptions, r as FieldPreset, t as CascadeOptions } from "./plugin-options-vFufQZMZ.mjs";
+import { h as RepositoryInstance, l as Plugin, p as RepositoryContext } from "./repository-Q16ErTu8.mjs";
+import { c as ValidationChainOptions, i as Logger, l as ValidatorDefinition, o as SoftDeleteOptions, r as FieldPreset, t as CascadeOptions } from "./plugin-options-BsFH0sTi.mjs";
 import { BulkWriteResult } from "@classytic/repo-core/repository";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { OffsetPaginationResult } from "@classytic/repo-core/pagination";
@@ -185,47 +185,6 @@ declare function elasticSearchPlugin(options: ElasticSearchOptions): Plugin;
  */
 declare function fieldFilterPlugin(fieldPreset: FieldPreset): Plugin;
 //#endregion
-//#region src/plugins/immutable-states.plugin.d.ts
-/** The slice of a `before:claim` context `allowClaim` predicates see. */
-interface ImmutableClaimView {
-  id: unknown;
-  transition: {
-    from?: unknown | readonly unknown[];
-    to?: unknown;
-    field?: string;
-    where?: Record<string, unknown>;
-  };
-  /** Operator-form patch (`{ $set: {...}, ... }`). */
-  data: Record<string, unknown> | undefined;
-}
-interface ImmutableStatesPluginOptions {
-  /** States in which the document is frozen (e.g. `['posted']`). */
-  states: readonly string[];
-  /** State field on the doc — dotted paths supported. Default `'state'`. */
-  field?: string | undefined;
-  /**
-   * Context flag the OWNING ENGINE's verbs set to pass the guard
-   * (private handshake — see module doc). Default `'_immutableInternal'`.
-   */
-  internalFlag?: string | undefined;
-  /** Tenant field used to scope state lookups (mirrors the repo's scope). */
-  tenantField?: string | undefined;
-  /**
-   * Exempt specific claim shapes that legitimately touch frozen rows
-   * (audit-trail stamps like ledger's reverse-mark). Return `true` to
-   * allow. Runs only after the claim was determined to reach a frozen
-   * state — keep the predicate a strict fingerprint.
-   */
-  allowClaim?: ((view: ImmutableClaimView) => boolean) | undefined;
-  /** Domain error to throw. Default: 403 `IMMUTABLE_STATE_VIOLATION`. */
-  errorFactory?: ((ctx: {
-    id: unknown;
-    operation: string;
-    state?: string | undefined;
-  }) => Error) | undefined;
-}
-declare function immutableStatesPlugin(options: ImmutableStatesPluginOptions): Plugin;
-//#endregion
 //#region src/plugins/idempotency-store.plugin.d.ts
 interface IdempotencyStorePluginOptions {
   /** Field carrying the deterministic operation key. @default `'key'` */
@@ -362,6 +321,47 @@ interface IdempotencyStoreMethods<TProgress = Record<string, unknown>, TResult =
 }
 declare function idempotencyStorePlugin(options?: IdempotencyStorePluginOptions): Plugin;
 //#endregion
+//#region src/plugins/immutable-states.plugin.d.ts
+/** The slice of a `before:claim` context `allowClaim` predicates see. */
+interface ImmutableClaimView {
+  id: unknown;
+  transition: {
+    from?: unknown | readonly unknown[];
+    to?: unknown;
+    field?: string;
+    where?: Record<string, unknown>;
+  };
+  /** Operator-form patch (`{ $set: {...}, ... }`). */
+  data: Record<string, unknown> | undefined;
+}
+interface ImmutableStatesPluginOptions {
+  /** States in which the document is frozen (e.g. `['posted']`). */
+  states: readonly string[];
+  /** State field on the doc — dotted paths supported. Default `'state'`. */
+  field?: string | undefined;
+  /**
+   * Context flag the OWNING ENGINE's verbs set to pass the guard
+   * (private handshake — see module doc). Default `'_immutableInternal'`.
+   */
+  internalFlag?: string | undefined;
+  /** Tenant field used to scope state lookups (mirrors the repo's scope). */
+  tenantField?: string | undefined;
+  /**
+   * Exempt specific claim shapes that legitimately touch frozen rows
+   * (audit-trail stamps like ledger's reverse-mark). Return `true` to
+   * allow. Runs only after the claim was determined to reach a frozen
+   * state — keep the predicate a strict fingerprint.
+   */
+  allowClaim?: ((view: ImmutableClaimView) => boolean) | undefined;
+  /** Domain error to throw. Default: 403 `IMMUTABLE_STATE_VIOLATION`. */
+  errorFactory?: ((ctx: {
+    id: unknown;
+    operation: string;
+    state?: string | undefined;
+  }) => Error) | undefined;
+}
+declare function immutableStatesPlugin(options: ImmutableStatesPluginOptions): Plugin;
+//#endregion
 //#region src/plugins/lease.plugin.d.ts
 interface LeasePluginOptions {
   /** Field carrying the row's status. @default `'status'` */
@@ -958,4 +958,4 @@ declare function immutableField(field: string): ValidatorDefinition;
  */
 declare function uniqueField(field: string, errorMessage?: string): ValidatorDefinition;
 //#endregion
-export { ImmutableStatesPluginOptions as A, AppendOnlyPluginOptions as B, LeasePluginOptions as C, IdempotencyStorePluginOptions as D, IdempotencyStoreMethods as E, cascadePlugin as F, AggregateHelpersMethods as H, BatchOperationsMethods as I, BulkWriteResult as L, fieldFilterPlugin as M, ElasticSearchOptions as N, idempotencyStorePlugin as O, elasticSearchPlugin as P, batchOperationsPlugin as R, LeaseMethods as S, IdempotencyClaim as T, aggregateHelpersPlugin as U, appendOnlyPlugin as V, observabilityPlugin as _, uniqueField as a, MethodRegistryRepository as b, TenantContext as c, SubdocumentMethods as d, subdocumentPlugin as f, OperationMetric as g, ObservabilityOptions as h, requireField as i, immutableStatesPlugin as j, ImmutableClaimView as k, TenantStore as l, softDeletePlugin as m, blockIf as n, validationChainPlugin as o, SoftDeleteMethods as p, immutableField as r, timestampPlugin as s, autoInject as t, createTenantContext as u, MongoOperationsMethods as v, leasePlugin as w, methodRegistryPlugin as x, mongoOperationsPlugin as y, auditLogPlugin as z };
+export { IdempotencyStoreMethods as A, auditLogPlugin as B, LeaseMethods as C, ImmutableStatesPluginOptions as D, ImmutableClaimView as E, elasticSearchPlugin as F, appendOnlyPlugin as H, cascadePlugin as I, BatchOperationsMethods as L, idempotencyStorePlugin as M, fieldFilterPlugin as N, immutableStatesPlugin as O, ElasticSearchOptions as P, BulkWriteResult as R, methodRegistryPlugin as S, leasePlugin as T, AggregateHelpersMethods as U, AppendOnlyPluginOptions as V, aggregateHelpersPlugin as W, OperationMetric as _, requireField as a, mongoOperationsPlugin as b, timestampPlugin as c, createTenantContext as d, SubdocumentMethods as f, ObservabilityOptions as g, softDeletePlugin as h, immutableField as i, IdempotencyStorePluginOptions as j, IdempotencyClaim as k, TenantContext as l, SoftDeleteMethods as m, autoInject as n, uniqueField as o, subdocumentPlugin as p, blockIf as r, validationChainPlugin as s, OperationType as t, TenantStore as u, observabilityPlugin as v, LeasePluginOptions as w, MethodRegistryRepository as x, MongoOperationsMethods as y, batchOperationsPlugin as z };