@zenstackhq/orm 3.8.0-beta.2 → 3.8.0

package/dist/index.mjs

@@ -2,7 +2,7 @@ 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$1, { ZodObject, ZodType, z } from "zod";
+import z, { ZodObject, ZodType, z as z$1 } from "zod";
 import { fromError } from "zod-validation-error/v4";
 import { P, match } from "ts-pattern";
 import { ExpressionUtils } from "@zenstackhq/schema";
@@ -1437,7 +1437,10 @@ var LateralJoinDialectBase = class extends BaseCrudDialect {
 				return { [field]: fieldValue };
 			}
 		}));
-		if (typeof payload === "object" && payload.include && typeof payload.include === "object") Object.assign(objArgs, ...Object.entries(payload.include).filter(([, value]) => value).map(([field]) => ({ [field]: eb.ref(`${parentResultName}$${field}.$data`) })));
+		if (typeof payload === "object" && payload.include && typeof payload.include === "object") Object.assign(objArgs, ...Object.entries(payload.include).filter(([, value]) => value).map(([field, value]) => {
+			if (field === "_count") return { [field]: this.buildCountJson(relationModel, eb, relationModelAlias, value) };
+			return { [field]: eb.ref(`${parentResultName}$${field}.$data`) };
+		}));
 		return objArgs;
 	}
 	buildRelationJoins(query, relationModel, relationModelAlias, payload, parentResultName) {
@@ -1832,7 +1835,7 @@ var PostgresCrudDialect = class PostgresCrudDialect extends LateralJoinDialectBa
 		return this.eb.fn("trim", [expression, sql.lit("\"")]);
 	}
 	buildArrayLength(array) {
-		return this.eb.fn("array_length", [array]);
+		return this.eb.fn("array_length", [array, sql.lit(1)]);
 	}
 	buildArrayValue(values, elemType) {
 		const arr = sql`ARRAY[${sql.join(values, sql.raw(","))}]`;
@@ -2112,6 +2115,10 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
 				} else return [sql.lit(field), this.fieldRef(relationModel, field, subQueryName, false)];
 			}).flatMap((v) => v));
 			if (typeof payload === "object" && payload.include && typeof payload.include === "object") objArgs.push(...Object.entries(payload.include).filter(([, value]) => value).map(([field, value]) => {
+				if (field === "_count") {
+					const subJson = this.buildCountJson(relationModel, eb, tmpAlias(`${parentAlias}$${relationField}`), value);
+					return [sql.lit(field), subJson];
+				}
 				const subJson = this.buildRelationJSON(relationModel, eb, field, tmpAlias(`${parentAlias}$${relationField}`), value);
 				return [sql.lit(field), subJson];
 			}).flatMap((v) => v));
@@ -2287,7 +2294,7 @@ function createQuerySchemaFactory(clientOrSchema, options) {
 * @see https://github.com/zenstackhq/zenstack/issues/2631
 */
 function coercedDateTimeSchema() {
-	return z.preprocess((val) => {
+	return z$1.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);
@@ -2296,10 +2303,10 @@ function coercedDateTimeSchema() {
 		}
 		const d = new Date(val);
 		return isNaN(d.getTime()) ? val : d;
-	}, z.union([
-		z.iso.datetime(),
-		z.iso.date(),
-		z.date()
+	}, z$1.union([
+		z$1.iso.datetime(),
+		z$1.iso.date(),
+		z$1.date()
 	]));
 }
 /**
@@ -2307,7 +2314,7 @@ function coercedDateTimeSchema() {
 */
 var ZodSchemaFactory = class {
 	schemaCache = /* @__PURE__ */ new Map();
-	schemaRegistry = z.registry();
+	schemaRegistry = z$1.registry();
 	allFilterKinds = [...new Set(Object.values(FILTER_PROPERTY_TO_KIND))];
 	schema;
 	options;
@@ -2399,7 +2406,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.toJSONSchema(this.schemaRegistry, { unrepresentable: "any" });
+		return z$1.toJSONSchema(this.schemaRegistry, { unrepresentable: "any" });
 	}
 	get cacheStats() {
 		return {
@@ -2428,13 +2435,13 @@ var ZodSchemaFactory = class {
 		fields["omit"] = this.makeOmitSchema(model).optional().nullable();
 		if (!unique) {
 			fields["skip"] = this.makeSkipSchema().optional();
-			if (findOne) fields["take"] = z.literal(1).optional();
+			if (findOne) fields["take"] = z$1.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.strictObject(fields);
+		const baseSchema = z$1.strictObject(fields);
 		let result = this.mergePluginArgsSchema(baseSchema, operation);
 		result = this.refineForSelectIncludeMutuallyExclusive(result);
 		result = this.refineForSelectOmitMutuallyExclusive(result);
@@ -2444,7 +2451,7 @@ var ZodSchemaFactory = class {
 		return result;
 	}
 	makeExistsSchema(model, options) {
-		const baseSchema = z.strictObject({ where: this.makeWhereSchema(model, false, false, false, options).optional() });
+		const baseSchema = z$1.strictObject({ where: this.makeWhereSchema(model, false, false, false, options).optional() });
 		const result = this.mergePluginArgsSchema(baseSchema, "exists").optional();
 		this.registerSchema(`${model}ExistsArgs`, result);
 		return result;
@@ -2452,31 +2459,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.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)
+		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)
 			]);
-		}).with("DateTime", () => this.makeDateTimeValueSchema()).with("Bytes", () => z.instanceof(Uint8Array)).with("Json", () => this.makeJsonValueSchema()).otherwise(() => z.unknown());
+		}).with("DateTime", () => this.makeDateTimeValueSchema()).with("Bytes", () => z$1.instanceof(Uint8Array)).with("Json", () => this.makeJsonValueSchema()).otherwise(() => z$1.unknown());
 	}
 	makeEnumSchema(_enum) {
 		const enumDef = getEnum(this.schema, _enum);
 		invariant(enumDef, `Enum "${_enum}" not found in schema`);
-		const schema = z.enum(Object.keys(enumDef.values));
+		const schema = z$1.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.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);
+		const schema = z$1.looseObject(Object.fromEntries(Object.entries(typeDef.fields).map(([field, def]) => {
+			let fieldSchema = isTypeDef(this.schema, def.type) ? z$1.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.any().superRefine((value, ctx) => {
+		const finalSchema = z$1.any().superRefine((value, ctx) => {
 			const parseResult = schema.safeParse(value);
 			if (!parseResult.success) parseResult.error.issues.forEach((issue) => ctx.addIssue(issue));
 		});
@@ -2492,17 +2499,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.never();
+				if (allowedFilterKinds && !allowedFilterKinds.includes("Relation")) fieldSchema = z$1.never();
 				else {
-					fieldSchema = z.lazy(() => this.makeWhereSchema(fieldDef.type, false, false, false, nextOpts).optional());
-					if (fieldDef.array) fieldSchema = z.strictObject({
+					fieldSchema = z$1.lazy(() => this.makeWhereSchema(fieldDef.type, false, false, false, nextOpts).optional());
+					if (fieldDef.array) fieldSchema = z$1.strictObject({
 						some: fieldSchema.optional(),
 						every: fieldSchema.optional(),
 						none: fieldSchema.optional()
 					});
 					else {
 						fieldSchema = this.nullableIf(fieldSchema, !fieldDef.array && !!fieldDef.optional);
-						fieldSchema = z.union([fieldSchema, z.strictObject({
+						fieldSchema = z$1.union([fieldSchema, z$1.strictObject({
 							is: fieldSchema.optional(),
 							isNot: fieldSchema.optional()
 						})]);
@@ -2521,21 +2528,21 @@ var ZodSchemaFactory = class {
 		}
 		if (unique) {
 			const uniqueFields = getUniqueFields(this.schema, model);
-			for (const uniqueField of uniqueFields) if ("defs" in uniqueField) fields[uniqueField.name] = z.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => {
+			for (const uniqueField of uniqueFields) if ("defs" in uniqueField) fields[uniqueField.name] = z$1.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.never();
+				else fieldSchema = z$1.never();
 				else fieldSchema = this.makePrimitiveFilterSchema(def.type, !!def.optional, false, void 0);
 				return [key, fieldSchema];
 			}))).optional();
 		}
-		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);
+		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);
 		let result = baseWhere;
 		if (unique) {
 			const uniqueFields = getUniqueFields(this.schema, model);
@@ -2561,26 +2568,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.strictObject(fieldSchemas));
+			candidates.push(z$1.strictObject(fieldSchemas));
 		}
-		const recursiveSchema = z.lazy(() => this.makeTypedJsonFilterSchema(type, optional, false, allowedFilterKinds)).optional();
-		if (array) candidates.push(z.strictObject({
+		const recursiveSchema = z$1.lazy(() => this.makeTypedJsonFilterSchema(type, optional, false, allowedFilterKinds)).optional();
+		if (array) candidates.push(z$1.strictObject({
 			some: recursiveSchema,
 			every: recursiveSchema,
 			none: recursiveSchema
 		}));
-		else candidates.push(z.strictObject({
+		else candidates.push(z$1.strictObject({
 			is: recursiveSchema,
 			isNot: recursiveSchema
 		}));
 		candidates.push(this.makeJsonFilterSchema(optional, allowedFilterKinds));
 		if (optional) {
-			candidates.push(z.null());
-			candidates.push(z.instanceof(DbNullClass));
-			candidates.push(z.instanceof(JsonNullClass));
-			candidates.push(z.instanceof(AnyNullClass));
+			candidates.push(z$1.null());
+			candidates.push(z$1.instanceof(DbNullClass));
+			candidates.push(z$1.instanceof(JsonNullClass));
+			candidates.push(z$1.instanceof(AnyNullClass));
 		}
-		const result = z.union(candidates);
+		const result = z$1.union(candidates);
 		this.registerSchema(`${type}Filter${this.filterSchemaSuffix({
 			optional,
 			array,
@@ -2589,7 +2596,7 @@ var ZodSchemaFactory = class {
 		return result;
 	}
 	makeNullableTypedJsonMutationSchema(fieldSchema) {
-		return z.any().superRefine((value, ctx) => {
+		return z$1.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));
@@ -2601,11 +2608,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.enum(Object.keys(enumDef.values));
+		const baseSchema = z$1.enum(Object.keys(enumDef.values));
 		let schema;
 		if (array) schema = this.internalMakeArrayFilterSchema(baseSchema, allowedFilterKinds);
 		else {
-			const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z.lazy(() => this.makeEnumFilterSchema(enumName, optional, array, withAggregations, allowedFilterKinds)), [
+			const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z$1.lazy(() => this.makeEnumFilterSchema(enumName, optional, array, withAggregations, allowedFilterKinds)), [
 				"equals",
 				"in",
 				"notIn",
@@ -2639,42 +2646,42 @@ var ZodSchemaFactory = class {
 			has: elementSchema.optional(),
 			hasEvery: elementSchema.array().optional(),
 			hasSome: elementSchema.array().optional(),
-			isEmpty: z.boolean().optional()
+			isEmpty: z$1.boolean().optional()
 		};
 		const filteredOperators = this.trimFilterOperators(operators, allowedFilterKinds);
-		return z.strictObject(filteredOperators);
+		return z$1.strictObject(filteredOperators);
 	}
 	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();
+		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$1.never()).exhaustive();
 	}
 	makeJsonValueSchema() {
-		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()])))
+		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()])))
 		]);
 		this.registerSchema("JsonValue", schema);
 		return schema;
 	}
 	makeJsonFilterSchema(optional, allowedFilterKinds) {
-		if (allowedFilterKinds && !allowedFilterKinds.includes("Json")) return z.never();
+		if (allowedFilterKinds && !allowedFilterKinds.includes("Json")) return z$1.never();
 		const filterMembers = [
 			this.makeJsonValueSchema(),
-			z.instanceof(DbNullClass),
-			z.instanceof(AnyNullClass)
+			z$1.instanceof(DbNullClass),
+			z$1.instanceof(AnyNullClass)
 		];
-		if (optional) filterMembers.push(z.null());
-		const filterValueSchema = z.union(filterMembers);
-		const schema = z.strictObject({
-			path: z.string().optional(),
+		if (optional) filterMembers.push(z$1.null());
+		const filterValueSchema = z$1.union(filterMembers);
+		const schema = z$1.strictObject({
+			path: z$1.string().optional(),
 			equals: filterValueSchema.optional(),
 			not: filterValueSchema.optional(),
-			string_contains: z.string().optional(),
-			string_starts_with: z.string().optional(),
-			string_ends_with: z.string().optional(),
+			string_contains: z$1.string().optional(),
+			string_starts_with: z$1.string().optional(),
+			string_ends_with: z$1.string().optional(),
 			mode: this.makeStringModeSchema().optional(),
 			array_contains: filterValueSchema.optional(),
 			array_starts_with: filterValueSchema.optional(),
@@ -2693,7 +2700,7 @@ var ZodSchemaFactory = class {
 	}
 	makeDateTimeFilterSchema(optional, withAggregations, allowedFilterKinds) {
 		const filterValueSchema = this.makeDateTimeValueSchema();
-		const schema = this.makeCommonPrimitiveFilterSchema(filterValueSchema, optional, () => z.lazy(() => this.makeDateTimeFilterSchema(optional, withAggregations, allowedFilterKinds)), withAggregations ? [
+		const schema = this.makeCommonPrimitiveFilterSchema(filterValueSchema, optional, () => z$1.lazy(() => this.makeDateTimeFilterSchema(optional, withAggregations, allowedFilterKinds)), withAggregations ? [
 			"_count",
 			"_min",
 			"_max"
@@ -2706,12 +2713,12 @@ var ZodSchemaFactory = class {
 		return schema;
 	}
 	makeBooleanFilterSchema(optional, withAggregations, allowedFilterKinds) {
-		const components = this.makeCommonPrimitiveFilterComponents(z.boolean(), optional, () => z.lazy(() => this.makeBooleanFilterSchema(optional, withAggregations, allowedFilterKinds)), ["equals", "not"], withAggregations ? [
+		const components = this.makeCommonPrimitiveFilterComponents(z$1.boolean(), optional, () => z$1.lazy(() => this.makeBooleanFilterSchema(optional, withAggregations, allowedFilterKinds)), ["equals", "not"], withAggregations ? [
 			"_count",
 			"_min",
 			"_max"
 		] : void 0, allowedFilterKinds);
-		const schema = this.createUnionFilterSchema(z.boolean(), optional, components, allowedFilterKinds);
+		const schema = this.createUnionFilterSchema(z$1.boolean(), optional, components, allowedFilterKinds);
 		this.registerSchema(`BooleanFilter${this.filterSchemaSuffix({
 			optional,
 			allowedFilterKinds,
@@ -2720,8 +2727,8 @@ var ZodSchemaFactory = class {
 		return schema;
 	}
 	makeBytesFilterSchema(optional, withAggregations, allowedFilterKinds) {
-		const baseSchema = z.instanceof(Uint8Array);
-		const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z.instanceof(Uint8Array), [
+		const baseSchema = z$1.instanceof(Uint8Array);
+		const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z$1.instanceof(Uint8Array), [
 			"equals",
 			"in",
 			"notIn",
@@ -2769,7 +2776,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.lazy(() => this.makeNumberFilterSchema(type, optional, withAggregations, allowedFilterKinds)), withAggregations ? [
+		const schema = this.makeCommonPrimitiveFilterSchema(this.makeScalarSchema(type), optional, () => z$1.lazy(() => this.makeNumberFilterSchema(type, optional, withAggregations, allowedFilterKinds)), withAggregations ? [
 			"_count",
 			"_avg",
 			"_sum",
@@ -2784,15 +2791,15 @@ var ZodSchemaFactory = class {
 		return schema;
 	}
 	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 ? [
+		const baseComponents = this.makeCommonPrimitiveFilterComponents(z$1.string(), optional, () => z$1.lazy(() => this.makeStringFilterSchema(optional, withAggregations, allowedFilterKinds, withFuzzy, withFullText)), void 0, withAggregations ? [
 			"_count",
 			"_min",
 			"_max"
 		] : void 0, allowedFilterKinds);
 		const stringSpecificOperators = {
-			startsWith: z.string().optional(),
-			endsWith: z.string().optional(),
-			contains: z.string().optional(),
+			startsWith: z$1.string().optional(),
+			endsWith: z$1.string().optional(),
+			contains: z$1.string().optional(),
 			...withFuzzy && this.providerSupportsFuzzySearch ? { fuzzy: this.makeFuzzyFilterSchema().optional() } : {},
 			...withFullText && this.providerSupportsFullTextSearch ? { fts: this.makeFullTextFilterSchema().optional() } : {},
 			...this.providerSupportsCaseSensitivity ? { mode: this.makeStringModeSchema().optional() } : {}
@@ -2802,7 +2809,7 @@ var ZodSchemaFactory = class {
 			...baseComponents,
 			...filteredStringOperators
 		};
-		const schema = this.createUnionFilterSchema(z.string(), optional, allComponents, allowedFilterKinds);
+		const schema = this.createUnionFilterSchema(z$1.string(), optional, allComponents, allowedFilterKinds);
 		const featureSuffix = `${withFuzzy ? "Fuzzy" : ""}${withFullText ? "FullText" : ""}`;
 		this.registerSchema(`StringFilter${this.filterSchemaSuffix({
 			optional,
@@ -2812,24 +2819,24 @@ var ZodSchemaFactory = class {
 		return schema;
 	}
 	makeStringModeSchema() {
-		return z.union([z.literal("default"), z.literal("insensitive")]);
+		return z$1.union([z$1.literal("default"), z$1.literal("insensitive")]);
 	}
 	makeFuzzyFilterSchema() {
-		return z.strictObject({
-			search: z.string().min(1),
-			mode: z.union([
-				z.literal("simple"),
-				z.literal("word"),
-				z.literal("strictWord")
+		return z$1.strictObject({
+			search: z$1.string().min(1),
+			mode: z$1.union([
+				z$1.literal("simple"),
+				z$1.literal("word"),
+				z$1.literal("strictWord")
 			]).default("simple"),
-			threshold: z.number().min(0).max(1).optional(),
-			unaccent: z.boolean().default(false)
+			threshold: z$1.number().min(0).max(1).optional(),
+			unaccent: z$1.boolean().default(false)
 		});
 	}
 	makeFullTextFilterSchema() {
-		return z.strictObject({
-			search: z.string().min(1),
-			config: z.string().min(1).optional()
+		return z$1.strictObject({
+			search: z$1.string().min(1),
+			config: z$1.string().min(1).optional()
 		});
 	}
 	makeSelectSchema(model, options) {
@@ -2837,13 +2844,14 @@ var ZodSchemaFactory = class {
 		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.boolean().optional();
+		} else if (this.options.allowQueryTimeOmitOverride === false && this.isFieldOmittedByConfig(model, field)) fields[field] = z$1.literal(false).optional();
+		else fields[field] = z$1.boolean().optional();
 		if (this.shouldIncludeRelations(options)) {
 			const _countSchema = this.makeCountSelectionSchema(model, options);
-			if (!(_countSchema instanceof z.ZodNever)) fields["_count"] = _countSchema;
+			if (!(_countSchema instanceof z$1.ZodNever)) fields["_count"] = _countSchema;
 		}
 		this.addExtResultFields(model, fields);
-		const result = z.strictObject(fields);
+		const result = z$1.strictObject(fields);
 		this.registerSchema(`${model}Select`, result);
 		return result;
 	}
@@ -2852,24 +2860,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.union([z.literal(true), z.strictObject({ select: z.strictObject(toManyRelations.reduce((acc, fieldDef) => ({
+			const schema = z$1.union([z$1.literal(true), z$1.strictObject({ select: z$1.strictObject(toManyRelations.reduce((acc, fieldDef) => ({
 				...acc,
-				[fieldDef.name]: z.union([z.boolean(), z.strictObject({ where: this.makeWhereSchema(fieldDef.type, false, false, false, nextOpts) })]).optional()
+				[fieldDef.name]: z$1.union([z$1.boolean(), z$1.strictObject({ where: this.makeWhereSchema(fieldDef.type, false, false, false, nextOpts) })]).optional()
 			}), {})) })]).optional();
 			this.registerSchema(`${model}CountSelection`, schema);
 			return schema;
-		} else return z.never();
+		} else return z$1.never();
 	}
 	makeRelationSelectIncludeSchema(model, field, options) {
 		const fieldDef = requireField(this.schema, model, field);
 		const nextOpts = this.nextOptions(options);
-		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(),
+		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(),
 			...fieldDef.array ? {
-				orderBy: z.lazy(() => this.orArray(this.makeOrderBySchema(fieldDef.type, true, false, nextOpts), true)).optional(),
+				orderBy: z$1.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(),
@@ -2879,16 +2887,25 @@ var ZodSchemaFactory = class {
 		objSchema = this.refineForSelectIncludeMutuallyExclusive(objSchema);
 		objSchema = this.refineForSelectOmitMutuallyExclusive(objSchema);
 		objSchema = this.refineForSelectHasTruthyField(objSchema);
-		const result = z.union([z.boolean(), objSchema]);
+		const result = z$1.union([z$1.boolean(), objSchema]);
 		this.registerSchema(`${model}${upperCaseFirst(field)}RelationInput`, result);
 		return result;
 	}
+	/**
+	* Determines whether a field is configured to be omitted at the schema or client-options level
+	* (query-level omit is excluded as it's mutually exclusive with `select`).
+	*/
+	isFieldOmittedByConfig(model, field) {
+		const omitConfig = this.options.omit?.[lowerCaseFirst(model)] ?? this.options.omit?.[model];
+		if (omitConfig && typeof omitConfig[field] === "boolean") return omitConfig[field];
+		return !!requireField(this.schema, model, field).omit;
+	}
 	makeOmitSchema(model) {
 		const fields = {};
-		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();
+		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();
 		this.addExtResultFields(model, fields);
-		const result = z.strictObject(fields);
+		const result = z$1.strictObject(fields);
 		this.registerSchema(`${model}OmitInput`, result);
 		return result;
 	}
@@ -2897,7 +2914,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.boolean().optional();
+				if (modelConfig) for (const field of Object.keys(modelConfig)) fields[field] = z$1.boolean().optional();
 			}
 		}
 	}
@@ -2913,26 +2930,26 @@ var ZodSchemaFactory = class {
 		}
 		if (this.shouldIncludeRelations(options)) {
 			const _countSchema = this.makeCountSelectionSchema(model, options);
-			if (!(_countSchema instanceof z.ZodNever)) fields["_count"] = _countSchema;
+			if (!(_countSchema instanceof z$1.ZodNever)) fields["_count"] = _countSchema;
 		}
-		const result = z.strictObject(fields);
+		const result = z$1.strictObject(fields);
 		this.registerSchema(`${model}Include`, result);
 		return result;
 	}
 	makeOrderBySchema(model, withRelation, WithAggregation, options) {
 		const fields = {};
-		const sort = z.union([z.literal("asc"), z.literal("desc")]);
+		const sort = z$1.union([z$1.literal("asc"), z$1.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.lazy(() => {
+			if (withRelation && this.shouldIncludeRelations(options)) fields[field] = z$1.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.union([sort, z.strictObject({
+		} else if (fieldDef.optional) fields[field] = z$1.union([sort, z$1.strictObject({
 			sort,
-			nulls: z.union([z.literal("first"), z.literal("last")]).optional()
+			nulls: z$1.union([z$1.literal("first"), z$1.literal("last")]).optional()
 		})]).optional();
 		else fields[field] = sort.optional();
 		if (WithAggregation) for (const agg of [
@@ -2941,31 +2958,31 @@ var ZodSchemaFactory = class {
 			"_sum",
 			"_min",
 			"_max"
-		]) fields[agg] = z.lazy(() => this.makeOrderBySchema(model, true, false, options).optional());
+		]) fields[agg] = z$1.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")
+			if (fuzzyFieldNames.length > 0) fields["_fuzzyRelevance"] = z$1.strictObject({
+				fields: z$1.array(z$1.enum(fuzzyFieldNames)).min(1),
+				search: z$1.string(),
+				mode: z$1.union([
+					z$1.literal("simple"),
+					z$1.literal("word"),
+					z$1.literal("strictWord")
 				]).default("simple"),
-				unaccent: z.boolean().default(false),
+				unaccent: z$1.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(),
+			if (fullTextFieldNames.length > 0) fields["_ftsRelevance"] = z$1.strictObject({
+				fields: z$1.array(z$1.enum(fullTextFieldNames)).min(1),
+				search: z$1.string().min(1),
+				config: z$1.string().min(1).optional(),
 				sort
 			}).optional();
 		}
-		const schema = refineAtMostOneKey(z.strictObject(fields));
+		const schema = refineAtMostOneKey(z$1.strictObject(fields));
 		let schemaId = `${model}OrderBy`;
 		if (withRelation) schemaId += "WithRelation";
 		if (WithAggregation) schemaId += "WithAggregation";
@@ -2975,7 +2992,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.enum(nonRelationFields), true) : z.never();
+		const schema = nonRelationFields.length > 0 ? this.orArray(z$1.enum(nonRelationFields), true) : z$1.never();
 		this.registerSchema(`${model}DistinctInput`, schema);
 		return schema;
 	}
@@ -2986,7 +3003,7 @@ var ZodSchemaFactory = class {
 	}
 	makeCreateSchema(model, options) {
 		const dataSchema = this.makeCreateDataSchema(model, false, [], false, options);
-		const baseSchema = z.strictObject({
+		const baseSchema = z$1.strictObject({
 			data: dataSchema,
 			select: this.makeSelectSchema(model, options).optional().nullable(),
 			include: this.makeIncludeSchema(model, options).optional().nullable(),
@@ -3035,7 +3052,7 @@ var ZodSchemaFactory = class {
 					const oppositeFieldDef = requireField(this.schema, fieldDef.type, oppositeField);
 					if (oppositeFieldDef.relation?.fields) excludeFields.push(...oppositeFieldDef.relation.fields);
 				}
-				let fieldSchema = z.lazy(() => this.makeRelationManipulationSchema(model, field, excludeFields, "create", nextOpts));
+				let fieldSchema = z$1.lazy(() => this.makeRelationManipulationSchema(model, field, excludeFields, "create", nextOpts));
 				if (fieldDef.optional || fieldDef.array) fieldSchema = fieldSchema.optional();
 				else {
 					let allFksOptional = false;
@@ -3052,23 +3069,23 @@ var ZodSchemaFactory = class {
 				let fieldSchema = this.makeScalarSchema(fieldDef.type, fieldDef.attributes);
 				if (fieldDef.array) {
 					fieldSchema = ZodUtils.addListValidation(fieldSchema.array(), fieldDef.attributes);
-					fieldSchema = z.union([fieldSchema, z.strictObject({ set: fieldSchema })]).optional();
+					fieldSchema = z$1.union([fieldSchema, z$1.strictObject({ set: fieldSchema })]).optional();
 				}
 				if (fieldDef.optional || fieldHasDefaultValue(fieldDef)) fieldSchema = fieldSchema.optional();
-				if (fieldDef.optional) if (fieldDef.type === "Json") fieldSchema = z.union([fieldSchema, z.instanceof(DbNullClass)]);
+				if (fieldDef.optional) if (fieldDef.type === "Json") fieldSchema = z$1.union([fieldSchema, z$1.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.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([
+		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([
 			uncheckedCreateSchema,
 			checkedCreateSchema,
-			...canBeArray ? [z.array(uncheckedCreateSchema)] : [],
-			...canBeArray ? [z.array(checkedCreateSchema)] : []
+			...canBeArray ? [z$1.array(uncheckedCreateSchema)] : [],
+			...canBeArray ? [z$1.array(checkedCreateSchema)] : []
 		]);
 		const idParts = [`${model}CreateData`];
 		if (canBeArray) idParts.push("Array");
@@ -3093,17 +3110,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.strictObject({
+			fields["update"] = array ? this.orArray(z$1.strictObject({
 				where: this.makeWhereSchema(fieldType, true, false, false, options),
 				data: this.makeUpdateDataSchema(fieldType, withoutFields, false, options)
-			}), true).optional() : z.union([z.strictObject({
+			}), true).optional() : z$1.union([z$1.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.strictObject({
+				fields["upsert"] = this.orArray(z$1.strictObject({
 					where: upsertWhere,
 					create: this.makeCreateDataSchema(fieldType, false, withoutFields, false, options),
 					update: this.makeUpdateDataSchema(fieldType, withoutFields, false, options)
@@ -3111,14 +3128,14 @@ var ZodSchemaFactory = class {
 			}
 			if (array) {
 				fields["set"] = this.makeSetDataSchema(fieldType, true, options).optional();
-				fields["updateMany"] = this.orArray(z.strictObject({
+				fields["updateMany"] = this.orArray(z$1.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.strictObject(fields);
+		return z$1.strictObject(fields);
 	}
 	makeSetDataSchema(model, canBeArray, options) {
 		return this.orArray(this.makeWhereSchema(model, true, false, false, options), canBeArray);
@@ -3128,23 +3145,23 @@ var ZodSchemaFactory = class {
 	}
 	makeDisconnectDataSchema(model, canBeArray, options) {
 		if (canBeArray) return this.orArray(this.makeWhereSchema(model, true, false, false, options), canBeArray);
-		else return z.union([z.boolean(), this.makeWhereSchema(model, false, false, false, options)]);
+		else return z$1.union([z$1.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.union([z.boolean(), this.makeWhereSchema(model, uniqueFilter, false, false, 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)]);
 	}
 	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.strictObject({
+		return this.orArray(z$1.strictObject({
 			where: whereSchema,
 			create: createSchema
 		}), canBeArray);
 	}
 	makeCreateManyPayloadSchema(model, withoutFields, options) {
-		const schema = z.strictObject({
+		const schema = z$1.strictObject({
 			data: this.makeCreateDataSchema(model, true, withoutFields, true, options),
-			skipDuplicates: z.boolean().optional()
+			skipDuplicates: z$1.boolean().optional()
 		});
 		const idParts = [`${model}CreateManyPayload`];
 		if (withoutFields.length) idParts.push(`Without${withoutFields.slice().sort().join("")}`);
@@ -3152,7 +3169,7 @@ var ZodSchemaFactory = class {
 		return schema;
 	}
 	makeUpdateSchema(model, options) {
-		const baseSchema = z.strictObject({
+		const baseSchema = z$1.strictObject({
 			where: this.makeWhereSchema(model, true, false, false, options),
 			data: this.makeUpdateDataSchema(model, [], false, options),
 			select: this.makeSelectSchema(model, options).optional().nullable(),
@@ -3167,10 +3184,10 @@ var ZodSchemaFactory = class {
 		return schema;
 	}
 	makeUpdateManySchema(model, options) {
-		const result = this.mergePluginArgsSchema(z.strictObject({
+		const result = this.mergePluginArgsSchema(z$1.strictObject({
 			where: this.makeWhereSchema(model, false, false, false, options).optional(),
 			data: this.makeUpdateDataSchema(model, [], true, options),
-			limit: z.number().int().nonnegative().optional()
+			limit: z$1.number().int().nonnegative().optional()
 		}), "updateMany");
 		this.registerSchema(`${model}UpdateManyArgs`, result);
 		return result;
@@ -3186,7 +3203,7 @@ var ZodSchemaFactory = class {
 		return schema;
 	}
 	makeUpsertSchema(model, options) {
-		const baseSchema = z.strictObject({
+		const baseSchema = z$1.strictObject({
 			where: this.makeWhereSchema(model, true, false, false, options),
 			create: this.makeCreateDataSchema(model, false, [], false, options),
 			update: this.makeUpdateDataSchema(model, [], false, options),
@@ -3222,27 +3239,27 @@ var ZodSchemaFactory = class {
 					const oppositeFieldDef = requireField(this.schema, fieldDef.type, oppositeField);
 					if (oppositeFieldDef.relation?.fields) excludeFields.push(...oppositeFieldDef.relation.fields);
 				}
-				let fieldSchema = z.lazy(() => this.makeRelationManipulationSchema(model, field, excludeFields, "update", nextOpts)).optional();
+				let fieldSchema = z$1.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.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()
+				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()
 				}).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.union([arraySchema, z.object({
+					fieldSchema = z$1.union([arraySchema, z$1.object({
 						set: arraySchema.optional(),
-						push: z.union([fieldSchema, fieldSchema.array()]).optional()
+						push: z$1.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.union([fieldSchema, z.instanceof(DbNullClass)]);
+				if (fieldDef.optional) if (fieldDef.type === "Json") fieldSchema = z$1.union([fieldSchema, z$1.instanceof(DbNullClass)]);
 				else if (this.isTypeDefType(fieldDef.type)) fieldSchema = this.makeNullableTypedJsonMutationSchema(fieldSchema);
 				else fieldSchema = fieldSchema.nullable();
 				fieldSchema = fieldSchema.optional();
@@ -3250,9 +3267,9 @@ var ZodSchemaFactory = class {
 				if (!fieldDef.foreignKeyFor) checkedVariantFields[field] = fieldSchema;
 			}
 		});
-		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 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 idParts = [`${model}UpdateData`];
 		if (withoutRelationFields) idParts.push("WithoutRelation");
 		if (withoutFields.length) idParts.push(`Without${withoutFields.slice().sort().join("")}`);
@@ -3260,7 +3277,7 @@ var ZodSchemaFactory = class {
 		return result;
 	}
 	makeDeleteSchema(model, options) {
-		const baseSchema = z.strictObject({
+		const baseSchema = z$1.strictObject({
 			where: this.makeWhereSchema(model, true, false, false, options),
 			select: this.makeSelectSchema(model, options).optional().nullable(),
 			include: this.makeIncludeSchema(model, options).optional().nullable(),
@@ -3274,15 +3291,15 @@ var ZodSchemaFactory = class {
 		return schema;
 	}
 	makeDeleteManySchema(model, options) {
-		const result = this.mergePluginArgsSchema(z.strictObject({
+		const result = this.mergePluginArgsSchema(z$1.strictObject({
 			where: this.makeWhereSchema(model, false, false, false, options).optional(),
-			limit: z.number().int().nonnegative().optional()
+			limit: z$1.number().int().nonnegative().optional()
 		}), "deleteMany").optional();
 		this.registerSchema(`${model}DeleteManyArgs`, result);
 		return result;
 	}
 	makeCountSchema(model, options) {
-		const result = this.mergePluginArgsSchema(z.strictObject({
+		const result = this.mergePluginArgsSchema(z$1.strictObject({
 			where: this.makeWhereSchema(model, false, false, false, options).optional(),
 			skip: this.makeSkipSchema().optional(),
 			take: this.makeTakeSchema().optional(),
@@ -3293,10 +3310,10 @@ var ZodSchemaFactory = class {
 		return result;
 	}
 	makeCountAggregateInputSchema(model) {
-		const schema = z.union([z.literal(true), z.strictObject({
-			_all: z.literal(true).optional(),
+		const schema = z$1.union([z$1.literal(true), z$1.strictObject({
+			_all: z$1.literal(true).optional(),
 			...this.getModelFields(model).reduce((acc, [field]) => {
-				acc[field] = z.literal(true).optional();
+				acc[field] = z$1.literal(true).optional();
 				return acc;
 			}, {})
 		})]);
@@ -3304,7 +3321,7 @@ var ZodSchemaFactory = class {
 		return schema;
 	}
 	makeAggregateSchema(model, options) {
-		const result = this.mergePluginArgsSchema(z.strictObject({
+		const result = this.mergePluginArgsSchema(z$1.strictObject({
 			where: this.makeWhereSchema(model, false, false, false, options).optional(),
 			skip: this.makeSkipSchema().optional(),
 			take: this.makeTakeSchema().optional(),
@@ -3319,16 +3336,16 @@ var ZodSchemaFactory = class {
 		return result;
 	}
 	makeSumAvgInputSchema(model) {
-		const schema = z.strictObject(this.getModelFields(model).reduce((acc, [field, fieldDef]) => {
-			if (this.isNumericField(fieldDef)) acc[field] = z.literal(true).optional();
+		const schema = z$1.strictObject(this.getModelFields(model).reduce((acc, [field, fieldDef]) => {
+			if (this.isNumericField(fieldDef)) acc[field] = z$1.literal(true).optional();
 			return acc;
 		}, {}));
 		this.registerSchema(`${model}SumAvgAggregateInput`, schema);
 		return schema;
 	}
 	makeMinMaxInputSchema(model) {
-		const schema = z.strictObject(this.getModelFields(model).reduce((acc, [field, fieldDef]) => {
-			if (!fieldDef.relation && !fieldDef.array) acc[field] = z.literal(true).optional();
+		const schema = z$1.strictObject(this.getModelFields(model).reduce((acc, [field, fieldDef]) => {
+			if (!fieldDef.relation && !fieldDef.array) acc[field] = z$1.literal(true).optional();
 			return acc;
 		}, {}));
 		this.registerSchema(`${model}MinMaxAggregateInput`, schema);
@@ -3336,8 +3353,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.enum(nonRelationFields), true) : z.never();
-		const baseSchema = z.strictObject({
+		const bySchema = nonRelationFields.length > 0 ? this.orArray(z$1.enum(nonRelationFields), true) : z$1.never();
+		const baseSchema = z$1.strictObject({
 			where: this.makeWhereSchema(model, false, false, false, options).optional(),
 			orderBy: this.orArray(this.makeOrderBySchema(model, false, true, options), true).optional(),
 			by: bySchema,
@@ -3389,7 +3406,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.object(shape);
+		const schema = z$1.object(shape);
 		this.registerSchema(`${procName}ProcArgs`, schema);
 		return schema;
 	}
@@ -3397,10 +3414,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.record(z.string(), z.unknown());
+		else if (param.type in (this.schema.models ?? {})) schema = z$1.record(z$1.string(), z$1.unknown());
 		else {
 			schema = this.makeScalarSchema(param.type);
-			if (schema instanceof z.ZodUnknown) throw createInternalError(`Unsupported procedure parameter type: ${param.type}`);
+			if (schema instanceof z$1.ZodUnknown) throw createInternalError(`Unsupported procedure parameter type: ${param.type}`);
 		}
 		if (param.array) schema = schema.array();
 		if (param.optional) schema = schema.optional();
@@ -3436,10 +3453,10 @@ var ZodSchemaFactory = class {
 		return result;
 	}
 	makeSkipSchema() {
-		return z.number().int().nonnegative();
+		return z$1.number().int().nonnegative();
 	}
 	makeTakeSchema() {
-		return z.number().int();
+		return z$1.number().int();
 	}
 	refineForSelectIncludeMutuallyExclusive(schema) {
 		return schema.refine((value) => !(value["select"] && value["include"]), "\"select\" and \"include\" cannot be used together");
@@ -3458,7 +3475,7 @@ var ZodSchemaFactory = class {
 		return nullable ? schema.nullable() : schema;
 	}
 	orArray(schema, canBeArray) {
-		return canBeArray ? z.union([schema, z.array(schema)]) : schema;
+		return canBeArray ? z$1.union([schema, z$1.array(schema)]) : schema;
 	}
 	isNumericField(fieldDef) {
 		return NUMERIC_FIELD_TYPES.includes(fieldDef.type) && !fieldDef.array;
@@ -3520,10 +3537,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.never();
+			return z$1.never();
 		}
-		if (!allowedFilterKinds || allowedFilterKinds.includes("Equality")) return z.union([this.nullableIf(valueSchema, optional), z.strictObject(components)]);
-		else return z.strictObject(components);
+		if (!allowedFilterKinds || allowedFilterKinds.includes("Equality")) return z$1.union([this.nullableIf(valueSchema, optional), z$1.strictObject(components)]);
+		else return z$1.strictObject(components);
 	}
 	canCreateModel(model) {
 		const modelDef = requireModel(this.schema, model);
@@ -7131,9 +7148,9 @@ var ClientImpl = class ClientImpl {
 	validateOptions(baseClient, options) {
 		if (!baseClient && !options.skipValidationForComputedFields) this.validateComputedFieldsConfig(options);
 		if (options.diagnostics) {
-			const parseResult = z$1.object({
-				slowQueryThresholdMs: z$1.number().nonnegative().optional(),
-				slowQueryMaxRecords: z$1.int().nonnegative().or(z$1.literal(Infinity)).optional()
+			const parseResult = z.object({
+				slowQueryThresholdMs: z.number().nonnegative().optional(),
+				slowQueryMaxRecords: z.int().nonnegative().or(z.literal(Infinity)).optional()
 			}).safeParse(options.diagnostics);
 			if (!parseResult.success) throw createConfigError(`Invalid diagnostics configuration: ${formatError(parseResult.error)}`);
 		}