@zenstackhq/orm 3.6.4 → 3.7.0

package/dist/index.mjs

@@ -1,7 +1,8 @@
 import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
+import { AnyNull, AnyNullClass, DbNull, DbNullClass, JsonNull, JsonNullClass } from "./common-types.mjs";
 import { clone, enumerate, invariant, isPlainObject, lowerCaseFirst, upperCaseFirst } from "@zenstackhq/common-helpers";
 import { AliasNode, AndNode, ColumnNode, ColumnUpdateNode, CompiledQuery, DefaultConnectionProvider, DefaultQueryExecutor, DeleteQueryNode, ExpressionWrapper, FromNode, IdentifierNode, InsertQueryNode, Kysely, Log, OperationNodeTransformer, OperationNodeVisitor, PrimitiveValueListNode, ReferenceNode, ReturningNode, SelectAllNode, SelectionNode, SingleConnectionProvider, TableNode, Transaction, UpdateQueryNode, ValueListNode, ValueNode, ValuesNode, WhereNode, createQueryId, expressionBuilder, sql } from "kysely";
-import z, { ZodObject, ZodType, z as z$1 } from "zod";
+import z$1, { ZodObject, ZodType, z } from "zod";
 import { fromError } from "zod-validation-error/v4";
 import { P, match } from "ts-pattern";
 import { ExpressionUtils } from "@zenstackhq/schema";
@@ -530,6 +531,8 @@ const FILTER_PROPERTY_TO_KIND = {
 	array_contains: "Json",
 	array_starts_with: "Json",
 	array_ends_with: "Json",
+	fuzzy: "Fuzzy",
+	fts: "FullText",
 	has: "List",
 	hasEvery: "List",
 	hasSome: "List",
@@ -549,6 +552,19 @@ let TransactionIsolationLevel = /* @__PURE__ */ function(TransactionIsolationLev
 	return TransactionIsolationLevel;
 }({});
 /**
+* Symbol used as a type-only key on `ClientContract` to brand the `ExtQueryArgs`
+* generic slot. Hidden from member-access autocomplete since symbol keys are
+* not surfaced. Consumed by `InferExtQueryArgs` to recover the slot.
+* @internal
+*/
+const ExtQueryArgsMarker = Symbol("zenstack.client.extQueryArgs");
+/**
+* Symbol used as a type-only key on `ClientContract` to brand the `ExtResult`
+* generic slot. Consumed by `InferExtResult` to recover the slot.
+* @internal
+*/
+const ExtResultMarker = Symbol("zenstack.client.extResult");
+/**
 * CRUD operations.
 */
 const CRUD = [
@@ -562,20 +578,6 @@ const CRUD = [
 */
 const CRUD_EXT = [...CRUD, "post-update"];
 //#endregion
-//#region src/common-types.ts
-var DbNullClass = class {
-	__brand = "DbNull";
-};
-const DbNull = new DbNullClass();
-var JsonNullClass = class {
-	__brand = "JsonNull";
-};
-const JsonNull = new JsonNullClass();
-var AnyNullClass = class {
-	__brand = "AnyNull";
-};
-const AnyNull = new AnyNullClass();
-//#endregion
 //#region src/client/crud/dialects/base-dialect.ts
 var BaseCrudDialect = class {
 	eb = expressionBuilder();
@@ -585,8 +587,13 @@ var BaseCrudDialect = class {
 	}
 	/**
 	* Transforms input value before sending to database.
+	*
+	* `fieldDef` is optional so existing callers that don't have it stay
+	* source-compatible. Dialects can use it to inspect `@db.*` native-type
+	* attributes (e.g. to format `@db.Time` values as `HH:MM:SS` rather than
+	* full ISO timestamps).
 	*/
-	transformInput(value, _type, _forArrayField) {
+	transformInput(value, _type, _forArrayField, _fieldDef) {
 		return value;
 	}
 	/**
@@ -629,7 +636,17 @@ var BaseCrudDialect = class {
 			if (existingOrderBy.length > 0 && !alreadySatisfied) effectiveOrderBy = [...distinctFields.map((f) => ({ [f]: "asc" })), ...existingOrderBy];
 		}
 		result = this.buildOrderBy(result, model, modelAlias, effectiveOrderBy, negateOrderBy, take);
-		if (args.cursor) result = this.buildCursorFilter(model, result, args.cursor, effectiveOrderBy, negateOrderBy, modelAlias);
+		if (args.cursor) {
+			if (effectiveOrderBy) {
+				const offendingKey = enumerate(effectiveOrderBy).map((ob) => {
+					if (typeof ob !== "object" || ob === null) return void 0;
+					if ("_fuzzyRelevance" in ob) return "_fuzzyRelevance";
+					if ("_ftsRelevance" in ob) return "_ftsRelevance";
+				}).find((k) => k !== void 0);
+				if (offendingKey) throw createNotSupportedError(`cursor pagination cannot be combined with "${offendingKey}" ordering`);
+			}
+			result = this.buildCursorFilter(model, result, args.cursor, effectiveOrderBy, negateOrderBy, modelAlias);
+		}
 		return result;
 	}
 	buildFilter(model, modelAlias, where) {
@@ -769,7 +786,7 @@ var BaseCrudDialect = class {
 		for (const [key, _value] of Object.entries(payload)) {
 			if (_value === void 0) continue;
 			invariant(fieldDef.array, "Field must be an array type to build array filter");
-			const value = this.transformInput(_value, fieldType, true);
+			const value = this.transformInput(_value, fieldType, true, fieldDef);
 			let receiver = fieldRef;
 			if (isEnum(this.schema, fieldType)) receiver = this.eb.cast(fieldRef, sql.raw("text[]"));
 			const buildArray = (value) => {
@@ -804,7 +821,7 @@ var BaseCrudDialect = class {
 			if (payload instanceof DbNullClass || payload instanceof JsonNullClass || payload instanceof AnyNullClass) return this.buildJsonValueFilterClause(fieldRef, payload);
 			return this.buildJsonFilter(fieldRef, payload, fieldDef);
 		}
-		return match(fieldDef.type).with("String", () => this.buildStringFilter(fieldRef, payload)).with(P.union("Int", "Float", "Decimal", "BigInt"), (type) => this.buildNumberFilter(fieldRef, type, payload)).with("Boolean", () => this.buildBooleanFilter(fieldRef, payload)).with("DateTime", () => this.buildDateTimeFilter(fieldRef, payload)).with("Bytes", () => this.buildBytesFilter(fieldRef, payload)).with("Json", () => this.buildJsonFilter(fieldRef, payload, fieldDef)).with("Unsupported", () => {
+		return match(fieldDef.type).with("String", () => this.buildStringFilter(fieldRef, payload, fieldDef)).with(P.union("Int", "Float", "Decimal", "BigInt"), (type) => this.buildNumberFilter(fieldRef, type, payload)).with("Boolean", () => this.buildBooleanFilter(fieldRef, payload)).with("DateTime", () => this.buildDateTimeFilter(fieldRef, payload)).with("Bytes", () => this.buildBytesFilter(fieldRef, payload)).with("Json", () => this.buildJsonFilter(fieldRef, payload, fieldDef)).with("Unsupported", () => {
 			throw createInvalidInputError(`Unsupported field cannot be used in filters`);
 		}).exhaustive();
 	}
@@ -972,13 +989,23 @@ var BaseCrudDialect = class {
 			consumedKeys
 		};
 	}
-	buildStringFilter(fieldRef, payload) {
+	buildStringFilter(fieldRef, payload, fieldDef) {
 		let mode;
 		if (payload && typeof payload === "object" && "mode" in payload) mode = payload.mode;
-		const { conditions, consumedKeys } = this.buildStandardFilter("String", payload, mode === "insensitive" ? this.eb.fn("lower", [fieldRef]) : fieldRef, (value) => this.prepStringCasing(this.eb, value, mode), (value) => this.buildStringFilter(fieldRef, value));
+		const { conditions, consumedKeys } = this.buildStandardFilter("String", payload, mode === "insensitive" ? this.eb.fn("lower", [fieldRef]) : fieldRef, (value) => this.prepStringCasing(this.eb, value, mode), (value) => this.buildStringFilter(fieldRef, value, fieldDef));
 		if (payload && typeof payload === "object") for (const [key, value] of Object.entries(payload)) {
 			if (key === "mode" || consumedKeys.includes(key)) continue;
 			if (value === void 0) continue;
+			if (key === "fuzzy") {
+				invariant(fieldDef?.fuzzy === true, `field "${fieldDef?.name ?? "<unknown>"}" is not fuzzy-searchable; add the \`@fuzzy\` attribute to use the \`fuzzy\` filter`);
+				conditions.push(this.buildFuzzyFilter(fieldRef, this.normalizeFuzzyOptions(value)));
+				continue;
+			}
+			if (key === "fts") {
+				invariant(fieldDef?.fullText === true, `field "${fieldDef?.name ?? "<unknown>"}" is not full-text-searchable; add the \`@fullText\` attribute to use the \`fts\` filter`);
+				conditions.push(this.buildFullTextFilter(fieldRef, value));
+				continue;
+			}
 			invariant(typeof value === "string", `${key} value must be a string`);
 			const escapedValue = this.escapeLikePattern(value);
 			const condition = match(key).with("contains", () => this.buildStringLike(fieldRef, `%${escapedValue}%`, mode === "insensitive")).with("startsWith", () => this.buildStringLike(fieldRef, `${escapedValue}%`, mode === "insensitive")).with("endsWith", () => this.buildStringLike(fieldRef, `%${escapedValue}`, mode === "insensitive")).otherwise(() => {
@@ -1047,6 +1074,14 @@ var BaseCrudDialect = class {
 		enumerate(orderBy).forEach((orderBy, index) => {
 			for (const [field, value] of Object.entries(orderBy)) {
 				if (!value) continue;
+				if (field === "_fuzzyRelevance") {
+					result = this.applyFuzzyRelevanceOrderBy(result, model, modelAlias, value, negated, buildFieldRef);
+					continue;
+				}
+				if (field === "_ftsRelevance") {
+					result = this.applyFtsRelevanceOrderBy(result, model, modelAlias, value, negated, buildFieldRef);
+					continue;
+				}
 				if ([
 					"_count",
 					"_avg",
@@ -1054,47 +1089,84 @@ var BaseCrudDialect = class {
 					"_min",
 					"_max"
 				].includes(field)) {
-					invariant(typeof value === "object", `invalid orderBy value for field "${field}"`);
-					for (const [k, v] of Object.entries(value)) {
-						invariant(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
-						result = result.orderBy((eb) => aggregate(eb, buildFieldRef(model, k, modelAlias), field), this.negateSort(v, negated));
-					}
+					result = this.applyAggregationOrderBy(result, model, modelAlias, field, value, negated, buildFieldRef);
 					continue;
 				}
 				const fieldDef = requireField(this.schema, model, field);
-				if (!fieldDef.relation) {
-					const fieldRef = buildFieldRef(model, field, modelAlias);
-					if (value === "asc" || value === "desc") result = result.orderBy(fieldRef, this.negateSort(value, negated));
-					else if (typeof value === "object" && "nulls" in value && "sort" in value && (value.sort === "asc" || value.sort === "desc") && (value.nulls === "first" || value.nulls === "last")) result = this.buildOrderByField(result, fieldRef, this.negateSort(value.sort, negated), value.nulls);
-				} else {
-					const relationModel = fieldDef.type;
-					if (fieldDef.array) {
-						if (typeof value !== "object") throw createInvalidInputError(`invalid orderBy value for field "${field}"`);
-						if ("_count" in value) {
-							invariant(value._count === "asc" || value._count === "desc", "invalid orderBy value for field \"_count\"");
-							const sort = this.negateSort(value._count, negated);
-							result = result.orderBy((eb) => {
-								const subQueryAlias = tmpAlias(`${modelAlias}$ob$${field}$ct`);
-								let subQuery = this.buildSelectModel(relationModel, subQueryAlias);
-								const joinPairs = buildJoinPairs(this.schema, model, modelAlias, field, subQueryAlias);
-								subQuery = subQuery.where(() => this.and(...joinPairs.map(([left, right]) => eb(this.eb.ref(left), "=", this.eb.ref(right)))));
-								subQuery = subQuery.select(() => eb.fn.count(eb.lit(1)).as("_count"));
-								return subQuery;
-							}, sort);
-						}
-					} else {
-						const joinAlias = tmpAlias(`${modelAlias}$ob$${index}`);
-						result = result.leftJoin(`${relationModel} as ${joinAlias}`, (join) => {
-							const joinPairs = buildJoinPairs(this.schema, model, modelAlias, field, joinAlias);
-							return join.on((eb) => this.and(...joinPairs.map(([left, right]) => eb(this.eb.ref(left), "=", this.eb.ref(right)))));
-						});
-						result = this.buildOrderBy(result, relationModel, joinAlias, value, negated, take);
-					}
-				}
+				if (!fieldDef.relation) result = this.applyScalarOrderBy(result, model, modelAlias, field, value, negated, buildFieldRef);
+				else result = this.applyRelationOrderBy(result, model, modelAlias, field, fieldDef, value, negated, take, index);
+			}
+		});
+		return result;
+	}
+	applyRelationOrderBy(query, model, modelAlias, field, fieldDef, value, negated, take, index) {
+		const relationModel = fieldDef.type;
+		if (fieldDef.array) {
+			if (typeof value !== "object") throw createInvalidInputError(`invalid orderBy value for field "${field}"`);
+			if ("_count" in value) {
+				invariant(value._count === "asc" || value._count === "desc", "invalid orderBy value for field \"_count\"");
+				const sort = this.negateSort(value._count, negated);
+				return query.orderBy((eb) => {
+					const subQueryAlias = tmpAlias(`${modelAlias}$ob$${field}$ct`);
+					let subQuery = this.buildSelectModel(relationModel, subQueryAlias);
+					const joinPairs = buildJoinPairs(this.schema, model, modelAlias, field, subQueryAlias);
+					subQuery = subQuery.where(() => this.and(...joinPairs.map(([left, right]) => eb(this.eb.ref(left), "=", this.eb.ref(right)))));
+					subQuery = subQuery.select(() => eb.fn.count(eb.lit(1)).as("_count"));
+					return subQuery;
+				}, sort);
 			}
+			return query;
+		}
+		const joinAlias = tmpAlias(`${modelAlias}$ob$${index}`);
+		const joined = query.leftJoin(`${relationModel} as ${joinAlias}`, (join) => {
+			const joinPairs = buildJoinPairs(this.schema, model, modelAlias, field, joinAlias);
+			return join.on((eb) => this.and(...joinPairs.map(([left, right]) => eb(this.eb.ref(left), "=", this.eb.ref(right)))));
 		});
+		return this.buildOrderBy(joined, relationModel, joinAlias, value, negated, take);
+	}
+	applyScalarOrderBy(query, model, modelAlias, field, value, negated, buildFieldRef) {
+		const fieldRef = buildFieldRef(model, field, modelAlias);
+		if (value === "asc" || value === "desc") return query.orderBy(fieldRef, this.negateSort(value, negated));
+		if (typeof value === "object" && "sort" in value && (value.sort === "asc" || value.sort === "desc")) {
+			const sort = this.negateSort(value.sort, negated);
+			if (value.nulls === "first" || value.nulls === "last") return this.buildOrderByField(query, fieldRef, sort, value.nulls);
+			else return query.orderBy(fieldRef, sort);
+		}
+		return query;
+	}
+	applyAggregationOrderBy(query, model, modelAlias, field, value, negated, buildFieldRef) {
+		invariant(typeof value === "object", `invalid orderBy value for field "${field}"`);
+		let result = query;
+		for (const [k, v] of Object.entries(value)) {
+			invariant(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
+			result = result.orderBy((eb) => aggregate(eb, buildFieldRef(model, k, modelAlias), field), this.negateSort(v, negated));
+		}
 		return result;
 	}
+	applyFuzzyRelevanceOrderBy(query, model, modelAlias, value, negated, buildFieldRef) {
+		invariant(typeof value === "object" && "fields" in value && "search" in value && "sort" in value, "invalid orderBy value for \"_fuzzyRelevance\"");
+		invariant(Array.isArray(value.fields) && value.fields.length > 0, "_fuzzyRelevance.fields must be a non-empty array");
+		invariant(value.sort === "asc" || value.sort === "desc", "invalid sort value for \"_fuzzyRelevance\"");
+		invariant(typeof value.search === "string" && value.search.length > 0, "_fuzzyRelevance.search must be a non-empty string");
+		const mode = value.mode ?? "simple";
+		invariant(mode === "simple" || mode === "word" || mode === "strictWord", "_fuzzyRelevance.mode must be \"simple\", \"word\" or \"strictWord\"");
+		const unaccent = value.unaccent ?? false;
+		invariant(typeof unaccent === "boolean", "_fuzzyRelevance.unaccent must be a boolean");
+		for (const fieldName of value.fields) invariant(requireField(this.schema, model, fieldName).fuzzy === true, `field "${fieldName}" is not fuzzy-searchable; add the \`@fuzzy\` attribute to use it in \`_fuzzyRelevance\``);
+		const fieldRefs = value.fields.map((f) => buildFieldRef(model, f, modelAlias));
+		return this.buildFuzzyRelevanceOrderBy(query, fieldRefs, value.search, this.negateSort(value.sort, negated), mode, unaccent);
+	}
+	applyFtsRelevanceOrderBy(query, model, modelAlias, value, negated, buildFieldRef) {
+		invariant(typeof value === "object" && "fields" in value && "search" in value && "sort" in value, "invalid orderBy value for \"_ftsRelevance\"");
+		invariant(Array.isArray(value.fields) && value.fields.length > 0, "_ftsRelevance.fields must be a non-empty array");
+		invariant(value.sort === "asc" || value.sort === "desc", "invalid sort value for \"_ftsRelevance\"");
+		invariant(typeof value.search === "string" && value.search.length > 0, "_ftsRelevance.search must be a non-empty string");
+		if (value.config !== void 0) invariant(typeof value.config === "string" && value.config.length > 0, "_ftsRelevance.config must be a non-empty string");
+		const config = value.config;
+		for (const fieldName of value.fields) invariant(requireField(this.schema, model, fieldName).fullText === true, `field "${fieldName}" is not full-text-searchable; add the \`@fullText\` attribute to use it in \`_ftsRelevance\``);
+		const fieldRefs = value.fields.map((f) => buildFieldRef(model, f, modelAlias));
+		return this.buildFtsRelevanceOrderBy(query, fieldRefs, value.search, config, this.negateSort(value.sort, negated));
+	}
 	buildSelectAllFields(model, query, omit, modelAlias) {
 		let result = query;
 		for (const fieldDef of getModelFields(this.schema, model, {
@@ -1237,6 +1309,27 @@ var BaseCrudDialect = class {
 	buildComparison(left, _leftFieldDef, op, right, _rightFieldDef) {
 		return this.eb(left, op, right);
 	}
+	/**
+	* Validate the user-provided fuzzy filter payload and apply defaults so dialects
+	* always receive a fully-resolved {@link FuzzyFilterOptions} value.
+	*/
+	normalizeFuzzyOptions(value) {
+		invariant(value !== null && typeof value === "object" && !Array.isArray(value), "fuzzy filter must be an object with at least a \"search\" field");
+		const raw = value;
+		invariant(typeof raw["search"] === "string" && raw["search"].length > 0, "fuzzy.search must be a non-empty string");
+		const mode = raw["mode"] ?? "simple";
+		invariant(mode === "simple" || mode === "word" || mode === "strictWord", "fuzzy.mode must be \"simple\", \"word\" or \"strictWord\"");
+		const threshold = raw["threshold"];
+		if (threshold !== void 0) invariant(typeof threshold === "number" && threshold >= 0 && threshold <= 1, "fuzzy.threshold must be a number between 0 and 1");
+		const unaccent = raw["unaccent"] ?? false;
+		invariant(typeof unaccent === "boolean", "fuzzy.unaccent must be a boolean");
+		return {
+			search: raw["search"],
+			mode,
+			threshold,
+			unaccent
+		};
+	}
 };
 //#endregion
 //#region src/client/crud/dialects/lateral-join-dialect-base.ts
@@ -1521,9 +1614,32 @@ var MySqlCrudDialect = class extends LateralJoinDialectBase {
 		}
 		return result;
 	}
+	buildFuzzyFilter(_fieldRef, _options) {
+		throw createNotSupportedError("\"fuzzy\" filter is not supported by the \"mysql\" provider");
+	}
+	buildFuzzyRelevanceOrderBy(_query, _fieldRefs, _search, _sort, _mode, _unaccent) {
+		throw createNotSupportedError("\"_fuzzyRelevance\" ordering is not supported by the \"mysql\" provider");
+	}
+	buildFullTextFilter(_fieldRef, _payload) {
+		throw createNotSupportedError("\"fts\" filter is not supported by the \"mysql\" provider");
+	}
+	buildFtsRelevanceOrderBy(_query, _fieldRefs, _search, _config, _sort) {
+		throw createNotSupportedError("\"_ftsRelevance\" ordering is not supported by the \"mysql\" provider");
+	}
 };
 //#endregion
 //#region src/client/crud/dialects/postgresql.ts
+/**
+* Formats a JS `Date` as a Postgres TIME / TIMETZ literal (`HH:MM:SS.fff`,
+* optionally with `+ZZ:ZZ` for TIMETZ). Reads UTC components so the value
+* round-trips with ISO-input parsing — callers anchor time-only inputs to
+* the Unix epoch.
+*/
+function formatTimeOfDay(date, withTimezone) {
+	const pad = (n, w = 2) => String(n).padStart(w, "0");
+	const time = `${pad(date.getUTCHours())}:${pad(date.getUTCMinutes())}:${pad(date.getUTCSeconds())}.${pad(date.getUTCMilliseconds(), 3)}`;
+	return withTimezone ? `${time}+00:00` : time;
+}
 var PostgresCrudDialect = class PostgresCrudDialect extends LateralJoinDialectBase {
 	static typeParserOverrideApplied = false;
 	zmodelToSqlTypeMap = {
@@ -1617,7 +1733,7 @@ var PostgresCrudDialect = class PostgresCrudDialect extends LateralJoinDialectBa
 	get insertIgnoreMethod() {
 		return "onConflict";
 	}
-	transformInput(value, type, forArrayField) {
+	transformInput(value, type, forArrayField, fieldDef) {
 		if (value === void 0) return value;
 		if (value instanceof JsonNullClass) return "null";
 		else if (value instanceof DbNullClass) return null;
@@ -1625,9 +1741,15 @@ var PostgresCrudDialect = class PostgresCrudDialect extends LateralJoinDialectBa
 		if (isTypeDef(this.schema, type)) if (typeof value !== "string") return JSON.stringify(value);
 		else return value;
 		else if (Array.isArray(value)) if (type === "Json" && !forArrayField) return JSON.stringify(value);
-		else return value.map((v) => this.transformInput(v, type, false));
+		else return value.map((v) => this.transformInput(v, type, false, fieldDef));
 		else switch (type) {
-			case "DateTime": return value instanceof Date ? value.toISOString() : typeof value === "string" ? new Date(value).toISOString() : value;
+			case "DateTime": {
+				const date = value instanceof Date ? value : typeof value === "string" ? new Date(value) : null;
+				if (date === null || isNaN(date.getTime())) return value;
+				const dbAttrName = fieldDef?.attributes?.find((a) => a.name.startsWith("@db."))?.name;
+				if (dbAttrName === "@db.Time" || dbAttrName === "@db.Timetz") return formatTimeOfDay(date, dbAttrName === "@db.Timetz");
+				return date.toISOString();
+			}
 			case "Decimal": return value !== null ? value.toString() : value;
 			case "Json": if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return JSON.stringify(value);
 			else return value;
@@ -1799,6 +1921,72 @@ var PostgresCrudDialect = class PostgresCrudDialect extends LateralJoinDialectBa
 			return ob;
 		});
 	}
+	/**
+	* Wraps an expression with `unaccent(lower(...))` or just `lower(...)` depending on
+	* whether the user opted into accent-insensitive matching. The lowering is always
+	* applied so trigram comparisons are case-insensitive on both sides.
+	*/
+	normalizeForTrigram(expr, applyUnaccent) {
+		return applyUnaccent ? sql`unaccent(lower(${expr}))` : sql`lower(${expr})`;
+	}
+	buildFuzzyFilter(fieldRef, options) {
+		const fieldExpr = this.normalizeForTrigram(fieldRef, options.unaccent);
+		const valueExpr = this.normalizeForTrigram(sql.val(options.search), options.unaccent);
+		if (options.threshold === void 0) switch (options.mode) {
+			case "simple": return sql`${fieldExpr} % ${valueExpr}`;
+			case "word": return sql`${valueExpr} <% ${fieldExpr}`;
+			case "strictWord": return sql`${valueExpr} <<% ${fieldExpr}`;
+		}
+		const threshold = sql.val(options.threshold);
+		switch (options.mode) {
+			case "simple": return sql`similarity(${fieldExpr}, ${valueExpr}) > ${threshold}`;
+			case "word": return sql`word_similarity(${valueExpr}, ${fieldExpr}) > ${threshold}`;
+			case "strictWord": return sql`strict_word_similarity(${valueExpr}, ${fieldExpr}) > ${threshold}`;
+		}
+	}
+	buildFuzzyRelevanceOrderBy(query, fieldRefs, search, sort, mode, unaccent) {
+		const valueExpr = this.normalizeForTrigram(sql.val(search), unaccent);
+		const buildSimilarity = (fieldRef) => {
+			const fieldExpr = this.normalizeForTrigram(fieldRef, unaccent);
+			switch (mode) {
+				case "simple": return sql`similarity(${fieldExpr}, ${valueExpr})`;
+				case "word": return sql`word_similarity(${valueExpr}, ${fieldExpr})`;
+				case "strictWord": return sql`strict_word_similarity(${valueExpr}, ${fieldExpr})`;
+			}
+		};
+		if (fieldRefs.length === 1) return query.orderBy(buildSimilarity(fieldRefs[0]), sort);
+		const similarities = fieldRefs.map((ref) => buildSimilarity(ref));
+		return query.orderBy(sql`GREATEST(${sql.join(similarities)})`, sort);
+	}
+	buildFullTextFilter(fieldRef, payload) {
+		const options = this.normalizeFullTextOptions(payload);
+		const query = sql.val(options.search);
+		if (options.config === void 0) return sql`to_tsvector(${fieldRef}) @@ to_tsquery(${query})`;
+		const cfg = sql.val(options.config);
+		return sql`to_tsvector(${cfg}::regconfig, ${fieldRef}) @@ to_tsquery(${cfg}::regconfig, ${query})`;
+	}
+	/**
+	* Validate the user-provided `fts` filter payload. When `config` is omitted
+	* it stays `undefined` so {@link buildFullTextFilter} can emit the no-regconfig
+	* SQL form and let Postgres fall back to `default_text_search_config`.
+	*/
+	normalizeFullTextOptions(value) {
+		invariant(value !== null && typeof value === "object" && !Array.isArray(value), "fts filter must be an object with at least a \"search\" field");
+		const raw = value;
+		invariant(typeof raw["search"] === "string" && raw["search"].length > 0, "fts.search must be a non-empty string");
+		if (raw["config"] !== void 0) invariant(typeof raw["config"] === "string" && raw["config"].length > 0, "fts.config must be a non-empty string");
+		return {
+			search: raw["search"],
+			config: raw["config"]
+		};
+	}
+	buildFtsRelevanceOrderBy(query, fieldRefs, search, config, sort) {
+		const q = sql.val(search);
+		const document = fieldRefs.length === 1 ? sql`coalesce(${fieldRefs[0]}, '')` : sql`concat_ws(' ', ${sql.join(fieldRefs)})`;
+		if (config === void 0) return query.orderBy(sql`ts_rank(to_tsvector(${document}), to_tsquery(${q}))`, sort);
+		const cfg = sql.val(config);
+		return query.orderBy(sql`ts_rank(to_tsvector(${cfg}::regconfig, ${document}), to_tsquery(${cfg}::regconfig, ${q}))`, sort);
+	}
 };
 //#endregion
 //#region src/client/crud/dialects/sqlite.ts
@@ -2016,6 +2204,18 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
 			return ob;
 		});
 	}
+	buildFuzzyFilter(_fieldRef, _options) {
+		throw createNotSupportedError("\"fuzzy\" filter is not supported by the \"sqlite\" provider");
+	}
+	buildFuzzyRelevanceOrderBy(_query, _fieldRefs, _search, _sort, _mode, _unaccent) {
+		throw createNotSupportedError("\"_fuzzyRelevance\" ordering is not supported by the \"sqlite\" provider");
+	}
+	buildFullTextFilter(_fieldRef, _payload) {
+		throw createNotSupportedError("\"fts\" filter is not supported by the \"sqlite\" provider");
+	}
+	buildFtsRelevanceOrderBy(_query, _fieldRefs, _search, _config, _sort) {
+		throw createNotSupportedError("\"_ftsRelevance\" ordering is not supported by the \"sqlite\" provider");
+	}
 };
 //#endregion
 //#region src/client/crud/dialects/index.ts
@@ -2071,11 +2271,38 @@ function createQuerySchemaFactory(clientOrSchema, options) {
 	return new ZodSchemaFactory(clientOrSchema, options);
 }
 /**
+* Builds a `DateTime` value schema that accepts a `Date` object or any string
+* the JS `Date` constructor parses, and coerces it to a `Date`. ISO datetime,
+* ISO date, and time-only strings (e.g. `"09:00:00"` for `@db.Time` fields,
+* anchored to the Unix epoch) are the documented happy paths; other formats
+* accepted by `new Date(...)` also pass through, mirroring Prisma's pre-3.5
+* behaviour. Strings the engine can't parse fall through and are rejected by
+* `z.date()` with the standard error.
+*
+* @see https://github.com/zenstackhq/zenstack/issues/2631
+*/
+function coercedDateTimeSchema() {
+	return z.preprocess((val) => {
+		if (typeof val !== "string") return val;
+		if (/^\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d\d(?::\d\d)?)?$/.test(val)) {
+			const hasTz = val.endsWith("Z") || /[+-]\d\d(?::\d\d)?$/.test(val);
+			const d = /* @__PURE__ */ new Date(`1970-01-01T${val}${hasTz ? "" : "Z"}`);
+			return isNaN(d.getTime()) ? val : d;
+		}
+		const d = new Date(val);
+		return isNaN(d.getTime()) ? val : d;
+	}, z.union([
+		z.iso.datetime(),
+		z.iso.date(),
+		z.date()
+	]));
+}
+/**
 * Factory class responsible for creating and caching Zod schemas for ORM input validation.
 */
 var ZodSchemaFactory = class {
 	schemaCache = /* @__PURE__ */ new Map();
-	schemaRegistry = z$1.registry();
+	schemaRegistry = z.registry();
 	allFilterKinds = [...new Set(Object.values(FILTER_PROPERTY_TO_KIND))];
 	schema;
 	options;
@@ -2167,7 +2394,7 @@ var ZodSchemaFactory = class {
 			this.makeGroupBySchema(m);
 		}
 		for (const procName of Object.keys(this.schema.procedures ?? {})) if (this.isProcedureAllowed(procName)) this.makeProcedureArgsSchema(procName);
-		return z$1.toJSONSchema(this.schemaRegistry, { unrepresentable: "any" });
+		return z.toJSONSchema(this.schemaRegistry, { unrepresentable: "any" });
 	}
 	get cacheStats() {
 		return {
@@ -2196,13 +2423,13 @@ var ZodSchemaFactory = class {
 		fields["omit"] = this.makeOmitSchema(model).optional().nullable();
 		if (!unique) {
 			fields["skip"] = this.makeSkipSchema().optional();
-			if (findOne) fields["take"] = z$1.literal(1).optional();
+			if (findOne) fields["take"] = z.literal(1).optional();
 			else fields["take"] = this.makeTakeSchema().optional();
 			fields["orderBy"] = this.orArray(this.makeOrderBySchema(model, true, false, options), true).optional();
 			fields["cursor"] = this.makeCursorSchema(model, options).optional();
 			fields["distinct"] = this.makeDistinctSchema(model).optional();
 		}
-		const baseSchema = z$1.strictObject(fields);
+		const baseSchema = z.strictObject(fields);
 		let result = this.mergePluginArgsSchema(baseSchema, operation);
 		result = this.refineForSelectIncludeMutuallyExclusive(result);
 		result = this.refineForSelectOmitMutuallyExclusive(result);
@@ -2212,7 +2439,7 @@ var ZodSchemaFactory = class {
 		return result;
 	}
 	makeExistsSchema(model, options) {
-		const baseSchema = z$1.strictObject({ where: this.makeWhereSchema(model, false, false, false, options).optional() });
+		const baseSchema = z.strictObject({ where: this.makeWhereSchema(model, false, false, false, options).optional() });
 		const result = this.mergePluginArgsSchema(baseSchema, "exists").optional();
 		this.registerSchema(`${model}ExistsArgs`, result);
 		return result;
@@ -2220,31 +2447,31 @@ var ZodSchemaFactory = class {
 	makeScalarSchema(type, attributes) {
 		if (this.schema.typeDefs && type in this.schema.typeDefs) return this.makeTypeDefSchema(type);
 		else if (this.schema.enums && type in this.schema.enums) return this.makeEnumSchema(type);
-		else return match(type).with("String", () => this.extraValidationsEnabled ? ZodUtils.addStringValidation(z$1.string(), attributes) : z$1.string()).with("Int", () => this.extraValidationsEnabled ? ZodUtils.addNumberValidation(z$1.number().int(), attributes) : z$1.number().int()).with("Float", () => this.extraValidationsEnabled ? ZodUtils.addNumberValidation(z$1.number(), attributes) : z$1.number()).with("Boolean", () => z$1.boolean()).with("BigInt", () => z$1.union([this.extraValidationsEnabled ? ZodUtils.addNumberValidation(z$1.number().int(), attributes) : z$1.number().int(), this.extraValidationsEnabled ? ZodUtils.addBigIntValidation(z$1.bigint(), attributes) : z$1.bigint()])).with("Decimal", () => {
-			return z$1.union([
-				this.extraValidationsEnabled ? ZodUtils.addNumberValidation(z$1.number(), attributes) : z$1.number(),
-				ZodUtils.addDecimalValidation(z$1.instanceof(Decimal), attributes, this.extraValidationsEnabled),
-				ZodUtils.addDecimalValidation(z$1.string(), attributes, this.extraValidationsEnabled)
+		else return match(type).with("String", () => this.extraValidationsEnabled ? ZodUtils.addStringValidation(z.string(), attributes) : z.string()).with("Int", () => this.extraValidationsEnabled ? ZodUtils.addNumberValidation(z.number().int(), attributes) : z.number().int()).with("Float", () => this.extraValidationsEnabled ? ZodUtils.addNumberValidation(z.number(), attributes) : z.number()).with("Boolean", () => z.boolean()).with("BigInt", () => z.union([this.extraValidationsEnabled ? ZodUtils.addNumberValidation(z.number().int(), attributes) : z.number().int(), this.extraValidationsEnabled ? ZodUtils.addBigIntValidation(z.bigint(), attributes) : z.bigint()])).with("Decimal", () => {
+			return z.union([
+				this.extraValidationsEnabled ? ZodUtils.addNumberValidation(z.number(), attributes) : z.number(),
+				ZodUtils.addDecimalValidation(z.instanceof(Decimal), attributes, this.extraValidationsEnabled),
+				ZodUtils.addDecimalValidation(z.string(), attributes, this.extraValidationsEnabled)
 			]);
-		}).with("DateTime", () => this.makeDateTimeValueSchema()).with("Bytes", () => z$1.instanceof(Uint8Array)).with("Json", () => this.makeJsonValueSchema()).otherwise(() => z$1.unknown());
+		}).with("DateTime", () => this.makeDateTimeValueSchema()).with("Bytes", () => z.instanceof(Uint8Array)).with("Json", () => this.makeJsonValueSchema()).otherwise(() => z.unknown());
 	}
 	makeEnumSchema(_enum) {
 		const enumDef = getEnum(this.schema, _enum);
 		invariant(enumDef, `Enum "${_enum}" not found in schema`);
-		const schema = z$1.enum(Object.keys(enumDef.values));
+		const schema = z.enum(Object.keys(enumDef.values));
 		this.registerSchema(_enum, schema);
 		return schema;
 	}
 	makeTypeDefSchema(type) {
 		const typeDef = getTypeDef(this.schema, type);
 		invariant(typeDef, `Type definition "${type}" not found in schema`);
-		const schema = z$1.looseObject(Object.fromEntries(Object.entries(typeDef.fields).map(([field, def]) => {
-			let fieldSchema = this.makeScalarSchema(def.type);
+		const schema = z.looseObject(Object.fromEntries(Object.entries(typeDef.fields).map(([field, def]) => {
+			let fieldSchema = isTypeDef(this.schema, def.type) ? z.lazy(() => this.makeTypeDefSchema(def.type)) : this.makeScalarSchema(def.type);
 			if (def.array) fieldSchema = fieldSchema.array();
 			if (def.optional) fieldSchema = fieldSchema.nullish();
 			return [field, fieldSchema];
 		})));
-		const finalSchema = z$1.any().superRefine((value, ctx) => {
+		const finalSchema = z.any().superRefine((value, ctx) => {
 			const parseResult = schema.safeParse(value);
 			if (!parseResult.success) parseResult.error.issues.forEach((issue) => ctx.addIssue(issue));
 		});
@@ -2260,17 +2487,17 @@ var ZodSchemaFactory = class {
 			if (fieldDef.relation) {
 				if (withoutRelationFields || !this.shouldIncludeRelations(options)) continue;
 				const allowedFilterKinds = this.getEffectiveFilterKinds(model, field);
-				if (allowedFilterKinds && !allowedFilterKinds.includes("Relation")) fieldSchema = z$1.never();
+				if (allowedFilterKinds && !allowedFilterKinds.includes("Relation")) fieldSchema = z.never();
 				else {
-					fieldSchema = z$1.lazy(() => this.makeWhereSchema(fieldDef.type, false, false, false, nextOpts).optional());
-					if (fieldDef.array) fieldSchema = z$1.strictObject({
+					fieldSchema = z.lazy(() => this.makeWhereSchema(fieldDef.type, false, false, false, nextOpts).optional());
+					if (fieldDef.array) fieldSchema = z.strictObject({
 						some: fieldSchema.optional(),
 						every: fieldSchema.optional(),
 						none: fieldSchema.optional()
 					});
 					else {
 						fieldSchema = this.nullableIf(fieldSchema, !fieldDef.array && !!fieldDef.optional);
-						fieldSchema = z$1.union([fieldSchema, z$1.strictObject({
+						fieldSchema = z.union([fieldSchema, z.strictObject({
 							is: fieldSchema.optional(),
 							isNot: fieldSchema.optional()
 						})]);
@@ -2283,27 +2510,27 @@ var ZodSchemaFactory = class {
 					if (Object.keys(enumDef.values).length > 0) fieldSchema = this.makeEnumFilterSchema(fieldDef.type, !!fieldDef.optional, !!fieldDef.array, withAggregations, allowedFilterKinds);
 				} else if (fieldDef.array) fieldSchema = this.makeArrayFilterSchema(fieldDef.type, allowedFilterKinds);
 				else if (this.isTypeDefType(fieldDef.type)) fieldSchema = this.makeTypedJsonFilterSchema(fieldDef.type, !!fieldDef.optional, !!fieldDef.array, allowedFilterKinds);
-				else fieldSchema = this.makePrimitiveFilterSchema(fieldDef.type, !!fieldDef.optional, withAggregations, allowedFilterKinds);
+				else fieldSchema = this.makePrimitiveFilterSchema(fieldDef.type, !!fieldDef.optional, withAggregations, allowedFilterKinds, !!fieldDef.fuzzy, !!fieldDef.fullText);
 			}
 			if (fieldSchema) fields[field] = fieldSchema.optional();
 		}
 		if (unique) {
 			const uniqueFields = getUniqueFields(this.schema, model);
-			for (const uniqueField of uniqueFields) if ("defs" in uniqueField) fields[uniqueField.name] = z$1.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => {
+			for (const uniqueField of uniqueFields) if ("defs" in uniqueField) fields[uniqueField.name] = z.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => {
 				invariant(!def.relation, "unique field cannot be a relation");
 				let fieldSchema;
 				const enumDef = getEnum(this.schema, def.type);
 				if (enumDef) if (Object.keys(enumDef.values).length > 0) fieldSchema = this.makeEnumFilterSchema(def.type, !!def.optional, !!def.array, false, void 0);
-				else fieldSchema = z$1.never();
+				else fieldSchema = z.never();
 				else fieldSchema = this.makePrimitiveFilterSchema(def.type, !!def.optional, false, void 0);
 				return [key, fieldSchema];
 			}))).optional();
 		}
-		fields["$expr"] = z$1.custom((v) => typeof v === "function", { error: "\"$expr\" must be a function" }).optional();
-		fields["AND"] = this.orArray(z$1.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields, false, options)), true).optional();
-		fields["OR"] = z$1.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields, false, options)).array().optional();
-		fields["NOT"] = this.orArray(z$1.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields, false, options)), true).optional();
-		const baseWhere = z$1.strictObject(fields);
+		fields["$expr"] = z.custom((v) => typeof v === "function", { error: "\"$expr\" must be a function" }).optional();
+		fields["AND"] = this.orArray(z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields, false, options)), true).optional();
+		fields["OR"] = z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields, false, options)).array().optional();
+		fields["NOT"] = this.orArray(z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields, false, options)), true).optional();
+		const baseWhere = z.strictObject(fields);
 		let result = baseWhere;
 		if (unique) {
 			const uniqueFields = getUniqueFields(this.schema, model);
@@ -2329,26 +2556,26 @@ var ZodSchemaFactory = class {
 			else if (getEnum(this.schema, fieldDef.type)) fieldSchemas[fieldName] = this.makeEnumFilterSchema(fieldDef.type, !!fieldDef.optional, !!fieldDef.array, false, void 0).optional();
 			else if (fieldDef.array) fieldSchemas[fieldName] = this.makeArrayFilterSchema(fieldDef.type, void 0).optional();
 			else fieldSchemas[fieldName] = this.makePrimitiveFilterSchema(fieldDef.type, !!fieldDef.optional, false, void 0).optional();
-			candidates.push(z$1.strictObject(fieldSchemas));
+			candidates.push(z.strictObject(fieldSchemas));
 		}
-		const recursiveSchema = z$1.lazy(() => this.makeTypedJsonFilterSchema(type, optional, false, allowedFilterKinds)).optional();
-		if (array) candidates.push(z$1.strictObject({
+		const recursiveSchema = z.lazy(() => this.makeTypedJsonFilterSchema(type, optional, false, allowedFilterKinds)).optional();
+		if (array) candidates.push(z.strictObject({
 			some: recursiveSchema,
 			every: recursiveSchema,
 			none: recursiveSchema
 		}));
-		else candidates.push(z$1.strictObject({
+		else candidates.push(z.strictObject({
 			is: recursiveSchema,
 			isNot: recursiveSchema
 		}));
 		candidates.push(this.makeJsonFilterSchema(optional, allowedFilterKinds));
 		if (optional) {
-			candidates.push(z$1.null());
-			candidates.push(z$1.instanceof(DbNullClass));
-			candidates.push(z$1.instanceof(JsonNullClass));
-			candidates.push(z$1.instanceof(AnyNullClass));
+			candidates.push(z.null());
+			candidates.push(z.instanceof(DbNullClass));
+			candidates.push(z.instanceof(JsonNullClass));
+			candidates.push(z.instanceof(AnyNullClass));
 		}
-		const result = z$1.union(candidates);
+		const result = z.union(candidates);
 		this.registerSchema(`${type}Filter${this.filterSchemaSuffix({
 			optional,
 			array,
@@ -2357,7 +2584,7 @@ var ZodSchemaFactory = class {
 		return result;
 	}
 	makeNullableTypedJsonMutationSchema(fieldSchema) {
-		return z$1.any().superRefine((value, ctx) => {
+		return z.any().superRefine((value, ctx) => {
 			if (value instanceof DbNullClass || value instanceof JsonNullClass || value === null || value === void 0) return;
 			const parseResult = fieldSchema.safeParse(value);
 			if (!parseResult.success) parseResult.error.issues.forEach((issue) => ctx.addIssue(issue));
@@ -2369,11 +2596,11 @@ var ZodSchemaFactory = class {
 	makeEnumFilterSchema(enumName, optional, array, withAggregations, allowedFilterKinds) {
 		const enumDef = getEnum(this.schema, enumName);
 		invariant(enumDef, `Enum "${enumName}" not found in schema`);
-		const baseSchema = z$1.enum(Object.keys(enumDef.values));
+		const baseSchema = z.enum(Object.keys(enumDef.values));
 		let schema;
 		if (array) schema = this.internalMakeArrayFilterSchema(baseSchema, allowedFilterKinds);
 		else {
-			const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z$1.lazy(() => this.makeEnumFilterSchema(enumName, optional, array, withAggregations, allowedFilterKinds)), [
+			const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z.lazy(() => this.makeEnumFilterSchema(enumName, optional, array, withAggregations, allowedFilterKinds)), [
 				"equals",
 				"in",
 				"notIn",
@@ -2407,42 +2634,42 @@ var ZodSchemaFactory = class {
 			has: elementSchema.optional(),
 			hasEvery: elementSchema.array().optional(),
 			hasSome: elementSchema.array().optional(),
-			isEmpty: z$1.boolean().optional()
+			isEmpty: z.boolean().optional()
 		};
 		const filteredOperators = this.trimFilterOperators(operators, allowedFilterKinds);
-		return z$1.strictObject(filteredOperators);
+		return z.strictObject(filteredOperators);
 	}
-	makePrimitiveFilterSchema(type, optional, withAggregations, allowedFilterKinds) {
-		return match(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations, allowedFilterKinds)).with(P.union("Int", "Float", "Decimal", "BigInt"), (type) => this.makeNumberFilterSchema(type, optional, withAggregations, allowedFilterKinds)).with("Boolean", () => this.makeBooleanFilterSchema(optional, withAggregations, allowedFilterKinds)).with("DateTime", () => this.makeDateTimeFilterSchema(optional, withAggregations, allowedFilterKinds)).with("Bytes", () => this.makeBytesFilterSchema(optional, withAggregations, allowedFilterKinds)).with("Json", () => this.makeJsonFilterSchema(optional, allowedFilterKinds)).with("Unsupported", () => z$1.never()).exhaustive();
+	makePrimitiveFilterSchema(type, optional, withAggregations, allowedFilterKinds, withFuzzy = false, withFullText = false) {
+		return match(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations, allowedFilterKinds, withFuzzy, withFullText)).with(P.union("Int", "Float", "Decimal", "BigInt"), (type) => this.makeNumberFilterSchema(type, optional, withAggregations, allowedFilterKinds)).with("Boolean", () => this.makeBooleanFilterSchema(optional, withAggregations, allowedFilterKinds)).with("DateTime", () => this.makeDateTimeFilterSchema(optional, withAggregations, allowedFilterKinds)).with("Bytes", () => this.makeBytesFilterSchema(optional, withAggregations, allowedFilterKinds)).with("Json", () => this.makeJsonFilterSchema(optional, allowedFilterKinds)).with("Unsupported", () => z.never()).exhaustive();
 	}
 	makeJsonValueSchema() {
-		const schema = z$1.union([
-			z$1.string(),
-			z$1.number(),
-			z$1.boolean(),
-			z$1.instanceof(JsonNullClass),
-			z$1.lazy(() => z$1.union([this.makeJsonValueSchema(), z$1.null()]).array()),
-			z$1.record(z$1.string(), z$1.lazy(() => z$1.union([this.makeJsonValueSchema(), z$1.null()])))
+		const schema = z.union([
+			z.string(),
+			z.number(),
+			z.boolean(),
+			z.instanceof(JsonNullClass),
+			z.lazy(() => z.union([this.makeJsonValueSchema(), z.null()]).array()),
+			z.record(z.string(), z.lazy(() => z.union([this.makeJsonValueSchema(), z.null()])))
 		]);
 		this.registerSchema("JsonValue", schema);
 		return schema;
 	}
 	makeJsonFilterSchema(optional, allowedFilterKinds) {
-		if (allowedFilterKinds && !allowedFilterKinds.includes("Json")) return z$1.never();
+		if (allowedFilterKinds && !allowedFilterKinds.includes("Json")) return z.never();
 		const filterMembers = [
 			this.makeJsonValueSchema(),
-			z$1.instanceof(DbNullClass),
-			z$1.instanceof(AnyNullClass)
+			z.instanceof(DbNullClass),
+			z.instanceof(AnyNullClass)
 		];
-		if (optional) filterMembers.push(z$1.null());
-		const filterValueSchema = z$1.union(filterMembers);
-		const schema = z$1.strictObject({
-			path: z$1.string().optional(),
+		if (optional) filterMembers.push(z.null());
+		const filterValueSchema = z.union(filterMembers);
+		const schema = z.strictObject({
+			path: z.string().optional(),
 			equals: filterValueSchema.optional(),
 			not: filterValueSchema.optional(),
-			string_contains: z$1.string().optional(),
-			string_starts_with: z$1.string().optional(),
-			string_ends_with: z$1.string().optional(),
+			string_contains: z.string().optional(),
+			string_starts_with: z.string().optional(),
+			string_ends_with: z.string().optional(),
 			mode: this.makeStringModeSchema().optional(),
 			array_contains: filterValueSchema.optional(),
 			array_starts_with: filterValueSchema.optional(),
@@ -2455,17 +2682,13 @@ var ZodSchemaFactory = class {
 		return schema;
 	}
 	makeDateTimeValueSchema() {
-		const schema = z$1.union([
-			z$1.iso.datetime(),
-			z$1.iso.date(),
-			z$1.date()
-		]);
+		const schema = coercedDateTimeSchema();
 		this.registerSchema("DateTime", schema);
 		return schema;
 	}
 	makeDateTimeFilterSchema(optional, withAggregations, allowedFilterKinds) {
 		const filterValueSchema = this.makeDateTimeValueSchema();
-		const schema = this.makeCommonPrimitiveFilterSchema(filterValueSchema, optional, () => z$1.lazy(() => this.makeDateTimeFilterSchema(optional, withAggregations, allowedFilterKinds)), withAggregations ? [
+		const schema = this.makeCommonPrimitiveFilterSchema(filterValueSchema, optional, () => z.lazy(() => this.makeDateTimeFilterSchema(optional, withAggregations, allowedFilterKinds)), withAggregations ? [
 			"_count",
 			"_min",
 			"_max"
@@ -2478,12 +2701,12 @@ var ZodSchemaFactory = class {
 		return schema;
 	}
 	makeBooleanFilterSchema(optional, withAggregations, allowedFilterKinds) {
-		const components = this.makeCommonPrimitiveFilterComponents(z$1.boolean(), optional, () => z$1.lazy(() => this.makeBooleanFilterSchema(optional, withAggregations, allowedFilterKinds)), ["equals", "not"], withAggregations ? [
+		const components = this.makeCommonPrimitiveFilterComponents(z.boolean(), optional, () => z.lazy(() => this.makeBooleanFilterSchema(optional, withAggregations, allowedFilterKinds)), ["equals", "not"], withAggregations ? [
 			"_count",
 			"_min",
 			"_max"
 		] : void 0, allowedFilterKinds);
-		const schema = this.createUnionFilterSchema(z$1.boolean(), optional, components, allowedFilterKinds);
+		const schema = this.createUnionFilterSchema(z.boolean(), optional, components, allowedFilterKinds);
 		this.registerSchema(`BooleanFilter${this.filterSchemaSuffix({
 			optional,
 			allowedFilterKinds,
@@ -2492,8 +2715,8 @@ var ZodSchemaFactory = class {
 		return schema;
 	}
 	makeBytesFilterSchema(optional, withAggregations, allowedFilterKinds) {
-		const baseSchema = z$1.instanceof(Uint8Array);
-		const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z$1.instanceof(Uint8Array), [
+		const baseSchema = z.instanceof(Uint8Array);
+		const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z.instanceof(Uint8Array), [
 			"equals",
 			"in",
 			"notIn",
@@ -2541,7 +2764,7 @@ var ZodSchemaFactory = class {
 		return this.createUnionFilterSchema(baseSchema, optional, components, allowedFilterKinds);
 	}
 	makeNumberFilterSchema(type, optional, withAggregations, allowedFilterKinds) {
-		const schema = this.makeCommonPrimitiveFilterSchema(this.makeScalarSchema(type), optional, () => z$1.lazy(() => this.makeNumberFilterSchema(type, optional, withAggregations, allowedFilterKinds)), withAggregations ? [
+		const schema = this.makeCommonPrimitiveFilterSchema(this.makeScalarSchema(type), optional, () => z.lazy(() => this.makeNumberFilterSchema(type, optional, withAggregations, allowedFilterKinds)), withAggregations ? [
 			"_count",
 			"_avg",
 			"_sum",
@@ -2555,16 +2778,18 @@ var ZodSchemaFactory = class {
 		})}`, schema);
 		return schema;
 	}
-	makeStringFilterSchema(optional, withAggregations, allowedFilterKinds) {
-		const baseComponents = this.makeCommonPrimitiveFilterComponents(z$1.string(), optional, () => z$1.lazy(() => this.makeStringFilterSchema(optional, withAggregations, allowedFilterKinds)), void 0, withAggregations ? [
+	makeStringFilterSchema(optional, withAggregations, allowedFilterKinds, withFuzzy = false, withFullText = false) {
+		const baseComponents = this.makeCommonPrimitiveFilterComponents(z.string(), optional, () => z.lazy(() => this.makeStringFilterSchema(optional, withAggregations, allowedFilterKinds, withFuzzy, withFullText)), void 0, withAggregations ? [
 			"_count",
 			"_min",
 			"_max"
 		] : void 0, allowedFilterKinds);
 		const stringSpecificOperators = {
-			startsWith: z$1.string().optional(),
-			endsWith: z$1.string().optional(),
-			contains: z$1.string().optional(),
+			startsWith: z.string().optional(),
+			endsWith: z.string().optional(),
+			contains: z.string().optional(),
+			...withFuzzy && this.providerSupportsFuzzySearch ? { fuzzy: this.makeFuzzyFilterSchema().optional() } : {},
+			...withFullText && this.providerSupportsFullTextSearch ? { fts: this.makeFullTextFilterSchema().optional() } : {},
 			...this.providerSupportsCaseSensitivity ? { mode: this.makeStringModeSchema().optional() } : {}
 		};
 		const filteredStringOperators = this.trimFilterOperators(stringSpecificOperators, allowedFilterKinds);
@@ -2572,29 +2797,48 @@ var ZodSchemaFactory = class {
 			...baseComponents,
 			...filteredStringOperators
 		};
-		const schema = this.createUnionFilterSchema(z$1.string(), optional, allComponents, allowedFilterKinds);
+		const schema = this.createUnionFilterSchema(z.string(), optional, allComponents, allowedFilterKinds);
+		const featureSuffix = `${withFuzzy ? "Fuzzy" : ""}${withFullText ? "FullText" : ""}`;
 		this.registerSchema(`StringFilter${this.filterSchemaSuffix({
 			optional,
 			allowedFilterKinds,
 			withAggregations
-		})}`, schema);
+		})}${featureSuffix}`, schema);
 		return schema;
 	}
 	makeStringModeSchema() {
-		return z$1.union([z$1.literal("default"), z$1.literal("insensitive")]);
+		return z.union([z.literal("default"), z.literal("insensitive")]);
+	}
+	makeFuzzyFilterSchema() {
+		return z.strictObject({
+			search: z.string().min(1),
+			mode: z.union([
+				z.literal("simple"),
+				z.literal("word"),
+				z.literal("strictWord")
+			]).default("simple"),
+			threshold: z.number().min(0).max(1).optional(),
+			unaccent: z.boolean().default(false)
+		});
+	}
+	makeFullTextFilterSchema() {
+		return z.strictObject({
+			search: z.string().min(1),
+			config: z.string().min(1).optional()
+		});
 	}
 	makeSelectSchema(model, options) {
 		const fields = {};
 		for (const [field, fieldDef] of this.getModelFields(model)) if (fieldDef.relation) {
 			if (!this.shouldIncludeRelations(options)) continue;
 			if (this.isModelAllowed(fieldDef.type)) fields[field] = this.makeRelationSelectIncludeSchema(model, field, options).optional();
-		} else fields[field] = z$1.boolean().optional();
+		} else fields[field] = z.boolean().optional();
 		if (this.shouldIncludeRelations(options)) {
 			const _countSchema = this.makeCountSelectionSchema(model, options);
-			if (!(_countSchema instanceof z$1.ZodNever)) fields["_count"] = _countSchema;
+			if (!(_countSchema instanceof z.ZodNever)) fields["_count"] = _countSchema;
 		}
 		this.addExtResultFields(model, fields);
-		const result = z$1.strictObject(fields);
+		const result = z.strictObject(fields);
 		this.registerSchema(`${model}Select`, result);
 		return result;
 	}
@@ -2603,24 +2847,24 @@ var ZodSchemaFactory = class {
 		const toManyRelations = Object.values(modelDef.fields).filter((def) => def.relation && def.array);
 		if (toManyRelations.length > 0) {
 			const nextOpts = this.nextOptions(options);
-			const schema = z$1.union([z$1.literal(true), z$1.strictObject({ select: z$1.strictObject(toManyRelations.reduce((acc, fieldDef) => ({
+			const schema = z.union([z.literal(true), z.strictObject({ select: z.strictObject(toManyRelations.reduce((acc, fieldDef) => ({
 				...acc,
-				[fieldDef.name]: z$1.union([z$1.boolean(), z$1.strictObject({ where: this.makeWhereSchema(fieldDef.type, false, false, false, nextOpts) })]).optional()
+				[fieldDef.name]: z.union([z.boolean(), z.strictObject({ where: this.makeWhereSchema(fieldDef.type, false, false, false, nextOpts) })]).optional()
 			}), {})) })]).optional();
 			this.registerSchema(`${model}CountSelection`, schema);
 			return schema;
-		} else return z$1.never();
+		} else return z.never();
 	}
 	makeRelationSelectIncludeSchema(model, field, options) {
 		const fieldDef = requireField(this.schema, model, field);
 		const nextOpts = this.nextOptions(options);
-		let objSchema = z$1.strictObject({
-			...fieldDef.array || fieldDef.optional ? { where: z$1.lazy(() => this.makeWhereSchema(fieldDef.type, false, false, false, nextOpts)).optional() } : {},
-			select: z$1.lazy(() => this.makeSelectSchema(fieldDef.type, nextOpts)).optional().nullable(),
-			include: z$1.lazy(() => this.makeIncludeSchema(fieldDef.type, nextOpts)).optional().nullable(),
-			omit: z$1.lazy(() => this.makeOmitSchema(fieldDef.type)).optional().nullable(),
+		let objSchema = z.strictObject({
+			...fieldDef.array || fieldDef.optional ? { where: z.lazy(() => this.makeWhereSchema(fieldDef.type, false, false, false, nextOpts)).optional() } : {},
+			select: z.lazy(() => this.makeSelectSchema(fieldDef.type, nextOpts)).optional().nullable(),
+			include: z.lazy(() => this.makeIncludeSchema(fieldDef.type, nextOpts)).optional().nullable(),
+			omit: z.lazy(() => this.makeOmitSchema(fieldDef.type)).optional().nullable(),
 			...fieldDef.array ? {
-				orderBy: z$1.lazy(() => this.orArray(this.makeOrderBySchema(fieldDef.type, true, false, nextOpts), true)).optional(),
+				orderBy: z.lazy(() => this.orArray(this.makeOrderBySchema(fieldDef.type, true, false, nextOpts), true)).optional(),
 				skip: this.makeSkipSchema().optional(),
 				take: this.makeTakeSchema().optional(),
 				cursor: this.makeCursorSchema(fieldDef.type, nextOpts).optional(),
@@ -2630,16 +2874,16 @@ var ZodSchemaFactory = class {
 		objSchema = this.refineForSelectIncludeMutuallyExclusive(objSchema);
 		objSchema = this.refineForSelectOmitMutuallyExclusive(objSchema);
 		objSchema = this.refineForSelectHasTruthyField(objSchema);
-		const result = z$1.union([z$1.boolean(), objSchema]);
+		const result = z.union([z.boolean(), objSchema]);
 		this.registerSchema(`${model}${upperCaseFirst(field)}RelationInput`, result);
 		return result;
 	}
 	makeOmitSchema(model) {
 		const fields = {};
-		for (const [field, fieldDef] of this.getModelFields(model)) if (!fieldDef.relation) if (this.options.allowQueryTimeOmitOverride !== false) fields[field] = z$1.boolean().optional();
-		else fields[field] = z$1.literal(true).optional();
+		for (const [field, fieldDef] of this.getModelFields(model)) if (!fieldDef.relation) if (this.options.allowQueryTimeOmitOverride !== false) fields[field] = z.boolean().optional();
+		else fields[field] = z.literal(true).optional();
 		this.addExtResultFields(model, fields);
-		const result = z$1.strictObject(fields);
+		const result = z.strictObject(fields);
 		this.registerSchema(`${model}OmitInput`, result);
 		return result;
 	}
@@ -2648,7 +2892,7 @@ var ZodSchemaFactory = class {
 			const resultConfig = plugin.result;
 			if (resultConfig) {
 				const modelConfig = resultConfig[lowerCaseFirst(model)];
-				if (modelConfig) for (const field of Object.keys(modelConfig)) fields[field] = z$1.boolean().optional();
+				if (modelConfig) for (const field of Object.keys(modelConfig)) fields[field] = z.boolean().optional();
 			}
 		}
 	}
@@ -2664,26 +2908,26 @@ var ZodSchemaFactory = class {
 		}
 		if (this.shouldIncludeRelations(options)) {
 			const _countSchema = this.makeCountSelectionSchema(model, options);
-			if (!(_countSchema instanceof z$1.ZodNever)) fields["_count"] = _countSchema;
+			if (!(_countSchema instanceof z.ZodNever)) fields["_count"] = _countSchema;
 		}
-		const result = z$1.strictObject(fields);
+		const result = z.strictObject(fields);
 		this.registerSchema(`${model}Include`, result);
 		return result;
 	}
 	makeOrderBySchema(model, withRelation, WithAggregation, options) {
 		const fields = {};
-		const sort = z$1.union([z$1.literal("asc"), z$1.literal("desc")]);
+		const sort = z.union([z.literal("asc"), z.literal("desc")]);
 		const refineAtMostOneKey = (s) => s.refine((v) => Object.keys(v).length <= 1, { message: "Each orderBy element must have at most one key" });
 		const nextOpts = this.nextOptions(options);
 		for (const [field, fieldDef] of this.getModelFields(model)) if (fieldDef.relation) {
-			if (withRelation && this.shouldIncludeRelations(options)) fields[field] = z$1.lazy(() => {
+			if (withRelation && this.shouldIncludeRelations(options)) fields[field] = z.lazy(() => {
 				let relationOrderBy = this.makeOrderBySchema(fieldDef.type, withRelation, WithAggregation, nextOpts);
 				if (fieldDef.array) relationOrderBy = refineAtMostOneKey(relationOrderBy.safeExtend({ _count: sort }));
 				return relationOrderBy;
 			}).optional();
-		} else if (fieldDef.optional) fields[field] = z$1.union([sort, z$1.strictObject({
+		} else if (fieldDef.optional) fields[field] = z.union([sort, z.strictObject({
 			sort,
-			nulls: z$1.union([z$1.literal("first"), z$1.literal("last")])
+			nulls: z.union([z.literal("first"), z.literal("last")]).optional()
 		})]).optional();
 		else fields[field] = sort.optional();
 		if (WithAggregation) for (const agg of [
@@ -2692,8 +2936,31 @@ var ZodSchemaFactory = class {
 			"_sum",
 			"_min",
 			"_max"
-		]) fields[agg] = z$1.lazy(() => this.makeOrderBySchema(model, true, false, options).optional());
-		const schema = refineAtMostOneKey(z$1.strictObject(fields));
+		]) fields[agg] = z.lazy(() => this.makeOrderBySchema(model, true, false, options).optional());
+		if (this.providerSupportsFuzzySearch) {
+			const fuzzyFieldNames = this.getModelFields(model).filter(([, def]) => !def.relation && def.type === "String" && def.fuzzy === true).map(([name]) => name);
+			if (fuzzyFieldNames.length > 0) fields["_fuzzyRelevance"] = z.strictObject({
+				fields: z.array(z.enum(fuzzyFieldNames)).min(1),
+				search: z.string(),
+				mode: z.union([
+					z.literal("simple"),
+					z.literal("word"),
+					z.literal("strictWord")
+				]).default("simple"),
+				unaccent: z.boolean().default(false),
+				sort
+			}).optional();
+		}
+		if (this.providerSupportsFullTextSearch) {
+			const fullTextFieldNames = this.getModelFields(model).filter(([, def]) => !def.relation && def.type === "String" && def.fullText === true).map(([name]) => name);
+			if (fullTextFieldNames.length > 0) fields["_ftsRelevance"] = z.strictObject({
+				fields: z.array(z.enum(fullTextFieldNames)).min(1),
+				search: z.string().min(1),
+				config: z.string().min(1).optional(),
+				sort
+			}).optional();
+		}
+		const schema = refineAtMostOneKey(z.strictObject(fields));
 		let schemaId = `${model}OrderBy`;
 		if (withRelation) schemaId += "WithRelation";
 		if (WithAggregation) schemaId += "WithAggregation";
@@ -2703,7 +2970,7 @@ var ZodSchemaFactory = class {
 	}
 	makeDistinctSchema(model) {
 		const nonRelationFields = this.getModelFields(model).filter(([, def]) => !def.relation).map(([name]) => name);
-		const schema = nonRelationFields.length > 0 ? this.orArray(z$1.enum(nonRelationFields), true) : z$1.never();
+		const schema = nonRelationFields.length > 0 ? this.orArray(z.enum(nonRelationFields), true) : z.never();
 		this.registerSchema(`${model}DistinctInput`, schema);
 		return schema;
 	}
@@ -2714,7 +2981,7 @@ var ZodSchemaFactory = class {
 	}
 	makeCreateSchema(model, options) {
 		const dataSchema = this.makeCreateDataSchema(model, false, [], false, options);
-		const baseSchema = z$1.strictObject({
+		const baseSchema = z.strictObject({
 			data: dataSchema,
 			select: this.makeSelectSchema(model, options).optional().nullable(),
 			include: this.makeIncludeSchema(model, options).optional().nullable(),
@@ -2763,7 +3030,7 @@ var ZodSchemaFactory = class {
 					const oppositeFieldDef = requireField(this.schema, fieldDef.type, oppositeField);
 					if (oppositeFieldDef.relation?.fields) excludeFields.push(...oppositeFieldDef.relation.fields);
 				}
-				let fieldSchema = z$1.lazy(() => this.makeRelationManipulationSchema(model, field, excludeFields, "create", nextOpts));
+				let fieldSchema = z.lazy(() => this.makeRelationManipulationSchema(model, field, excludeFields, "create", nextOpts));
 				if (fieldDef.optional || fieldDef.array) fieldSchema = fieldSchema.optional();
 				else {
 					let allFksOptional = false;
@@ -2780,23 +3047,23 @@ var ZodSchemaFactory = class {
 				let fieldSchema = this.makeScalarSchema(fieldDef.type, fieldDef.attributes);
 				if (fieldDef.array) {
 					fieldSchema = ZodUtils.addListValidation(fieldSchema.array(), fieldDef.attributes);
-					fieldSchema = z$1.union([fieldSchema, z$1.strictObject({ set: fieldSchema })]).optional();
+					fieldSchema = z.union([fieldSchema, z.strictObject({ set: fieldSchema })]).optional();
 				}
 				if (fieldDef.optional || fieldHasDefaultValue(fieldDef)) fieldSchema = fieldSchema.optional();
-				if (fieldDef.optional) if (fieldDef.type === "Json") fieldSchema = z$1.union([fieldSchema, z$1.instanceof(DbNullClass)]);
+				if (fieldDef.optional) if (fieldDef.type === "Json") fieldSchema = z.union([fieldSchema, z.instanceof(DbNullClass)]);
 				else if (this.isTypeDefType(fieldDef.type)) fieldSchema = this.makeNullableTypedJsonMutationSchema(fieldSchema);
 				else fieldSchema = fieldSchema.nullable();
 				uncheckedVariantFields[field] = fieldSchema;
 				if (!fieldDef.foreignKeyFor) checkedVariantFields[field] = fieldSchema;
 			}
 		});
-		const uncheckedCreateSchema = this.extraValidationsEnabled ? ZodUtils.addCustomValidation(z$1.strictObject(uncheckedVariantFields), modelDef.attributes) : z$1.strictObject(uncheckedVariantFields);
-		const checkedCreateSchema = this.extraValidationsEnabled ? ZodUtils.addCustomValidation(z$1.strictObject(checkedVariantFields), modelDef.attributes) : z$1.strictObject(checkedVariantFields);
-		const result = !hasRelation ? this.orArray(uncheckedCreateSchema, canBeArray) : z$1.union([
+		const uncheckedCreateSchema = this.extraValidationsEnabled ? ZodUtils.addCustomValidation(z.strictObject(uncheckedVariantFields), modelDef.attributes) : z.strictObject(uncheckedVariantFields);
+		const checkedCreateSchema = this.extraValidationsEnabled ? ZodUtils.addCustomValidation(z.strictObject(checkedVariantFields), modelDef.attributes) : z.strictObject(checkedVariantFields);
+		const result = !hasRelation ? this.orArray(uncheckedCreateSchema, canBeArray) : z.union([
 			uncheckedCreateSchema,
 			checkedCreateSchema,
-			...canBeArray ? [z$1.array(uncheckedCreateSchema)] : [],
-			...canBeArray ? [z$1.array(checkedCreateSchema)] : []
+			...canBeArray ? [z.array(uncheckedCreateSchema)] : [],
+			...canBeArray ? [z.array(checkedCreateSchema)] : []
 		]);
 		const idParts = [`${model}CreateData`];
 		if (canBeArray) idParts.push("Array");
@@ -2821,17 +3088,17 @@ var ZodSchemaFactory = class {
 				fields["disconnect"] = this.makeDisconnectDataSchema(fieldType, array, options).optional();
 				fields["delete"] = this.makeDeleteRelationDataSchema(fieldType, array, true, options).optional();
 			}
-			fields["update"] = array ? this.orArray(z$1.strictObject({
+			fields["update"] = array ? this.orArray(z.strictObject({
 				where: this.makeWhereSchema(fieldType, true, false, false, options),
 				data: this.makeUpdateDataSchema(fieldType, withoutFields, false, options)
-			}), true).optional() : z$1.union([z$1.strictObject({
+			}), true).optional() : z.union([z.strictObject({
 				where: this.makeWhereSchema(fieldType, false, false, false, options).optional(),
 				data: this.makeUpdateDataSchema(fieldType, withoutFields, false, options)
 			}), this.makeUpdateDataSchema(fieldType, withoutFields, false, options)]).optional();
 			if (canCreateModel) {
 				let upsertWhere = this.makeWhereSchema(fieldType, true, false, false, options);
 				if (!fieldDef.array) upsertWhere = upsertWhere.optional();
-				fields["upsert"] = this.orArray(z$1.strictObject({
+				fields["upsert"] = this.orArray(z.strictObject({
 					where: upsertWhere,
 					create: this.makeCreateDataSchema(fieldType, false, withoutFields, false, options),
 					update: this.makeUpdateDataSchema(fieldType, withoutFields, false, options)
@@ -2839,14 +3106,14 @@ var ZodSchemaFactory = class {
 			}
 			if (array) {
 				fields["set"] = this.makeSetDataSchema(fieldType, true, options).optional();
-				fields["updateMany"] = this.orArray(z$1.strictObject({
+				fields["updateMany"] = this.orArray(z.strictObject({
 					where: this.makeWhereSchema(fieldType, false, true, false, options),
 					data: this.makeUpdateDataSchema(fieldType, withoutFields, false, options)
 				}), true).optional();
 				fields["deleteMany"] = this.makeDeleteRelationDataSchema(fieldType, true, false, options).optional();
 			}
 		}
-		return z$1.strictObject(fields);
+		return z.strictObject(fields);
 	}
 	makeSetDataSchema(model, canBeArray, options) {
 		return this.orArray(this.makeWhereSchema(model, true, false, false, options), canBeArray);
@@ -2856,23 +3123,23 @@ var ZodSchemaFactory = class {
 	}
 	makeDisconnectDataSchema(model, canBeArray, options) {
 		if (canBeArray) return this.orArray(this.makeWhereSchema(model, true, false, false, options), canBeArray);
-		else return z$1.union([z$1.boolean(), this.makeWhereSchema(model, false, false, false, options)]);
+		else return z.union([z.boolean(), this.makeWhereSchema(model, false, false, false, options)]);
 	}
 	makeDeleteRelationDataSchema(model, toManyRelation, uniqueFilter, options) {
-		return toManyRelation ? this.orArray(this.makeWhereSchema(model, uniqueFilter, false, false, options), true) : z$1.union([z$1.boolean(), this.makeWhereSchema(model, uniqueFilter, false, false, options)]);
+		return toManyRelation ? this.orArray(this.makeWhereSchema(model, uniqueFilter, false, false, options), true) : z.union([z.boolean(), this.makeWhereSchema(model, uniqueFilter, false, false, options)]);
 	}
 	makeConnectOrCreateDataSchema(model, canBeArray, withoutFields, options) {
 		const whereSchema = this.makeWhereSchema(model, true, false, false, options);
 		const createSchema = this.makeCreateDataSchema(model, false, withoutFields, false, options);
-		return this.orArray(z$1.strictObject({
+		return this.orArray(z.strictObject({
 			where: whereSchema,
 			create: createSchema
 		}), canBeArray);
 	}
 	makeCreateManyPayloadSchema(model, withoutFields, options) {
-		const schema = z$1.strictObject({
+		const schema = z.strictObject({
 			data: this.makeCreateDataSchema(model, true, withoutFields, true, options),
-			skipDuplicates: z$1.boolean().optional()
+			skipDuplicates: z.boolean().optional()
 		});
 		const idParts = [`${model}CreateManyPayload`];
 		if (withoutFields.length) idParts.push(`Without${withoutFields.slice().sort().join("")}`);
@@ -2880,7 +3147,7 @@ var ZodSchemaFactory = class {
 		return schema;
 	}
 	makeUpdateSchema(model, options) {
-		const baseSchema = z$1.strictObject({
+		const baseSchema = z.strictObject({
 			where: this.makeWhereSchema(model, true, false, false, options),
 			data: this.makeUpdateDataSchema(model, [], false, options),
 			select: this.makeSelectSchema(model, options).optional().nullable(),
@@ -2895,10 +3162,10 @@ var ZodSchemaFactory = class {
 		return schema;
 	}
 	makeUpdateManySchema(model, options) {
-		const result = this.mergePluginArgsSchema(z$1.strictObject({
+		const result = this.mergePluginArgsSchema(z.strictObject({
 			where: this.makeWhereSchema(model, false, false, false, options).optional(),
 			data: this.makeUpdateDataSchema(model, [], true, options),
-			limit: z$1.number().int().nonnegative().optional()
+			limit: z.number().int().nonnegative().optional()
 		}), "updateMany");
 		this.registerSchema(`${model}UpdateManyArgs`, result);
 		return result;
@@ -2914,7 +3181,7 @@ var ZodSchemaFactory = class {
 		return schema;
 	}
 	makeUpsertSchema(model, options) {
-		const baseSchema = z$1.strictObject({
+		const baseSchema = z.strictObject({
 			where: this.makeWhereSchema(model, true, false, false, options),
 			create: this.makeCreateDataSchema(model, false, [], false, options),
 			update: this.makeUpdateDataSchema(model, [], false, options),
@@ -2950,27 +3217,27 @@ var ZodSchemaFactory = class {
 					const oppositeFieldDef = requireField(this.schema, fieldDef.type, oppositeField);
 					if (oppositeFieldDef.relation?.fields) excludeFields.push(...oppositeFieldDef.relation.fields);
 				}
-				let fieldSchema = z$1.lazy(() => this.makeRelationManipulationSchema(model, field, excludeFields, "update", nextOpts)).optional();
+				let fieldSchema = z.lazy(() => this.makeRelationManipulationSchema(model, field, excludeFields, "update", nextOpts)).optional();
 				if (fieldDef.optional && !fieldDef.array) fieldSchema = fieldSchema.nullable();
 				checkedVariantFields[field] = fieldSchema;
 				if (fieldDef.array || !fieldDef.relation.references) uncheckedVariantFields[field] = fieldSchema;
 			} else {
 				let fieldSchema = this.makeScalarSchema(fieldDef.type, fieldDef.attributes);
-				if (this.isNumericField(fieldDef)) fieldSchema = z$1.union([fieldSchema, z$1.object({
-					set: this.nullableIf(z$1.number().optional(), !!fieldDef.optional).optional(),
-					increment: z$1.number().optional(),
-					decrement: z$1.number().optional(),
-					multiply: z$1.number().optional(),
-					divide: z$1.number().optional()
+				if (this.isNumericField(fieldDef)) fieldSchema = z.union([fieldSchema, z.object({
+					set: this.nullableIf(z.number().optional(), !!fieldDef.optional).optional(),
+					increment: z.number().optional(),
+					decrement: z.number().optional(),
+					multiply: z.number().optional(),
+					divide: z.number().optional()
 				}).refine((v) => Object.keys(v).length === 1, "Only one of \"set\", \"increment\", \"decrement\", \"multiply\", or \"divide\" can be provided")]);
 				if (fieldDef.array) {
 					const arraySchema = ZodUtils.addListValidation(fieldSchema.array(), fieldDef.attributes);
-					fieldSchema = z$1.union([arraySchema, z$1.object({
+					fieldSchema = z.union([arraySchema, z.object({
 						set: arraySchema.optional(),
-						push: z$1.union([fieldSchema, fieldSchema.array()]).optional()
+						push: z.union([fieldSchema, fieldSchema.array()]).optional()
 					}).refine((v) => Object.keys(v).length === 1, "Only one of \"set\", \"push\" can be provided")]);
 				}
-				if (fieldDef.optional) if (fieldDef.type === "Json") fieldSchema = z$1.union([fieldSchema, z$1.instanceof(DbNullClass)]);
+				if (fieldDef.optional) if (fieldDef.type === "Json") fieldSchema = z.union([fieldSchema, z.instanceof(DbNullClass)]);
 				else if (this.isTypeDefType(fieldDef.type)) fieldSchema = this.makeNullableTypedJsonMutationSchema(fieldSchema);
 				else fieldSchema = fieldSchema.nullable();
 				fieldSchema = fieldSchema.optional();
@@ -2978,9 +3245,9 @@ var ZodSchemaFactory = class {
 				if (!fieldDef.foreignKeyFor) checkedVariantFields[field] = fieldSchema;
 			}
 		});
-		const uncheckedUpdateSchema = this.extraValidationsEnabled ? ZodUtils.addCustomValidation(z$1.strictObject(uncheckedVariantFields), modelDef.attributes) : z$1.strictObject(uncheckedVariantFields);
-		const checkedUpdateSchema = this.extraValidationsEnabled ? ZodUtils.addCustomValidation(z$1.strictObject(checkedVariantFields), modelDef.attributes) : z$1.strictObject(checkedVariantFields);
-		const result = !hasRelation ? uncheckedUpdateSchema : z$1.union([uncheckedUpdateSchema, checkedUpdateSchema]);
+		const uncheckedUpdateSchema = this.extraValidationsEnabled ? ZodUtils.addCustomValidation(z.strictObject(uncheckedVariantFields), modelDef.attributes) : z.strictObject(uncheckedVariantFields);
+		const checkedUpdateSchema = this.extraValidationsEnabled ? ZodUtils.addCustomValidation(z.strictObject(checkedVariantFields), modelDef.attributes) : z.strictObject(checkedVariantFields);
+		const result = !hasRelation ? uncheckedUpdateSchema : z.union([uncheckedUpdateSchema, checkedUpdateSchema]);
 		const idParts = [`${model}UpdateData`];
 		if (withoutRelationFields) idParts.push("WithoutRelation");
 		if (withoutFields.length) idParts.push(`Without${withoutFields.slice().sort().join("")}`);
@@ -2988,7 +3255,7 @@ var ZodSchemaFactory = class {
 		return result;
 	}
 	makeDeleteSchema(model, options) {
-		const baseSchema = z$1.strictObject({
+		const baseSchema = z.strictObject({
 			where: this.makeWhereSchema(model, true, false, false, options),
 			select: this.makeSelectSchema(model, options).optional().nullable(),
 			include: this.makeIncludeSchema(model, options).optional().nullable(),
@@ -3002,15 +3269,15 @@ var ZodSchemaFactory = class {
 		return schema;
 	}
 	makeDeleteManySchema(model, options) {
-		const result = this.mergePluginArgsSchema(z$1.strictObject({
+		const result = this.mergePluginArgsSchema(z.strictObject({
 			where: this.makeWhereSchema(model, false, false, false, options).optional(),
-			limit: z$1.number().int().nonnegative().optional()
+			limit: z.number().int().nonnegative().optional()
 		}), "deleteMany").optional();
 		this.registerSchema(`${model}DeleteManyArgs`, result);
 		return result;
 	}
 	makeCountSchema(model, options) {
-		const result = this.mergePluginArgsSchema(z$1.strictObject({
+		const result = this.mergePluginArgsSchema(z.strictObject({
 			where: this.makeWhereSchema(model, false, false, false, options).optional(),
 			skip: this.makeSkipSchema().optional(),
 			take: this.makeTakeSchema().optional(),
@@ -3021,10 +3288,10 @@ var ZodSchemaFactory = class {
 		return result;
 	}
 	makeCountAggregateInputSchema(model) {
-		const schema = z$1.union([z$1.literal(true), z$1.strictObject({
-			_all: z$1.literal(true).optional(),
+		const schema = z.union([z.literal(true), z.strictObject({
+			_all: z.literal(true).optional(),
 			...this.getModelFields(model).reduce((acc, [field]) => {
-				acc[field] = z$1.literal(true).optional();
+				acc[field] = z.literal(true).optional();
 				return acc;
 			}, {})
 		})]);
@@ -3032,7 +3299,7 @@ var ZodSchemaFactory = class {
 		return schema;
 	}
 	makeAggregateSchema(model, options) {
-		const result = this.mergePluginArgsSchema(z$1.strictObject({
+		const result = this.mergePluginArgsSchema(z.strictObject({
 			where: this.makeWhereSchema(model, false, false, false, options).optional(),
 			skip: this.makeSkipSchema().optional(),
 			take: this.makeTakeSchema().optional(),
@@ -3047,16 +3314,16 @@ var ZodSchemaFactory = class {
 		return result;
 	}
 	makeSumAvgInputSchema(model) {
-		const schema = z$1.strictObject(this.getModelFields(model).reduce((acc, [field, fieldDef]) => {
-			if (this.isNumericField(fieldDef)) acc[field] = z$1.literal(true).optional();
+		const schema = z.strictObject(this.getModelFields(model).reduce((acc, [field, fieldDef]) => {
+			if (this.isNumericField(fieldDef)) acc[field] = z.literal(true).optional();
 			return acc;
 		}, {}));
 		this.registerSchema(`${model}SumAvgAggregateInput`, schema);
 		return schema;
 	}
 	makeMinMaxInputSchema(model) {
-		const schema = z$1.strictObject(this.getModelFields(model).reduce((acc, [field, fieldDef]) => {
-			if (!fieldDef.relation && !fieldDef.array) acc[field] = z$1.literal(true).optional();
+		const schema = z.strictObject(this.getModelFields(model).reduce((acc, [field, fieldDef]) => {
+			if (!fieldDef.relation && !fieldDef.array) acc[field] = z.literal(true).optional();
 			return acc;
 		}, {}));
 		this.registerSchema(`${model}MinMaxAggregateInput`, schema);
@@ -3064,8 +3331,8 @@ var ZodSchemaFactory = class {
 	}
 	makeGroupBySchema(model, options) {
 		const nonRelationFields = this.getModelFields(model).filter(([, def]) => !def.relation).map(([name]) => name);
-		const bySchema = nonRelationFields.length > 0 ? this.orArray(z$1.enum(nonRelationFields), true) : z$1.never();
-		const baseSchema = z$1.strictObject({
+		const bySchema = nonRelationFields.length > 0 ? this.orArray(z.enum(nonRelationFields), true) : z.never();
+		const baseSchema = z.strictObject({
 			where: this.makeWhereSchema(model, false, false, false, options).optional(),
 			orderBy: this.orArray(this.makeOrderBySchema(model, false, true, options), true).optional(),
 			by: bySchema,
@@ -3117,7 +3384,7 @@ var ZodSchemaFactory = class {
 		if (!procDef) throw createInternalError(`Procedure not found: ${procName}`);
 		const shape = {};
 		for (const param of Object.values(procDef.params ?? {})) shape[param.name] = this.makeProcedureParamSchema(param);
-		const schema = z$1.object(shape);
+		const schema = z.object(shape);
 		this.registerSchema(`${procName}ProcArgs`, schema);
 		return schema;
 	}
@@ -3125,10 +3392,10 @@ var ZodSchemaFactory = class {
 		let schema;
 		if (isTypeDef(this.schema, param.type)) schema = this.makeTypeDefSchema(param.type);
 		else if (isEnum(this.schema, param.type)) schema = this.makeEnumSchema(param.type);
-		else if (param.type in (this.schema.models ?? {})) schema = z$1.record(z$1.string(), z$1.unknown());
+		else if (param.type in (this.schema.models ?? {})) schema = z.record(z.string(), z.unknown());
 		else {
 			schema = this.makeScalarSchema(param.type);
-			if (schema instanceof z$1.ZodUnknown) throw createInternalError(`Unsupported procedure parameter type: ${param.type}`);
+			if (schema instanceof z.ZodUnknown) throw createInternalError(`Unsupported procedure parameter type: ${param.type}`);
 		}
 		if (param.array) schema = schema.array();
 		if (param.optional) schema = schema.optional();
@@ -3164,10 +3431,10 @@ var ZodSchemaFactory = class {
 		return result;
 	}
 	makeSkipSchema() {
-		return z$1.number().int().nonnegative();
+		return z.number().int().nonnegative();
 	}
 	makeTakeSchema() {
-		return z$1.number().int();
+		return z.number().int();
 	}
 	refineForSelectIncludeMutuallyExclusive(schema) {
 		return schema.refine((value) => !(value["select"] && value["include"]), "\"select\" and \"include\" cannot be used together");
@@ -3186,7 +3453,7 @@ var ZodSchemaFactory = class {
 		return nullable ? schema.nullable() : schema;
 	}
 	orArray(schema, canBeArray) {
-		return canBeArray ? z$1.union([schema, z$1.array(schema)]) : schema;
+		return canBeArray ? z.union([schema, z.array(schema)]) : schema;
 	}
 	isNumericField(fieldDef) {
 		return NUMERIC_FIELD_TYPES.includes(fieldDef.type) && !fieldDef.array;
@@ -3194,6 +3461,12 @@ var ZodSchemaFactory = class {
 	get providerSupportsCaseSensitivity() {
 		return this.schema.provider.type === "postgresql";
 	}
+	get providerSupportsFullTextSearch() {
+		return this.schema.provider.type === "postgresql";
+	}
+	get providerSupportsFuzzySearch() {
+		return this.schema.provider.type === "postgresql";
+	}
 	/**
 	* Gets the effective set of allowed FilterKind values for a specific model and field.
 	* Respects the precedence: model[field] > model.$all > $all[field] > $all.$all.
@@ -3242,10 +3515,10 @@ var ZodSchemaFactory = class {
 	createUnionFilterSchema(valueSchema, optional, components, allowedFilterKinds) {
 		if (Object.keys(components).length === 0) {
 			if (!allowedFilterKinds || allowedFilterKinds.includes("Equality")) return this.nullableIf(valueSchema, optional);
-			return z$1.never();
+			return z.never();
 		}
-		if (!allowedFilterKinds || allowedFilterKinds.includes("Equality")) return z$1.union([this.nullableIf(valueSchema, optional), z$1.strictObject(components)]);
-		else return z$1.strictObject(components);
+		if (!allowedFilterKinds || allowedFilterKinds.includes("Equality")) return z.union([this.nullableIf(valueSchema, optional), z.strictObject(components)]);
+		else return z.strictObject(components);
 	}
 	canCreateModel(model) {
 		const modelDef = requireModel(this.schema, model);
@@ -3355,6 +3628,8 @@ __decorate([
 		Object,
 		Boolean,
 		Boolean,
+		Object,
+		Object,
 		Object
 	]),
 	__decorateMetadata("design:returntype", void 0)
@@ -3424,6 +3699,8 @@ __decorate([
 	__decorateMetadata("design:paramtypes", [
 		Boolean,
 		Boolean,
+		Object,
+		Object,
 		Object
 	]),
 	__decorateMetadata("design:returntype", typeof (_ref10 = typeof ZodType !== "undefined" && ZodType) === "function" ? _ref10 : Object)
@@ -3913,7 +4190,7 @@ var BaseOperationHandler = class {
 		return new this.constructor(client, this.model, this.inputValidator);
 	}
 	get hasPolicyEnabled() {
-		return this.options.plugins?.some((plugin) => plugin.constructor.name === "PolicyPlugin");
+		return this.options.plugins?.some((plugin) => plugin.id === "policy") ?? false;
 	}
 	requireModel(model) {
 		return requireModel(this.schema, model);
@@ -4014,8 +4291,8 @@ var BaseOperationHandler = class {
 		const postCreateRelations = {};
 		for (const [field, value] of Object.entries(data)) {
 			const fieldDef = this.requireField(model, field);
-			if (isScalarField(this.schema, model, field) || isForeignKeyField(this.schema, model, field)) if (fieldDef.array && value && typeof value === "object" && "set" in value && Array.isArray(value.set)) createFields[field] = this.dialect.transformInput(value.set, fieldDef.type, true);
-			else createFields[field] = this.dialect.transformInput(value, fieldDef.type, !!fieldDef.array);
+			if (isScalarField(this.schema, model, field) || isForeignKeyField(this.schema, model, field)) if (fieldDef.array && value && typeof value === "object" && "set" in value && Array.isArray(value.set)) createFields[field] = this.dialect.transformInput(value.set, fieldDef.type, true, fieldDef);
+			else createFields[field] = this.dialect.transformInput(value, fieldDef.type, !!fieldDef.array, fieldDef);
 			else if (!getManyToManyRelation(this.schema, model, field) && fieldDef.relation?.fields && fieldDef.relation?.references) {
 				const fkValues = await this.processOwnedRelationForCreate(kysely, fieldDef, value);
 				for (let i = 0; i < fieldDef.relation.fields.length; i++) createFields[fieldDef.relation.fields[i]] = fkValues[fieldDef.relation.references[i]];
@@ -4215,7 +4492,7 @@ var BaseOperationHandler = class {
 			for (const [name, value] of Object.entries(item)) {
 				const fieldDef = this.requireField(model, name);
 				invariant(!fieldDef.relation, "createMany does not support relations");
-				newItem[name] = this.dialect.transformInput(value, fieldDef.type, !!fieldDef.array);
+				newItem[name] = this.dialect.transformInput(value, fieldDef.type, !!fieldDef.array, fieldDef);
 			}
 			if (fromRelation) for (const { fk, pk } of relationKeyPairs) newItem[fk] = fromRelation.ids[pk];
 			return this.fillGeneratedAndDefaultValues(modelDef, newItem);
@@ -4231,7 +4508,7 @@ var BaseOperationHandler = class {
 				if (Object.keys(item).length === allPassedFields.length) continue;
 				for (const field of allPassedFields) if (!(field in item)) {
 					const fieldDef = this.requireField(model, field);
-					if (fieldDef.default !== void 0 && fieldDef.default !== null && typeof fieldDef.default !== "object") item[field] = this.dialect.transformInput(fieldDef.default, fieldDef.type, !!fieldDef.array);
+					if (fieldDef.default !== void 0 && fieldDef.default !== null && typeof fieldDef.default !== "object") item[field] = this.dialect.transformInput(fieldDef.default, fieldDef.type, !!fieldDef.array, fieldDef);
 				}
 			}
 		}
@@ -4294,15 +4571,15 @@ var BaseOperationHandler = class {
 			if (!(field in data)) {
 				if (typeof fieldDef?.default === "object" && "kind" in fieldDef.default) {
 					const generated = this.evalGenerator(fieldDef.default);
-					if (generated !== void 0) values[field] = this.dialect.transformInput(generated, fieldDef.type, !!fieldDef.array);
-				} else if (fieldDef?.updatedAt) values[field] = this.dialect.transformInput(/* @__PURE__ */ new Date(), "DateTime", false);
+					if (generated !== void 0) values[field] = this.dialect.transformInput(generated, fieldDef.type, !!fieldDef.array, fieldDef);
+				} else if (fieldDef?.updatedAt) values[field] = this.dialect.transformInput(/* @__PURE__ */ new Date(), "DateTime", false, fieldDef);
 				else if (fieldDef?.default !== void 0) {
 					let value = fieldDef.default;
 					if (fieldDef.type === "Json") {
 						if (fieldDef.array && Array.isArray(value)) value = value.map((v) => typeof v === "string" ? JSON.parse(v) : v);
 						else if (typeof value === "string") value = JSON.parse(value);
 					}
-					values[field] = this.dialect.transformInput(value, fieldDef.type, !!fieldDef.array);
+					values[field] = this.dialect.transformInput(value, fieldDef.type, !!fieldDef.array, fieldDef);
 				}
 			}
 		}
@@ -4352,7 +4629,7 @@ var BaseOperationHandler = class {
 			const ignoredFields = new Set(typeof fieldDef.updatedAt === "boolean" ? [] : fieldDef.updatedAt.ignore);
 			if (Object.keys(data).some((field) => (isScalarField(this.schema, modelDef.name, field) || isForeignKeyField(this.schema, modelDef.name, field)) && !ignoredFields.has(field))) {
 				if (finalData === data) finalData = clone(data);
-				finalData[fieldName] = this.dialect.transformInput(/* @__PURE__ */ new Date(), "DateTime", false);
+				finalData[fieldName] = this.dialect.transformInput(/* @__PURE__ */ new Date(), "DateTime", false, fieldDef);
 				autoUpdatedFields.push(fieldName);
 			}
 		}
@@ -4456,7 +4733,7 @@ var BaseOperationHandler = class {
 		const fieldDef = this.requireField(model, field);
 		if (this.isNumericIncrementalUpdate(fieldDef, data[field])) return this.transformIncrementalUpdate(model, field, fieldDef, data[field]);
 		if (fieldDef.array && typeof data[field] === "object" && !Array.isArray(data[field]) && data[field]) return this.transformScalarListUpdate(model, field, fieldDef, data[field]);
-		return this.dialect.transformInput(data[field], fieldDef.type, !!fieldDef.array);
+		return this.dialect.transformInput(data[field], fieldDef.type, !!fieldDef.array, fieldDef);
 	}
 	isNumericIncrementalUpdate(fieldDef, value) {
 		if (!this.isNumericField(fieldDef)) return false;
@@ -4484,7 +4761,7 @@ var BaseOperationHandler = class {
 	transformIncrementalUpdate(model, field, fieldDef, payload) {
 		invariant(Object.keys(payload).length === 1, "Only one of \"set\", \"increment\", \"decrement\", \"multiply\", or \"divide\" can be provided");
 		const key = Object.keys(payload)[0];
-		const value = this.dialect.transformInput(payload[key], fieldDef.type, false);
+		const value = this.dialect.transformInput(payload[key], fieldDef.type, false, fieldDef);
 		const eb = expressionBuilder();
 		const fieldRef = this.dialect.fieldRef(model, field);
 		return match(key).with("set", () => value).with("increment", () => eb(fieldRef, "+", value)).with("decrement", () => eb(fieldRef, "-", value)).with("multiply", () => eb(fieldRef, "*", value)).with("divide", () => eb(fieldRef, "/", value)).otherwise(() => {
@@ -4494,7 +4771,7 @@ var BaseOperationHandler = class {
 	transformScalarListUpdate(model, field, fieldDef, payload) {
 		invariant(Object.keys(payload).length === 1, "Only one of \"set\", \"push\" can be provided");
 		const key = Object.keys(payload)[0];
-		const value = this.dialect.transformInput(payload[key], fieldDef.type, true);
+		const value = this.dialect.transformInput(payload[key], fieldDef.type, true, fieldDef);
 		const eb = expressionBuilder();
 		const fieldRef = this.dialect.fieldRef(model, field);
 		return match(key).with("set", () => value).with("push", () => {
@@ -6849,9 +7126,9 @@ var ClientImpl = class ClientImpl {
 	validateOptions(baseClient, options) {
 		if (!baseClient && !options.skipValidationForComputedFields) this.validateComputedFieldsConfig(options);
 		if (options.diagnostics) {
-			const parseResult = z.object({
-				slowQueryThresholdMs: z.number().nonnegative().optional(),
-				slowQueryMaxRecords: z.int().nonnegative().or(z.literal(Infinity)).optional()
+			const parseResult = z$1.object({
+				slowQueryThresholdMs: z$1.number().nonnegative().optional(),
+				slowQueryMaxRecords: z$1.int().nonnegative().or(z$1.literal(Infinity)).optional()
 			}).safeParse(options.diagnostics);
 			if (!parseResult.success) throw createConfigError(`Invalid diagnostics configuration: ${formatError(parseResult.error)}`);
 		}
@@ -6905,12 +7182,21 @@ var ClientImpl = class ClientImpl {
 			});
 		}
 	}
+	getPromiseCallback(promise) {
+		invariant(promise.cb, "Invalid ZenStackPromise, missing cb property");
+		const cb = promise.cb;
+		invariant(typeof cb === "function", "Invalid ZenStackPromise, cb property is not a function");
+		return promise.cb;
+	}
 	async sequentialTransaction(arg, options) {
 		const execute = async (tx) => {
 			const txClient = new ClientImpl(this.schema, this.$options, this);
 			txClient.kysely = tx;
 			const result = [];
-			for (const promise of arg) result.push(await promise.cb(txClient));
+			for (const promise of arg) {
+				const cb = this.getPromiseCallback(promise);
+				result.push(await cb(txClient));
+			}
 			return result;
 		};
 		if (this.kysely.isTransaction) return execute(this.kysely);
@@ -7697,6 +7983,15 @@ var DefaultOperationNodeVisitor = class extends OperationNodeVisitor {
 	visitCollate(node) {
 		this.defaultVisit(node);
 	}
+	visitAlterType(node) {
+		this.defaultVisit(node);
+	}
+	visitAddValue(node) {
+		this.defaultVisit(node);
+	}
+	visitRenameValue(node) {
+		this.defaultVisit(node);
+	}
 };
 //#endregion
 //#region src/utils/schema-utils.ts
@@ -7756,6 +8051,6 @@ var MatchingExpressionVisitor = class extends ExpressionVisitor {
 	}
 };
 //#endregion
-export { AllCrudOperations, AllReadOperations, AllWriteOperations, AnyNull, AnyNullClass, BaseCrudDialect, CRUD, CRUD_EXT, CoreCreateOperations, CoreCrudOperations, CoreDeleteOperations, CoreReadOperations, CoreUpdateOperations, CoreWriteOperations, DbNull, DbNullClass, InputValidator, JsonNull, JsonNullClass, kysely_utils_exports as KyselyUtils, ORMError, ORMErrorReason, query_utils_exports as QueryUtils, RejectedByPolicyReason, schema_utils_exports as SchemaUtils, TransactionIsolationLevel, ZenStackClient, createQuerySchemaFactory, definePlugin, getCrudDialect };
+export { AllCrudOperations, AllReadOperations, AllWriteOperations, AnyNull, AnyNullClass, BaseCrudDialect, CRUD, CRUD_EXT, CoreCreateOperations, CoreCrudOperations, CoreDeleteOperations, CoreReadOperations, CoreUpdateOperations, CoreWriteOperations, DbNull, DbNullClass, ExtQueryArgsMarker, ExtResultMarker, InputValidator, JsonNull, JsonNullClass, kysely_utils_exports as KyselyUtils, ORMError, ORMErrorReason, query_utils_exports as QueryUtils, RejectedByPolicyReason, schema_utils_exports as SchemaUtils, TransactionIsolationLevel, ZenStackClient, createQuerySchemaFactory, definePlugin, getCrudDialect };
 
 //# sourceMappingURL=index.mjs.map