@stryke/prisma-trpc-generator 0.3.3 → 0.4.1

package/dist/index.js

@@ -2485,11 +2485,11 @@ var exists = /* @__PURE__ */ __name(async (filePath) => {
 
 // ../fs/src/helpers.ts
 import { mkdir, readFile, rm } from "node:fs/promises";
-async function createDirectory(path5) {
-  if (await exists(path5)) {
+async function createDirectory(path7) {
+  if (await exists(path7)) {
     return;
   }
-  return mkdir(path5, {
+  return mkdir(path7, {
     recursive: true
   });
 }
@@ -2511,65 +2511,65 @@ var _DRIVE_LETTER_RE = /^[A-Z]:$/i;
 var isAbsolute = /* @__PURE__ */ __name(function(p) {
   return _IS_ABSOLUTE_RE.test(p);
 }, "isAbsolute");
-var correctPaths = /* @__PURE__ */ __name(function(path5) {
-  if (!path5 || path5.length === 0) {
+var correctPaths = /* @__PURE__ */ __name(function(path7) {
+  if (!path7 || path7.length === 0) {
     return ".";
   }
-  path5 = normalizeWindowsPath(path5);
-  const isUNCPath = path5.match(_UNC_REGEX);
-  const isPathAbsolute = isAbsolute(path5);
-  const trailingSeparator = path5[path5.length - 1] === "/";
-  path5 = normalizeString(path5, !isPathAbsolute);
-  if (path5.length === 0) {
+  path7 = normalizeWindowsPath(path7);
+  const isUNCPath = path7.match(_UNC_REGEX);
+  const isPathAbsolute = isAbsolute(path7);
+  const trailingSeparator = path7[path7.length - 1] === "/";
+  path7 = normalizeString(path7, !isPathAbsolute);
+  if (path7.length === 0) {
     if (isPathAbsolute) {
       return "/";
     }
     return trailingSeparator ? "./" : ".";
   }
   if (trailingSeparator) {
-    path5 += "/";
+    path7 += "/";
   }
-  if (_DRIVE_LETTER_RE.test(path5)) {
-    path5 += "/";
+  if (_DRIVE_LETTER_RE.test(path7)) {
+    path7 += "/";
   }
   if (isUNCPath) {
     if (!isPathAbsolute) {
-      return `//./${path5}`;
+      return `//./${path7}`;
     }
-    return `//${path5}`;
+    return `//${path7}`;
   }
-  return isPathAbsolute && !isAbsolute(path5) ? `/${path5}` : path5;
+  return isPathAbsolute && !isAbsolute(path7) ? `/${path7}` : path7;
 }, "correctPaths");
 var joinPaths = /* @__PURE__ */ __name(function(...segments) {
-  let path5 = "";
+  let path7 = "";
   for (const seg of segments) {
     if (!seg) {
       continue;
     }
-    if (path5.length > 0) {
-      const pathTrailing = path5[path5.length - 1] === "/";
+    if (path7.length > 0) {
+      const pathTrailing = path7[path7.length - 1] === "/";
       const segLeading = seg[0] === "/";
       const both = pathTrailing && segLeading;
       if (both) {
-        path5 += seg.slice(1);
+        path7 += seg.slice(1);
       } else {
-        path5 += pathTrailing || segLeading ? seg : `/${seg}`;
+        path7 += pathTrailing || segLeading ? seg : `/${seg}`;
       }
     } else {
-      path5 += seg;
+      path7 += seg;
     }
   }
-  return correctPaths(path5);
+  return correctPaths(path7);
 }, "joinPaths");
-function normalizeString(path5, allowAboveRoot) {
+function normalizeString(path7, allowAboveRoot) {
   let res = "";
   let lastSegmentLength = 0;
   let lastSlash = -1;
   let dots = 0;
   let char = null;
-  for (let index = 0; index <= path5.length; ++index) {
-    if (index < path5.length) {
-      char = path5[index];
+  for (let index = 0; index <= path7.length; ++index) {
+    if (index < path7.length) {
+      char = path7[index];
     } else if (char === "/") {
       break;
     } else {
@@ -2605,9 +2605,9 @@ function normalizeString(path5, allowAboveRoot) {
         }
       } else {
         if (res.length > 0) {
-          res += `/${path5.slice(lastSlash + 1, index)}`;
+          res += `/${path7.slice(lastSlash + 1, index)}`;
         } else {
-          res = path5.slice(lastSlash + 1, index);
+          res = path7.slice(lastSlash + 1, index);
         }
         lastSegmentLength = index - lastSlash - 1;
       }
@@ -2625,7 +2625,7 @@ __name(normalizeString, "normalizeString");
 
 // src/prisma-generator.ts
 var import_pluralize = __toESM(require_pluralize(), 1);
-import path4 from "node:path";
+import path6 from "node:path";
 
 // src/config.ts
 init_esm_shims();
@@ -2992,8 +2992,8 @@ function getErrorMap() {
 }
 __name(getErrorMap, "getErrorMap");
 var makeIssue = /* @__PURE__ */ __name((params) => {
-  const { data, path: path5, errorMaps, issueData } = params;
-  const fullPath = [...path5, ...issueData.path || []];
+  const { data, path: path7, errorMaps, issueData } = params;
+  const fullPath = [...path7, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -3127,11 +3127,11 @@ var ParseInputLazyPath = class {
   static {
     __name(this, "ParseInputLazyPath");
   }
-  constructor(parent, value, path5, key) {
+  constructor(parent, value, path7, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path5;
+    this._path = path7;
     this._key = key;
   }
   get path() {
@@ -7116,34 +7116,34 @@ __name2(normalizeWindowsPath2, "normalizeWindowsPath");
 var _UNC_REGEX2 = /^[/\\]{2}/;
 var _IS_ABSOLUTE_RE2 = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
 var _DRIVE_LETTER_RE2 = /^[A-Za-z]:$/;
-var correctPaths2 = /* @__PURE__ */ __name2(function(path5) {
-  if (!path5 || path5.length === 0) {
+var correctPaths2 = /* @__PURE__ */ __name2(function(path7) {
+  if (!path7 || path7.length === 0) {
     return ".";
   }
-  path5 = normalizeWindowsPath2(path5);
-  const isUNCPath = path5.match(_UNC_REGEX2);
-  const isPathAbsolute = isAbsolute2(path5);
-  const trailingSeparator = path5[path5.length - 1] === "/";
-  path5 = normalizeString2(path5, !isPathAbsolute);
-  if (path5.length === 0) {
+  path7 = normalizeWindowsPath2(path7);
+  const isUNCPath = path7.match(_UNC_REGEX2);
+  const isPathAbsolute = isAbsolute2(path7);
+  const trailingSeparator = path7[path7.length - 1] === "/";
+  path7 = normalizeString2(path7, !isPathAbsolute);
+  if (path7.length === 0) {
     if (isPathAbsolute) {
       return "/";
     }
     return trailingSeparator ? "./" : ".";
   }
   if (trailingSeparator) {
-    path5 += "/";
+    path7 += "/";
   }
-  if (_DRIVE_LETTER_RE2.test(path5)) {
-    path5 += "/";
+  if (_DRIVE_LETTER_RE2.test(path7)) {
+    path7 += "/";
   }
   if (isUNCPath) {
     if (!isPathAbsolute) {
-      return `//./${path5}`;
+      return `//./${path7}`;
     }
-    return `//${path5}`;
+    return `//${path7}`;
   }
-  return isPathAbsolute && !isAbsolute2(path5) ? `/${path5}` : path5;
+  return isPathAbsolute && !isAbsolute2(path7) ? `/${path7}` : path7;
 }, "correctPaths");
 function cwd() {
   if (typeof process !== "undefined" && typeof process.cwd === "function") {
@@ -7153,15 +7153,15 @@ function cwd() {
 }
 __name(cwd, "cwd");
 __name2(cwd, "cwd");
-function normalizeString2(path5, allowAboveRoot) {
+function normalizeString2(path7, allowAboveRoot) {
   let res = "";
   let lastSegmentLength = 0;
   let lastSlash = -1;
   let dots = 0;
   let char = null;
-  for (let index = 0; index <= path5.length; ++index) {
-    if (index < path5.length) {
-      char = path5[index];
+  for (let index = 0; index <= path7.length; ++index) {
+    if (index < path7.length) {
+      char = path7[index];
     } else if (char === "/") {
       break;
     } else {
@@ -7197,9 +7197,9 @@ function normalizeString2(path5, allowAboveRoot) {
         }
       } else {
         if (res.length > 0) {
-          res += `/${path5.slice(lastSlash + 1, index)}`;
+          res += `/${path7.slice(lastSlash + 1, index)}`;
         } else {
-          res = path5.slice(lastSlash + 1, index);
+          res = path7.slice(lastSlash + 1, index);
         }
         lastSegmentLength = index - lastSlash - 1;
       }
@@ -7299,20 +7299,20 @@ init_esm_shims();
 // ../path/src/is-file.ts
 init_esm_shims();
 import { lstatSync, statSync } from "node:fs";
-function isFile(path5, additionalPath) {
-  return Boolean(statSync(additionalPath ? joinPaths(additionalPath, path5) : path5, {
+function isFile(path7, additionalPath) {
+  return Boolean(statSync(additionalPath ? joinPaths(additionalPath, path7) : path7, {
     throwIfNoEntry: false
   })?.isFile());
 }
 __name(isFile, "isFile");
-function isDirectory(path5, additionalPath) {
-  return Boolean(statSync(additionalPath ? joinPaths(additionalPath, path5) : path5, {
+function isDirectory(path7, additionalPath) {
+  return Boolean(statSync(additionalPath ? joinPaths(additionalPath, path7) : path7, {
     throwIfNoEntry: false
   })?.isDirectory());
 }
 __name(isDirectory, "isDirectory");
-function isAbsolutePath(path5) {
-  return !/^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Z]:[/\\]/i.test(path5);
+function isAbsolutePath(path7) {
+  return !/^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Z]:[/\\]/i.test(path7);
 }
 __name(isAbsolutePath, "isAbsolutePath");
 
@@ -7327,45 +7327,45 @@ function normalizeWindowsPath3(input = "") {
 __name(normalizeWindowsPath3, "normalizeWindowsPath");
 var _UNC_REGEX3 = /^[/\\]{2}/;
 var _DRIVE_LETTER_RE3 = /^[A-Z]:$/i;
-function correctPath(path5) {
-  if (!path5 || path5.length === 0) {
+function correctPath(path7) {
+  if (!path7 || path7.length === 0) {
     return ".";
   }
-  path5 = normalizeWindowsPath3(path5);
-  const isUNCPath = path5.match(_UNC_REGEX3);
-  const isPathAbsolute = isAbsolutePath(path5);
-  const trailingSeparator = path5[path5.length - 1] === "/";
-  path5 = normalizeString3(path5, !isPathAbsolute);
-  if (path5.length === 0) {
+  path7 = normalizeWindowsPath3(path7);
+  const isUNCPath = path7.match(_UNC_REGEX3);
+  const isPathAbsolute = isAbsolutePath(path7);
+  const trailingSeparator = path7[path7.length - 1] === "/";
+  path7 = normalizeString3(path7, !isPathAbsolute);
+  if (path7.length === 0) {
     if (isPathAbsolute) {
       return "/";
     }
     return trailingSeparator ? "./" : ".";
   }
   if (trailingSeparator) {
-    path5 += "/";
+    path7 += "/";
   }
-  if (_DRIVE_LETTER_RE3.test(path5)) {
-    path5 += "/";
+  if (_DRIVE_LETTER_RE3.test(path7)) {
+    path7 += "/";
   }
   if (isUNCPath) {
     if (!isPathAbsolute) {
-      return `//./${path5}`;
+      return `//./${path7}`;
     }
-    return `//${path5}`;
+    return `//${path7}`;
   }
-  return isPathAbsolute && !isAbsolutePath(path5) ? `/${path5}` : path5;
+  return isPathAbsolute && !isAbsolutePath(path7) ? `/${path7}` : path7;
 }
 __name(correctPath, "correctPath");
-function normalizeString3(path5, allowAboveRoot) {
+function normalizeString3(path7, allowAboveRoot) {
   let res = "";
   let lastSegmentLength = 0;
   let lastSlash = -1;
   let dots = 0;
   let char = null;
-  for (let index = 0; index <= path5.length; ++index) {
-    if (index < path5.length) {
-      char = path5[index];
+  for (let index = 0; index <= path7.length; ++index) {
+    if (index < path7.length) {
+      char = path7[index];
     } else if (char === "/") {
       break;
     } else {
@@ -7401,9 +7401,9 @@ function normalizeString3(path5, allowAboveRoot) {
         }
       } else {
         if (res.length > 0) {
-          res += `/${path5.slice(lastSlash + 1, index)}`;
+          res += `/${path7.slice(lastSlash + 1, index)}`;
         } else {
-          res = path5.slice(lastSlash + 1, index);
+          res = path7.slice(lastSlash + 1, index);
         }
         lastSegmentLength = index - lastSlash - 1;
       }
@@ -7438,17 +7438,17 @@ function findFilePath(filePath) {
   }), "");
 }
 __name(findFilePath, "findFilePath");
-function resolvePath(path5, cwd2 = getWorkspaceRoot()) {
-  const paths = normalizeWindowsPath3(path5).split("/");
+function resolvePath(path7, cwd2 = getWorkspaceRoot()) {
+  const paths = normalizeWindowsPath3(path7).split("/");
   let resolvedPath = "";
   let resolvedAbsolute = false;
   for (let index = paths.length - 1; index >= -1 && !resolvedAbsolute; index--) {
-    const path6 = index >= 0 ? paths[index] : cwd2;
-    if (!path6 || path6.length === 0) {
+    const path8 = index >= 0 ? paths[index] : cwd2;
+    if (!path8 || path8.length === 0) {
       continue;
     }
-    resolvedPath = joinPaths(path6, resolvedPath);
-    resolvedAbsolute = isAbsolutePath(path6);
+    resolvedPath = joinPaths(path8, resolvedPath);
+    resolvedAbsolute = isAbsolutePath(path8);
   }
   resolvedPath = normalizeString3(resolvedPath, !resolvedAbsolute);
   if (resolvedAbsolute && !isAbsolutePath(resolvedPath)) {
@@ -7458,13 +7458,13 @@ function resolvePath(path5, cwd2 = getWorkspaceRoot()) {
 }
 __name(resolvePath, "resolvePath");
 function resolvePaths(...paths) {
-  return resolvePath(joinPaths(...paths.map((path5) => normalizeWindowsPath3(path5))));
+  return resolvePath(joinPaths(...paths.map((path7) => normalizeWindowsPath3(path7))));
 }
 __name(resolvePaths, "resolvePaths");
 
 // ../path/src/get-parent-path.ts
-var resolveParentPath = /* @__PURE__ */ __name((path5) => {
-  return resolvePaths(path5, "..");
+var resolveParentPath = /* @__PURE__ */ __name((path7) => {
+  return resolvePaths(path7, "..");
 }, "resolveParentPath");
 var getParentPath = /* @__PURE__ */ __name((name, cwd2, options) => {
   const ignoreCase = options?.ignoreCase ?? true;
@@ -7850,15 +7850,15 @@ var getProcedureTypeByOpName = /* @__PURE__ */ __name((opName) => {
   return procType;
 }, "getProcedureTypeByOpName");
 function resolveModelsComments(models, hiddenModels) {
-  const modelAttributeRegex = /(?:@@Gen\.)+[A-z]+\(.+\)/;
-  const attributeNameRegex = /\.+[A-Z]+\(+/i;
-  const attributeArgsRegex = /\(+[A-Z]+:.+\)/i;
+  const modelAttributeRegex2 = /(?:@@Gen\.)+[A-z]+\(.+\)/;
+  const attributeNameRegex2 = /\.+[A-Z]+\(+/i;
+  const attributeArgsRegex2 = /\(+[A-Z]+:.+\)/i;
   for (const model of models) {
     if (model.documentation) {
-      const attribute = model.documentation?.match(modelAttributeRegex)?.[0];
-      const attributeName = attribute?.match(attributeNameRegex)?.[0]?.slice(1, -1);
+      const attribute = model.documentation?.match(modelAttributeRegex2)?.[0];
+      const attributeName = attribute?.match(attributeNameRegex2)?.[0]?.slice(1, -1);
       if (attributeName !== "model") continue;
-      const rawAttributeArgs = attribute?.match(attributeArgsRegex)?.[0]?.slice(1, -1);
+      const rawAttributeArgs = attribute?.match(attributeArgsRegex2)?.[0]?.slice(1, -1);
       const parsedAttributeArgs = {};
       if (rawAttributeArgs) {
         const rawAttributeArgsParts = rawAttributeArgs.split(":").map((it) => it.trim()).map((part) => part.startsWith("[") ? part : part.split(",")).flat().map((it) => it.trim());
@@ -9167,7 +9167,7 @@ var isURL = /* @__PURE__ */ __name((payload) => payload instanceof URL, "isURL")
 // ../../node_modules/.pnpm/superjson@2.2.2/node_modules/superjson/dist/pathstringifier.js
 init_esm_shims();
 var escapeKey = /* @__PURE__ */ __name((key) => key.replace(/\./g, "\\."), "escapeKey");
-var stringifyPath = /* @__PURE__ */ __name((path5) => path5.map(String).map(escapeKey).join("."), "stringifyPath");
+var stringifyPath = /* @__PURE__ */ __name((path7) => path7.map(String).map(escapeKey).join("."), "stringifyPath");
 var parsePath = /* @__PURE__ */ __name((string) => {
   const result = [];
   let segment = "";
@@ -9430,27 +9430,27 @@ var getNthKey = /* @__PURE__ */ __name((value, n) => {
   }
   return keys.next().value;
 }, "getNthKey");
-function validatePath(path5) {
-  if (includes(path5, "__proto__")) {
+function validatePath(path7) {
+  if (includes(path7, "__proto__")) {
     throw new Error("__proto__ is not allowed as a property");
   }
-  if (includes(path5, "prototype")) {
+  if (includes(path7, "prototype")) {
     throw new Error("prototype is not allowed as a property");
   }
-  if (includes(path5, "constructor")) {
+  if (includes(path7, "constructor")) {
     throw new Error("constructor is not allowed as a property");
   }
 }
 __name(validatePath, "validatePath");
-var getDeep = /* @__PURE__ */ __name((object, path5) => {
-  validatePath(path5);
-  for (let i = 0; i < path5.length; i++) {
-    const key = path5[i];
+var getDeep = /* @__PURE__ */ __name((object, path7) => {
+  validatePath(path7);
+  for (let i = 0; i < path7.length; i++) {
+    const key = path7[i];
     if (isSet(object)) {
       object = getNthKey(object, +key);
     } else if (isMap(object)) {
       const row = +key;
-      const type = +path5[++i] === 0 ? "key" : "value";
+      const type = +path7[++i] === 0 ? "key" : "value";
       const keyOfRow = getNthKey(object, row);
       switch (type) {
         case "key":
@@ -9466,14 +9466,14 @@ var getDeep = /* @__PURE__ */ __name((object, path5) => {
   }
   return object;
 }, "getDeep");
-var setDeep = /* @__PURE__ */ __name((object, path5, mapper) => {
-  validatePath(path5);
-  if (path5.length === 0) {
+var setDeep = /* @__PURE__ */ __name((object, path7, mapper) => {
+  validatePath(path7);
+  if (path7.length === 0) {
     return mapper(object);
   }
   let parent = object;
-  for (let i = 0; i < path5.length - 1; i++) {
-    const key = path5[i];
+  for (let i = 0; i < path7.length - 1; i++) {
+    const key = path7[i];
     if (isArray(parent)) {
       const index = +key;
       parent = parent[index];
@@ -9483,12 +9483,12 @@ var setDeep = /* @__PURE__ */ __name((object, path5, mapper) => {
       const row = +key;
       parent = getNthKey(parent, row);
     } else if (isMap(parent)) {
-      const isEnd = i === path5.length - 2;
+      const isEnd = i === path7.length - 2;
       if (isEnd) {
         break;
       }
       const row = +key;
-      const type = +path5[++i] === 0 ? "key" : "value";
+      const type = +path7[++i] === 0 ? "key" : "value";
       const keyOfRow = getNthKey(parent, row);
       switch (type) {
         case "key":
@@ -9500,7 +9500,7 @@ var setDeep = /* @__PURE__ */ __name((object, path5, mapper) => {
       }
     }
   }
-  const lastKey = path5[path5.length - 1];
+  const lastKey = path7[path7.length - 1];
   if (isArray(parent)) {
     parent[+lastKey] = mapper(parent[+lastKey]);
   } else if (isPlainObject2(parent)) {
@@ -9515,7 +9515,7 @@ var setDeep = /* @__PURE__ */ __name((object, path5, mapper) => {
     }
   }
   if (isMap(parent)) {
-    const row = +path5[path5.length - 2];
+    const row = +path7[path7.length - 2];
     const keyToRow = getNthKey(parent, row);
     const type = +lastKey === 0 ? "key" : "value";
     switch (type) {
@@ -9561,15 +9561,15 @@ function traverse(tree, walker2, origin = []) {
 }
 __name(traverse, "traverse");
 function applyValueAnnotations(plain, annotations, superJson) {
-  traverse(annotations, (type, path5) => {
-    plain = setDeep(plain, path5, (v) => untransformValue(v, type, superJson));
+  traverse(annotations, (type, path7) => {
+    plain = setDeep(plain, path7, (v) => untransformValue(v, type, superJson));
   });
   return plain;
 }
 __name(applyValueAnnotations, "applyValueAnnotations");
 function applyReferentialEqualityAnnotations(plain, annotations) {
-  function apply(identicalPaths, path5) {
-    const object = getDeep(plain, parsePath(path5));
+  function apply(identicalPaths, path7) {
+    const object = getDeep(plain, parsePath(path7));
     identicalPaths.map(parsePath).forEach((identicalObjectPath) => {
       plain = setDeep(plain, identicalObjectPath, () => object);
     });
@@ -9590,13 +9590,13 @@ function applyReferentialEqualityAnnotations(plain, annotations) {
 }
 __name(applyReferentialEqualityAnnotations, "applyReferentialEqualityAnnotations");
 var isDeep = /* @__PURE__ */ __name((object, superJson) => isPlainObject2(object) || isArray(object) || isMap(object) || isSet(object) || isInstanceOfRegisteredClass(object, superJson), "isDeep");
-function addIdentity(object, path5, identities) {
+function addIdentity(object, path7, identities) {
   const existingSet = identities.get(object);
   if (existingSet) {
-    existingSet.push(path5);
+    existingSet.push(path7);
   } else {
     identities.set(object, [
-      path5
+      path7
     ]);
   }
 }
@@ -9609,7 +9609,7 @@ function generateReferentialEqualityAnnotations(identitites, dedupe) {
       return;
     }
     if (!dedupe) {
-      paths = paths.map((path5) => path5.map(String)).sort((a, b) => a.length - b.length);
+      paths = paths.map((path7) => path7.map(String)).sort((a, b) => a.length - b.length);
     }
     const [representativePath, ...identicalPaths] = paths;
     if (representativePath.length === 0) {
@@ -9634,10 +9634,10 @@ function generateReferentialEqualityAnnotations(identitites, dedupe) {
   }
 }
 __name(generateReferentialEqualityAnnotations, "generateReferentialEqualityAnnotations");
-var walker = /* @__PURE__ */ __name((object, identities, superJson, dedupe, path5 = [], objectsInThisPath = [], seenObjects = /* @__PURE__ */ new Map()) => {
+var walker = /* @__PURE__ */ __name((object, identities, superJson, dedupe, path7 = [], objectsInThisPath = [], seenObjects = /* @__PURE__ */ new Map()) => {
   const primitive = isPrimitive(object);
   if (!primitive) {
-    addIdentity(object, path5, identities);
+    addIdentity(object, path7, identities);
     const seen = seenObjects.get(object);
     if (seen) {
       return dedupe ? {
@@ -9674,7 +9674,7 @@ var walker = /* @__PURE__ */ __name((object, identities, superJson, dedupe, path
       throw new Error(`Detected property ${index}. This is a prototype pollution risk, please remove it from your object.`);
     }
     const recursiveResult = walker(value, identities, superJson, dedupe, [
-      ...path5,
+      ...path7,
       index
     ], [
       ...objectsInThisPath,
@@ -10253,6 +10253,9 @@ var writeFile = /* @__PURE__ */ __name(async (filePath, content, options) => {
   return writeFileFs(filePath, content || "", options);
 }, "writeFile");
 
+// src/utils/write-file-safely.ts
+import path4 from "node:path";
+
 // src/utils/format-file.ts
 init_esm_shims();
 import prettier from "prettier";
@@ -10279,13 +10282,1188 @@ async function formatFile(content) {
 __name(formatFile, "formatFile");
 
 // src/utils/write-file-safely.ts
-var writeFileSafely = /* @__PURE__ */ __name(async (writeLocation, content) => {
+var indexExports = /* @__PURE__ */ new Set();
+var addIndexExport = /* @__PURE__ */ __name((filePath) => {
+  indexExports.add(filePath);
+}, "addIndexExport");
+var writeFileSafely = /* @__PURE__ */ __name(async (writeLocation, content, addToIndex = true) => {
   const [fileContent] = await Promise.all([
     formatFile(content),
     createDirectory(findFilePath(writeLocation))
   ]);
   await writeFile(writeLocation, fileContent);
+  if (addToIndex) {
+    addIndexExport(writeLocation);
+  }
 }, "writeFileSafely");
+var writeIndexFile = /* @__PURE__ */ __name(async (indexPath) => {
+  const rows = Array.from(indexExports).map((filePath) => {
+    let relativePath = path4.relative(path4.dirname(indexPath), filePath);
+    if (relativePath.endsWith(".ts")) {
+      relativePath = relativePath.slice(0, relativePath.lastIndexOf(".ts"));
+    }
+    const normalized = correctPath(relativePath);
+    return `export * from './${normalized}'`;
+  });
+  await writeFileSafely(indexPath, rows.join("\n"), false);
+}, "writeIndexFile");
+
+// src/zod-helpers/aggregate-helpers.ts
+init_esm_shims();
+var isAggregateOutputType = /* @__PURE__ */ __name((name) => /(?:Count|Avg|Sum|Min|Max)AggregateOutputType$/.test(name), "isAggregateOutputType");
+var isAggregateInputType = /* @__PURE__ */ __name((name) => name.endsWith("CountAggregateInput") || name.endsWith("SumAggregateInput") || name.endsWith("AvgAggregateInput") || name.endsWith("MinAggregateInput") || name.endsWith("MaxAggregateInput"), "isAggregateInputType");
+function addMissingInputObjectTypesForAggregate(inputObjectTypes, outputObjectTypes) {
+  const aggregateOutputTypes = outputObjectTypes.filter(({ name }) => isAggregateOutputType(name));
+  for (const aggregateOutputType of aggregateOutputTypes) {
+    const name = aggregateOutputType.name.replace(/(?:OutputType|Output)$/, "");
+    inputObjectTypes.push({
+      constraints: {
+        maxNumFields: null,
+        minNumFields: null
+      },
+      name: `${name}Input`,
+      fields: aggregateOutputType.fields.map((field) => ({
+        name: field.name,
+        isNullable: false,
+        isRequired: false,
+        inputTypes: [
+          {
+            isList: false,
+            type: "True",
+            location: "scalar"
+          }
+        ]
+      }))
+    });
+  }
+}
+__name(addMissingInputObjectTypesForAggregate, "addMissingInputObjectTypesForAggregate");
+function resolveZodAggregateOperationSupport(inputObjectTypes) {
+  const aggregateOperationSupport = {};
+  for (const inputType of inputObjectTypes) {
+    if (isAggregateInputType(inputType.name)) {
+      const name = inputType.name.replace("AggregateInput", "");
+      if (name.endsWith("Count")) {
+        const model = name.replace("Count", "");
+        aggregateOperationSupport[model] = {
+          ...aggregateOperationSupport[model],
+          count: true
+        };
+      } else if (name.endsWith("Min")) {
+        const model = name.replace("Min", "");
+        aggregateOperationSupport[model] = {
+          ...aggregateOperationSupport[model],
+          min: true
+        };
+      } else if (name.endsWith("Max")) {
+        const model = name.replace("Max", "");
+        aggregateOperationSupport[model] = {
+          ...aggregateOperationSupport[model],
+          max: true
+        };
+      } else if (name.endsWith("Sum")) {
+        const model = name.replace("Sum", "");
+        aggregateOperationSupport[model] = {
+          ...aggregateOperationSupport[model],
+          sum: true
+        };
+      } else if (name.endsWith("Avg")) {
+        const model = name.replace("Avg", "");
+        aggregateOperationSupport[model] = {
+          ...aggregateOperationSupport[model],
+          avg: true
+        };
+      }
+    }
+  }
+  return aggregateOperationSupport;
+}
+__name(resolveZodAggregateOperationSupport, "resolveZodAggregateOperationSupport");
+
+// src/zod-helpers/comments-helpers.ts
+init_esm_shims();
+var modelAttributeRegex = /(?:@@Gen\.)+[A-z]+\(.+\)/;
+var attributeNameRegex = /\.+[A-Z]+\(+/i;
+var attributeArgsRegex = /\(+[A-Z]+:.+\)/i;
+function resolveZodModelsComments(models, modelOperations, enumTypes, hiddenModels, hiddenFields) {
+  models = collectHiddenModels(models, hiddenModels);
+  collectHiddenFields(models, hiddenModels, hiddenFields);
+  hideModelOperations(models, modelOperations);
+  hideEnums(enumTypes, hiddenModels);
+}
+__name(resolveZodModelsComments, "resolveZodModelsComments");
+function collectHiddenModels(models, hiddenModels) {
+  return models.map((model) => {
+    if (model.documentation) {
+      const attribute = model.documentation?.match(modelAttributeRegex)?.[0];
+      const attributeName = attribute?.match(attributeNameRegex)?.[0]?.slice(1, -1);
+      if (attributeName !== "model") {
+        return model;
+      }
+      const rawAttributeArgs = attribute?.match(attributeArgsRegex)?.[0]?.slice(1, -1);
+      const parsedAttributeArgs = {};
+      if (rawAttributeArgs) {
+        const rawAttributeArgsParts = rawAttributeArgs.split(":").map((it) => it.trim()).map((part) => part.startsWith("[") ? part : part.split(",")).flat().map((it) => it.trim());
+        for (let i = 0; i < rawAttributeArgsParts.length; i += 2) {
+          const key = rawAttributeArgsParts[i];
+          const value = rawAttributeArgsParts[i + 1];
+          parsedAttributeArgs[key] = JSON.parse(value);
+        }
+      }
+      if (parsedAttributeArgs.hide) {
+        hiddenModels.push(model.name);
+        return null;
+      }
+    }
+    return model;
+  }).filter(Boolean);
+}
+__name(collectHiddenModels, "collectHiddenModels");
+function collectHiddenFields(models, hiddenModels, hiddenFields) {
+  models.forEach((model) => {
+    model.fields.forEach((field) => {
+      if (hiddenModels.includes(field.type)) {
+        hiddenFields.push(field.name);
+        if (field.relationFromFields) {
+          field.relationFromFields.forEach((item) => hiddenFields.push(item));
+        }
+      }
+    });
+  });
+}
+__name(collectHiddenFields, "collectHiddenFields");
+function hideEnums(enumTypes, hiddenModels) {
+  enumTypes.prisma = enumTypes.prisma.filter((item) => !hiddenModels.find((model) => item.name.startsWith(model)));
+}
+__name(hideEnums, "hideEnums");
+function hideModelOperations(models, modelOperations) {
+  let i = modelOperations.length;
+  while (i >= 0) {
+    --i;
+    const modelOperation = modelOperations[i];
+    if (modelOperation && !models.find((model) => {
+      return model.name === modelOperation.model;
+    })) {
+      modelOperations.splice(i, 1);
+    }
+  }
+}
+__name(hideModelOperations, "hideModelOperations");
+function hideZodInputObjectTypesAndRelatedFields(inputObjectTypes, hiddenModels, hiddenFields) {
+  let j = inputObjectTypes.length;
+  while (j >= 0) {
+    --j;
+    const inputType = inputObjectTypes[j];
+    if (inputType && (hiddenModels.includes(inputType?.meta?.source) || hiddenModels.find((model) => inputType.name.startsWith(model)))) {
+      inputObjectTypes.splice(j, 1);
+    } else {
+      let k = inputType?.fields?.length ?? 0;
+      while (k >= 0) {
+        --k;
+        const field = inputType?.fields?.[k];
+        if (field && hiddenFields.includes(field.name)) {
+          inputObjectTypes[j].fields.slice(k, 1);
+        }
+      }
+    }
+  }
+}
+__name(hideZodInputObjectTypesAndRelatedFields, "hideZodInputObjectTypesAndRelatedFields");
+
+// src/zod-helpers/generator-helpers.ts
+init_esm_shims();
+
+// src/zod-helpers/transformer.ts
+init_esm_shims();
+import path5 from "node:path";
+
+// src/zod-helpers/model-helpers.ts
+init_esm_shims();
+function checkModelHasModelRelation(model) {
+  const { fields: modelFields } = model;
+  for (const modelField of modelFields) {
+    const isRelationField = checkIsModelRelationField(modelField);
+    if (isRelationField) {
+      return true;
+    }
+  }
+  return false;
+}
+__name(checkModelHasModelRelation, "checkModelHasModelRelation");
+function checkModelHasManyModelRelation(model) {
+  const { fields: modelFields } = model;
+  for (const modelField of modelFields) {
+    const isManyRelationField = checkIsManyModelRelationField(modelField);
+    if (isManyRelationField) {
+      return true;
+    }
+  }
+  return false;
+}
+__name(checkModelHasManyModelRelation, "checkModelHasManyModelRelation");
+function checkIsModelRelationField(modelField) {
+  const { kind, relationName } = modelField;
+  return kind === "object" && !!relationName;
+}
+__name(checkIsModelRelationField, "checkIsModelRelationField");
+function checkIsManyModelRelationField(modelField) {
+  return checkIsModelRelationField(modelField) && modelField.isList;
+}
+__name(checkIsManyModelRelationField, "checkIsManyModelRelationField");
+function findModelByName(models, modelName) {
+  return models.find(({ name }) => name === modelName);
+}
+__name(findModelByName, "findModelByName");
+
+// src/zod-helpers/mongodb-helpers.ts
+init_esm_shims();
+function addMissingInputObjectTypesForMongoDbRawOpsAndQueries(modelOperations, outputObjectTypes, inputObjectTypes) {
+  const rawOpsMap = resolveMongoDbRawOperations(modelOperations);
+  Transformer.rawOpsMap = rawOpsMap ?? {};
+  const mongoDbRawQueryInputObjectTypes = resolveMongoDbRawQueryInputObjectTypes(outputObjectTypes);
+  for (const mongoDbRawQueryInputType of mongoDbRawQueryInputObjectTypes) {
+    inputObjectTypes.push(mongoDbRawQueryInputType);
+  }
+}
+__name(addMissingInputObjectTypesForMongoDbRawOpsAndQueries, "addMissingInputObjectTypesForMongoDbRawOpsAndQueries");
+function resolveMongoDbRawOperations(modelOperations) {
+  const rawOpsMap = {};
+  const rawOpsNames = [
+    ...new Set(modelOperations.reduce((result, current) => {
+      const keys = Object.keys(current);
+      keys?.forEach((key) => {
+        if (key.includes("Raw")) {
+          result.push(key);
+        }
+      });
+      return result;
+    }, []))
+  ];
+  const modelNames = modelOperations.map((item) => item.model);
+  rawOpsNames.forEach((opName) => {
+    modelNames.forEach((modelName) => {
+      const isFind = opName === "findRaw";
+      const opWithModel = `${opName.replace("Raw", "")}${modelName}Raw`;
+      rawOpsMap[opWithModel] = isFind ? `${modelName}FindRawArgs` : `${modelName}AggregateRawArgs`;
+    });
+  });
+  return rawOpsMap;
+}
+__name(resolveMongoDbRawOperations, "resolveMongoDbRawOperations");
+function resolveMongoDbRawQueryInputObjectTypes(outputObjectTypes) {
+  const mongoDbRawQueries = getMongoDbRawQueries(outputObjectTypes);
+  const mongoDbRawQueryInputObjectTypes = mongoDbRawQueries.map((item) => ({
+    name: item.name,
+    constraints: {
+      maxNumFields: null,
+      minNumFields: null
+    },
+    fields: item.args.map((arg) => ({
+      name: arg.name,
+      isRequired: arg.isRequired,
+      isNullable: arg.isNullable,
+      inputTypes: arg.inputTypes
+    }))
+  }));
+  return mongoDbRawQueryInputObjectTypes;
+}
+__name(resolveMongoDbRawQueryInputObjectTypes, "resolveMongoDbRawQueryInputObjectTypes");
+function getMongoDbRawQueries(outputObjectTypes) {
+  const queryOutputTypes = outputObjectTypes.filter((item) => item.name === "Query");
+  const mongodbRawQueries = queryOutputTypes?.[0].fields.filter((field) => field.name.includes("Raw")) ?? [];
+  return mongodbRawQueries;
+}
+__name(getMongoDbRawQueries, "getMongoDbRawQueries");
+var isMongodbRawOp = /* @__PURE__ */ __name((name) => /find[\s\S]*?Raw/.test(name) || /aggregate[\s\S]*?Raw/.test(name), "isMongodbRawOp");
+
+// src/zod-helpers/transformer.ts
+var Transformer = class _Transformer {
+  static {
+    __name(this, "Transformer");
+  }
+  name;
+  fields;
+  schemaImports = /* @__PURE__ */ new Set();
+  models;
+  modelOperations;
+  aggregateOperationSupport;
+  enumTypes;
+  static enumNames = [];
+  static rawOpsMap = {};
+  static provider;
+  static previewFeatures;
+  static outputPath = "./generated";
+  hasJson = false;
+  static prismaClientOutputPath = "@prisma/client";
+  static isCustomPrismaClientOutputPath = false;
+  static isGenerateSelect = false;
+  static isGenerateInclude = false;
+  constructor(params) {
+    this.name = params.name ?? "";
+    this.fields = params.fields ?? [];
+    this.models = params.models ?? [];
+    this.modelOperations = params.modelOperations ?? [];
+    this.aggregateOperationSupport = params.aggregateOperationSupport ?? {};
+    this.enumTypes = params.enumTypes ?? [];
+  }
+  static setOutputPath(outPath) {
+    this.outputPath = outPath;
+  }
+  static setIsGenerateSelect(isGenerateSelect) {
+    this.isGenerateSelect = isGenerateSelect;
+  }
+  static setIsGenerateInclude(isGenerateInclude) {
+    this.isGenerateInclude = isGenerateInclude;
+  }
+  static getOutputPath() {
+    return this.outputPath;
+  }
+  static setPrismaClientOutputPath(prismaClientCustomPath) {
+    this.prismaClientOutputPath = prismaClientCustomPath;
+    this.isCustomPrismaClientOutputPath = prismaClientCustomPath !== "@prisma/client";
+  }
+  static async generateIndex() {
+    const indexPath = path5.join(_Transformer.outputPath, "schemas/index.ts");
+    await writeIndexFile(indexPath);
+  }
+  async generateEnumSchemas() {
+    for (const enumType2 of this.enumTypes) {
+      const { name, values } = enumType2;
+      await writeFileSafely(path5.join(_Transformer.outputPath, `schemas/enums/${name}.schema.ts`), `${this.generateImportZodStatement()}
+${this.generateExportSchemaStatement(`${name}`, `z.enum(${JSON.stringify(values)})`)}`);
+    }
+  }
+  generateImportZodStatement() {
+    return "import { z } from 'zod';\n";
+  }
+  generateExportSchemaStatement(name, schema) {
+    return `export const ${name}Schema = ${schema}`;
+  }
+  async generateObjectSchema() {
+    const zodObjectSchemaFields = this.generateObjectSchemaFields();
+    const objectSchema = this.prepareObjectSchema(zodObjectSchemaFields);
+    const objectSchemaName = this.resolveObjectSchemaName();
+    await writeFileSafely(path5.join(_Transformer.outputPath, `schemas/objects/${objectSchemaName}.schema.ts`), objectSchema);
+  }
+  generateObjectSchemaFields() {
+    const zodObjectSchemaFields = this.fields.map((field) => this.generateObjectSchemaField(field)).flatMap((item) => item).map((item) => {
+      const [zodStringWithMainType, field, skipValidators] = item;
+      const value = skipValidators ? zodStringWithMainType : this.generateFieldValidators(zodStringWithMainType, field);
+      return value.trim();
+    });
+    return zodObjectSchemaFields;
+  }
+  generateObjectSchemaField(field) {
+    const lines = field.inputTypes;
+    if (lines.length === 0) {
+      return [];
+    }
+    let alternatives = lines.reduce((result, inputType) => {
+      if (inputType.type === "String") {
+        result.push(this.wrapWithZodValidators("z.string()", field));
+      } else if (inputType.type === "Int" || inputType.type === "Float" || inputType.type === "Decimal") {
+        result.push(this.wrapWithZodValidators("z.number()", field));
+      } else if (inputType.type === "BigInt") {
+        result.push(this.wrapWithZodValidators("z.bigint()", field));
+      } else if (inputType.type === "Boolean") {
+        result.push(this.wrapWithZodValidators("z.boolean()", field));
+      } else if (inputType.type === "DateTime") {
+        result.push(this.wrapWithZodValidators("z.coerce.date()", field));
+      } else if (inputType.type === "Json") {
+        this.hasJson = true;
+        result.push(this.wrapWithZodValidators("jsonSchema", field));
+      } else if (inputType.type === "True") {
+        result.push(this.wrapWithZodValidators("z.literal(true)", field));
+      } else if (inputType.type === "Bytes") {
+        result.push(this.wrapWithZodValidators("z.instanceof(Buffer)", field));
+      } else {
+        const isEnum = inputType.location === "enumTypes";
+        if (inputType.namespace === "prisma" || isEnum) {
+          if (inputType.type !== this.name && typeof inputType.type === "string") {
+            this.addSchemaImport(inputType.type);
+          }
+          result.push(this.generatePrismaStringLine(field, lines.length));
+        }
+      }
+      return result;
+    }, []);
+    if (alternatives.length === 0) {
+      return [];
+    }
+    if (alternatives.length > 1) {
+      alternatives = alternatives.map((alter) => alter.replace(".optional()", ""));
+    }
+    const fieldName = alternatives.some((alt) => alt.includes(":")) ? "" : `  ${field.name}:`;
+    const opt = !field.isRequired ? ".optional()" : "";
+    let resString = alternatives.length === 1 ? alternatives.join(",\r\n") : `z.union([${alternatives.join(",\r\n")}])${opt}`;
+    if (field.isNullable) {
+      resString += ".nullable()";
+    }
+    return [
+      [
+        `  ${fieldName} ${resString} `,
+        field,
+        true
+      ]
+    ];
+  }
+  wrapWithZodValidators(mainValidator, field) {
+    let line = "";
+    line = mainValidator;
+    if (field.inputTypes.some((inputType) => inputType.isList)) {
+      line += ".array()";
+    }
+    if (!field.isRequired) {
+      line += ".optional()";
+    }
+    return line;
+  }
+  addSchemaImport(name) {
+    this.schemaImports.add(name);
+  }
+  generatePrismaStringLine(field, inputsLength) {
+    if (field.inputTypes.length === 0 || !field.inputTypes[0]) {
+      return "";
+    }
+    const inputType = field.inputTypes[0];
+    const isEnum = inputType.location === "enumTypes";
+    const inputTypeString = inputType.type;
+    const { isModelQueryType, modelName, queryName } = this.checkIsModelQueryType(inputTypeString);
+    const objectSchemaLine = isModelQueryType ? this.resolveModelQuerySchemaName(modelName, queryName) : `${inputTypeString}ObjectSchema`;
+    const enumSchemaLine = `${inputTypeString}Schema`;
+    const schema = inputType.type === this.name ? objectSchemaLine : isEnum ? enumSchemaLine : objectSchemaLine;
+    const arr = inputType.isList ? ".array()" : "";
+    const opt = !field.isRequired ? ".optional()" : "";
+    const nullable = field.inputTypes.length > 1 && field.inputTypes[1]?.type === "Null" ? ".nullable()" : "";
+    return inputsLength === 1 ? `  ${field.name}: z.lazy(() => ${schema})${arr}${opt}` : `z.lazy(() => ${schema})${arr}${opt}${nullable}`;
+  }
+  generateFieldValidators(zodStringWithMainType, field) {
+    const { isRequired, isNullable } = field;
+    if (!isRequired) {
+      zodStringWithMainType += ".optional()";
+    }
+    if (isNullable) {
+      zodStringWithMainType += ".nullable()";
+    }
+    return zodStringWithMainType;
+  }
+  prepareObjectSchema(zodObjectSchemaFields) {
+    const objectSchema = `${this.generateExportObjectSchemaStatement(this.addFinalWrappers({
+      zodStringFields: zodObjectSchemaFields
+    }))}
+`;
+    const prismaImportStatement = this.generateImportPrismaStatement();
+    const json = this.generateJsonSchemaImplementation();
+    return `${this.generateObjectSchemaImportStatements()}${prismaImportStatement}${json}${objectSchema}`;
+  }
+  generateExportObjectSchemaStatement(schema) {
+    let name = this.name;
+    let exportName = this.name;
+    if (_Transformer.provider === "mongodb") {
+      if (isMongodbRawOp(name)) {
+        name = _Transformer.rawOpsMap[name];
+        exportName = name.replace("Args", "");
+      }
+    }
+    if (isAggregateInputType(name)) {
+      name = `${name}Type`;
+    }
+    const end = `export const ${exportName}ObjectSchema = Schema`;
+    return `const Schema: z.ZodType<Prisma.${name}> = ${schema};
+
+ ${end}`;
+  }
+  addFinalWrappers({ zodStringFields }) {
+    const fields = [
+      ...zodStringFields
+    ];
+    return `${this.wrapWithZodObject(fields)}.strict()`;
+  }
+  generateImportPrismaStatement() {
+    let prismaClientImportPath;
+    if (_Transformer.isCustomPrismaClientOutputPath) {
+      const fromPath = path5.join(_Transformer.outputPath, "schemas", "objects");
+      const toPath = _Transformer.prismaClientOutputPath;
+      const relativePathFromOutputToPrismaClient = path5.relative(fromPath, toPath).split(path5.sep).join(path5.posix.sep);
+      prismaClientImportPath = relativePathFromOutputToPrismaClient;
+    } else {
+      prismaClientImportPath = _Transformer.prismaClientOutputPath;
+    }
+    return `import type { Prisma } from '${prismaClientImportPath}';
+
+`;
+  }
+  generateJsonSchemaImplementation() {
+    let jsonSchemaImplementation = "";
+    if (this.hasJson) {
+      jsonSchemaImplementation += `
+`;
+      jsonSchemaImplementation += `const literalSchema = z.union([z.string(), z.number(), z.boolean()]);
+`;
+      jsonSchemaImplementation += `const jsonSchema: z.ZodType<Prisma.InputJsonValue> = z.lazy(() =>
+`;
+      jsonSchemaImplementation += `  z.union([literalSchema, z.array(jsonSchema.nullable()), z.record(jsonSchema.nullable())])
+`;
+      jsonSchemaImplementation += `);
+
+`;
+    }
+    return jsonSchemaImplementation;
+  }
+  generateObjectSchemaImportStatements() {
+    let generatedImports = this.generateImportZodStatement();
+    generatedImports += this.generateSchemaImports();
+    generatedImports += "\n\n";
+    return generatedImports;
+  }
+  generateSchemaImports() {
+    return [
+      ...this.schemaImports
+    ].map((name) => {
+      const { isModelQueryType, modelName, queryName } = this.checkIsModelQueryType(name);
+      if (isModelQueryType) {
+        return `import { ${this.resolveModelQuerySchemaName(modelName, queryName)} } from '../${queryName}${modelName}.schema'`;
+      } else if (_Transformer.enumNames.includes(name)) {
+        return `import { ${name}Schema } from '../enums/${name}.schema'`;
+      } else {
+        return `import { ${name}ObjectSchema } from './${name}.schema'`;
+      }
+    }).join(";\r\n");
+  }
+  checkIsModelQueryType(type) {
+    const modelQueryTypeSuffixToQueryName = {
+      FindManyArgs: "findMany"
+    };
+    for (const modelQueryType of [
+      "FindManyArgs"
+    ]) {
+      if (type.includes(modelQueryType)) {
+        const modelQueryTypeSuffixIndex = type.indexOf(modelQueryType);
+        return {
+          isModelQueryType: true,
+          modelName: type.substring(0, modelQueryTypeSuffixIndex),
+          queryName: modelQueryTypeSuffixToQueryName[modelQueryType]
+        };
+      }
+    }
+    return {
+      isModelQueryType: false
+    };
+  }
+  resolveModelQuerySchemaName(modelName, queryName) {
+    const modelNameCapitalized = modelName.charAt(0).toUpperCase() + modelName.slice(1);
+    const queryNameCapitalized = queryName.charAt(0).toUpperCase() + queryName.slice(1);
+    return `${modelNameCapitalized}${queryNameCapitalized}Schema`;
+  }
+  wrapWithZodUnion(zodStringFields) {
+    let wrapped = "";
+    wrapped += "z.union([";
+    wrapped += "\n";
+    wrapped += `  ${zodStringFields.join(",")}`;
+    wrapped += "\n";
+    wrapped += "])";
+    return wrapped;
+  }
+  wrapWithZodObject(zodStringFields) {
+    let wrapped = "";
+    wrapped += "z.object({";
+    wrapped += "\n";
+    wrapped += `  ${typeof zodStringFields === "string" ? zodStringFields : zodStringFields.join(",\n  ")}`;
+    wrapped += "\n";
+    wrapped += "})";
+    return wrapped;
+  }
+  resolveObjectSchemaName() {
+    let name = this.name;
+    let exportName = this.name;
+    if (isMongodbRawOp(name)) {
+      name = _Transformer.rawOpsMap[name];
+      exportName = name.replace("Args", "");
+    }
+    return exportName;
+  }
+  async generateModelSchemas() {
+    for (const modelOperation of this.modelOperations) {
+      const {
+        model: modelName,
+        findUnique,
+        findFirst,
+        findMany,
+        // @ts-ignore
+        createOne,
+        createMany,
+        // @ts-ignore
+        deleteOne,
+        // @ts-ignore
+        updateOne,
+        deleteMany,
+        updateMany,
+        // @ts-ignore
+        upsertOne,
+        aggregate,
+        groupBy
+      } = modelOperation;
+      const model = findModelByName(this.models, modelName);
+      const { selectImport, includeImport, selectZodSchemaLine, includeZodSchemaLine, selectZodSchemaLineLazy, includeZodSchemaLineLazy } = this.resolveSelectIncludeImportAndZodSchemaLine(model);
+      const { orderByImport, orderByZodSchemaLine } = this.resolveOrderByWithRelationImportAndZodSchemaLine(model);
+      if (findUnique) {
+        const imports = [
+          selectImport,
+          includeImport,
+          `import { ${modelName}WhereUniqueInputObjectSchema } from './objects/${modelName}WhereUniqueInput.schema'`
+        ];
+        await writeFileSafely(path5.join(_Transformer.outputPath, `schemas/${findUnique}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}FindUnique`, `z.object({ ${selectZodSchemaLine} ${includeZodSchemaLine} where: ${modelName}WhereUniqueInputObjectSchema })`)}`);
+      }
+      if (findFirst) {
+        const imports = [
+          selectImport,
+          includeImport,
+          orderByImport,
+          `import { ${modelName}WhereInputObjectSchema } from './objects/${modelName}WhereInput.schema'`,
+          `import { ${modelName}WhereUniqueInputObjectSchema } from './objects/${modelName}WhereUniqueInput.schema'`,
+          `import { ${modelName}ScalarFieldEnumSchema } from './enums/${modelName}ScalarFieldEnum.schema'`
+        ];
+        await writeFileSafely(path5.join(_Transformer.outputPath, `schemas/${findFirst}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}FindFirst`, `z.object({ ${selectZodSchemaLine} ${includeZodSchemaLine} ${orderByZodSchemaLine} where: ${modelName}WhereInputObjectSchema.optional(), cursor: ${modelName}WhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.array(${modelName}ScalarFieldEnumSchema).optional() })`)}`);
+      }
+      if (findMany) {
+        const imports = [
+          selectImport,
+          includeImport,
+          orderByImport,
+          `import { ${modelName}WhereInputObjectSchema } from './objects/${modelName}WhereInput.schema'`,
+          `import { ${modelName}WhereUniqueInputObjectSchema } from './objects/${modelName}WhereUniqueInput.schema'`,
+          `import { ${modelName}ScalarFieldEnumSchema } from './enums/${modelName}ScalarFieldEnum.schema'`
+        ];
+        await writeFileSafely(path5.join(_Transformer.outputPath, `schemas/${findMany}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}FindMany`, `z.object({ ${selectZodSchemaLineLazy} ${includeZodSchemaLineLazy} ${orderByZodSchemaLine} where: ${modelName}WhereInputObjectSchema.optional(), cursor: ${modelName}WhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.array(${modelName}ScalarFieldEnumSchema).optional()  })`)}`);
+      }
+      if (createOne) {
+        const imports = [
+          selectImport,
+          includeImport,
+          `import { ${modelName}CreateInputObjectSchema } from './objects/${modelName}CreateInput.schema'`,
+          `import { ${modelName}UncheckedCreateInputObjectSchema } from './objects/${modelName}UncheckedCreateInput.schema'`
+        ];
+        await writeFileSafely(path5.join(_Transformer.outputPath, `schemas/${createOne}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}CreateOne`, `z.object({ ${selectZodSchemaLine} ${includeZodSchemaLine} data: z.union([${modelName}CreateInputObjectSchema, ${modelName}UncheckedCreateInputObjectSchema])  })`)}`);
+      }
+      if (createMany) {
+        const imports = [
+          `import { ${modelName}CreateManyInputObjectSchema } from './objects/${modelName}CreateManyInput.schema'`
+        ];
+        await writeFileSafely(path5.join(_Transformer.outputPath, `schemas/${createMany}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}CreateMany`, `z.object({ data: z.union([ ${modelName}CreateManyInputObjectSchema, z.array(${modelName}CreateManyInputObjectSchema) ]), ${_Transformer.provider === "mongodb" || _Transformer.provider === "sqlserver" ? "" : "skipDuplicates: z.boolean().optional()"} })`)}`);
+      }
+      if (deleteOne) {
+        const imports = [
+          selectImport,
+          includeImport,
+          `import { ${modelName}WhereUniqueInputObjectSchema } from './objects/${modelName}WhereUniqueInput.schema'`
+        ];
+        await writeFileSafely(path5.join(_Transformer.outputPath, `schemas/${deleteOne}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}DeleteOne`, `z.object({ ${selectZodSchemaLine} ${includeZodSchemaLine} where: ${modelName}WhereUniqueInputObjectSchema  })`)}`);
+      }
+      if (deleteMany) {
+        const imports = [
+          `import { ${modelName}WhereInputObjectSchema } from './objects/${modelName}WhereInput.schema'`
+        ];
+        await writeFileSafely(path5.join(_Transformer.outputPath, `schemas/${deleteMany}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}DeleteMany`, `z.object({ where: ${modelName}WhereInputObjectSchema.optional()  })`)}`);
+      }
+      if (updateOne) {
+        const imports = [
+          selectImport,
+          includeImport,
+          `import { ${modelName}UpdateInputObjectSchema } from './objects/${modelName}UpdateInput.schema'`,
+          `import { ${modelName}UncheckedUpdateInputObjectSchema } from './objects/${modelName}UncheckedUpdateInput.schema'`,
+          `import { ${modelName}WhereUniqueInputObjectSchema } from './objects/${modelName}WhereUniqueInput.schema'`
+        ];
+        await writeFileSafely(path5.join(_Transformer.outputPath, `schemas/${updateOne}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}UpdateOne`, `z.object({ ${selectZodSchemaLine} ${includeZodSchemaLine} data: z.union([${modelName}UpdateInputObjectSchema, ${modelName}UncheckedUpdateInputObjectSchema]), where: ${modelName}WhereUniqueInputObjectSchema  })`)}`);
+      }
+      if (updateMany) {
+        const imports = [
+          `import { ${modelName}UpdateManyMutationInputObjectSchema } from './objects/${modelName}UpdateManyMutationInput.schema'`,
+          `import { ${modelName}WhereInputObjectSchema } from './objects/${modelName}WhereInput.schema'`
+        ];
+        await writeFileSafely(path5.join(_Transformer.outputPath, `schemas/${updateMany}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}UpdateMany`, `z.object({ data: ${modelName}UpdateManyMutationInputObjectSchema, where: ${modelName}WhereInputObjectSchema.optional()  })`)}`);
+      }
+      if (upsertOne) {
+        const imports = [
+          selectImport,
+          includeImport,
+          `import { ${modelName}WhereUniqueInputObjectSchema } from './objects/${modelName}WhereUniqueInput.schema'`,
+          `import { ${modelName}CreateInputObjectSchema } from './objects/${modelName}CreateInput.schema'`,
+          `import { ${modelName}UncheckedCreateInputObjectSchema } from './objects/${modelName}UncheckedCreateInput.schema'`,
+          `import { ${modelName}UpdateInputObjectSchema } from './objects/${modelName}UpdateInput.schema'`,
+          `import { ${modelName}UncheckedUpdateInputObjectSchema } from './objects/${modelName}UncheckedUpdateInput.schema'`
+        ];
+        await writeFileSafely(path5.join(_Transformer.outputPath, `schemas/${upsertOne}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}Upsert`, `z.object({ ${selectZodSchemaLine} ${includeZodSchemaLine} where: ${modelName}WhereUniqueInputObjectSchema, create: z.union([ ${modelName}CreateInputObjectSchema, ${modelName}UncheckedCreateInputObjectSchema ]), update: z.union([ ${modelName}UpdateInputObjectSchema, ${modelName}UncheckedUpdateInputObjectSchema ])  })`)}`);
+      }
+      if (aggregate) {
+        const imports = [
+          orderByImport,
+          `import { ${modelName}WhereInputObjectSchema } from './objects/${modelName}WhereInput.schema'`,
+          `import { ${modelName}WhereUniqueInputObjectSchema } from './objects/${modelName}WhereUniqueInput.schema'`
+        ];
+        const aggregateOperations = [];
+        if (this.aggregateOperationSupport[modelName]) {
+          if (this.aggregateOperationSupport[modelName].count) {
+            imports.push(`import { ${modelName}CountAggregateInputObjectSchema } from './objects/${modelName}CountAggregateInput.schema'`);
+            aggregateOperations.push(`_count: z.union([ z.literal(true), ${modelName}CountAggregateInputObjectSchema ]).optional()`);
+          }
+          if (this.aggregateOperationSupport[modelName].min) {
+            imports.push(`import { ${modelName}MinAggregateInputObjectSchema } from './objects/${modelName}MinAggregateInput.schema'`);
+            aggregateOperations.push(`_min: ${modelName}MinAggregateInputObjectSchema.optional()`);
+          }
+          if (this.aggregateOperationSupport[modelName].max) {
+            imports.push(`import { ${modelName}MaxAggregateInputObjectSchema } from './objects/${modelName}MaxAggregateInput.schema'`);
+            aggregateOperations.push(`_max: ${modelName}MaxAggregateInputObjectSchema.optional()`);
+          }
+          if (this.aggregateOperationSupport[modelName].avg) {
+            imports.push(`import { ${modelName}AvgAggregateInputObjectSchema } from './objects/${modelName}AvgAggregateInput.schema'`);
+            aggregateOperations.push(`_avg: ${modelName}AvgAggregateInputObjectSchema.optional()`);
+          }
+          if (this.aggregateOperationSupport[modelName].sum) {
+            imports.push(`import { ${modelName}SumAggregateInputObjectSchema } from './objects/${modelName}SumAggregateInput.schema'`);
+            aggregateOperations.push(`_sum: ${modelName}SumAggregateInputObjectSchema.optional()`);
+          }
+        }
+        await writeFileSafely(path5.join(_Transformer.outputPath, `schemas/${aggregate}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}Aggregate`, `z.object({ ${orderByZodSchemaLine} where: ${modelName}WhereInputObjectSchema.optional(), cursor: ${modelName}WhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), ${aggregateOperations.join(", ")} })`)}`);
+      }
+      if (groupBy) {
+        const imports = [
+          `import { ${modelName}WhereInputObjectSchema } from './objects/${modelName}WhereInput.schema'`,
+          `import { ${modelName}OrderByWithAggregationInputObjectSchema } from './objects/${modelName}OrderByWithAggregationInput.schema'`,
+          `import { ${modelName}ScalarWhereWithAggregatesInputObjectSchema } from './objects/${modelName}ScalarWhereWithAggregatesInput.schema'`,
+          `import { ${modelName}ScalarFieldEnumSchema } from './enums/${modelName}ScalarFieldEnum.schema'`
+        ];
+        await writeFileSafely(path5.join(_Transformer.outputPath, `schemas/${groupBy}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}GroupBy`, `z.object({ where: ${modelName}WhereInputObjectSchema.optional(), orderBy: z.union([${modelName}OrderByWithAggregationInputObjectSchema, ${modelName}OrderByWithAggregationInputObjectSchema.array()]).optional(), having: ${modelName}ScalarWhereWithAggregatesInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), by: z.array(${modelName}ScalarFieldEnumSchema)  })`)}`);
+      }
+    }
+  }
+  generateImportStatements(imports) {
+    let generatedImports = this.generateImportZodStatement();
+    generatedImports += imports?.filter((importItem) => !!importItem).join(";\r\n") ?? "";
+    generatedImports += "\n\n";
+    return generatedImports;
+  }
+  resolveSelectIncludeImportAndZodSchemaLine(model) {
+    const { name: modelName } = model;
+    const hasRelationToAnotherModel = checkModelHasModelRelation(model);
+    const selectImport = _Transformer.isGenerateSelect ? `import { ${modelName}SelectObjectSchema } from './objects/${modelName}Select.schema'` : "";
+    const includeImport = _Transformer.isGenerateInclude && hasRelationToAnotherModel ? `import { ${modelName}IncludeObjectSchema } from './objects/${modelName}Include.schema'` : "";
+    let selectZodSchemaLine = "";
+    let includeZodSchemaLine = "";
+    let selectZodSchemaLineLazy = "";
+    let includeZodSchemaLineLazy = "";
+    if (_Transformer.isGenerateSelect) {
+      const zodSelectObjectSchema = `${modelName}SelectObjectSchema.optional()`;
+      selectZodSchemaLine = `select: ${zodSelectObjectSchema},`;
+      selectZodSchemaLineLazy = `select: z.lazy(() => ${zodSelectObjectSchema}),`;
+    }
+    if (_Transformer.isGenerateInclude && hasRelationToAnotherModel) {
+      const zodIncludeObjectSchema = `${modelName}IncludeObjectSchema.optional()`;
+      includeZodSchemaLine = `include: ${zodIncludeObjectSchema},`;
+      includeZodSchemaLineLazy = `include: z.lazy(() => ${zodIncludeObjectSchema}),`;
+    }
+    return {
+      selectImport,
+      includeImport,
+      selectZodSchemaLine,
+      includeZodSchemaLine,
+      selectZodSchemaLineLazy,
+      includeZodSchemaLineLazy
+    };
+  }
+  resolveOrderByWithRelationImportAndZodSchemaLine(model) {
+    const { name: modelName } = model;
+    let modelOrderBy = "";
+    if ([
+      "postgresql",
+      "mysql"
+    ].includes(_Transformer.provider) && _Transformer.previewFeatures?.includes("fullTextSearch")) {
+      modelOrderBy = `${modelName}OrderByWithRelationAndSearchRelevanceInput`;
+    } else {
+      modelOrderBy = `${modelName}OrderByWithRelationInput`;
+    }
+    const orderByImport = `import { ${modelOrderBy}ObjectSchema } from './objects/${modelOrderBy}.schema'`;
+    const orderByZodSchemaLine = `orderBy: z.union([${modelOrderBy}ObjectSchema, ${modelOrderBy}ObjectSchema.array()]).optional(),`;
+    return {
+      orderByImport,
+      orderByZodSchemaLine
+    };
+  }
+};
+
+// src/zod-helpers/generator-helpers.ts
+async function generateZodEnumSchemas(prismaSchemaEnum, modelSchemaEnum) {
+  const enumTypes = [
+    ...prismaSchemaEnum,
+    ...modelSchemaEnum
+  ];
+  const enumNames = enumTypes.map((enumItem) => enumItem.name);
+  Transformer.enumNames = enumNames ?? [];
+  const transformer = new Transformer({
+    enumTypes
+  });
+  await transformer.generateEnumSchemas();
+}
+__name(generateZodEnumSchemas, "generateZodEnumSchemas");
+async function generateZodObjectSchemas(inputObjectTypes) {
+  for (let i = 0; i < inputObjectTypes.length; i += 1) {
+    const fields = inputObjectTypes[i]?.fields;
+    const name = inputObjectTypes[i]?.name;
+    const transformer = new Transformer({
+      name,
+      fields
+    });
+    await transformer.generateObjectSchema();
+  }
+}
+__name(generateZodObjectSchemas, "generateZodObjectSchemas");
+async function generateZodModelSchemas(models, modelOperations, aggregateOperationSupport) {
+  const transformer = new Transformer({
+    models,
+    modelOperations,
+    aggregateOperationSupport
+  });
+  await transformer.generateModelSchemas();
+}
+__name(generateZodModelSchemas, "generateZodModelSchemas");
+async function generateZodIndex() {
+  await Transformer.generateIndex();
+}
+__name(generateZodIndex, "generateZodIndex");
+
+// src/zod-helpers/helpers.ts
+init_esm_shims();
+
+// src/zod-helpers/include-helpers.ts
+init_esm_shims();
+function addMissingInputObjectTypesForInclude(inputObjectTypes, models, isGenerateSelect) {
+  const generatedIncludeInputObjectTypes = generateModelIncludeInputObjectTypes(models, isGenerateSelect);
+  for (const includeInputObjectType of generatedIncludeInputObjectTypes) {
+    inputObjectTypes.push(includeInputObjectType);
+  }
+}
+__name(addMissingInputObjectTypesForInclude, "addMissingInputObjectTypesForInclude");
+function generateModelIncludeInputObjectTypes(models, isGenerateSelect) {
+  const modelIncludeInputObjectTypes = [];
+  for (const model of models) {
+    const { name: modelName, fields: modelFields } = model;
+    const fields = [];
+    for (const modelField of modelFields) {
+      const { name: modelFieldName, isList, type } = modelField;
+      const isRelationField = checkIsModelRelationField(modelField);
+      if (isRelationField) {
+        const field = {
+          name: modelFieldName,
+          isRequired: false,
+          isNullable: false,
+          inputTypes: [
+            {
+              isList: false,
+              type: "Boolean",
+              location: "scalar"
+            },
+            {
+              isList: false,
+              type: isList ? `${type}FindManyArgs` : `${type}Args`,
+              location: "inputObjectTypes",
+              namespace: "prisma"
+            }
+          ]
+        };
+        fields.push(field);
+      }
+    }
+    const hasRelationToAnotherModel = checkModelHasModelRelation(model);
+    if (!hasRelationToAnotherModel) {
+      continue;
+    }
+    const hasManyRelationToAnotherModel = checkModelHasManyModelRelation(model);
+    const shouldAddCountField = hasManyRelationToAnotherModel;
+    if (shouldAddCountField) {
+      const inputTypes = [
+        {
+          isList: false,
+          type: "Boolean",
+          location: "scalar"
+        }
+      ];
+      if (isGenerateSelect) {
+        inputTypes.push({
+          isList: false,
+          type: `${modelName}CountOutputTypeArgs`,
+          location: "inputObjectTypes",
+          namespace: "prisma"
+        });
+      }
+      const _countField = {
+        name: "_count",
+        isRequired: false,
+        isNullable: false,
+        inputTypes
+      };
+      fields.push(_countField);
+    }
+    const modelIncludeInputObjectType = {
+      name: `${modelName}Include`,
+      constraints: {
+        maxNumFields: null,
+        minNumFields: null
+      },
+      fields
+    };
+    modelIncludeInputObjectTypes.push(modelIncludeInputObjectType);
+  }
+  return modelIncludeInputObjectTypes;
+}
+__name(generateModelIncludeInputObjectTypes, "generateModelIncludeInputObjectTypes");
+
+// src/zod-helpers/modelArgs-helpers.ts
+init_esm_shims();
+function addMissingInputObjectTypesForModelArgs(inputObjectTypes, models, isGenerateSelect, isGenerateInclude) {
+  const modelArgsInputObjectTypes = generateModelArgsInputObjectTypes(models, isGenerateSelect, isGenerateInclude);
+  for (const modelArgsInputObjectType of modelArgsInputObjectTypes) {
+    inputObjectTypes.push(modelArgsInputObjectType);
+  }
+}
+__name(addMissingInputObjectTypesForModelArgs, "addMissingInputObjectTypesForModelArgs");
+function generateModelArgsInputObjectTypes(models, isGenerateSelect, isGenerateInclude) {
+  const modelArgsInputObjectTypes = [];
+  for (const model of models) {
+    const { name: modelName } = model;
+    const fields = [];
+    if (isGenerateSelect) {
+      const selectField = {
+        name: "select",
+        isRequired: false,
+        isNullable: false,
+        inputTypes: [
+          {
+            isList: false,
+            type: `${modelName}Select`,
+            location: "inputObjectTypes",
+            namespace: "prisma"
+          }
+        ]
+      };
+      fields.push(selectField);
+    }
+    const hasRelationToAnotherModel = checkModelHasModelRelation(model);
+    if (isGenerateInclude && hasRelationToAnotherModel) {
+      const includeField = {
+        name: "include",
+        isRequired: false,
+        isNullable: false,
+        inputTypes: [
+          {
+            isList: false,
+            type: `${modelName}Include`,
+            location: "inputObjectTypes",
+            namespace: "prisma"
+          }
+        ]
+      };
+      fields.push(includeField);
+    }
+    const modelArgsInputObjectType = {
+      name: `${modelName}Args`,
+      constraints: {
+        maxNumFields: null,
+        minNumFields: null
+      },
+      fields
+    };
+    modelArgsInputObjectTypes.push(modelArgsInputObjectType);
+  }
+  return modelArgsInputObjectTypes;
+}
+__name(generateModelArgsInputObjectTypes, "generateModelArgsInputObjectTypes");
+
+// src/zod-helpers/select-helpers.ts
+init_esm_shims();
+function addMissingInputObjectTypesForSelect(inputObjectTypes, outputObjectTypes, models) {
+  const modelCountOutputTypes = getModelCountOutputTypes(outputObjectTypes);
+  const modelCountOutputTypeSelectInputObjectTypes = generateModelCountOutputTypeSelectInputObjectTypes(modelCountOutputTypes);
+  const modelCountOutputTypeArgsInputObjectTypes = generateModelCountOutputTypeArgsInputObjectTypes(modelCountOutputTypes);
+  const modelSelectInputObjectTypes = generateModelSelectInputObjectTypes(models);
+  const generatedInputObjectTypes = [
+    modelCountOutputTypeSelectInputObjectTypes,
+    modelCountOutputTypeArgsInputObjectTypes,
+    modelSelectInputObjectTypes
+  ].flat();
+  for (const inputObjectType of generatedInputObjectTypes) {
+    inputObjectTypes.push(inputObjectType);
+  }
+}
+__name(addMissingInputObjectTypesForSelect, "addMissingInputObjectTypesForSelect");
+function getModelCountOutputTypes(outputObjectTypes) {
+  return outputObjectTypes.filter(({ name }) => name.includes("CountOutputType"));
+}
+__name(getModelCountOutputTypes, "getModelCountOutputTypes");
+function generateModelCountOutputTypeSelectInputObjectTypes(modelCountOutputTypes) {
+  const modelCountOutputTypeSelectInputObjectTypes = [];
+  for (const modelCountOutputType of modelCountOutputTypes) {
+    const { name: modelCountOutputTypeName, fields: modelCountOutputTypeFields } = modelCountOutputType;
+    const modelCountOutputTypeSelectInputObjectType = {
+      name: `${modelCountOutputTypeName}Select`,
+      constraints: {
+        maxNumFields: null,
+        minNumFields: null
+      },
+      fields: modelCountOutputTypeFields.map(({ name }) => ({
+        name,
+        isRequired: false,
+        isNullable: false,
+        inputTypes: [
+          {
+            isList: false,
+            type: `Boolean`,
+            location: "scalar"
+          }
+        ]
+      }))
+    };
+    modelCountOutputTypeSelectInputObjectTypes.push(modelCountOutputTypeSelectInputObjectType);
+  }
+  return modelCountOutputTypeSelectInputObjectTypes;
+}
+__name(generateModelCountOutputTypeSelectInputObjectTypes, "generateModelCountOutputTypeSelectInputObjectTypes");
+function generateModelCountOutputTypeArgsInputObjectTypes(modelCountOutputTypes) {
+  const modelCountOutputTypeArgsInputObjectTypes = [];
+  for (const modelCountOutputType of modelCountOutputTypes) {
+    const { name: modelCountOutputTypeName } = modelCountOutputType;
+    const modelCountOutputTypeArgsInputObjectType = {
+      name: `${modelCountOutputTypeName}Args`,
+      constraints: {
+        maxNumFields: null,
+        minNumFields: null
+      },
+      fields: [
+        {
+          name: "select",
+          isRequired: false,
+          isNullable: false,
+          inputTypes: [
+            {
+              isList: false,
+              type: `${modelCountOutputTypeName}Select`,
+              location: "inputObjectTypes",
+              namespace: "prisma"
+            }
+          ]
+        }
+      ]
+    };
+    modelCountOutputTypeArgsInputObjectTypes.push(modelCountOutputTypeArgsInputObjectType);
+  }
+  return modelCountOutputTypeArgsInputObjectTypes;
+}
+__name(generateModelCountOutputTypeArgsInputObjectTypes, "generateModelCountOutputTypeArgsInputObjectTypes");
+function generateModelSelectInputObjectTypes(models) {
+  const modelSelectInputObjectTypes = [];
+  for (const model of models) {
+    const { name: modelName, fields: modelFields } = model;
+    const fields = [];
+    for (const modelField of modelFields) {
+      const { name: modelFieldName, isList, type } = modelField;
+      const isRelationField = checkIsModelRelationField(modelField);
+      const field = {
+        name: modelFieldName,
+        isRequired: false,
+        isNullable: false,
+        inputTypes: [
+          {
+            isList: false,
+            type: "Boolean",
+            location: "scalar"
+          }
+        ]
+      };
+      if (isRelationField) {
+        const schemaArgInputType = {
+          isList: false,
+          type: isList ? `${type}FindManyArgs` : `${type}Args`,
+          location: "inputObjectTypes",
+          namespace: "prisma"
+        };
+        field.inputTypes.push(schemaArgInputType);
+      }
+      fields.push(field);
+    }
+    const hasManyRelationToAnotherModel = checkModelHasManyModelRelation(model);
+    const shouldAddCountField = hasManyRelationToAnotherModel;
+    if (shouldAddCountField) {
+      const _countField = {
+        name: "_count",
+        isRequired: false,
+        isNullable: false,
+        inputTypes: [
+          {
+            isList: false,
+            type: "Boolean",
+            location: "scalar"
+          },
+          {
+            isList: false,
+            type: `${modelName}CountOutputTypeArgs`,
+            location: "inputObjectTypes",
+            namespace: "prisma"
+          }
+        ]
+      };
+      fields.push(_countField);
+    }
+    const modelSelectInputObjectType = {
+      name: `${modelName}Select`,
+      constraints: {
+        maxNumFields: null,
+        minNumFields: null
+      },
+      fields
+    };
+    modelSelectInputObjectTypes.push(modelSelectInputObjectType);
+  }
+  return modelSelectInputObjectTypes;
+}
+__name(generateModelSelectInputObjectTypes, "generateModelSelectInputObjectTypes");
+
+// src/zod-helpers/whereUniqueInput-helpers.ts
+init_esm_shims();
+function changeOptionalToRequiredFields(inputObjectTypes) {
+  inputObjectTypes.map((item) => {
+    if (item.name.includes("WhereUniqueInput") && // eslint-disable-next-line ts/no-non-null-asserted-optional-chain
+    item.constraints.fields?.length > 0) {
+      item.fields = item.fields.map((subItem) => {
+        if (item.constraints.fields?.includes(subItem.name)) {
+          subItem.isRequired = true;
+          return subItem;
+        }
+        return subItem;
+      });
+    }
+    return item;
+  });
+}
+__name(changeOptionalToRequiredFields, "changeOptionalToRequiredFields");
+
+// src/zod-helpers/helpers.ts
+function addMissingZodInputObjectTypes(inputObjectTypes, outputObjectTypes, models, modelOperations, dataSourceProvider, options) {
+  if (dataSourceProvider === "mongodb") {
+    addMissingInputObjectTypesForMongoDbRawOpsAndQueries(modelOperations, outputObjectTypes, inputObjectTypes);
+  }
+  addMissingInputObjectTypesForAggregate(inputObjectTypes, outputObjectTypes);
+  if (options.isGenerateSelect) {
+    addMissingInputObjectTypesForSelect(inputObjectTypes, outputObjectTypes, models);
+    Transformer.setIsGenerateSelect(true);
+  }
+  if (options.isGenerateSelect || options.isGenerateInclude) {
+    addMissingInputObjectTypesForModelArgs(inputObjectTypes, models, options.isGenerateSelect, options.isGenerateInclude);
+  }
+  if (options.isGenerateInclude) {
+    addMissingInputObjectTypesForInclude(inputObjectTypes, models, options.isGenerateSelect);
+    Transformer.setIsGenerateInclude(true);
+  }
+  changeOptionalToRequiredFields(inputObjectTypes);
+}
+__name(addMissingZodInputObjectTypes, "addMissingZodInputObjectTypes");
 
 // src/prisma-generator.ts
 async function generate(options) {
@@ -10307,13 +11485,6 @@ async function generate(options) {
   consoleLog(`Preparing output directory: ${outputDir}`);
   await createDirectory(outputDir);
   await removeDir(outputDir, true);
-  if (config.withZod !== false) {
-    consoleLog("Generating Zod schemas");
-    const prismaZodGenerator = await getJiti().import(getJiti().esmResolve("prisma-zod-generator/lib/prisma-generator"));
-    await prismaZodGenerator.generate(options);
-  } else {
-    consoleLog("Skipping Zod schemas generation");
-  }
   consoleLog("Finding Prisma Client generator");
   const prismaClientProvider = options.otherGenerators.find((it) => internals.parseEnvValue(it.provider) === "prisma-client-js");
   if (!prismaClientProvider) {
@@ -10325,8 +11496,41 @@ async function generate(options) {
     previewFeatures: prismaClientProvider?.previewFeatures
   });
   const modelOperations = prismaClientDmmf.mappings.modelOperations;
+  const inputObjectTypes = prismaClientDmmf.schema.inputObjectTypes.prisma;
+  const outputObjectTypes = prismaClientDmmf.schema.outputObjectTypes.prisma;
+  const enumTypes = prismaClientDmmf.schema.enumTypes;
   const models = prismaClientDmmf.datamodel.models;
   const hiddenModels = [];
+  const hiddenFields = [];
+  if (config.withZod !== false) {
+    consoleLog("Generating Zod schemas");
+    const zodOutputPath = internals.parseEnvValue(options.generator.output);
+    await createDirectory(zodOutputPath);
+    Transformer.setOutputPath(zodOutputPath);
+    if (prismaClientProvider?.isCustomOutput) {
+      Transformer.setPrismaClientOutputPath(prismaClientProvider.output?.value);
+    }
+    resolveZodModelsComments(models, modelOperations, enumTypes, hiddenModels, hiddenFields);
+    await generateZodEnumSchemas(enumTypes.prisma, enumTypes.model);
+    const dataSource = options.datasources?.[0];
+    if (!dataSource) {
+      throw new Error("No datasource found");
+    }
+    const previewFeatures = prismaClientProvider?.previewFeatures;
+    Transformer.provider = dataSource.provider;
+    Transformer.previewFeatures = previewFeatures;
+    addMissingZodInputObjectTypes(inputObjectTypes, outputObjectTypes, models, modelOperations, dataSource.provider, {
+      isGenerateSelect: true,
+      isGenerateInclude: true
+    });
+    const aggregateOperationSupport = resolveZodAggregateOperationSupport(inputObjectTypes);
+    hideZodInputObjectTypesAndRelatedFields(inputObjectTypes, hiddenModels, hiddenFields);
+    await generateZodObjectSchemas(inputObjectTypes);
+    await generateZodModelSchemas(models, modelOperations, aggregateOperationSupport);
+    await generateZodIndex();
+  } else {
+    consoleLog("Skipping Zod schemas generation");
+  }
   if (config.withShield !== false) {
     consoleLog("Generating tRPC Shield");
     const shieldOutputDir = joinPaths(outputDir, "shield");
@@ -10390,7 +11594,7 @@ async function generate(options) {
   }
   consoleLog(`Generating tRPC source code for ${models.length} models`);
   resolveModelsComments(models, hiddenModels);
-  const createRouter = project.createSourceFile(path4.resolve(outputDir, "routers", "helpers", "createRouter.ts"), void 0, {
+  const createRouter = project.createSourceFile(path6.resolve(outputDir, "routers", "helpers", "createRouter.ts"), void 0, {
     overwrite: true
   });
   consoleLog("Generating tRPC imports");
@@ -10403,7 +11607,7 @@ async function generate(options) {
   createRouter.formatText({
     indentSize: 2
   });
-  const appRouter = project.createSourceFile(path4.resolve(outputDir, "routers", `index.ts`), void 0, {
+  const appRouter = project.createSourceFile(path6.resolve(outputDir, "routers", `index.ts`), void 0, {
     overwrite: true
   });
   consoleLog("Generating tRPC router imports");
@@ -10425,7 +11629,7 @@ async function generate(options) {
     const plural = (0, import_pluralize.default)(model.toLowerCase());
     consoleLog(`Generating tRPC router for model ${model}`);
     generateRouterImport(appRouter, plural, model);
-    const modelRouter = project.createSourceFile(path4.resolve(outputDir, "routers", `${model}.router.ts`), void 0, {
+    const modelRouter = project.createSourceFile(path6.resolve(outputDir, "routers", `${model}.router.ts`), void 0, {
       overwrite: true
     });
     generateCreateRouterImport({