@stryke/prisma-trpc-generator 0.2.12 → 0.2.13

package/dist/generator.js

@@ -673,1568 +673,6 @@ var require_pluralize = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/helpers/comments-helpers.js
-var require_comments_helpers = __commonJS({
-  "../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/helpers/comments-helpers.js"(exports) {
-    "use strict";
-    init_esm_shims();
-    Object.defineProperty(exports, "__esModule", {
-      value: true
-    });
-    exports.hideInputObjectTypesAndRelatedFields = exports.resolveModelsComments = void 0;
-    var modelAttributeRegex = /(@@Gen\.)+([A-z])+(\()+(.+)+(\))+/;
-    var attributeNameRegex = /(?:\.)+([A-Za-z])+(?:\()+/;
-    var attributeArgsRegex = /(?:\()+([A-Za-z])+\:+(.+)+(?:\))+/;
-    function resolveModelsComments2(models, modelOperations, enumTypes, hiddenModels, hiddenFields) {
-      models = collectHiddenModels(models, hiddenModels);
-      collectHiddenFields(models, hiddenModels, hiddenFields);
-      hideModelOperations(models, modelOperations);
-      hideEnums(enumTypes, hiddenModels);
-    }
-    __name(resolveModelsComments2, "resolveModelsComments");
-    exports.resolveModelsComments = resolveModelsComments2;
-    function collectHiddenModels(models, hiddenModels) {
-      return models.map((model) => {
-        var _a, _b, _c, _d, _e, _f;
-        if (model.documentation) {
-          const attribute = (_b = (_a = model.documentation) === null || _a === void 0 ? void 0 : _a.match(modelAttributeRegex)) === null || _b === void 0 ? void 0 : _b[0];
-          const attributeName = (_d = (_c = attribute === null || attribute === void 0 ? void 0 : attribute.match(attributeNameRegex)) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.slice(1, -1);
-          if (attributeName !== "model") model;
-          const rawAttributeArgs = (_f = (_e = attribute === null || attribute === void 0 ? void 0 : attribute.match(attributeArgsRegex)) === null || _e === void 0 ? void 0 : _e[0]) === null || _f === void 0 ? void 0 : _f.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 hideInputObjectTypesAndRelatedFields(inputObjectTypes, hiddenModels, hiddenFields) {
-      var _a, _b, _c, _d;
-      let j = inputObjectTypes.length;
-      while (j >= 0) {
-        --j;
-        const inputType = inputObjectTypes[j];
-        if (inputType && (hiddenModels.includes((_a = inputType === null || inputType === void 0 ? void 0 : inputType.meta) === null || _a === void 0 ? void 0 : _a.source) || hiddenModels.find((model) => inputType.name.startsWith(model)))) {
-          inputObjectTypes.splice(j, 1);
-        } else {
-          let k = (_c = (_b = inputType === null || inputType === void 0 ? void 0 : inputType.fields) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0;
-          while (k >= 0) {
-            --k;
-            const field = (_d = inputType === null || inputType === void 0 ? void 0 : inputType.fields) === null || _d === void 0 ? void 0 : _d[k];
-            if (field && hiddenFields.includes(field.name)) {
-              inputObjectTypes[j].fields.splice(k, 1);
-            }
-          }
-        }
-      }
-    }
-    __name(hideInputObjectTypesAndRelatedFields, "hideInputObjectTypesAndRelatedFields");
-    exports.hideInputObjectTypesAndRelatedFields = hideInputObjectTypesAndRelatedFields;
-  }
-});
-
-// ../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/helpers/aggregate-helpers.js
-var require_aggregate_helpers = __commonJS({
-  "../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/helpers/aggregate-helpers.js"(exports) {
-    "use strict";
-    init_esm_shims();
-    Object.defineProperty(exports, "__esModule", {
-      value: true
-    });
-    exports.resolveAggregateOperationSupport = exports.addMissingInputObjectTypesForAggregate = exports.isAggregateInputType = void 0;
-    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");
-    exports.isAggregateInputType = 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");
-    exports.addMissingInputObjectTypesForAggregate = addMissingInputObjectTypesForAggregate;
-    function resolveAggregateOperationSupport(inputObjectTypes) {
-      const aggregateOperationSupport = {};
-      for (const inputType of inputObjectTypes) {
-        if ((0, exports.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(resolveAggregateOperationSupport, "resolveAggregateOperationSupport");
-    exports.resolveAggregateOperationSupport = resolveAggregateOperationSupport;
-  }
-});
-
-// ../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/utils/formatFile.js
-var require_formatFile = __commonJS({
-  "../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/utils/formatFile.js"(exports) {
-    "use strict";
-    init_esm_shims();
-    var __importDefault = exports && exports.__importDefault || function(mod) {
-      return mod && mod.__esModule ? mod : {
-        "default": mod
-      };
-    };
-    Object.defineProperty(exports, "__esModule", {
-      value: true
-    });
-    exports.formatFile = void 0;
-    var prettier_1 = __importDefault(__require("prettier"));
-    var formatFile2 = /* @__PURE__ */ __name((content) => {
-      return new Promise((res, rej) => prettier_1.default.resolveConfig(process.cwd()).then((options) => {
-        let formatOptions = options;
-        if (!options) {
-          formatOptions = {
-            trailingComma: "all",
-            tabWidth: 2,
-            printWidth: 80,
-            bracketSpacing: true,
-            semi: true,
-            singleQuote: true,
-            useTabs: false
-          };
-        }
-        try {
-          const formatted = prettier_1.default.format(content, {
-            ...formatOptions,
-            parser: "typescript"
-          });
-          res(formatted);
-        } catch (error) {
-          rej(error);
-        }
-      }));
-    }, "formatFile");
-    exports.formatFile = formatFile2;
-  }
-});
-
-// ../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/utils/writeIndexFile.js
-var require_writeIndexFile = __commonJS({
-  "../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/utils/writeIndexFile.js"(exports) {
-    "use strict";
-    init_esm_shims();
-    var __importDefault = exports && exports.__importDefault || function(mod) {
-      return mod && mod.__esModule ? mod : {
-        "default": mod
-      };
-    };
-    Object.defineProperty(exports, "__esModule", {
-      value: true
-    });
-    exports.writeIndexFile = exports.addIndexExport = void 0;
-    var path_1 = __importDefault(__require("path"));
-    var writeFileSafely_1 = require_writeFileSafely();
-    var indexExports = /* @__PURE__ */ new Set();
-    var addIndexExport = /* @__PURE__ */ __name((filePath) => {
-      indexExports.add(filePath);
-    }, "addIndexExport");
-    exports.addIndexExport = addIndexExport;
-    function normalizePath(path7) {
-      if (typeof path7 !== "string") {
-        throw new TypeError("Expected argument path to be a string");
-      }
-      if (path7 === "\\" || path7 === "/") return "/";
-      let len = path7.length;
-      if (len <= 1) return path7;
-      let prefix = "";
-      if (len > 4 && path7[3] === "\\") {
-        let ch = path7[2];
-        if ((ch === "?" || ch === ".") && path7.slice(0, 2) === "\\\\") {
-          path7 = path7.slice(2);
-          prefix = "//";
-        }
-      }
-      let segs = path7.split(/[/\\]+/);
-      return prefix + segs.join("/");
-    }
-    __name(normalizePath, "normalizePath");
-    var writeIndexFile = /* @__PURE__ */ __name(async (indexPath) => {
-      const rows = Array.from(indexExports).map((filePath) => {
-        let relativePath = path_1.default.relative(path_1.default.dirname(indexPath), filePath);
-        if (relativePath.endsWith(".ts")) {
-          relativePath = relativePath.slice(0, relativePath.lastIndexOf(".ts"));
-        }
-        const normalized = normalizePath(relativePath);
-        return `export * from './${normalized}'`;
-      });
-      const content = rows.join("\n");
-      await (0, writeFileSafely_1.writeFileSafely)(indexPath, content, false);
-    }, "writeIndexFile");
-    exports.writeIndexFile = writeIndexFile;
-  }
-});
-
-// ../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/utils/writeFileSafely.js
-var require_writeFileSafely = __commonJS({
-  "../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/utils/writeFileSafely.js"(exports) {
-    "use strict";
-    init_esm_shims();
-    var __importDefault = exports && exports.__importDefault || function(mod) {
-      return mod && mod.__esModule ? mod : {
-        "default": mod
-      };
-    };
-    Object.defineProperty(exports, "__esModule", {
-      value: true
-    });
-    exports.writeFileSafely = void 0;
-    var fs_1 = __importDefault(__require("fs"));
-    var path_1 = __importDefault(__require("path"));
-    var formatFile_1 = require_formatFile();
-    var writeIndexFile_1 = require_writeIndexFile();
-    var writeFileSafely2 = /* @__PURE__ */ __name(async (writeLocation, content, addToIndex = true) => {
-      fs_1.default.mkdirSync(path_1.default.dirname(writeLocation), {
-        recursive: true
-      });
-      fs_1.default.writeFileSync(writeLocation, await (0, formatFile_1.formatFile)(content));
-      if (addToIndex) {
-        (0, writeIndexFile_1.addIndexExport)(writeLocation);
-      }
-    }, "writeFileSafely");
-    exports.writeFileSafely = writeFileSafely2;
-  }
-});
-
-// ../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/transformer.js
-var require_transformer = __commonJS({
-  "../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/transformer.js"(exports) {
-    "use strict";
-    init_esm_shims();
-    var __importDefault = exports && exports.__importDefault || function(mod) {
-      return mod && mod.__esModule ? mod : {
-        "default": mod
-      };
-    };
-    Object.defineProperty(exports, "__esModule", {
-      value: true
-    });
-    var path_1 = __importDefault(__require("path"));
-    var helpers_1 = require_helpers2();
-    var aggregate_helpers_1 = require_aggregate_helpers();
-    var writeFileSafely_1 = require_writeFileSafely();
-    var writeIndexFile_1 = require_writeIndexFile();
-    var Transformer = class Transformer2 {
-      static {
-        __name(this, "Transformer");
-      }
-      constructor(params) {
-        var _a, _b, _c, _d, _e, _f;
-        this.schemaImports = /* @__PURE__ */ new Set();
-        this.hasJson = false;
-        this.name = (_a = params.name) !== null && _a !== void 0 ? _a : "";
-        this.fields = (_b = params.fields) !== null && _b !== void 0 ? _b : [];
-        this.models = (_c = params.models) !== null && _c !== void 0 ? _c : [];
-        this.modelOperations = (_d = params.modelOperations) !== null && _d !== void 0 ? _d : [];
-        this.aggregateOperationSupport = (_e = params.aggregateOperationSupport) !== null && _e !== void 0 ? _e : {};
-        this.enumTypes = (_f = params.enumTypes) !== null && _f !== void 0 ? _f : [];
-      }
-      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 = path_1.default.join(Transformer2.outputPath, "schemas/index.ts");
-        await (0, writeIndexFile_1.writeIndexFile)(indexPath);
-      }
-      async generateEnumSchemas() {
-        for (const enumType2 of this.enumTypes) {
-          const { name, values } = enumType2;
-          await (0, writeFileSafely_1.writeFileSafely)(path_1.default.join(Transformer2.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 (0, writeFileSafely_1.writeFileSafely)(path_1.default.join(Transformer2.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) {
-        let 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, inputType));
-          } else if (inputType.type === "Int" || inputType.type === "Float" || inputType.type === "Decimal") {
-            result.push(this.wrapWithZodValidators("z.number()", field, inputType));
-          } else if (inputType.type === "BigInt") {
-            result.push(this.wrapWithZodValidators("z.bigint()", field, inputType));
-          } else if (inputType.type === "Boolean") {
-            result.push(this.wrapWithZodValidators("z.boolean()", field, inputType));
-          } else if (inputType.type === "DateTime") {
-            result.push(this.wrapWithZodValidators("z.coerce.date()", field, inputType));
-          } else if (inputType.type === "Json") {
-            this.hasJson = true;
-            result.push(this.wrapWithZodValidators("jsonSchema", field, inputType));
-          } else if (inputType.type === "True") {
-            result.push(this.wrapWithZodValidators("z.literal(true)", field, inputType));
-          } else if (inputType.type === "Bytes") {
-            result.push(this.wrapWithZodValidators("z.instanceof(Buffer)", field, inputType));
-          } 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, inputType, 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, inputType) {
-        let line = "";
-        line = mainValidator;
-        if (inputType.isList) {
-          line += ".array()";
-        }
-        if (!field.isRequired) {
-          line += ".optional()";
-        }
-        return line;
-      }
-      addSchemaImport(name) {
-        this.schemaImports.add(name);
-      }
-      generatePrismaStringLine(field, inputType, inputsLength) {
-        const isEnum = inputType.location === "enumTypes";
-        const { isModelQueryType, modelName, queryName } = this.checkIsModelQueryType(inputType.type);
-        let objectSchemaLine = isModelQueryType ? this.resolveModelQuerySchemaName(modelName, queryName) : `${inputType.type}ObjectSchema`;
-        let enumSchemaLine = `${inputType.type}Schema`;
-        const schema = inputType.type === this.name ? objectSchemaLine : isEnum ? enumSchemaLine : objectSchemaLine;
-        const arr = inputType.isList ? ".array()" : "";
-        const opt = !field.isRequired ? ".optional()" : "";
-        return inputsLength === 1 ? `  ${field.name}: z.lazy(() => ${schema})${arr}${opt}` : `z.lazy(() => ${schema})${arr}${opt}`;
-      }
-      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 (Transformer2.provider === "mongodb") {
-          if ((0, helpers_1.isMongodbRawOp)(name)) {
-            name = Transformer2.rawOpsMap[name];
-            exportName = name.replace("Args", "");
-          }
-        }
-        if ((0, aggregate_helpers_1.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 (Transformer2.isCustomPrismaClientOutputPath) {
-          const fromPath = path_1.default.join(Transformer2.outputPath, "schemas", "objects");
-          const toPath = Transformer2.prismaClientOutputPath;
-          const relativePathFromOutputToPrismaClient = path_1.default.relative(fromPath, toPath).split(path_1.default.sep).join(path_1.default.posix.sep);
-          prismaClientImportPath = relativePathFromOutputToPrismaClient;
-        } else {
-          prismaClientImportPath = Transformer2.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 (Transformer2.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 += "  " + zodStringFields;
-        wrapped += "\n";
-        wrapped += "})";
-        return wrapped;
-      }
-      resolveObjectSchemaName() {
-        let name = this.name;
-        let exportName = this.name;
-        if ((0, helpers_1.isMongodbRawOp)(name)) {
-          name = Transformer2.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 = (0, helpers_1.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 (0, writeFileSafely_1.writeFileSafely)(path_1.default.join(Transformer2.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 (0, writeFileSafely_1.writeFileSafely)(path_1.default.join(Transformer2.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 (0, writeFileSafely_1.writeFileSafely)(path_1.default.join(Transformer2.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 (0, writeFileSafely_1.writeFileSafely)(path_1.default.join(Transformer2.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 (0, writeFileSafely_1.writeFileSafely)(path_1.default.join(Transformer2.outputPath, `schemas/${createMany}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}CreateMany`, `z.object({ data: z.union([ ${modelName}CreateManyInputObjectSchema, z.array(${modelName}CreateManyInputObjectSchema) ]), ${Transformer2.provider === "mongodb" || Transformer2.provider === "sqlserver" ? "" : "skipDuplicates: z.boolean().optional()"} })`)}`);
-          }
-          if (deleteOne) {
-            const imports = [
-              selectImport,
-              includeImport,
-              `import { ${modelName}WhereUniqueInputObjectSchema } from './objects/${modelName}WhereUniqueInput.schema'`
-            ];
-            await (0, writeFileSafely_1.writeFileSafely)(path_1.default.join(Transformer2.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 (0, writeFileSafely_1.writeFileSafely)(path_1.default.join(Transformer2.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 (0, writeFileSafely_1.writeFileSafely)(path_1.default.join(Transformer2.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 (0, writeFileSafely_1.writeFileSafely)(path_1.default.join(Transformer2.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 (0, writeFileSafely_1.writeFileSafely)(path_1.default.join(Transformer2.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].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 (0, writeFileSafely_1.writeFileSafely)(path_1.default.join(Transformer2.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 (0, writeFileSafely_1.writeFileSafely)(path_1.default.join(Transformer2.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) {
-        var _a;
-        let generatedImports = this.generateImportZodStatement();
-        generatedImports += (_a = imports === null || imports === void 0 ? void 0 : imports.filter((importItem) => !!importItem).join(";\r\n")) !== null && _a !== void 0 ? _a : "";
-        generatedImports += "\n\n";
-        return generatedImports;
-      }
-      resolveSelectIncludeImportAndZodSchemaLine(model) {
-        const { name: modelName } = model;
-        const hasRelationToAnotherModel = (0, helpers_1.checkModelHasModelRelation)(model);
-        const selectImport = Transformer2.isGenerateSelect ? `import { ${modelName}SelectObjectSchema } from './objects/${modelName}Select.schema'` : "";
-        const includeImport = Transformer2.isGenerateInclude && hasRelationToAnotherModel ? `import { ${modelName}IncludeObjectSchema } from './objects/${modelName}Include.schema'` : "";
-        let selectZodSchemaLine = "";
-        let includeZodSchemaLine = "";
-        let selectZodSchemaLineLazy = "";
-        let includeZodSchemaLineLazy = "";
-        if (Transformer2.isGenerateSelect) {
-          const zodSelectObjectSchema = `${modelName}SelectObjectSchema.optional()`;
-          selectZodSchemaLine = `select: ${zodSelectObjectSchema},`;
-          selectZodSchemaLineLazy = `select: z.lazy(() => ${zodSelectObjectSchema}),`;
-        }
-        if (Transformer2.isGenerateInclude && hasRelationToAnotherModel) {
-          const zodIncludeObjectSchema = `${modelName}IncludeObjectSchema.optional()`;
-          includeZodSchemaLine = `include: ${zodIncludeObjectSchema},`;
-          includeZodSchemaLineLazy = `include: z.lazy(() => ${zodIncludeObjectSchema}),`;
-        }
-        return {
-          selectImport,
-          includeImport,
-          selectZodSchemaLine,
-          includeZodSchemaLine,
-          selectZodSchemaLineLazy,
-          includeZodSchemaLineLazy
-        };
-      }
-      resolveOrderByWithRelationImportAndZodSchemaLine(model) {
-        var _a;
-        const { name: modelName } = model;
-        let modelOrderBy = "";
-        if ([
-          "postgresql",
-          "mysql"
-        ].includes(Transformer2.provider) && ((_a = Transformer2.previewFeatures) === null || _a === void 0 ? void 0 : _a.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
-        };
-      }
-    };
-    exports.default = Transformer;
-    Transformer.enumNames = [];
-    Transformer.rawOpsMap = {};
-    Transformer.outputPath = "./generated";
-    Transformer.prismaClientOutputPath = "@prisma/client";
-    Transformer.isCustomPrismaClientOutputPath = false;
-    Transformer.isGenerateSelect = false;
-    Transformer.isGenerateInclude = false;
-  }
-});
-
-// ../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/helpers/model-helpers.js
-var require_model_helpers = __commonJS({
-  "../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/helpers/model-helpers.js"(exports) {
-    "use strict";
-    init_esm_shims();
-    Object.defineProperty(exports, "__esModule", {
-      value: true
-    });
-    exports.findModelByName = exports.checkIsManyModelRelationField = exports.checkIsModelRelationField = exports.checkModelHasManyModelRelation = exports.checkModelHasModelRelation = void 0;
-    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");
-    exports.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");
-    exports.checkModelHasManyModelRelation = checkModelHasManyModelRelation;
-    function checkIsModelRelationField(modelField) {
-      const { kind, relationName } = modelField;
-      return kind === "object" && !!relationName;
-    }
-    __name(checkIsModelRelationField, "checkIsModelRelationField");
-    exports.checkIsModelRelationField = checkIsModelRelationField;
-    function checkIsManyModelRelationField(modelField) {
-      return checkIsModelRelationField(modelField) && modelField.isList;
-    }
-    __name(checkIsManyModelRelationField, "checkIsManyModelRelationField");
-    exports.checkIsManyModelRelationField = checkIsManyModelRelationField;
-    function findModelByName(models, modelName) {
-      return models.find(({ name }) => name === modelName);
-    }
-    __name(findModelByName, "findModelByName");
-    exports.findModelByName = findModelByName;
-  }
-});
-
-// ../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/helpers/include-helpers.js
-var require_include_helpers = __commonJS({
-  "../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/helpers/include-helpers.js"(exports) {
-    "use strict";
-    init_esm_shims();
-    Object.defineProperty(exports, "__esModule", {
-      value: true
-    });
-    exports.addMissingInputObjectTypesForInclude = void 0;
-    var model_helpers_1 = require_model_helpers();
-    function addMissingInputObjectTypesForInclude(inputObjectTypes, models, isGenerateSelect) {
-      const generatedIncludeInputObjectTypes = generateModelIncludeInputObjectTypes(models, isGenerateSelect);
-      for (const includeInputObjectType of generatedIncludeInputObjectTypes) {
-        inputObjectTypes.push(includeInputObjectType);
-      }
-    }
-    __name(addMissingInputObjectTypesForInclude, "addMissingInputObjectTypesForInclude");
-    exports.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 = (0, model_helpers_1.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 = (0, model_helpers_1.checkModelHasModelRelation)(model);
-        if (!hasRelationToAnotherModel) {
-          continue;
-        }
-        const hasManyRelationToAnotherModel = (0, model_helpers_1.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");
-  }
-});
-
-// ../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/helpers/modelArgs-helpers.js
-var require_modelArgs_helpers = __commonJS({
-  "../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/helpers/modelArgs-helpers.js"(exports) {
-    "use strict";
-    init_esm_shims();
-    Object.defineProperty(exports, "__esModule", {
-      value: true
-    });
-    exports.addMissingInputObjectTypesForModelArgs = void 0;
-    var model_helpers_1 = require_model_helpers();
-    function addMissingInputObjectTypesForModelArgs(inputObjectTypes, models, isGenerateSelect, isGenerateInclude) {
-      const modelArgsInputObjectTypes = generateModelArgsInputObjectTypes(models, isGenerateSelect, isGenerateInclude);
-      for (const modelArgsInputObjectType of modelArgsInputObjectTypes) {
-        inputObjectTypes.push(modelArgsInputObjectType);
-      }
-    }
-    __name(addMissingInputObjectTypesForModelArgs, "addMissingInputObjectTypesForModelArgs");
-    exports.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 = (0, model_helpers_1.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");
-  }
-});
-
-// ../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/helpers/mongodb-helpers.js
-var require_mongodb_helpers = __commonJS({
-  "../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/helpers/mongodb-helpers.js"(exports) {
-    "use strict";
-    init_esm_shims();
-    var __importDefault = exports && exports.__importDefault || function(mod) {
-      return mod && mod.__esModule ? mod : {
-        "default": mod
-      };
-    };
-    Object.defineProperty(exports, "__esModule", {
-      value: true
-    });
-    exports.isMongodbRawOp = exports.addMissingInputObjectTypesForMongoDbRawOpsAndQueries = void 0;
-    var transformer_1 = __importDefault(require_transformer());
-    function addMissingInputObjectTypesForMongoDbRawOpsAndQueries(modelOperations, outputObjectTypes, inputObjectTypes) {
-      const rawOpsMap = resolveMongoDbRawOperations(modelOperations);
-      transformer_1.default.rawOpsMap = rawOpsMap !== null && rawOpsMap !== void 0 ? rawOpsMap : {};
-      const mongoDbRawQueryInputObjectTypes = resolveMongoDbRawQueryInputObjectTypes(outputObjectTypes);
-      for (const mongoDbRawQueryInputType of mongoDbRawQueryInputObjectTypes) {
-        inputObjectTypes.push(mongoDbRawQueryInputType);
-      }
-    }
-    __name(addMissingInputObjectTypesForMongoDbRawOpsAndQueries, "addMissingInputObjectTypesForMongoDbRawOpsAndQueries");
-    exports.addMissingInputObjectTypesForMongoDbRawOpsAndQueries = addMissingInputObjectTypesForMongoDbRawOpsAndQueries;
-    function resolveMongoDbRawOperations(modelOperations) {
-      const rawOpsMap = {};
-      const rawOpsNames = [
-        ...new Set(modelOperations.reduce((result, current) => {
-          const keys = Object.keys(current);
-          keys === null || keys === void 0 ? void 0 : 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) {
-      var _a;
-      const queryOutputTypes = outputObjectTypes.filter((item) => item.name === "Query");
-      const mongodbRawQueries = (_a = queryOutputTypes === null || queryOutputTypes === void 0 ? void 0 : queryOutputTypes[0].fields.filter((field) => field.name.includes("Raw"))) !== null && _a !== void 0 ? _a : [];
-      return mongodbRawQueries;
-    }
-    __name(getMongoDbRawQueries, "getMongoDbRawQueries");
-    var isMongodbRawOp = /* @__PURE__ */ __name((name) => /find([^]*?)Raw/.test(name) || /aggregate([^]*?)Raw/.test(name), "isMongodbRawOp");
-    exports.isMongodbRawOp = isMongodbRawOp;
-  }
-});
-
-// ../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/helpers/select-helpers.js
-var require_select_helpers = __commonJS({
-  "../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/helpers/select-helpers.js"(exports) {
-    "use strict";
-    init_esm_shims();
-    Object.defineProperty(exports, "__esModule", {
-      value: true
-    });
-    exports.addMissingInputObjectTypesForSelect = void 0;
-    var model_helpers_1 = require_model_helpers();
-    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");
-    exports.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 = (0, model_helpers_1.checkIsModelRelationField)(modelField);
-          const field = {
-            name: modelFieldName,
-            isRequired: false,
-            isNullable: false,
-            inputTypes: [
-              {
-                isList: false,
-                type: "Boolean",
-                location: "scalar"
-              }
-            ]
-          };
-          if (isRelationField) {
-            let schemaArgInputType = {
-              isList: false,
-              type: isList ? `${type}FindManyArgs` : `${type}Args`,
-              location: "inputObjectTypes",
-              namespace: "prisma"
-            };
-            field.inputTypes.push(schemaArgInputType);
-          }
-          fields.push(field);
-        }
-        const hasManyRelationToAnotherModel = (0, model_helpers_1.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");
-  }
-});
-
-// ../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/helpers/whereUniqueInput-helpers.js
-var require_whereUniqueInput_helpers = __commonJS({
-  "../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/helpers/whereUniqueInput-helpers.js"(exports) {
-    "use strict";
-    init_esm_shims();
-    Object.defineProperty(exports, "__esModule", {
-      value: true
-    });
-    exports.changeOptionalToRequiredFields = void 0;
-    function changeOptionalToRequiredFields(inputObjectTypes) {
-      inputObjectTypes.map((item) => {
-        var _a;
-        if (item.name.includes("WhereUniqueInput") && ((_a = item.constraints.fields) === null || _a === void 0 ? void 0 : _a.length) > 0) {
-          item.fields = item.fields.map((subItem) => {
-            var _a2;
-            if ((_a2 = item.constraints.fields) === null || _a2 === void 0 ? void 0 : _a2.includes(subItem.name)) {
-              subItem.isRequired = true;
-              return subItem;
-            }
-            return subItem;
-          });
-        }
-        return item;
-      });
-    }
-    __name(changeOptionalToRequiredFields, "changeOptionalToRequiredFields");
-    exports.changeOptionalToRequiredFields = changeOptionalToRequiredFields;
-  }
-});
-
-// ../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/helpers/helpers.js
-var require_helpers = __commonJS({
-  "../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/helpers/helpers.js"(exports) {
-    "use strict";
-    init_esm_shims();
-    var __importDefault = exports && exports.__importDefault || function(mod) {
-      return mod && mod.__esModule ? mod : {
-        "default": mod
-      };
-    };
-    Object.defineProperty(exports, "__esModule", {
-      value: true
-    });
-    exports.resolveAddMissingInputObjectTypeOptions = exports.addMissingInputObjectTypes = void 0;
-    var transformer_1 = __importDefault(require_transformer());
-    var aggregate_helpers_1 = require_aggregate_helpers();
-    var include_helpers_1 = require_include_helpers();
-    var modelArgs_helpers_1 = require_modelArgs_helpers();
-    var mongodb_helpers_1 = require_mongodb_helpers();
-    var select_helpers_1 = require_select_helpers();
-    var whereUniqueInput_helpers_1 = require_whereUniqueInput_helpers();
-    function addMissingInputObjectTypes(inputObjectTypes, outputObjectTypes, models, modelOperations, dataSourceProvider, options) {
-      if (dataSourceProvider === "mongodb") {
-        (0, mongodb_helpers_1.addMissingInputObjectTypesForMongoDbRawOpsAndQueries)(modelOperations, outputObjectTypes, inputObjectTypes);
-      }
-      (0, aggregate_helpers_1.addMissingInputObjectTypesForAggregate)(inputObjectTypes, outputObjectTypes);
-      if (options.isGenerateSelect) {
-        (0, select_helpers_1.addMissingInputObjectTypesForSelect)(inputObjectTypes, outputObjectTypes, models);
-        transformer_1.default.setIsGenerateSelect(true);
-      }
-      if (options.isGenerateSelect || options.isGenerateInclude) {
-        (0, modelArgs_helpers_1.addMissingInputObjectTypesForModelArgs)(inputObjectTypes, models, options.isGenerateSelect, options.isGenerateInclude);
-      }
-      if (options.isGenerateInclude) {
-        (0, include_helpers_1.addMissingInputObjectTypesForInclude)(inputObjectTypes, models, options.isGenerateSelect);
-        transformer_1.default.setIsGenerateInclude(true);
-      }
-      (0, whereUniqueInput_helpers_1.changeOptionalToRequiredFields)(inputObjectTypes);
-    }
-    __name(addMissingInputObjectTypes, "addMissingInputObjectTypes");
-    exports.addMissingInputObjectTypes = addMissingInputObjectTypes;
-    function resolveAddMissingInputObjectTypeOptions(generatorConfigOptions) {
-      return {
-        isGenerateSelect: generatorConfigOptions.isGenerateSelect === "true",
-        isGenerateInclude: generatorConfigOptions.isGenerateInclude === "true"
-      };
-    }
-    __name(resolveAddMissingInputObjectTypeOptions, "resolveAddMissingInputObjectTypeOptions");
-    exports.resolveAddMissingInputObjectTypeOptions = resolveAddMissingInputObjectTypeOptions;
-  }
-});
-
-// ../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/helpers/index.js
-var require_helpers2 = __commonJS({
-  "../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/helpers/index.js"(exports) {
-    "use strict";
-    init_esm_shims();
-    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      var desc = Object.getOwnPropertyDescriptor(m, k);
-      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-        desc = {
-          enumerable: true,
-          get: /* @__PURE__ */ __name(function() {
-            return m[k];
-          }, "get")
-        };
-      }
-      Object.defineProperty(o, k2, desc);
-    } : function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      o[k2] = m[k];
-    });
-    var __exportStar = exports && exports.__exportStar || function(m, exports1) {
-      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports1, p)) __createBinding(exports1, m, p);
-    };
-    Object.defineProperty(exports, "__esModule", {
-      value: true
-    });
-    __exportStar(require_comments_helpers(), exports);
-    __exportStar(require_helpers(), exports);
-    __exportStar(require_model_helpers(), exports);
-    __exportStar(require_mongodb_helpers(), exports);
-    __exportStar(require_whereUniqueInput_helpers(), exports);
-  }
-});
-
-// ../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/utils/removeDir.js
-var require_removeDir = __commonJS({
-  "../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/utils/removeDir.js"(exports) {
-    "use strict";
-    init_esm_shims();
-    var __importDefault = exports && exports.__importDefault || function(mod) {
-      return mod && mod.__esModule ? mod : {
-        "default": mod
-      };
-    };
-    Object.defineProperty(exports, "__esModule", {
-      value: true
-    });
-    var path_1 = __importDefault(__require("path"));
-    var fs_1 = __require("fs");
-    async function removeDir2(dirPath, onlyContent) {
-      const dirEntries = await fs_1.promises.readdir(dirPath, {
-        withFileTypes: true
-      });
-      await Promise.all(dirEntries.map(async (dirEntry) => {
-        const fullPath = path_1.default.join(dirPath, dirEntry.name);
-        return dirEntry.isDirectory() ? await removeDir2(fullPath, false) : await fs_1.promises.unlink(fullPath);
-      }));
-      if (!onlyContent) {
-        await fs_1.promises.rmdir(dirPath);
-      }
-    }
-    __name(removeDir2, "removeDir");
-    exports.default = removeDir2;
-  }
-});
-
-// ../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/prisma-generator.js
-var require_prisma_generator = __commonJS({
-  "../../node_modules/.pnpm/prisma-zod-generator@0.8.13/node_modules/prisma-zod-generator/lib/prisma-generator.js"(exports) {
-    "use strict";
-    init_esm_shims();
-    var __importDefault = exports && exports.__importDefault || function(mod) {
-      return mod && mod.__esModule ? mod : {
-        "default": mod
-      };
-    };
-    Object.defineProperty(exports, "__esModule", {
-      value: true
-    });
-    exports.generate = void 0;
-    var internals_1 = __require("@prisma/internals");
-    var fs_1 = __require("fs");
-    var helpers_1 = require_helpers2();
-    var aggregate_helpers_1 = require_aggregate_helpers();
-    var transformer_1 = __importDefault(require_transformer());
-    var removeDir_1 = __importDefault(require_removeDir());
-    async function generate2(options) {
-      var _a, _b;
-      try {
-        await handleGeneratorOutputValue(options.generator.output);
-        const prismaClientGeneratorConfig = getGeneratorConfigByProvider(options.otherGenerators, "prisma-client-js");
-        const prismaClientDmmf = await (0, internals_1.getDMMF)({
-          datamodel: options.datamodel,
-          previewFeatures: prismaClientGeneratorConfig === null || prismaClientGeneratorConfig === void 0 ? void 0 : prismaClientGeneratorConfig.previewFeatures
-        });
-        checkForCustomPrismaClientOutputPath(prismaClientGeneratorConfig);
-        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 = [];
-        (0, helpers_1.resolveModelsComments)(models, modelOperations, enumTypes, hiddenModels, hiddenFields);
-        await generateEnumSchemas(prismaClientDmmf.schema.enumTypes.prisma, (_a = prismaClientDmmf.schema.enumTypes.model) !== null && _a !== void 0 ? _a : []);
-        const dataSource = (_b = options.datasources) === null || _b === void 0 ? void 0 : _b[0];
-        const previewFeatures = prismaClientGeneratorConfig === null || prismaClientGeneratorConfig === void 0 ? void 0 : prismaClientGeneratorConfig.previewFeatures;
-        transformer_1.default.provider = dataSource.provider;
-        transformer_1.default.previewFeatures = previewFeatures;
-        const generatorConfigOptions = options.generator.config;
-        const addMissingInputObjectTypeOptions = (0, helpers_1.resolveAddMissingInputObjectTypeOptions)(generatorConfigOptions);
-        (0, helpers_1.addMissingInputObjectTypes)(inputObjectTypes, outputObjectTypes, models, modelOperations, dataSource.provider, addMissingInputObjectTypeOptions);
-        const aggregateOperationSupport = (0, aggregate_helpers_1.resolveAggregateOperationSupport)(inputObjectTypes);
-        (0, helpers_1.hideInputObjectTypesAndRelatedFields)(inputObjectTypes, hiddenModels, hiddenFields);
-        await generateObjectSchemas(inputObjectTypes);
-        await generateModelSchemas(models, modelOperations, aggregateOperationSupport);
-        await generateIndex();
-      } catch (error) {
-        console.error(error);
-      }
-    }
-    __name(generate2, "generate");
-    exports.generate = generate2;
-    async function handleGeneratorOutputValue(generatorOutputValue) {
-      const outputDirectoryPath = (0, internals_1.parseEnvValue)(generatorOutputValue);
-      await fs_1.promises.mkdir(outputDirectoryPath, {
-        recursive: true
-      });
-      const isRemoveContentsOnly = true;
-      await (0, removeDir_1.default)(outputDirectoryPath, isRemoveContentsOnly);
-      transformer_1.default.setOutputPath(outputDirectoryPath);
-    }
-    __name(handleGeneratorOutputValue, "handleGeneratorOutputValue");
-    function getGeneratorConfigByProvider(generators, provider2) {
-      return generators.find((it) => (0, internals_1.parseEnvValue)(it.provider) === provider2);
-    }
-    __name(getGeneratorConfigByProvider, "getGeneratorConfigByProvider");
-    function checkForCustomPrismaClientOutputPath(prismaClientGeneratorConfig) {
-      var _a;
-      if (prismaClientGeneratorConfig === null || prismaClientGeneratorConfig === void 0 ? void 0 : prismaClientGeneratorConfig.isCustomOutput) {
-        transformer_1.default.setPrismaClientOutputPath((_a = prismaClientGeneratorConfig.output) === null || _a === void 0 ? void 0 : _a.value);
-      }
-    }
-    __name(checkForCustomPrismaClientOutputPath, "checkForCustomPrismaClientOutputPath");
-    async function generateEnumSchemas(prismaSchemaEnum, modelSchemaEnum) {
-      const enumTypes = [
-        ...prismaSchemaEnum,
-        ...modelSchemaEnum
-      ];
-      const enumNames = enumTypes.map((enumItem) => enumItem.name);
-      transformer_1.default.enumNames = enumNames !== null && enumNames !== void 0 ? enumNames : [];
-      const transformer = new transformer_1.default({
-        enumTypes
-      });
-      await transformer.generateEnumSchemas();
-    }
-    __name(generateEnumSchemas, "generateEnumSchemas");
-    async function generateObjectSchemas(inputObjectTypes) {
-      var _a, _b;
-      for (let i = 0; i < inputObjectTypes.length; i += 1) {
-        const fields = (_a = inputObjectTypes[i]) === null || _a === void 0 ? void 0 : _a.fields;
-        const name = (_b = inputObjectTypes[i]) === null || _b === void 0 ? void 0 : _b.name;
-        const transformer = new transformer_1.default({
-          name,
-          fields
-        });
-        await transformer.generateObjectSchema();
-      }
-    }
-    __name(generateObjectSchemas, "generateObjectSchemas");
-    async function generateModelSchemas(models, modelOperations, aggregateOperationSupport) {
-      const transformer = new transformer_1.default({
-        models,
-        modelOperations,
-        aggregateOperationSupport
-      });
-      await transformer.generateModelSchemas();
-    }
-    __name(generateModelSchemas, "generateModelSchemas");
-    async function generateIndex() {
-      await transformer_1.default.generateIndex();
-    }
-    __name(generateIndex, "generateIndex");
-  }
-});
-
 // ../../node_modules/.pnpm/@dotenvx+dotenvx@1.35.0/node_modules/@dotenvx/dotenvx/package.json
 var require_package = __commonJS({
   "../../node_modules/.pnpm/@dotenvx+dotenvx@1.35.0/node_modules/@dotenvx/dotenvx/package.json"(exports, module) {
@@ -15718,7 +14156,6 @@ init_esm_shims();
 // src/prisma-generator.ts
 init_esm_shims();
 var import_pluralize = __toESM(require_pluralize(), 1);
-var import_prisma_generator = __toESM(require_prisma_generator(), 1);
 import { promises as fs4 } from "node:fs";
 import path6 from "node:path";
 
@@ -19982,7 +18419,10 @@ var configSchema = z.object({
 // src/helpers.ts
 init_esm_shims();
 
-// src/utils/getPrismaInternals.ts
+// src/utils/get-prisma-internals.ts
+init_esm_shims();
+
+// src/utils/get-jiti.ts
 init_esm_shims();
 
 // ../env/src/index.ts
@@ -23346,7 +21786,7 @@ __name(detectRuntime, "detectRuntime");
 var runtimeInfo = detectRuntime();
 var runtime = runtimeInfo?.name || "";
 
-// src/utils/getPrismaInternals.ts
+// src/utils/get-jiti.ts
 import { createJiti } from "jiti";
 var jiti;
 function getJiti() {
@@ -23360,6 +21800,8 @@ function getJiti() {
   return jiti;
 }
 __name(getJiti, "getJiti");
+
+// src/utils/get-prisma-internals.ts
 async function getPrismaInternals() {
   return getJiti().import(getJiti().esmResolve("@prisma/internals"));
 }
@@ -23369,7 +21811,7 @@ async function getPrismaGeneratorHelper() {
 }
 __name(getPrismaGeneratorHelper, "getPrismaGeneratorHelper");
 
-// src/utils/getRelativePath.ts
+// src/utils/get-relative-path.ts
 init_esm_shims();
 import path2 from "node:path";
 function getRelativePath(outputPath, filePath, isOutsideOutputPath, schemaPath) {
@@ -23385,7 +21827,7 @@ function getRelativePath(outputPath, filePath, isOutsideOutputPath, schemaPath)
 }
 __name(getRelativePath, "getRelativePath");
 
-// src/utils/uncapitalizeFirstLetter.ts
+// src/utils/uncapitalize-first-letter.ts
 init_esm_shims();
 var uncapitalizeFirstLetter = /* @__PURE__ */ __name((str) => {
   return str.charAt(0).toLowerCase() + str.slice(1);
@@ -23750,7 +22192,7 @@ init_esm_shims();
 import { promises as fs3 } from "node:fs";
 import path5 from "node:path";
 
-// src/utils/removeDir.ts
+// src/utils/remove-dir.ts
 init_esm_shims();
 import { promises as fs } from "node:fs";
 import path3 from "node:path";
@@ -23768,12 +22210,12 @@ async function removeDir(dirPath, onlyContent) {
 }
 __name(removeDir, "removeDir");
 
-// src/utils/writeFileSafely.ts
+// src/utils/write-file-safely.ts
 init_esm_shims();
 import fs2 from "node:fs";
 import path4 from "node:path";
 
-// src/utils/formatFile.ts
+// src/utils/format-file.ts
 init_esm_shims();
 import prettier from "prettier";
 async function formatFile(content) {
@@ -23798,7 +22240,7 @@ async function formatFile(content) {
 }
 __name(formatFile, "formatFile");
 
-// src/utils/writeFileSafely.ts
+// src/utils/write-file-safely.ts
 var writeFileSafely = /* @__PURE__ */ __name(async (writeLocation, content) => {
   fs2.mkdirSync(path4.dirname(writeLocation), {
     recursive: true
@@ -23889,7 +22331,8 @@ async function generate(options) {
   });
   await removeDir(outputDir, true);
   if (config.withZod !== false) {
-    await (0, import_prisma_generator.generate)(options);
+    const prismaZodGenerator = await getJiti().import(getJiti().esmResolve("prisma-zod-generator/lib/prisma-generator"));
+    await prismaZodGenerator.generate(options);
   }
   if (config.withShield !== false) {
     const shieldOutputPath = path6.join(outputDir, "./shield");
@@ -23898,6 +22341,7 @@ async function generate(options) {
       generator: {
         ...options.generator,
         output: {
+          fromEnvVar: null,
           ...options.generator.output,
           value: shieldOutputPath
         },