@stryke/prisma-trpc-generator 0.13.26 → 0.13.34

package/dist/index.cjs

@@ -1,2728 +1,50 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// ../../node_modules/.pnpm/tsup@8.5.1_@microsoft+api-extractor@7.55.1_@types+node@24.10.1__@swc+core@1.15.3_@swc+h_88727a58a5077acdeb714aa851988eef/node_modules/tsup/assets/cjs_shims.js
-var init_cjs_shims = __esm({
-  "../../node_modules/.pnpm/tsup@8.5.1_@microsoft+api-extractor@7.55.1_@types+node@24.10.1__@swc+core@1.15.3_@swc+h_88727a58a5077acdeb714aa851988eef/node_modules/tsup/assets/cjs_shims.js"() {
-    "use strict";
-  }
-});
-
-// ../../node_modules/.pnpm/pluralize@8.0.0/node_modules/pluralize/pluralize.js
-var require_pluralize = __commonJS({
-  "../../node_modules/.pnpm/pluralize@8.0.0/node_modules/pluralize/pluralize.js"(exports2, module2) {
-    "use strict";
-    init_cjs_shims();
-    (function(root, pluralize2) {
-      if (typeof require === "function" && typeof exports2 === "object" && typeof module2 === "object") {
-        module2.exports = pluralize2();
-      } else if (typeof define === "function" && define.amd) {
-        define(function() {
-          return pluralize2();
-        });
-      } else {
-        root.pluralize = pluralize2();
-      }
-    })(exports2, function() {
-      var pluralRules = [];
-      var singularRules = [];
-      var uncountables = {};
-      var irregularPlurals = {};
-      var irregularSingles = {};
-      function sanitizeRule(rule) {
-        if (typeof rule === "string") {
-          return new RegExp("^" + rule + "$", "i");
-        }
-        return rule;
-      }
-      __name(sanitizeRule, "sanitizeRule");
-      function restoreCase(word, token) {
-        if (word === token) return token;
-        if (word === word.toLowerCase()) return token.toLowerCase();
-        if (word === word.toUpperCase()) return token.toUpperCase();
-        if (word[0] === word[0].toUpperCase()) {
-          return token.charAt(0).toUpperCase() + token.substr(1).toLowerCase();
-        }
-        return token.toLowerCase();
-      }
-      __name(restoreCase, "restoreCase");
-      function interpolate(str, args) {
-        return str.replace(/\$(\d{1,2})/g, function(match, index) {
-          return args[index] || "";
-        });
-      }
-      __name(interpolate, "interpolate");
-      function replace(word, rule) {
-        return word.replace(rule[0], function(match, index) {
-          var result = interpolate(rule[1], arguments);
-          if (match === "") {
-            return restoreCase(word[index - 1], result);
-          }
-          return restoreCase(match, result);
-        });
-      }
-      __name(replace, "replace");
-      function sanitizeWord(token, word, rules) {
-        if (!token.length || uncountables.hasOwnProperty(token)) {
-          return word;
-        }
-        var len = rules.length;
-        while (len--) {
-          var rule = rules[len];
-          if (rule[0].test(word)) return replace(word, rule);
-        }
-        return word;
-      }
-      __name(sanitizeWord, "sanitizeWord");
-      function replaceWord(replaceMap, keepMap, rules) {
-        return function(word) {
-          var token = word.toLowerCase();
-          if (keepMap.hasOwnProperty(token)) {
-            return restoreCase(word, token);
-          }
-          if (replaceMap.hasOwnProperty(token)) {
-            return restoreCase(word, replaceMap[token]);
-          }
-          return sanitizeWord(token, word, rules);
-        };
-      }
-      __name(replaceWord, "replaceWord");
-      function checkWord(replaceMap, keepMap, rules, bool) {
-        return function(word) {
-          var token = word.toLowerCase();
-          if (keepMap.hasOwnProperty(token)) return true;
-          if (replaceMap.hasOwnProperty(token)) return false;
-          return sanitizeWord(token, token, rules) === token;
-        };
-      }
-      __name(checkWord, "checkWord");
-      function pluralize2(word, count, inclusive) {
-        var pluralized = count === 1 ? pluralize2.singular(word) : pluralize2.plural(word);
-        return (inclusive ? count + " " : "") + pluralized;
-      }
-      __name(pluralize2, "pluralize");
-      pluralize2.plural = replaceWord(irregularSingles, irregularPlurals, pluralRules);
-      pluralize2.isPlural = checkWord(irregularSingles, irregularPlurals, pluralRules);
-      pluralize2.singular = replaceWord(irregularPlurals, irregularSingles, singularRules);
-      pluralize2.isSingular = checkWord(irregularPlurals, irregularSingles, singularRules);
-      pluralize2.addPluralRule = function(rule, replacement) {
-        pluralRules.push([
-          sanitizeRule(rule),
-          replacement
-        ]);
-      };
-      pluralize2.addSingularRule = function(rule, replacement) {
-        singularRules.push([
-          sanitizeRule(rule),
-          replacement
-        ]);
-      };
-      pluralize2.addUncountableRule = function(word) {
-        if (typeof word === "string") {
-          uncountables[word.toLowerCase()] = true;
-          return;
-        }
-        pluralize2.addPluralRule(word, "$0");
-        pluralize2.addSingularRule(word, "$0");
-      };
-      pluralize2.addIrregularRule = function(single, plural) {
-        plural = plural.toLowerCase();
-        single = single.toLowerCase();
-        irregularSingles[single] = plural;
-        irregularPlurals[plural] = single;
-      };
-      [
-        // Pronouns.
-        [
-          "I",
-          "we"
-        ],
-        [
-          "me",
-          "us"
-        ],
-        [
-          "he",
-          "they"
-        ],
-        [
-          "she",
-          "they"
-        ],
-        [
-          "them",
-          "them"
-        ],
-        [
-          "myself",
-          "ourselves"
-        ],
-        [
-          "yourself",
-          "yourselves"
-        ],
-        [
-          "itself",
-          "themselves"
-        ],
-        [
-          "herself",
-          "themselves"
-        ],
-        [
-          "himself",
-          "themselves"
-        ],
-        [
-          "themself",
-          "themselves"
-        ],
-        [
-          "is",
-          "are"
-        ],
-        [
-          "was",
-          "were"
-        ],
-        [
-          "has",
-          "have"
-        ],
-        [
-          "this",
-          "these"
-        ],
-        [
-          "that",
-          "those"
-        ],
-        // Words ending in with a consonant and `o`.
-        [
-          "echo",
-          "echoes"
-        ],
-        [
-          "dingo",
-          "dingoes"
-        ],
-        [
-          "volcano",
-          "volcanoes"
-        ],
-        [
-          "tornado",
-          "tornadoes"
-        ],
-        [
-          "torpedo",
-          "torpedoes"
-        ],
-        // Ends with `us`.
-        [
-          "genus",
-          "genera"
-        ],
-        [
-          "viscus",
-          "viscera"
-        ],
-        // Ends with `ma`.
-        [
-          "stigma",
-          "stigmata"
-        ],
-        [
-          "stoma",
-          "stomata"
-        ],
-        [
-          "dogma",
-          "dogmata"
-        ],
-        [
-          "lemma",
-          "lemmata"
-        ],
-        [
-          "schema",
-          "schemata"
-        ],
-        [
-          "anathema",
-          "anathemata"
-        ],
-        // Other irregular rules.
-        [
-          "ox",
-          "oxen"
-        ],
-        [
-          "axe",
-          "axes"
-        ],
-        [
-          "die",
-          "dice"
-        ],
-        [
-          "yes",
-          "yeses"
-        ],
-        [
-          "foot",
-          "feet"
-        ],
-        [
-          "eave",
-          "eaves"
-        ],
-        [
-          "goose",
-          "geese"
-        ],
-        [
-          "tooth",
-          "teeth"
-        ],
-        [
-          "quiz",
-          "quizzes"
-        ],
-        [
-          "human",
-          "humans"
-        ],
-        [
-          "proof",
-          "proofs"
-        ],
-        [
-          "carve",
-          "carves"
-        ],
-        [
-          "valve",
-          "valves"
-        ],
-        [
-          "looey",
-          "looies"
-        ],
-        [
-          "thief",
-          "thieves"
-        ],
-        [
-          "groove",
-          "grooves"
-        ],
-        [
-          "pickaxe",
-          "pickaxes"
-        ],
-        [
-          "passerby",
-          "passersby"
-        ]
-      ].forEach(function(rule) {
-        return pluralize2.addIrregularRule(rule[0], rule[1]);
-      });
-      [
-        [
-          /s?$/i,
-          "s"
-        ],
-        [
-          /[^\u0000-\u007F]$/i,
-          "$0"
-        ],
-        [
-          /([^aeiou]ese)$/i,
-          "$1"
-        ],
-        [
-          /(ax|test)is$/i,
-          "$1es"
-        ],
-        [
-          /(alias|[^aou]us|t[lm]as|gas|ris)$/i,
-          "$1es"
-        ],
-        [
-          /(e[mn]u)s?$/i,
-          "$1s"
-        ],
-        [
-          /([^l]ias|[aeiou]las|[ejzr]as|[iu]am)$/i,
-          "$1"
-        ],
-        [
-          /(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i,
-          "$1i"
-        ],
-        [
-          /(alumn|alg|vertebr)(?:a|ae)$/i,
-          "$1ae"
-        ],
-        [
-          /(seraph|cherub)(?:im)?$/i,
-          "$1im"
-        ],
-        [
-          /(her|at|gr)o$/i,
-          "$1oes"
-        ],
-        [
-          /(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|automat|quor)(?:a|um)$/i,
-          "$1a"
-        ],
-        [
-          /(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)(?:a|on)$/i,
-          "$1a"
-        ],
-        [
-          /sis$/i,
-          "ses"
-        ],
-        [
-          /(?:(kni|wi|li)fe|(ar|l|ea|eo|oa|hoo)f)$/i,
-          "$1$2ves"
-        ],
-        [
-          /([^aeiouy]|qu)y$/i,
-          "$1ies"
-        ],
-        [
-          /([^ch][ieo][ln])ey$/i,
-          "$1ies"
-        ],
-        [
-          /(x|ch|ss|sh|zz)$/i,
-          "$1es"
-        ],
-        [
-          /(matr|cod|mur|sil|vert|ind|append)(?:ix|ex)$/i,
-          "$1ices"
-        ],
-        [
-          /\b((?:tit)?m|l)(?:ice|ouse)$/i,
-          "$1ice"
-        ],
-        [
-          /(pe)(?:rson|ople)$/i,
-          "$1ople"
-        ],
-        [
-          /(child)(?:ren)?$/i,
-          "$1ren"
-        ],
-        [
-          /eaux$/i,
-          "$0"
-        ],
-        [
-          /m[ae]n$/i,
-          "men"
-        ],
-        [
-          "thou",
-          "you"
-        ]
-      ].forEach(function(rule) {
-        return pluralize2.addPluralRule(rule[0], rule[1]);
-      });
-      [
-        [
-          /s$/i,
-          ""
-        ],
-        [
-          /(ss)$/i,
-          "$1"
-        ],
-        [
-          /(wi|kni|(?:after|half|high|low|mid|non|night|[^\w]|^)li)ves$/i,
-          "$1fe"
-        ],
-        [
-          /(ar|(?:wo|[ae])l|[eo][ao])ves$/i,
-          "$1f"
-        ],
-        [
-          /ies$/i,
-          "y"
-        ],
-        [
-          /\b([pl]|zomb|(?:neck|cross)?t|coll|faer|food|gen|goon|group|lass|talk|goal|cut)ies$/i,
-          "$1ie"
-        ],
-        [
-          /\b(mon|smil)ies$/i,
-          "$1ey"
-        ],
-        [
-          /\b((?:tit)?m|l)ice$/i,
-          "$1ouse"
-        ],
-        [
-          /(seraph|cherub)im$/i,
-          "$1"
-        ],
-        [
-          /(x|ch|ss|sh|zz|tto|go|cho|alias|[^aou]us|t[lm]as|gas|(?:her|at|gr)o|[aeiou]ris)(?:es)?$/i,
-          "$1"
-        ],
-        [
-          /(analy|diagno|parenthe|progno|synop|the|empha|cri|ne)(?:sis|ses)$/i,
-          "$1sis"
-        ],
-        [
-          /(movie|twelve|abuse|e[mn]u)s$/i,
-          "$1"
-        ],
-        [
-          /(test)(?:is|es)$/i,
-          "$1is"
-        ],
-        [
-          /(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i,
-          "$1us"
-        ],
-        [
-          /(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|quor)a$/i,
-          "$1um"
-        ],
-        [
-          /(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)a$/i,
-          "$1on"
-        ],
-        [
-          /(alumn|alg|vertebr)ae$/i,
-          "$1a"
-        ],
-        [
-          /(cod|mur|sil|vert|ind)ices$/i,
-          "$1ex"
-        ],
-        [
-          /(matr|append)ices$/i,
-          "$1ix"
-        ],
-        [
-          /(pe)(rson|ople)$/i,
-          "$1rson"
-        ],
-        [
-          /(child)ren$/i,
-          "$1"
-        ],
-        [
-          /(eau)x?$/i,
-          "$1"
-        ],
-        [
-          /men$/i,
-          "man"
-        ]
-      ].forEach(function(rule) {
-        return pluralize2.addSingularRule(rule[0], rule[1]);
-      });
-      [
-        // Singular words with no plurals.
-        "adulthood",
-        "advice",
-        "agenda",
-        "aid",
-        "aircraft",
-        "alcohol",
-        "ammo",
-        "analytics",
-        "anime",
-        "athletics",
-        "audio",
-        "bison",
-        "blood",
-        "bream",
-        "buffalo",
-        "butter",
-        "carp",
-        "cash",
-        "chassis",
-        "chess",
-        "clothing",
-        "cod",
-        "commerce",
-        "cooperation",
-        "corps",
-        "debris",
-        "diabetes",
-        "digestion",
-        "elk",
-        "energy",
-        "equipment",
-        "excretion",
-        "expertise",
-        "firmware",
-        "flounder",
-        "fun",
-        "gallows",
-        "garbage",
-        "graffiti",
-        "hardware",
-        "headquarters",
-        "health",
-        "herpes",
-        "highjinks",
-        "homework",
-        "housework",
-        "information",
-        "jeans",
-        "justice",
-        "kudos",
-        "labour",
-        "literature",
-        "machinery",
-        "mackerel",
-        "mail",
-        "media",
-        "mews",
-        "moose",
-        "music",
-        "mud",
-        "manga",
-        "news",
-        "only",
-        "personnel",
-        "pike",
-        "plankton",
-        "pliers",
-        "police",
-        "pollution",
-        "premises",
-        "rain",
-        "research",
-        "rice",
-        "salmon",
-        "scissors",
-        "series",
-        "sewage",
-        "shambles",
-        "shrimp",
-        "software",
-        "species",
-        "staff",
-        "swine",
-        "tennis",
-        "traffic",
-        "transportation",
-        "trout",
-        "tuna",
-        "wealth",
-        "welfare",
-        "whiting",
-        "wildebeest",
-        "wildlife",
-        "you",
-        /pok[eé]mon$/i,
-        // Regexes.
-        /[^aeiou]ese$/i,
-        /deer$/i,
-        /fish$/i,
-        /measles$/i,
-        /o[iu]s$/i,
-        /pox$/i,
-        /sheep$/i
-      ].forEach(pluralize2.addUncountableRule);
-      return pluralize2;
-    });
-  }
-});
-
-// src/index.ts
-init_cjs_shims();
-
-// src/prisma-generator.ts
-init_cjs_shims();
-var import_exists = require("@stryke/fs/exists");
-var import_helpers2 = require("@stryke/fs/helpers");
-var import_join_paths4 = require("@stryke/path/join-paths");
-
-// ../string-format/src/lower-case-first.ts
-init_cjs_shims();
-function lowerCaseFirst(input) {
-  return input ? input.charAt(0).toLowerCase() + input.slice(1) : input;
-}
-__name(lowerCaseFirst, "lowerCaseFirst");
-
-// src/prisma-generator.ts
-var import_node_path5 = __toESM(require("node:path"), 1);
-var import_pluralize = __toESM(require_pluralize(), 1);
-
-// src/config.ts
-init_cjs_shims();
-var import_zod = require("zod");
-var ModelAction = /* @__PURE__ */ (function(ModelAction2) {
-  ModelAction2["findUnique"] = "findUnique";
-  ModelAction2["findUniqueOrThrow"] = "findUniqueOrThrow";
-  ModelAction2["findFirst"] = "findFirst";
-  ModelAction2["findFirstOrThrow"] = "findFirstOrThrow";
-  ModelAction2["findMany"] = "findMany";
-  ModelAction2["create"] = "create";
-  ModelAction2["createMany"] = "createMany";
-  ModelAction2["createManyAndReturn"] = "createManyAndReturn";
-  ModelAction2["update"] = "update";
-  ModelAction2["updateMany"] = "updateMany";
-  ModelAction2["updateManyAndReturn"] = "updateManyAndReturn";
-  ModelAction2["upsert"] = "upsert";
-  ModelAction2["delete"] = "delete";
-  ModelAction2["deleteMany"] = "deleteMany";
-  ModelAction2["groupBy"] = "groupBy";
-  ModelAction2["count"] = "count";
-  ModelAction2["aggregate"] = "aggregate";
-  ModelAction2["findRaw"] = "findRaw";
-  ModelAction2["aggregateRaw"] = "aggregateRaw";
-  return ModelAction2;
-})({});
-var modelActionEnum = import_zod.z.nativeEnum(ModelAction);
-var configBoolean = import_zod.z.string().trim().transform((value) => !value || value.toLowerCase() === "false" || value.toLowerCase() === "n" || value.toLowerCase() === "no" || value === "0" ? false : value.toLowerCase() === "true" || value.toLowerCase() === "y" || value.toLowerCase() === "yes" || value === "1" ? true : value);
-var configSchema = import_zod.z.object({
-  debug: configBoolean.default("false"),
-  withNext: configBoolean.default("true"),
-  withMiddleware: configBoolean.default("false"),
-  withShield: configBoolean.default("false"),
-  contextPath: import_zod.z.string().trim().default("../context"),
-  trpcOptions: configBoolean.default("true"),
-  showModelNameInProcedure: configBoolean.default("false"),
-  generateModelActions: import_zod.z.string().default(Object.values(ModelAction).join(",")).transform((arg) => {
-    return arg.split(",").map((action) => modelActionEnum.parse(action.trim()));
-  }),
-  // Zod configuration
-  withZod: configBoolean.default("true"),
-  relationModel: configBoolean.default("true").or(import_zod.z.literal("default")),
-  modelSuffix: import_zod.z.string().default("Schema"),
-  modelCase: import_zod.z.enum([
-    "PascalCase",
-    "camelCase"
-  ]).default("camelCase"),
-  useDecimalJs: configBoolean.default("true"),
-  imports: import_zod.z.string().optional(),
-  prismaJsonNullability: configBoolean.default("true")
-});
-
-// src/helpers.ts
-init_cjs_shims();
-var import_file_path_fns = require("@stryke/path/file-path-fns");
-var import_join_paths3 = require("@stryke/path/join-paths");
-
-// src/project.ts
-init_cjs_shims();
-var import_ts_morph = require("ts-morph");
-var compilerOptions = {
-  target: import_ts_morph.ScriptTarget.ESNext,
-  module: import_ts_morph.ModuleKind.ESNext,
-  emitDecoratorMetadata: true,
-  experimentalDecorators: true,
-  esModuleInterop: true
-};
-var project = new import_ts_morph.Project({
-  compilerOptions: {
-    ...compilerOptions
-  }
-});
-
-// src/utils/get-prisma-internals.ts
-init_cjs_shims();
-
-// src/utils/get-jiti.ts
-init_cjs_shims();
-
-// ../env/src/get-env-paths.ts
-init_cjs_shims();
-var import_join_paths = require("@stryke/path/join-paths");
-
-// ../string-format/src/title-case.ts
-init_cjs_shims();
-
-// ../string-format/src/combine.ts
-init_cjs_shims();
-function combine(acc, str) {
-  return `${acc} ${str}`;
-}
-__name(combine, "combine");
-
-// ../string-format/src/decamelize.ts
-init_cjs_shims();
-function decamelize(value) {
-  return value.replace(/([a-z\d])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z\d]+)/g, "$1_$2").toLowerCase();
-}
-__name(decamelize, "decamelize");
-
-// ../string-format/src/format-special-cases.ts
-init_cjs_shims();
-
-// ../string-format/src/acronyms.ts
-init_cjs_shims();
-var ACRONYMS = {
-  "2D": {
-    description: "Two-Dimensional",
-    display: "2d"
-  },
-  "3D": {
-    description: "Three-Dimensional",
-    display: "3d"
-  },
-  "4D": {
-    description: "Four-Dimensional",
-    display: "4d"
-  },
-  "5G": {
-    description: "Fifth Generation (mobile networks)"
-  },
-  "6G": {
-    description: "Sixth Generation (mobile networks)"
-  },
-  "7G": {
-    description: "Seventh Generation (mobile networks)"
-  },
-  "8G": {
-    description: "Eighth Generation (mobile networks)"
-  },
-  "ACID": {
-    description: "Atomicity, Consistency, Isolation, Durability"
-  },
-  "AITA": {
-    description: "Am I The Asshole"
-  },
-  "AES": {
-    description: "Advanced Encryption Standard"
-  },
-  "AI": {
-    description: "Artificial Intelligence"
-  },
-  "AJAX": {
-    description: "Asynchronous JavaScript and XML"
-  },
-  "API": {
-    description: "Application Programming Interface"
-  },
-  "AR": {
-    description: "Augmented Reality"
-  },
-  "ASCII": {
-    description: "American Standard Code for Information Interchange"
-  },
-  "ATF": {
-    description: "Bureau of Alcohol, Tobacco, Firearms and Explosives"
-  },
-  "ATM": {
-    description: "Automated Teller Machine"
-  },
-  "B2B": {
-    description: "Business to Business"
-  },
-  "B2C": {
-    description: "Business to Consumer"
-  },
-  "BATFE": {
-    description: "Bureau of Alcohol, Tobacco, Firearms and Explosives"
-  },
-  "BFF": {
-    description: "Best Friends Forever"
-  },
-  "BFFS": {
-    description: "Best Friends Forever (plural)"
-  },
-  "BI": {
-    description: "Business Intelligence"
-  },
-  "BIOS": {
-    description: "Basic Input/Output System"
-  },
-  "BGP": {
-    description: "Border Gateway Protocol"
-  },
-  "BOM": {
-    description: "Bill of Materials / Byte Order Mark"
-  },
-  "BSON": {
-    description: "Binary JSON"
-  },
-  "BYOD": {
-    description: "Bring Your Own Device"
-  },
-  "C2C": {
-    description: "Consumer to Consumer"
-  },
-  "CAGR": {
-    description: "Compound Annual Growth Rate"
-  },
-  "CAPTCHA": {
-    description: "Completely Automated Public Turing test to tell Computers and Humans Apart"
-  },
-  "CCTV": {
-    description: "Closed-Circuit Television"
-  },
-  "CD": {
-    description: "Continuous Delivery / Compact Disc"
-  },
-  "CDN": {
-    description: "Content Delivery Network"
-  },
-  "CDP": {
-    description: "Customer Data Platform"
-  },
-  "CDT": {
-    description: "Central Daylight Time"
-  },
-  "CIA": {
-    description: "Central Intelligence Agency"
-  },
-  "CI": {
-    description: "Continuous Integration"
-  },
-  "CI/CD": {
-    description: "Continuous Integration/Continuous Delivery"
-  },
-  "CIAM": {
-    description: "Customer Identity and Access Management"
-  },
-  "CICD": {
-    description: "Continuous Integration Continuous Delivery",
-    display: "CI/CD"
-  },
-  "CLI": {
-    description: "Command Line Interface"
-  },
-  "CMDB": {
-    description: "Configuration Management Database"
-  },
-  "CORS": {
-    description: "Cross-Origin Resource Sharing"
-  },
-  "CPA": {
-    description: "Certified Public Accountant"
-  },
-  "CPU": {
-    description: "Central Processing Unit"
-  },
-  "CRUD": {
-    description: "Create, Read, Update, Delete"
-  },
-  "CSR": {
-    description: "Certificate Signing Request / Corporate Social Responsibility"
-  },
-  "CSS": {
-    description: "Cascading Style Sheets"
-  },
-  "CST": {
-    description: "Central Standard Time"
-  },
-  "CTA": {
-    description: "Call To Action"
-  },
-  "CWD": {
-    description: "Current Working Directory"
-  },
-  "CX": {
-    description: "Customer Experience"
-  },
-  "DAG": {
-    description: "Directed Acyclic Graph"
-  },
-  "DBMS": {
-    description: "Database Management System"
-  },
-  "DDOS": {
-    description: "Distributed Denial of Service",
-    display: "DDoS"
-  },
-  "DEA": {
-    description: "Drug Enforcement Administration"
-  },
-  "DEVENV": {
-    description: "Devenv",
-    display: "Devenv"
-  },
-  "DEVOPS": {
-    description: "Development Operations",
-    display: "DevOps"
-  },
-  "DHS": {
-    description: "Department of Homeland Security"
-  },
-  "DIRENV": {
-    description: "DirEnv",
-    display: "DirEnv"
-  },
-  "DNC": {
-    description: "Democratic National Committee / Do Not Call"
-  },
-  "DNS": {
-    description: "Domain Name System"
-  },
-  "DNSSEC": {
-    description: "Domain Name System Security Extensions"
-  },
-  "DOD": {
-    description: "Department of Defense",
-    display: "DoD"
-  },
-  "DOJ": {
-    description: "Department of Justice",
-    display: "DoJ"
-  },
-  "DOM": {
-    description: "Document Object Model"
-  },
-  "DOT": {
-    description: "Department of Transportation",
-    display: "DoT"
-  },
-  "DOTENV": {
-    description: "Dotenv (.env)",
-    display: "Dotenv"
-  },
-  "DR": {
-    description: "Disaster Recovery"
-  },
-  "DRM": {
-    description: "Digital Rights Management"
-  },
-  "DSN": {
-    description: "Data Source Name"
-  },
-  "DWH": {
-    description: "Data Warehouse"
-  },
-  "E2E": {
-    description: "End to End"
-  },
-  "EAI": {
-    description: "Enterprise Application Integration"
-  },
-  "EDT": {
-    description: "Eastern Daylight Time"
-  },
-  "EEA": {
-    description: "European Economic Area"
-  },
-  "EKS": {
-    description: "Elastic Kubernetes Service"
-  },
-  "EOF": {
-    description: "End Of File"
-  },
-  "EOD": {
-    description: "End Of Day / Explosive Ordnance Disposal"
-  },
-  "EPA": {
-    description: "Environmental Protection Agency"
-  },
-  "ER": {
-    description: "Emergency Room / Entity Relationship"
-  },
-  "EST": {
-    description: "Eastern Standard Time"
-  },
-  "ETC": {
-    description: "Et Cetera"
-  },
-  "ETL": {
-    description: "Extract, Transform, Load"
-  },
-  "EULA": {
-    description: "End User License Agreement"
-  },
-  "FAAS": {
-    description: "Function as a Service",
-    display: "FaaS"
-  },
-  "FAQ": {
-    description: "Frequently Asked Questions",
-    display: "FAQs"
-  },
-  "FAQS": {
-    description: "Frequently Asked Questions"
-  },
-  "FBI": {
-    description: "Federal Bureau of Investigation"
-  },
-  "FCC": {
-    description: "Federal Communications Commission"
-  },
-  "FDA": {
-    description: "Food and Drug Administration"
-  },
-  "FIDO": {
-    description: "Fast IDentity Online"
-  },
-  "FLOTUS": {
-    description: "First Lady of the United States"
-  },
-  "FQDN": {
-    description: "Fully Qualified Domain Name"
-  },
-  "FTC": {
-    description: "Federal Trade Commission"
-  },
-  "FTP": {
-    description: "File Transfer Protocol"
-  },
-  "GC": {
-    description: "Garbage Collection"
-  },
-  "GCP": {
-    description: "Google Cloud Platform"
-  },
-  "GDPR": {
-    description: "General Data Protection Regulation"
-  },
-  "GMT": {
-    description: "Greenwich Mean Time"
-  },
-  "GOP": {
-    description: "Grand Old Party"
-  },
-  "GPU": {
-    description: "Graphics Processing Unit"
-  },
-  "GUID": {
-    description: "Globally Unique Identifier"
-  },
-  "GUI": {
-    description: "Graphical User Interface"
-  },
-  "GZIP": {
-    description: "GNU Zip"
-  },
-  "HCI": {
-    description: "Human Computer Interaction / Hyper-Converged Infrastructure"
-  },
-  "HDD": {
-    description: "Hard Disk Drive"
-  },
-  "HDFS": {
-    description: "Hadoop Distributed File System"
-  },
-  "HHS": {
-    description: "Health and Human Services"
-  },
-  "HIPAA": {
-    description: "Health Insurance Portability and Accountability Act"
-  },
-  "HMAC": {
-    description: "Hash-based Message Authentication Code"
-  },
-  "HOTP": {
-    description: "HMAC-based One-Time Password"
-  },
-  "HSM": {
-    description: "Hardware Security Module"
-  },
-  "HTML": {
-    description: "HyperText Markup Language"
-  },
-  "HTTP": {
-    description: "HyperText Transfer Protocol (HTTP)"
-  },
-  "HTTP/2": {
-    description: "HyperText Transfer Protocol Version 2 (HTTP/2)"
-  },
-  "HTTP/2.0": {
-    description: "HyperText Transfer Protocol Version 2 (HTTP/2)",
-    display: "HTTP2"
-  },
-  "HTTP/3": {
-    description: "HyperText Transfer Protocol Version 3 (HTTP/3)"
-  },
-  "HTTP/3.0": {
-    description: "HyperText Transfer Protocol Version 3 (HTTP/3)",
-    display: "HTTP3"
-  },
-  "HTTP2": {
-    description: "HyperText Transfer Protocol Version 2 (HTTP/2)",
-    display: "HTTP2"
-  },
-  "HTTP2.0": {
-    description: "HyperText Transfer Protocol Version 2 (HTTP/2)",
-    display: "HTTP2"
-  },
-  "HTTP3": {
-    description: "HyperText Transfer Protocol Version 3 (HTTP/3)",
-    display: "HTTP3"
-  },
-  "HTTP3.0": {
-    description: "HyperText Transfer Protocol Version 3 (HTTP/3)",
-    display: "HTTP3"
-  },
-  "HTTPS": {
-    description: "HyperText Transfer Protocol Secure (HTTPS)"
-  },
-  "HTTPS/2": {
-    description: "HyperText Transfer Protocol Secure Version 2 (HTTPS/2)"
-  },
-  "HTTPS/2.0": {
-    description: "HyperText Transfer Protocol Secure Version 2 (HTTPS/2)",
-    display: "HTTPS2"
-  },
-  "HTTPS/3": {
-    description: "HyperText Transfer Protocol Secure Version 3 (HTTPS/3)"
-  },
-  "HTTPS/3.0": {
-    description: "HyperText Transfer Protocol Secure Version 3 (HTTPS/3)",
-    display: "HTTPS3"
-  },
-  "HTTPS2": {
-    description: "HyperText Transfer Protocol Secure Version 2 (HTTPS/2)",
-    display: "HTTPS2"
-  },
-  "HTTPS2.0": {
-    description: "HyperText Transfer Protocol Secure Version 2 (HTTPS/2)",
-    display: "HTTPS2"
-  },
-  "HTTPS3": {
-    description: "HyperText Transfer Protocol Secure Version 3 (HTTPS/3)",
-    display: "HTTPS3"
-  },
-  "HTTPS3.0": {
-    description: "HyperText Transfer Protocol Secure Version 3 (HTTPS/3)",
-    display: "HTTPS3"
-  },
-  "IAAS": {
-    description: "Infrastructure as a Service",
-    display: "IaaS"
-  },
-  "IAM": {
-    description: "Identity and Access Management"
-  },
-  "IAMM": {
-    description: "Identity and Access Management and Monitoring"
-  },
-  "IAMT": {
-    description: "Identity and Access Management Tool"
-  },
-  "ID": {
-    description: "Identifier",
-    display: "Id"
-  },
-  "IFTTT": {
-    description: "If This Then That"
-  },
-  "IMAP": {
-    description: "Internet Message Access Protocol"
-  },
-  "IO": {
-    description: "Input/Output"
-  },
-  "IP": {
-    description: "Internet Protocol"
-  },
-  "IPFS": {
-    description: "InterPlanetary File System"
-  },
-  "IPS": {
-    description: "Intrusion Prevention System"
-  },
-  "ISO": {
-    description: "International Organization for Standardization"
-  },
-  "IQ": {
-    description: "Intelligence Quotient",
-    display: "IQ"
-  },
-  "IOT": {
-    description: "Internet of Things",
-    display: "IoT"
-  },
-  "JSON": {
-    description: "JavaScript Object Notation"
-  },
-  "JSONP": {
-    description: "JSON with Padding"
-  },
-  "JWT": {
-    description: "JSON Web Token"
-  },
-  "K8S": {
-    description: "Kubernetes",
-    display: "K8s"
-  },
-  "KMS": {
-    description: "Key Management Service"
-  },
-  "KPI": {
-    description: "Key Performance Indicator"
-  },
-  "KV": {
-    description: "Key Value"
-  },
-  "LAN": {
-    description: "Local Area Network"
-  },
-  "LHS": {
-    description: "Left Hand Side"
-  },
-  "LPGA": {
-    description: "Ladies Professional Golf Association"
-  },
-  "LXC": {
-    description: "Linux Containers"
-  },
-  "MDT": {
-    description: "Mountain Daylight Time"
-  },
-  "MFA": {
-    description: "Multi-Factor Authentication"
-  },
-  "ML": {
-    description: "Machine Learning"
-  },
-  "MLB": {
-    description: "Major League Baseball"
-  },
-  "MLOps": {
-    description: "Machine Learning Operations"
-  },
-  "MPA": {
-    description: "Multi-Page Application"
-  },
-  "MST": {
-    description: "Mountain Standard Time"
-  },
-  "MVC": {
-    description: "Model View Controller"
-  },
-  "MVP": {
-    description: "Minimum Viable Product / Most Valuable Player"
-  },
-  "NAIA": {
-    description: "National Association of Intercollegiate Athletics"
-  },
-  "NAS": {
-    description: "Network Attached Storage"
-  },
-  "NASA": {
-    description: "National Aeronautics and Space Administration"
-  },
-  "NASCAR": {
-    description: "National Association for Stock Car Auto Racing"
-  },
-  "NAT": {
-    description: "Network Address Translation"
-  },
-  "NBA": {
-    description: "National Basketball Association"
-  },
-  "NCAA": {
-    description: "National Collegiate Athletic Association"
-  },
-  "NDA": {
-    description: "Non-Disclosure Agreement"
-  },
-  "NFS": {
-    description: "Network File System"
-  },
-  "NHL": {
-    description: "National Hockey League"
-  },
-  "NIST": {
-    description: "National Institute of Standards and Technology"
-  },
-  "NLP": {
-    description: "Natural Language Processing"
-  },
-  "NPS": {
-    description: "Net Promoter Score"
-  },
-  "NRA": {
-    description: "National Rifle Association"
-  },
-  "NSFW": {
-    description: "Not Safe For Work"
-  },
-  "NX": {
-    description: "Nx",
-    display: "Nx"
-  },
-  "OCR": {
-    description: "Optical Character Recognition"
-  },
-  "OEM": {
-    description: "Original Equipment Manufacturer"
-  },
-  "OKR": {
-    description: "Objectives and Key Results"
-  },
-  "OLAP": {
-    description: "Online Analytical Processing"
-  },
-  "OLTP": {
-    description: "Online Transaction Processing"
-  },
-  "OOP": {
-    description: "Object Oriented Programming"
-  },
-  "ORM": {
-    description: "Object Relational Mapping"
-  },
-  "OS": {
-    description: "Operating System"
-  },
-  "OSINT": {
-    description: "Open Source Intelligence"
-  },
-  "OSS": {
-    description: "Open Source Software"
-  },
-  "OTP": {
-    description: "One-Time Password"
-  },
-  "P2P": {
-    description: "Peer to Peer"
-  },
-  "PAAS": {
-    description: "Platform as a Service",
-    display: "PaaS"
-  },
-  "PCI": {
-    description: "Payment Card Industry"
-  },
-  "PDP": {
-    description: "Policy Decision Point / Product Detail Page"
-  },
-  "PDT": {
-    description: "Pacific Daylight Time"
-  },
-  "PGA": {
-    description: "Professional Golfers' Association"
-  },
-  "POTUS": {
-    description: "President of the United States"
-  },
-  "PP": {
-    description: "Pages / PayPal / Percentage Points"
-  },
-  "PST": {
-    description: "Pacific Standard Time"
-  },
-  "PTO": {
-    description: "Paid Time Off / Power Take-Off"
-  },
-  "PKI": {
-    description: "Public Key Infrastructure"
-  },
-  "PWA": {
-    description: "Progressive Web App"
-  },
-  "PX": {
-    description: "Pixel"
-  },
-  "QA": {
-    description: "Quality Assurance"
-  },
-  "R2": {
-    description: "R2"
-  },
-  "RAID": {
-    description: "Redundant Array of Independent Disks"
-  },
-  "RAM": {
-    description: "Random Access Memory"
-  },
-  "RDS": {
-    description: "Relational Database Service"
-  },
-  "REST": {
-    description: "Representational State Transfer"
-  },
-  "RHS": {
-    description: "Right Hand Side"
-  },
-  "ROI": {
-    description: "Return on Investment"
-  },
-  "RPC": {
-    description: "Remote Procedure Call"
-  },
-  "RPA": {
-    description: "Robotic Process Automation"
-  },
-  "RSC": {
-    description: "React Server Components"
-  },
-  "RSS": {
-    description: "Really Simple Syndication"
-  },
-  "RUM": {
-    description: "Real User Monitoring"
-  },
-  "S3": {
-    description: "Simple Storage Service (S3)"
-  },
-  "SAN": {
-    description: "Storage Area Network"
-  },
-  "SASE": {
-    description: "Secure Access Service Edge"
-  },
-  "SCOTUS": {
-    description: "Supreme Court of the United States"
-  },
-  "SDLC": {
-    description: "Software Development Life Cycle"
-  },
-  "SDK": {
-    description: "Software Development Kit"
-  },
-  "SEC": {
-    description: "Securities and Exchange Commission"
-  },
-  "SEO": {
-    description: "Search Engine Optimization"
-  },
-  "SFTP": {
-    description: "SSH File Transfer Protocol / Secure File Transfer Protocol"
-  },
-  "SIEM": {
-    description: "Security Information and Event Management"
-  },
-  "SLA": {
-    description: "Service Level Agreement"
-  },
-  "SMB": {
-    description: "Server Message Block / Small and Medium Business"
-  },
-  "SMTP": {
-    description: "Simple Mail Transfer Protocol"
-  },
-  "SOAP": {
-    description: "Simple Object Access Protocol"
-  },
-  "SOA": {
-    description: "Service Oriented Architecture"
-  },
-  "SOC": {
-    description: "Security Operations Center / System on Chip"
-  },
-  "SPA": {
-    description: "Single Page Application"
-  },
-  "SPDY": {
-    description: 'Speedy (pronounced "SPeeDY")'
-  },
-  "SPF": {
-    description: "Sender Policy Framework"
-  },
-  "SQL": {
-    description: "Structured Query Language"
-  },
-  "SRV": {
-    description: "Service"
-  },
-  "SRE": {
-    description: "Site Reliability Engineering"
-  },
-  "SSH": {
-    description: "Secure Shell"
-  },
-  "SSDL": {
-    description: "Secure Software Development Lifecycle"
-  },
-  "SSG": {
-    description: "Static Site Generation"
-  },
-  "SSR": {
-    description: "Server Side Rendering"
-  },
-  "SSO": {
-    description: "Single Sign-On"
-  },
-  "SSL": {
-    description: "Secure Sockets Layer"
-  },
-  "TDD": {
-    description: "Test Driven Development"
-  },
-  "TLD": {
-    description: "Top Level Domain"
-  },
-  "TLS": {
-    description: "Transport Layer Security"
-  },
-  "TLS1.3": {
-    description: "Transport Layer Security 1.3"
-  },
-  "TOR": {
-    description: "The Onion Router"
-  },
-  "TOTP": {
-    description: "Time-based One-Time Password"
-  },
-  "TRPC": {
-    description: "TypeScript Remote Procedure Call"
-  },
-  "TSA": {
-    description: "Transportation Security Administration"
-  },
-  "TTL": {
-    description: "Time To Live"
-  },
-  "UDP": {
-    description: "User Datagram Protocol"
-  },
-  "UI": {
-    description: "User Interface"
-  },
-  "UID": {
-    description: "Unique Identifier"
-  },
-  "URI": {
-    description: "Uniform Resource Identifier"
-  },
-  "URL": {
-    description: "Uniform Resource Locator"
-  },
-  "USOPC": {
-    description: "United States Olympic & Paralympic Committee"
-  },
-  "USPS": {
-    description: "United States Postal Service"
-  },
-  "USTA": {
-    description: "United States Tennis Association"
-  },
-  "UTF": {
-    description: "Unicode Transformation Format"
-  },
-  "UTC": {
-    description: "Coordinated Universal Time"
-  },
-  "UUID": {
-    description: "Universally Unique Identifier"
-  },
-  "UX": {
-    description: "User Experience"
-  },
-  "VM": {
-    description: "Virtual Machine"
-  },
-  "VLAN": {
-    description: "Virtual Local Area Network"
-  },
-  "VPN": {
-    description: "Virtual Private Network"
-  },
-  "VPPA": {
-    description: "Video Privacy Protection Act"
-  },
-  "VR": {
-    description: "Virtual Reality"
-  },
-  "WAF": {
-    description: "Web Application Firewall"
-  },
-  "WAN": {
-    description: "Wide Area Network"
-  },
-  "WNBA": {
-    description: "Women's National Basketball Association"
-  },
-  "WLAN": {
-    description: "Wireless Local Area Network"
-  },
-  "WPA": {
-    description: "Wi-Fi Protected Access"
-  },
-  "WPA2": {
-    description: "Wi-Fi Protected Access II"
-  },
-  "WPA3": {
-    description: "Wi-Fi Protected Access III"
-  },
-  "WWW": {
-    description: "World Wide Web"
-  },
-  "WYSIWYG": {
-    description: "What You See Is What You Get"
-  },
-  "XACML": {
-    description: "eXtensible Access Control Markup Language"
-  },
-  "XDG": {
-    description: "Cross-Desktop Group"
-  },
-  "XML": {
-    description: "eXtensible Markup Language"
-  },
-  "XSRF": {
-    description: "Cross-Site Request Forgery"
-  },
-  "XSS": {
-    description: "Cross-Site Scripting"
-  },
-  "XR": {
-    description: "Extended Reality"
-  },
-  "YAML": {
-    description: "YAML Ain't Markup Language"
-  },
-  "YMCA": {
-    description: "Young Men's Christian Association"
-  },
-  "YWCA": {
-    description: "Young Women's Christian Association"
-  },
-  "ZTA": {
-    description: "Zero Trust Architecture"
-  }
-};
-var ACRONYM_DISPLAY = Object.fromEntries(Object.entries(ACRONYMS).map(([key, value]) => [
-  key,
-  value.display ?? key
-]));
-var ACRONYM_DESCRIPTION = Object.fromEntries(Object.entries(ACRONYMS).map(([key, value]) => [
-  key,
-  value.description
-]));
-var ACRONYM_LIST = Object.keys(ACRONYMS);
-
-// ../string-format/src/articles.ts
-init_cjs_shims();
-var ARTICLES = [
-  "a",
-  "an",
-  "the"
-];
-
-// ../string-format/src/conjunctions.ts
-init_cjs_shims();
-var CONJUNCTIONS = [
-  "and",
-  "that",
-  "but",
-  "or",
-  "as",
-  "if",
-  "when",
-  "than",
-  "because",
-  "while",
-  "where",
-  "after",
-  "so",
-  "though",
-  "since",
-  "until",
-  "whether",
-  "before",
-  "although",
-  "nor",
-  "like",
-  "once",
-  "unless",
-  "now",
-  "except"
-];
-
-// ../string-format/src/prepositions.ts
-init_cjs_shims();
-var PREPOSITIONS = [
-  "about",
-  "above",
-  "across",
-  "after",
-  "against",
-  "along",
-  "among",
-  "around",
-  "at",
-  "because of",
-  "before",
-  "behind",
-  "below",
-  "beneath",
-  "beside",
-  "besides",
-  "between",
-  "beyond",
-  "but",
-  "by",
-  "concerning",
-  "despite",
-  "down",
-  "during",
-  "except",
-  "excepting",
-  "for",
-  "from",
-  "in",
-  "in front of",
-  "inside",
-  "in spite of",
-  "instead of",
-  "into",
-  "like",
-  "near",
-  "of",
-  "off",
-  "on",
-  "onto",
-  "out",
-  "outside",
-  "over",
-  "past",
-  "regarding",
-  "since",
-  "through",
-  "throughout",
-  "to",
-  "toward",
-  "under",
-  "underneath",
-  "until",
-  "up",
-  "upon",
-  "up to",
-  "with",
-  "within",
-  "without",
-  "with regard to",
-  "with respect to"
-];
-
-// ../string-format/src/special-cases.ts
-init_cjs_shims();
-var SPECIAL_CASES = [
-  "2FA",
-  "4K",
-  "5K",
-  "8K",
-  "AGI",
-  "BI",
-  "ChatGPT",
-  "CTA",
-  "DateTime",
-  "FMS",
-  "GitHub",
-  "GPT",
-  "HD",
-  "IBMid",
-  "IDs",
-  "iMac",
-  "IMAX",
-  "iOS",
-  "iPad",
-  "iPhone",
-  "iPod",
-  "LDAP",
-  "LinkedIn",
-  "LLM",
-  "macOS",
-  "McDonalds",
-  "MCP",
-  "ML",
-  "MySQL",
-  "NLG",
-  "NLP",
-  "NLU",
-  "OpenAI",
-  "PDFs",
-  "PIM",
-  "PEFT",
-  "pH",
-  "PostgreSQL",
-  "SEO",
-  "TTS",
-  "UHD",
-  "UUID",
-  "XSS",
-  "YouTube",
-  "CSpell",
-  "ESLint"
-];
-
-// ../string-format/src/format-special-cases.ts
-function formatSpecialCases(value, index, words, options) {
-  const lowercaseStr = value.toLowerCase();
-  const uppercaseStr = value.toUpperCase();
-  for (const special of SPECIAL_CASES) {
-    if (special.toLowerCase() === lowercaseStr) {
-      return special;
-    }
-  }
-  if (ACRONYMS[uppercaseStr]) {
-    return options?.useDescriptions !== false ? ACRONYMS[uppercaseStr].description : ACRONYMS[uppercaseStr].display || uppercaseStr;
-  }
-  if (index === 0) {
-    return value;
-  }
-  if (index === words.length - 1) {
-    return value;
-  }
-  if (value.length >= 4) {
-    return value;
-  }
-  if (PREPOSITIONS.includes(lowercaseStr)) {
-    return lowercaseStr;
-  }
-  if (CONJUNCTIONS.includes(lowercaseStr)) {
-    return lowercaseStr;
-  }
-  if (ARTICLES.includes(lowercaseStr)) {
-    return lowercaseStr;
-  }
-  return value;
-}
-__name(formatSpecialCases, "formatSpecialCases");
-
-// ../string-format/src/upper-case-first.ts
-init_cjs_shims();
-function upperCaseFirst(input) {
-  return input ? input.charAt(0).toUpperCase() + input.slice(1) : input;
-}
-__name(upperCaseFirst, "upperCaseFirst");
-
-// ../string-format/src/title-case.ts
-function titleCase(input, options) {
-  return input?.split(/\s+-\s+/).map((segment) => decamelize(segment).split(/[\s\-_]/).map(upperCaseFirst).map((value, index, array) => formatSpecialCases(value, index, array, options)).reduce(combine)).join(" - ");
-}
-__name(titleCase, "titleCase");
-
-// ../env/src/get-env-paths.ts
-var import_node_os = __toESM(require("node:os"), 1);
-var import_node_path = __toESM(require("node:path"), 1);
-var homedir = import_node_os.default.homedir();
-var tmpdir = import_node_os.default.tmpdir();
-var macos = /* @__PURE__ */ __name((orgId) => {
-  const library = (0, import_join_paths.joinPaths)(homedir, "Library");
-  return {
-    data: (0, import_join_paths.joinPaths)(library, "Application Support", orgId),
-    config: (0, import_join_paths.joinPaths)(library, "Preferences", orgId),
-    cache: (0, import_join_paths.joinPaths)(library, "Caches", orgId),
-    log: (0, import_join_paths.joinPaths)(library, "Logs", orgId),
-    temp: (0, import_join_paths.joinPaths)(tmpdir, orgId)
-  };
-}, "macos");
-var windows = /* @__PURE__ */ __name((orgId) => {
-  const appData = process.env.APPDATA || (0, import_join_paths.joinPaths)(homedir, "AppData", "Roaming");
-  const localAppData = process.env.LOCALAPPDATA || (0, import_join_paths.joinPaths)(homedir, "AppData", "Local");
-  const windowsFormattedOrgId = titleCase(orgId).trim().replace(/\s+/g, "");
-  return {
-    // Data/config/cache/log are invented by me as Windows isn't opinionated about this
-    data: (0, import_join_paths.joinPaths)(localAppData, windowsFormattedOrgId, "Data"),
-    config: (0, import_join_paths.joinPaths)(appData, windowsFormattedOrgId, "Config"),
-    cache: (0, import_join_paths.joinPaths)(localAppData, "Cache", orgId),
-    log: (0, import_join_paths.joinPaths)(localAppData, windowsFormattedOrgId, "Log"),
-    temp: (0, import_join_paths.joinPaths)(tmpdir, orgId)
-  };
-}, "windows");
-var linux = /* @__PURE__ */ __name((orgId) => {
-  const username = import_node_path.default.basename(homedir);
-  return {
-    data: (0, import_join_paths.joinPaths)(process.env.XDG_DATA_HOME || (0, import_join_paths.joinPaths)(homedir, ".local", "share"), orgId),
-    config: (0, import_join_paths.joinPaths)(process.env.XDG_CONFIG_HOME || (0, import_join_paths.joinPaths)(homedir, ".config"), orgId),
-    cache: (0, import_join_paths.joinPaths)(process.env.XDG_CACHE_HOME || (0, import_join_paths.joinPaths)(homedir, ".cache"), orgId),
-    // https://wiki.debian.org/XDGBaseDirectorySpecification#state
-    log: (0, import_join_paths.joinPaths)(process.env.XDG_STATE_HOME || (0, import_join_paths.joinPaths)(homedir, ".local", "state"), orgId),
-    // https://devenv.sh/files-and-variables/#devenv_root
-    temp: process.env.DEVENV_RUNTIME || process.env.XDG_RUNTIME_DIR ? (0, import_join_paths.joinPaths)(process.env.DEVENV_RUNTIME || process.env.XDG_RUNTIME_DIR, orgId) : (0, import_join_paths.joinPaths)(tmpdir, username, orgId)
-  };
-}, "linux");
-function getEnvPaths(options = {}) {
-  let orgId = options.orgId || "storm-software";
-  if (!orgId) {
-    throw new Error("You need to provide an orgId to the `getEnvPaths` function");
-  }
-  if (options.suffix) {
-    orgId += `-${typeof options.suffix === "string" ? options.suffix : "nodejs"}`;
-  }
-  let result = {};
-  if (process.platform === "darwin") {
-    result = macos(orgId);
-  } else if (process.platform === "win32") {
-    result = windows(orgId);
-  } else {
-    result = linux(orgId);
-  }
-  if (process.env.STORM_DATA_DIR) {
-    result.data = process.env.STORM_DATA_DIR;
-  } else if (process.env.STORM_CONFIG_DIR) {
-    result.config = process.env.STORM_CONFIG_DIR;
-  } else if (process.env.STORM_CACHE_DIR) {
-    result.cache = process.env.STORM_CACHE_DIR;
-  } else if (process.env.STORM_LOG_DIR) {
-    result.log = process.env.STORM_LOG_DIR;
-  } else if (process.env.STORM_TEMP_DIR) {
-    result.temp = process.env.STORM_TEMP_DIR;
-  }
-  if (options.workspaceRoot) {
-    result.cache ??= (0, import_join_paths.joinPaths)(options.workspaceRoot, "node_modules", ".cache", orgId);
-    result.temp ??= (0, import_join_paths.joinPaths)(options.workspaceRoot, "tmp", orgId);
-    result.log ??= (0, import_join_paths.joinPaths)(result.temp, "logs");
-    result.config ??= (0, import_join_paths.joinPaths)(options.workspaceRoot, ".config", orgId);
-  }
-  return Object.keys(result).reduce((ret, key) => {
-    if (result[key]) {
-      const filePath = result[key];
-      ret[key] = options.appId && options.appId !== options.orgId && options.appId !== options.nestedDir ? (0, import_join_paths.joinPaths)(filePath, options.appId) : filePath;
-      if (options.nestedDir && options.nestedDir !== options.orgId && options.nestedDir !== options.appId) {
-        ret[key] = (0, import_join_paths.joinPaths)(ret[key], options.nestedDir);
-      }
-    }
-    return ret;
-  }, {});
-}
-__name(getEnvPaths, "getEnvPaths");
-
-// src/utils/get-jiti.ts
-var import_get_workspace_root = require("@stryke/fs/get-workspace-root");
-var import_join_paths2 = require("@stryke/path/join-paths");
-var import_jiti = require("jiti");
-var jiti;
-function getJiti() {
-  if (!jiti) {
-    const envPaths = getEnvPaths();
-    jiti = (0, import_jiti.createJiti)((0, import_get_workspace_root.getWorkspaceRoot)(), {
-      fsCache: (0, import_join_paths2.joinPaths)(envPaths.cache, "jiti"),
-      interopDefault: true
-    });
-  }
-  return jiti;
-}
-__name(getJiti, "getJiti");
-
-// src/utils/get-prisma-internals.ts
-async function getPrismaInternals() {
-  return getJiti().import(getJiti().esmResolve("@prisma/internals"));
-}
-__name(getPrismaInternals, "getPrismaInternals");
-async function getPrismaGeneratorHelper() {
-  return getJiti().import(getJiti().esmResolve("@prisma/generator-helper"));
-}
-__name(getPrismaGeneratorHelper, "getPrismaGeneratorHelper");
-
-// src/zod/model-helpers.ts
-init_cjs_shims();
-var import_node_path2 = __toESM(require("node:path"), 1);
-var import_ts_morph2 = require("ts-morph");
-
-// src/zod/docs-helpers.ts
-init_cjs_shims();
-var import_parenthesis = __toESM(require("parenthesis"), 1);
-var getJSDocs = /* @__PURE__ */ __name((docString) => {
-  const lines = [];
-  if (docString) {
-    const docLines = docString.split("\n").filter((dL) => !dL.trimStart().startsWith("@zod"));
-    if (docLines.length) {
-      lines.push("/**");
-      docLines.forEach((dL) => lines.push(` * ${dL}`));
-      lines.push(" */");
-    }
-  }
-  return lines;
-}, "getJSDocs");
-var getZodDocElements = /* @__PURE__ */ __name((docString) => docString.split("\n").filter((line) => line.trimStart().startsWith("@zod")).map((line) => line.trimStart().slice(4)).flatMap((line) => (
-  // Array.from(line.matchAll(/\.([^().]+\(.*?\))/g), (m) => m.slice(1)).flat()
-  chunk(import_parenthesis.default.parse(line), 2).slice(0, -1).map(([each, contents]) => `${each.replace(/\)?\./, "")}${import_parenthesis.default.stringify(contents)})`)
-)), "getZodDocElements");
-
-// src/zod/model-helpers.ts
-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");
-var writeArray = /* @__PURE__ */ __name((writer, array, newLine = true) => array.forEach((line) => writer.write(line).conditionalNewLine(newLine)), "writeArray");
-var useModelNames = /* @__PURE__ */ __name(({ modelCase, modelSuffix, relationModel }) => {
-  const formatModelName = /* @__PURE__ */ __name((name, prefix = "") => {
-    if (modelCase === "camelCase") {
-      name = name.slice(0, 1).toLowerCase() + name.slice(1);
-    }
-    return `${prefix}${name}${modelSuffix}`;
-  }, "formatModelName");
-  return {
-    modelName: /* @__PURE__ */ __name((name) => formatModelName(name, relationModel === "default" ? "_" : ""), "modelName"),
-    relatedModelName: /* @__PURE__ */ __name((name) => formatModelName(relationModel === "default" ? name.toString() : `Related${name.toString()}`), "relatedModelName")
-  };
-}, "useModelNames");
-var dotSlash = /* @__PURE__ */ __name((input) => {
-  const converted = input.replace(/^\\\\\?\\/, "").replace(/\\/g, "/").replace(/\/{2,}/g, "/");
-  if (converted.includes(`/node_modules/`)) return converted.split(`/node_modules/`).slice(-1)[0];
-  if (converted.startsWith(`../`)) return converted;
-  return `./${converted}`;
-}, "dotSlash");
-var chunk = /* @__PURE__ */ __name((input, size) => {
-  return input.reduce((arr, item, idx) => {
-    return idx % size === 0 ? [
-      ...arr,
-      [
-        item
-      ]
-    ] : [
-      ...arr.slice(0, -1),
-      [
-        ...arr.slice(-1)[0],
-        item
-      ]
-    ];
-  }, []);
-}, "chunk");
-var needsRelatedModel = /* @__PURE__ */ __name((model, config) => model.fields.some((field) => field.kind === "object") && config.relationModel !== false, "needsRelatedModel");
-var writeImportsForModel = /* @__PURE__ */ __name(async (model, sourceFile, config, options) => {
-  const internals = await getPrismaInternals();
-  const outputPath = internals.parseEnvValue(options.generator.output);
-  const { relatedModelName } = useModelNames(config);
-  const importList = [
-    {
-      kind: import_ts_morph2.StructureKind.ImportDeclaration,
-      namespaceImport: "z",
-      moduleSpecifier: "zod"
-    }
-  ];
-  if (config.imports) {
-    importList.push({
-      kind: import_ts_morph2.StructureKind.ImportDeclaration,
-      namespaceImport: "imports",
-      moduleSpecifier: dotSlash(import_node_path2.default.relative(outputPath, import_node_path2.default.resolve(import_node_path2.default.dirname(options.schemaPath), config.imports)))
-    });
-  }
-  if (config.useDecimalJs && model.fields.some((f) => f.type === "Decimal")) {
-    importList.push({
-      kind: import_ts_morph2.StructureKind.ImportDeclaration,
-      namedImports: [
-        "Decimal"
-      ],
-      moduleSpecifier: "decimal.js"
-    });
-  }
-  const enumFields = model.fields.filter((f) => f.kind === "enum");
-  const relationFields = model.fields.filter((f) => f.kind === "object");
-  const clientPath = options.otherGenerators.find((each) => each.provider.value === "prisma-client-js").output.value;
-  const relativePath2 = import_node_path2.default.relative(outputPath, clientPath);
-  if (enumFields.length > 0) {
-    importList.push({
-      kind: import_ts_morph2.StructureKind.ImportDeclaration,
-      isTypeOnly: enumFields.length === 0,
-      moduleSpecifier: dotSlash(relativePath2),
-      namedImports: enumFields.map((f) => f.type)
-    });
-  }
-  if (config.relationModel !== false && relationFields.length > 0) {
-    const filteredFields = relationFields.filter((f) => f.type !== model.name);
-    if (filteredFields.length > 0) {
-      importList.push({
-        kind: import_ts_morph2.StructureKind.ImportDeclaration,
-        moduleSpecifier: "./index",
-        namedImports: Array.from(new Set(filteredFields.flatMap((f) => [
-          `${f.type}`,
-          relatedModelName(f.type)
-        ])))
-      });
-    }
-  }
-  sourceFile.addImportDeclarations(importList);
-}, "writeImportsForModel");
-var computeCustomSchema = /* @__PURE__ */ __name((docString) => {
-  return getZodDocElements(docString).find((modifier) => modifier.startsWith("custom("))?.slice(7).slice(0, -1);
-}, "computeCustomSchema");
-var computeModifiers = /* @__PURE__ */ __name((docString) => {
-  return getZodDocElements(docString).filter((each) => !each.startsWith("custom("));
-}, "computeModifiers");
-var getZodConstructor = /* @__PURE__ */ __name((field, getRelatedModelName = (name) => name.toString()) => {
-  let zodType = "z.unknown()";
-  const extraModifiers = [
-    ""
-  ];
-  if (field.kind === "scalar") {
-    switch (field.type) {
-      case "String":
-        zodType = "z.string()";
-        break;
-      case "Int":
-        zodType = "z.number()";
-        extraModifiers.push("int()");
-        break;
-      case "BigInt":
-        zodType = "z.bigint()";
-        break;
-      case "DateTime":
-        zodType = "z.date()";
-        break;
-      case "Float":
-        zodType = "z.number()";
-        break;
-      case "Decimal":
-        zodType = "z.number()";
-        break;
-      case "Json":
-        zodType = "jsonSchema";
-        break;
-      case "Boolean":
-        zodType = "z.boolean()";
-        break;
-      // TODO: Proper type for bytes fields
-      case "Bytes":
-        zodType = "z.unknown()";
-        break;
-    }
-  } else if (field.kind === "enum") {
-    zodType = `z.nativeEnum(${field.type})`;
-  } else if (field.kind === "object") {
-    zodType = getRelatedModelName(field.type);
-  }
-  if (field.isList) extraModifiers.push("array()");
-  if (field.documentation) {
-    zodType = computeCustomSchema(field.documentation) ?? zodType;
-    extraModifiers.push(...computeModifiers(field.documentation));
-  }
-  if (!field.isRequired && field.type !== "Json") extraModifiers.push("nullish()");
-  return `${zodType}${extraModifiers.join(".")}`;
-}, "getZodConstructor");
-var writeTypeSpecificSchemas = /* @__PURE__ */ __name((model, sourceFile, config) => {
-  if (model.fields.some((f) => f.type === "Json")) {
-    sourceFile.addStatements((writer) => {
-      writer.newLine();
-      writeArray(writer, [
-        "// Helper schema for JSON fields",
-        `type Literal = boolean | number | string${config.prismaJsonNullability ? "" : "| null"}`,
-        "type Json = Literal | { [key: string]: Json } | Json[]",
-        `const literalSchema = z.union([z.string(), z.number(), z.boolean()${config.prismaJsonNullability ? "" : ", z.null()"}])`,
-        "const jsonSchema: z.ZodSchema<Json> = z.lazy(() => z.union([literalSchema, z.array(jsonSchema), z.record(jsonSchema)]))"
-      ]);
-    });
-  }
-  if (config.useDecimalJs && model.fields.some((f) => f.type === "Decimal")) {
-    sourceFile.addStatements((writer) => {
-      writer.newLine();
-      writeArray(writer, [
-        "// Helper schema for Decimal fields",
-        "z",
-        ".instanceof(Decimal)",
-        ".or(z.string())",
-        ".or(z.number())",
-        ".refine((value) => {",
-        "  try {",
-        "    return new Decimal(value);",
-        "  } catch (error) {",
-        "    return false;",
-        "  }",
-        "})",
-        ".transform((value) => new Decimal(value));"
-      ]);
-    });
-  }
-}, "writeTypeSpecificSchemas");
-var generateSchemaForModel = /* @__PURE__ */ __name((model, sourceFile, config) => {
-  const { modelName } = useModelNames(config);
-  sourceFile.addVariableStatement({
-    declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
-    isExported: true,
-    leadingTrivia: /* @__PURE__ */ __name((writer) => writer.blankLineIfLastNot(), "leadingTrivia"),
-    declarations: [
-      {
-        name: modelName(model.name),
-        initializer(writer) {
-          writer.write("z.object(").inlineBlock(() => {
-            model.fields.filter((f) => f.kind !== "object").forEach((field) => {
-              writeArray(writer, getJSDocs(field.documentation));
-              writer.write(`${field.name}: ${getZodConstructor(field)}`).write(",").newLine();
-            });
-          }).write(")");
-        }
-      }
-    ]
-  });
-}, "generateSchemaForModel");
-var generateRelatedSchemaForModel = /* @__PURE__ */ __name((model, sourceFile, config) => {
-  const { modelName, relatedModelName } = useModelNames(config);
-  const relationFields = model.fields.filter((f) => f.kind === "object");
-  sourceFile.addInterface({
-    name: `${model.name}`,
-    isExported: true,
-    extends: [
-      `z.infer<typeof ${modelName(model.name)}>`
-    ],
-    properties: relationFields.map((f) => ({
-      hasQuestionToken: !f.isRequired,
-      name: f.name,
-      type: `${f.type}${f.isList ? "[]" : ""}${!f.isRequired ? " | null" : ""}`
-    }))
-  });
-  sourceFile.addStatements((writer) => writeArray(writer, [
-    "",
-    "/**",
-    ` * ${relatedModelName(model.name)} contains all relations on your model in addition to the scalars`,
-    " *",
-    " * NOTE: Lazy required in case of potential circular dependencies within schema",
-    " */"
-  ]));
-  sourceFile.addVariableStatement({
-    declarationKind: import_ts_morph2.VariableDeclarationKind.Const,
-    isExported: true,
-    declarations: [
-      {
-        name: relatedModelName(model.name),
-        type: `z.ZodSchema<${model.name}>`,
-        initializer(writer) {
-          writer.write(`z.lazy(() => ${modelName(model.name)}.extend(`).inlineBlock(() => {
-            relationFields.forEach((field) => {
-              writeArray(writer, getJSDocs(field.documentation));
-              writer.write(`${field.name}: ${getZodConstructor(field, relatedModelName)}`).write(",").newLine();
-            });
-          }).write("))");
-        }
-      }
-    ]
-  });
-}, "generateRelatedSchemaForModel");
-var populateModelFile = /* @__PURE__ */ __name(async (model, sourceFile, config, options) => {
-  await writeImportsForModel(model, sourceFile, config, options);
-  writeTypeSpecificSchemas(model, sourceFile, config);
-  generateSchemaForModel(model, sourceFile, config);
-  if (needsRelatedModel(model, config)) generateRelatedSchemaForModel(model, sourceFile, config);
-}, "populateModelFile");
-var generateBarrelFile = /* @__PURE__ */ __name((models, indexFile) => {
-  models.forEach((model) => indexFile.addExportDeclaration({
-    moduleSpecifier: `./${lowerCaseFirst(model.name)}.schema`
-  }));
-}, "generateBarrelFile");
-
-// src/helpers.ts
-var getProcedureName = /* @__PURE__ */ __name((config) => {
-  return config.withShield ? "shieldedProcedure" : config.withMiddleware ? "protectedProcedure" : "publicProcedure";
-}, "getProcedureName");
-var generateCreateRouterImport = /* @__PURE__ */ __name(({ sourceFile, config }) => {
-  const imports = [
-    "t"
-  ];
-  if (config) {
-    imports.push(getProcedureName(config));
-  }
-  sourceFile.addImportDeclaration({
-    moduleSpecifier: "../trpc",
-    namedImports: imports
-  });
-}, "generateCreateRouterImport");
-var generateRouterImport = /* @__PURE__ */ __name((sourceFile, modelNamePlural, modelNameCamelCase) => {
-  sourceFile.addImportDeclaration({
-    moduleSpecifier: `./${lowerCaseFirst(modelNameCamelCase)}.router`,
-    namedImports: [
-      `${modelNamePlural}Router`
-    ]
-  });
-}, "generateRouterImport");
-async function generateTRPCExports(sourceFile, config, options, outputDir) {
-  if (config.withShield) {
-    sourceFile.addImportDeclaration({
-      moduleSpecifier: (0, import_file_path_fns.relativePath)(outputDir, (0, import_join_paths3.joinPaths)(outputDir, typeof config.withShield === "string" ? config.withShield : "shield")),
-      namedImports: [
-        "permissions"
-      ]
-    });
-  }
-  sourceFile.addStatements(
-    /* ts */
-    `import type { Context } from '${(0, import_file_path_fns.relativePath)(outputDir, (0, import_join_paths3.joinPaths)(outputDir, config.contextPath))}';`
-  );
-  if (config.trpcOptions) {
-    sourceFile.addStatements(
-      /* ts */
-      `import trpcOptions from '${typeof config.trpcOptions === "string" ? (0, import_file_path_fns.relativePath)(outputDir, (0, import_join_paths3.joinPaths)(outputDir, config.trpcOptions)) : "./options"}';`
-    );
-  }
-  if (config.withNext) {
-    sourceFile.addStatements(
-      /* ts */
-      `import { createContext } from '${(0, import_file_path_fns.relativePath)(outputDir, (0, import_join_paths3.joinPaths)(outputDir, config.contextPath))}';
+var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports),s=(e,i,o,s)=>{if(i&&typeof i==`object`||typeof i==`function`)for(var c=r(i),l=0,u=c.length,d;l<u;l++)d=c[l],!a.call(e,d)&&d!==o&&t(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=n(i,d))||s.enumerable});return e},c=(n,r,a)=>(a=n==null?{}:e(i(n)),s(r||!n||!n.__esModule?t(a,`default`,{value:n,enumerable:!0}):a,n));let l=require(`@stryke/fs/exists`),u=require(`@stryke/fs/helpers`),d=require(`@stryke/path/join-paths`),f=require(`node:path`);f=c(f);let p=require(`zod`),m=require(`@stryke/path/file-path-fns`),h=require(`ts-morph`),g=require(`node:os`);g=c(g);let _=require(`@stryke/fs/get-workspace-root`),v=require(`jiti`),y=require(`parenthesis`);y=c(y);let b=require(`@stryke/fs/write-file`),x=require(`@stryke/path/correct-path`),S=require(`prettier`);S=c(S);function C(e){return e&&e.charAt(0).toLowerCase()+e.slice(1)}var w=o(((e,t)=>{(function(n,r){typeof require==`function`&&typeof e==`object`&&typeof t==`object`?t.exports=r():typeof define==`function`&&define.amd?define(function(){return r()}):n.pluralize=r()})(e,function(){var e=[],t=[],n={},r={},i={};function a(e){return typeof e==`string`?RegExp(`^`+e+`$`,`i`):e}function o(e,t){return e===t?t:e===e.toLowerCase()?t.toLowerCase():e===e.toUpperCase()?t.toUpperCase():e[0]===e[0].toUpperCase()?t.charAt(0).toUpperCase()+t.substr(1).toLowerCase():t.toLowerCase()}function s(e,t){return e.replace(/\$(\d{1,2})/g,function(e,n){return t[n]||``})}function c(e,t){return e.replace(t[0],function(n,r){var i=s(t[1],arguments);return o(n===``?e[r-1]:n,i)})}function l(e,t,r){if(!e.length||n.hasOwnProperty(e))return t;for(var i=r.length;i--;){var a=r[i];if(a[0].test(t))return c(t,a)}return t}function u(e,t,n){return function(r){var i=r.toLowerCase();return t.hasOwnProperty(i)?o(r,i):e.hasOwnProperty(i)?o(r,e[i]):l(i,r,n)}}function d(e,t,n,r){return function(r){var i=r.toLowerCase();return t.hasOwnProperty(i)?!0:e.hasOwnProperty(i)?!1:l(i,i,n)===i}}function f(e,t,n){var r=t===1?f.singular(e):f.plural(e);return(n?t+` `:``)+r}return f.plural=u(i,r,e),f.isPlural=d(i,r,e),f.singular=u(r,i,t),f.isSingular=d(r,i,t),f.addPluralRule=function(t,n){e.push([a(t),n])},f.addSingularRule=function(e,n){t.push([a(e),n])},f.addUncountableRule=function(e){if(typeof e==`string`){n[e.toLowerCase()]=!0;return}f.addPluralRule(e,`$0`),f.addSingularRule(e,`$0`)},f.addIrregularRule=function(e,t){t=t.toLowerCase(),e=e.toLowerCase(),i[e]=t,r[t]=e},[[`I`,`we`],[`me`,`us`],[`he`,`they`],[`she`,`they`],[`them`,`them`],[`myself`,`ourselves`],[`yourself`,`yourselves`],[`itself`,`themselves`],[`herself`,`themselves`],[`himself`,`themselves`],[`themself`,`themselves`],[`is`,`are`],[`was`,`were`],[`has`,`have`],[`this`,`these`],[`that`,`those`],[`echo`,`echoes`],[`dingo`,`dingoes`],[`volcano`,`volcanoes`],[`tornado`,`tornadoes`],[`torpedo`,`torpedoes`],[`genus`,`genera`],[`viscus`,`viscera`],[`stigma`,`stigmata`],[`stoma`,`stomata`],[`dogma`,`dogmata`],[`lemma`,`lemmata`],[`schema`,`schemata`],[`anathema`,`anathemata`],[`ox`,`oxen`],[`axe`,`axes`],[`die`,`dice`],[`yes`,`yeses`],[`foot`,`feet`],[`eave`,`eaves`],[`goose`,`geese`],[`tooth`,`teeth`],[`quiz`,`quizzes`],[`human`,`humans`],[`proof`,`proofs`],[`carve`,`carves`],[`valve`,`valves`],[`looey`,`looies`],[`thief`,`thieves`],[`groove`,`grooves`],[`pickaxe`,`pickaxes`],[`passerby`,`passersby`]].forEach(function(e){return f.addIrregularRule(e[0],e[1])}),[[/s?$/i,`s`],[/[^\u0000-\u007F]$/i,`$0`],[/([^aeiou]ese)$/i,`$1`],[/(ax|test)is$/i,`$1es`],[/(alias|[^aou]us|t[lm]as|gas|ris)$/i,`$1es`],[/(e[mn]u)s?$/i,`$1s`],[/([^l]ias|[aeiou]las|[ejzr]as|[iu]am)$/i,`$1`],[/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i,`$1i`],[/(alumn|alg|vertebr)(?:a|ae)$/i,`$1ae`],[/(seraph|cherub)(?:im)?$/i,`$1im`],[/(her|at|gr)o$/i,`$1oes`],[/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|automat|quor)(?:a|um)$/i,`$1a`],[/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)(?:a|on)$/i,`$1a`],[/sis$/i,`ses`],[/(?:(kni|wi|li)fe|(ar|l|ea|eo|oa|hoo)f)$/i,`$1$2ves`],[/([^aeiouy]|qu)y$/i,`$1ies`],[/([^ch][ieo][ln])ey$/i,`$1ies`],[/(x|ch|ss|sh|zz)$/i,`$1es`],[/(matr|cod|mur|sil|vert|ind|append)(?:ix|ex)$/i,`$1ices`],[/\b((?:tit)?m|l)(?:ice|ouse)$/i,`$1ice`],[/(pe)(?:rson|ople)$/i,`$1ople`],[/(child)(?:ren)?$/i,`$1ren`],[/eaux$/i,`$0`],[/m[ae]n$/i,`men`],[`thou`,`you`]].forEach(function(e){return f.addPluralRule(e[0],e[1])}),[[/s$/i,``],[/(ss)$/i,`$1`],[/(wi|kni|(?:after|half|high|low|mid|non|night|[^\w]|^)li)ves$/i,`$1fe`],[/(ar|(?:wo|[ae])l|[eo][ao])ves$/i,`$1f`],[/ies$/i,`y`],[/\b([pl]|zomb|(?:neck|cross)?t|coll|faer|food|gen|goon|group|lass|talk|goal|cut)ies$/i,`$1ie`],[/\b(mon|smil)ies$/i,`$1ey`],[/\b((?:tit)?m|l)ice$/i,`$1ouse`],[/(seraph|cherub)im$/i,`$1`],[/(x|ch|ss|sh|zz|tto|go|cho|alias|[^aou]us|t[lm]as|gas|(?:her|at|gr)o|[aeiou]ris)(?:es)?$/i,`$1`],[/(analy|diagno|parenthe|progno|synop|the|empha|cri|ne)(?:sis|ses)$/i,`$1sis`],[/(movie|twelve|abuse|e[mn]u)s$/i,`$1`],[/(test)(?:is|es)$/i,`$1is`],[/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i,`$1us`],[/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|quor)a$/i,`$1um`],[/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)a$/i,`$1on`],[/(alumn|alg|vertebr)ae$/i,`$1a`],[/(cod|mur|sil|vert|ind)ices$/i,`$1ex`],[/(matr|append)ices$/i,`$1ix`],[/(pe)(rson|ople)$/i,`$1rson`],[/(child)ren$/i,`$1`],[/(eau)x?$/i,`$1`],[/men$/i,`man`]].forEach(function(e){return f.addSingularRule(e[0],e[1])}),[`adulthood`,`advice`,`agenda`,`aid`,`aircraft`,`alcohol`,`ammo`,`analytics`,`anime`,`athletics`,`audio`,`bison`,`blood`,`bream`,`buffalo`,`butter`,`carp`,`cash`,`chassis`,`chess`,`clothing`,`cod`,`commerce`,`cooperation`,`corps`,`debris`,`diabetes`,`digestion`,`elk`,`energy`,`equipment`,`excretion`,`expertise`,`firmware`,`flounder`,`fun`,`gallows`,`garbage`,`graffiti`,`hardware`,`headquarters`,`health`,`herpes`,`highjinks`,`homework`,`housework`,`information`,`jeans`,`justice`,`kudos`,`labour`,`literature`,`machinery`,`mackerel`,`mail`,`media`,`mews`,`moose`,`music`,`mud`,`manga`,`news`,`only`,`personnel`,`pike`,`plankton`,`pliers`,`police`,`pollution`,`premises`,`rain`,`research`,`rice`,`salmon`,`scissors`,`series`,`sewage`,`shambles`,`shrimp`,`software`,`species`,`staff`,`swine`,`tennis`,`traffic`,`transportation`,`trout`,`tuna`,`wealth`,`welfare`,`whiting`,`wildebeest`,`wildlife`,`you`,/pok[eé]mon$/i,/[^aeiou]ese$/i,/deer$/i,/fish$/i,/measles$/i,/o[iu]s$/i,/pox$/i,/sheep$/i].forEach(f.addUncountableRule),f})})),ee=c(w(),1);let T=function(e){return e.findUnique=`findUnique`,e.findUniqueOrThrow=`findUniqueOrThrow`,e.findFirst=`findFirst`,e.findFirstOrThrow=`findFirstOrThrow`,e.findMany=`findMany`,e.create=`create`,e.createMany=`createMany`,e.createManyAndReturn=`createManyAndReturn`,e.update=`update`,e.updateMany=`updateMany`,e.updateManyAndReturn=`updateManyAndReturn`,e.upsert=`upsert`,e.delete=`delete`,e.deleteMany=`deleteMany`,e.groupBy=`groupBy`,e.count=`count`,e.aggregate=`aggregate`,e.findRaw=`findRaw`,e.aggregateRaw=`aggregateRaw`,e}({});const E=p.z.nativeEnum(T),D=p.z.string().trim().transform(e=>!e||e.toLowerCase()===`false`||e.toLowerCase()===`n`||e.toLowerCase()===`no`||e===`0`?!1:e.toLowerCase()===`true`||e.toLowerCase()===`y`||e.toLowerCase()===`yes`||e===`1`?!0:e),te=p.z.object({debug:D.default(`false`),withNext:D.default(`true`),withMiddleware:D.default(`false`),withShield:D.default(`false`),contextPath:p.z.string().trim().default(`../context`),trpcOptions:D.default(`true`),showModelNameInProcedure:D.default(`false`),generateModelActions:p.z.string().default(Object.values(T).join(`,`)).transform(e=>e.split(`,`).map(e=>E.parse(e.trim()))),withZod:D.default(`true`),relationModel:D.default(`true`).or(p.z.literal(`default`)),modelSuffix:p.z.string().default(`Schema`),modelCase:p.z.enum([`PascalCase`,`camelCase`]).default(`camelCase`),useDecimalJs:D.default(`true`),imports:p.z.string().optional(),prismaJsonNullability:D.default(`true`)}),ne={target:h.ScriptTarget.ESNext,module:h.ModuleKind.ESNext,emitDecoratorMetadata:!0,experimentalDecorators:!0,esModuleInterop:!0},O=new h.Project({compilerOptions:{...ne}});function re(e,t){return`${e} ${t}`}function ie(e){return e.replace(/([a-z\d])([A-Z])/g,`$1_$2`).replace(/([A-Z]+)([A-Z][a-z\d]+)/g,`$1_$2`).toLowerCase()}const k={"2D":{description:`Two-Dimensional`,display:`2d`},"3D":{description:`Three-Dimensional`,display:`3d`},"4D":{description:`Four-Dimensional`,display:`4d`},"5G":{description:`Fifth Generation (mobile networks)`},"6G":{description:`Sixth Generation (mobile networks)`},"7G":{description:`Seventh Generation (mobile networks)`},"8G":{description:`Eighth Generation (mobile networks)`},ACID:{description:`Atomicity, Consistency, Isolation, Durability`},AITA:{description:`Am I The Asshole`},AES:{description:`Advanced Encryption Standard`},AI:{description:`Artificial Intelligence`},AJAX:{description:`Asynchronous JavaScript and XML`},API:{description:`Application Programming Interface`},AR:{description:`Augmented Reality`},ASCII:{description:`American Standard Code for Information Interchange`},ATF:{description:`Bureau of Alcohol, Tobacco, Firearms and Explosives`},ATM:{description:`Automated Teller Machine`},B2B:{description:`Business to Business`},B2C:{description:`Business to Consumer`},BATFE:{description:`Bureau of Alcohol, Tobacco, Firearms and Explosives`},BFF:{description:`Best Friends Forever`},BFFS:{description:`Best Friends Forever (plural)`},BI:{description:`Business Intelligence`},BIOS:{description:`Basic Input/Output System`},BGP:{description:`Border Gateway Protocol`},BOM:{description:`Bill of Materials / Byte Order Mark`},BSON:{description:`Binary JSON`},BYOD:{description:`Bring Your Own Device`},C2C:{description:`Consumer to Consumer`},CAGR:{description:`Compound Annual Growth Rate`},CAPTCHA:{description:`Completely Automated Public Turing test to tell Computers and Humans Apart`},CCTV:{description:`Closed-Circuit Television`},CD:{description:`Continuous Delivery / Compact Disc`},CDN:{description:`Content Delivery Network`},CDP:{description:`Customer Data Platform`},CDT:{description:`Central Daylight Time`},CIA:{description:`Central Intelligence Agency`},CI:{description:`Continuous Integration`},"CI/CD":{description:`Continuous Integration/Continuous Delivery`},CIAM:{description:`Customer Identity and Access Management`},CICD:{description:`Continuous Integration Continuous Delivery`,display:`CI/CD`},CLI:{description:`Command Line Interface`},CMDB:{description:`Configuration Management Database`},CORS:{description:`Cross-Origin Resource Sharing`},CPA:{description:`Certified Public Accountant`},CPU:{description:`Central Processing Unit`},CRUD:{description:`Create, Read, Update, Delete`},CSR:{description:`Certificate Signing Request / Corporate Social Responsibility`},CSS:{description:`Cascading Style Sheets`},CST:{description:`Central Standard Time`},CTA:{description:`Call To Action`},CWD:{description:`Current Working Directory`},CX:{description:`Customer Experience`},DAG:{description:`Directed Acyclic Graph`},DBMS:{description:`Database Management System`},DDOS:{description:`Distributed Denial of Service`,display:`DDoS`},DEA:{description:`Drug Enforcement Administration`},DEVENV:{description:`Devenv`,display:`Devenv`},DEVOPS:{description:`Development Operations`,display:`DevOps`},DHS:{description:`Department of Homeland Security`},DIRENV:{description:`DirEnv`,display:`DirEnv`},DNC:{description:`Democratic National Committee / Do Not Call`},DNS:{description:`Domain Name System`},DNSSEC:{description:`Domain Name System Security Extensions`},DOD:{description:`Department of Defense`,display:`DoD`},DOJ:{description:`Department of Justice`,display:`DoJ`},DOM:{description:`Document Object Model`},DOT:{description:`Department of Transportation`,display:`DoT`},DOTENV:{description:`Dotenv (.env)`,display:`Dotenv`},DR:{description:`Disaster Recovery`},DRM:{description:`Digital Rights Management`},DSN:{description:`Data Source Name`},DWH:{description:`Data Warehouse`},E2E:{description:`End to End`},EAI:{description:`Enterprise Application Integration`},EDT:{description:`Eastern Daylight Time`},EEA:{description:`European Economic Area`},EKS:{description:`Elastic Kubernetes Service`},EOF:{description:`End Of File`},EOD:{description:`End Of Day / Explosive Ordnance Disposal`},EPA:{description:`Environmental Protection Agency`},ER:{description:`Emergency Room / Entity Relationship`},EST:{description:`Eastern Standard Time`},ETC:{description:`Et Cetera`},ETL:{description:`Extract, Transform, Load`},EULA:{description:`End User License Agreement`},FAAS:{description:`Function as a Service`,display:`FaaS`},FAQ:{description:`Frequently Asked Questions`,display:`FAQs`},FAQS:{description:`Frequently Asked Questions`},FBI:{description:`Federal Bureau of Investigation`},FCC:{description:`Federal Communications Commission`},FDA:{description:`Food and Drug Administration`},FIDO:{description:`Fast IDentity Online`},FLOTUS:{description:`First Lady of the United States`},FQDN:{description:`Fully Qualified Domain Name`},FTC:{description:`Federal Trade Commission`},FTP:{description:`File Transfer Protocol`},GC:{description:`Garbage Collection`},GCP:{description:`Google Cloud Platform`},GDPR:{description:`General Data Protection Regulation`},GMT:{description:`Greenwich Mean Time`},GOP:{description:`Grand Old Party`},GPU:{description:`Graphics Processing Unit`},GUID:{description:`Globally Unique Identifier`},GUI:{description:`Graphical User Interface`},GZIP:{description:`GNU Zip`},HCI:{description:`Human Computer Interaction / Hyper-Converged Infrastructure`},HDD:{description:`Hard Disk Drive`},HDFS:{description:`Hadoop Distributed File System`},HHS:{description:`Health and Human Services`},HIPAA:{description:`Health Insurance Portability and Accountability Act`},HMAC:{description:`Hash-based Message Authentication Code`},HOTP:{description:`HMAC-based One-Time Password`},HSM:{description:`Hardware Security Module`},HTML:{description:`HyperText Markup Language`},HTTP:{description:`HyperText Transfer Protocol (HTTP)`},"HTTP/2":{description:`HyperText Transfer Protocol Version 2 (HTTP/2)`},"HTTP/2.0":{description:`HyperText Transfer Protocol Version 2 (HTTP/2)`,display:`HTTP2`},"HTTP/3":{description:`HyperText Transfer Protocol Version 3 (HTTP/3)`},"HTTP/3.0":{description:`HyperText Transfer Protocol Version 3 (HTTP/3)`,display:`HTTP3`},HTTP2:{description:`HyperText Transfer Protocol Version 2 (HTTP/2)`,display:`HTTP2`},"HTTP2.0":{description:`HyperText Transfer Protocol Version 2 (HTTP/2)`,display:`HTTP2`},HTTP3:{description:`HyperText Transfer Protocol Version 3 (HTTP/3)`,display:`HTTP3`},"HTTP3.0":{description:`HyperText Transfer Protocol Version 3 (HTTP/3)`,display:`HTTP3`},HTTPS:{description:`HyperText Transfer Protocol Secure (HTTPS)`},"HTTPS/2":{description:`HyperText Transfer Protocol Secure Version 2 (HTTPS/2)`},"HTTPS/2.0":{description:`HyperText Transfer Protocol Secure Version 2 (HTTPS/2)`,display:`HTTPS2`},"HTTPS/3":{description:`HyperText Transfer Protocol Secure Version 3 (HTTPS/3)`},"HTTPS/3.0":{description:`HyperText Transfer Protocol Secure Version 3 (HTTPS/3)`,display:`HTTPS3`},HTTPS2:{description:`HyperText Transfer Protocol Secure Version 2 (HTTPS/2)`,display:`HTTPS2`},"HTTPS2.0":{description:`HyperText Transfer Protocol Secure Version 2 (HTTPS/2)`,display:`HTTPS2`},HTTPS3:{description:`HyperText Transfer Protocol Secure Version 3 (HTTPS/3)`,display:`HTTPS3`},"HTTPS3.0":{description:`HyperText Transfer Protocol Secure Version 3 (HTTPS/3)`,display:`HTTPS3`},IAAS:{description:`Infrastructure as a Service`,display:`IaaS`},IAM:{description:`Identity and Access Management`},IAMM:{description:`Identity and Access Management and Monitoring`},IAMT:{description:`Identity and Access Management Tool`},ID:{description:`Identifier`,display:`Id`},IFTTT:{description:`If This Then That`},IMAP:{description:`Internet Message Access Protocol`},IO:{description:`Input/Output`},IP:{description:`Internet Protocol`},IPFS:{description:`InterPlanetary File System`},IPS:{description:`Intrusion Prevention System`},ISO:{description:`International Organization for Standardization`},IQ:{description:`Intelligence Quotient`,display:`IQ`},IOT:{description:`Internet of Things`,display:`IoT`},JSON:{description:`JavaScript Object Notation`},JSONP:{description:`JSON with Padding`},JWT:{description:`JSON Web Token`},K8S:{description:`Kubernetes`,display:`K8s`},KMS:{description:`Key Management Service`},KPI:{description:`Key Performance Indicator`},KV:{description:`Key Value`},LAN:{description:`Local Area Network`},LHS:{description:`Left Hand Side`},LPGA:{description:`Ladies Professional Golf Association`},LXC:{description:`Linux Containers`},MDT:{description:`Mountain Daylight Time`},MFA:{description:`Multi-Factor Authentication`},ML:{description:`Machine Learning`},MLB:{description:`Major League Baseball`},MLOps:{description:`Machine Learning Operations`},MPA:{description:`Multi-Page Application`},MST:{description:`Mountain Standard Time`},MVC:{description:`Model View Controller`},MVP:{description:`Minimum Viable Product / Most Valuable Player`},NAIA:{description:`National Association of Intercollegiate Athletics`},NAS:{description:`Network Attached Storage`},NASA:{description:`National Aeronautics and Space Administration`},NASCAR:{description:`National Association for Stock Car Auto Racing`},NAT:{description:`Network Address Translation`},NBA:{description:`National Basketball Association`},NCAA:{description:`National Collegiate Athletic Association`},NDA:{description:`Non-Disclosure Agreement`},NFS:{description:`Network File System`},NHL:{description:`National Hockey League`},NIST:{description:`National Institute of Standards and Technology`},NLP:{description:`Natural Language Processing`},NPS:{description:`Net Promoter Score`},NRA:{description:`National Rifle Association`},NSFW:{description:`Not Safe For Work`},NX:{description:`Nx`,display:`Nx`},OCR:{description:`Optical Character Recognition`},OEM:{description:`Original Equipment Manufacturer`},OKR:{description:`Objectives and Key Results`},OLAP:{description:`Online Analytical Processing`},OLTP:{description:`Online Transaction Processing`},OOP:{description:`Object Oriented Programming`},ORM:{description:`Object Relational Mapping`},OS:{description:`Operating System`},OSINT:{description:`Open Source Intelligence`},OSS:{description:`Open Source Software`},OTP:{description:`One-Time Password`},P2P:{description:`Peer to Peer`},PAAS:{description:`Platform as a Service`,display:`PaaS`},PCI:{description:`Payment Card Industry`},PDP:{description:`Policy Decision Point / Product Detail Page`},PDT:{description:`Pacific Daylight Time`},PGA:{description:`Professional Golfers' Association`},POTUS:{description:`President of the United States`},PP:{description:`Pages / PayPal / Percentage Points`},PST:{description:`Pacific Standard Time`},PTO:{description:`Paid Time Off / Power Take-Off`},PKI:{description:`Public Key Infrastructure`},PWA:{description:`Progressive Web App`},PX:{description:`Pixel`},QA:{description:`Quality Assurance`},R2:{description:`R2`},RAID:{description:`Redundant Array of Independent Disks`},RAM:{description:`Random Access Memory`},RDS:{description:`Relational Database Service`},REST:{description:`Representational State Transfer`},RHS:{description:`Right Hand Side`},ROI:{description:`Return on Investment`},RPC:{description:`Remote Procedure Call`},RPA:{description:`Robotic Process Automation`},RSC:{description:`React Server Components`},RSS:{description:`Really Simple Syndication`},RUM:{description:`Real User Monitoring`},S3:{description:`Simple Storage Service (S3)`},SAN:{description:`Storage Area Network`},SASE:{description:`Secure Access Service Edge`},SCOTUS:{description:`Supreme Court of the United States`},SDLC:{description:`Software Development Life Cycle`},SDK:{description:`Software Development Kit`},SEC:{description:`Securities and Exchange Commission`},SEO:{description:`Search Engine Optimization`},SFTP:{description:`SSH File Transfer Protocol / Secure File Transfer Protocol`},SIEM:{description:`Security Information and Event Management`},SLA:{description:`Service Level Agreement`},SMB:{description:`Server Message Block / Small and Medium Business`},SMTP:{description:`Simple Mail Transfer Protocol`},SOAP:{description:`Simple Object Access Protocol`},SOA:{description:`Service Oriented Architecture`},SOC:{description:`Security Operations Center / System on Chip`},SPA:{description:`Single Page Application`},SPDY:{description:`Speedy (pronounced "SPeeDY")`},SPF:{description:`Sender Policy Framework`},SQL:{description:`Structured Query Language`},SRV:{description:`Service`},SRE:{description:`Site Reliability Engineering`},SSH:{description:`Secure Shell`},SSDL:{description:`Secure Software Development Lifecycle`},SSG:{description:`Static Site Generation`},SSR:{description:`Server Side Rendering`},SSO:{description:`Single Sign-On`},SSL:{description:`Secure Sockets Layer`},TDD:{description:`Test Driven Development`},TLD:{description:`Top Level Domain`},TLS:{description:`Transport Layer Security`},"TLS1.3":{description:`Transport Layer Security 1.3`},TOR:{description:`The Onion Router`},TOTP:{description:`Time-based One-Time Password`},TRPC:{description:`TypeScript Remote Procedure Call`},TSA:{description:`Transportation Security Administration`},TTL:{description:`Time To Live`},UDP:{description:`User Datagram Protocol`},UI:{description:`User Interface`},UID:{description:`Unique Identifier`},URI:{description:`Uniform Resource Identifier`},URL:{description:`Uniform Resource Locator`},USOPC:{description:`United States Olympic & Paralympic Committee`},USPS:{description:`United States Postal Service`},USTA:{description:`United States Tennis Association`},UTF:{description:`Unicode Transformation Format`},UTC:{description:`Coordinated Universal Time`},UUID:{description:`Universally Unique Identifier`},UX:{description:`User Experience`},VM:{description:`Virtual Machine`},VLAN:{description:`Virtual Local Area Network`},VPN:{description:`Virtual Private Network`},VPPA:{description:`Video Privacy Protection Act`},VR:{description:`Virtual Reality`},WAF:{description:`Web Application Firewall`},WAN:{description:`Wide Area Network`},WNBA:{description:`Women's National Basketball Association`},WLAN:{description:`Wireless Local Area Network`},WPA:{description:`Wi-Fi Protected Access`},WPA2:{description:`Wi-Fi Protected Access II`},WPA3:{description:`Wi-Fi Protected Access III`},WWW:{description:`World Wide Web`},WYSIWYG:{description:`What You See Is What You Get`},XACML:{description:`eXtensible Access Control Markup Language`},XDG:{description:`Cross-Desktop Group`},XML:{description:`eXtensible Markup Language`},XSRF:{description:`Cross-Site Request Forgery`},XSS:{description:`Cross-Site Scripting`},XR:{description:`Extended Reality`},YAML:{description:`YAML Ain't Markup Language`},YMCA:{description:`Young Men's Christian Association`},YWCA:{description:`Young Women's Christian Association`},ZTA:{description:`Zero Trust Architecture`}},ae=Object.fromEntries(Object.entries(k).map(([e,t])=>[e,t.display??e])),oe=Object.fromEntries(Object.entries(k).map(([e,t])=>[e,t.description])),se=Object.keys(k),ce=[`a`,`an`,`the`],le=[`and`,`that`,`but`,`or`,`as`,`if`,`when`,`than`,`because`,`while`,`where`,`after`,`so`,`though`,`since`,`until`,`whether`,`before`,`although`,`nor`,`like`,`once`,`unless`,`now`,`except`],ue=`about.above.across.after.against.along.among.around.at.because of.before.behind.below.beneath.beside.besides.between.beyond.but.by.concerning.despite.down.during.except.excepting.for.from.in.in front of.inside.in spite of.instead of.into.like.near.of.off.on.onto.out.outside.over.past.regarding.since.through.throughout.to.toward.under.underneath.until.up.upon.up to.with.within.without.with regard to.with respect to`.split(`.`),de=`2FA.4K.5K.8K.AGI.BI.ChatGPT.CTA.DateTime.FMS.GitHub.GPT.HD.IBMid.IDs.iMac.IMAX.iOS.iPad.iPhone.iPod.LDAP.LinkedIn.LLM.macOS.McDonalds.MCP.ML.MySQL.NLG.NLP.NLU.OpenAI.PDFs.PIM.PEFT.pH.PostgreSQL.SEO.TTS.UHD.UUID.XSS.YouTube.CSpell.ESLint`.split(`.`);function fe(e,t,n,r){let i=e.toLowerCase(),a=e.toUpperCase();for(let e of de)if(e.toLowerCase()===i)return e;return k[a]?r?.useDescriptions===!1?k[a].display||a:k[a].description:t===0||t===n.length-1||e.length>=4?e:ue.includes(i)||le.includes(i)||ce.includes(i)?i:e}function A(e){return e&&e.charAt(0).toUpperCase()+e.slice(1)}function pe(e,t){return e?.split(/\s+-\s+/).map(e=>ie(e).split(/[\s\-_]/).map(A).map((e,n,r)=>fe(e,n,r,t)).reduce(re)).join(` - `)}const j=g.default.homedir(),M=g.default.tmpdir(),me=e=>{let t=(0,d.joinPaths)(j,`Library`);return{data:(0,d.joinPaths)(t,`Application Support`,e),config:(0,d.joinPaths)(t,`Preferences`,e),cache:(0,d.joinPaths)(t,`Caches`,e),log:(0,d.joinPaths)(t,`Logs`,e),temp:(0,d.joinPaths)(M,e)}},he=e=>{let t=process.env.APPDATA||(0,d.joinPaths)(j,`AppData`,`Roaming`),n=process.env.LOCALAPPDATA||(0,d.joinPaths)(j,`AppData`,`Local`),r=pe(e).trim().replace(/\s+/g,``);return{data:(0,d.joinPaths)(n,r,`Data`),config:(0,d.joinPaths)(t,r,`Config`),cache:(0,d.joinPaths)(n,`Cache`,e),log:(0,d.joinPaths)(n,r,`Log`),temp:(0,d.joinPaths)(M,e)}},ge=e=>{let t=f.default.basename(j);return{data:(0,d.joinPaths)(process.env.XDG_DATA_HOME||(0,d.joinPaths)(j,`.local`,`share`),e),config:(0,d.joinPaths)(process.env.XDG_CONFIG_HOME||(0,d.joinPaths)(j,`.config`),e),cache:(0,d.joinPaths)(process.env.XDG_CACHE_HOME||(0,d.joinPaths)(j,`.cache`),e),log:(0,d.joinPaths)(process.env.XDG_STATE_HOME||(0,d.joinPaths)(j,`.local`,`state`),e),temp:process.env.DEVENV_RUNTIME||process.env.XDG_RUNTIME_DIR?(0,d.joinPaths)(process.env.DEVENV_RUNTIME||process.env.XDG_RUNTIME_DIR,e):(0,d.joinPaths)(M,t,e)}};function _e(e={}){let t=e.orgId||`storm-software`;if(!t)throw Error("You need to provide an orgId to the `getEnvPaths` function");e.suffix&&(t+=`-${typeof e.suffix==`string`?e.suffix:`nodejs`}`);let n={};return n=process.platform===`darwin`?me(t):process.platform===`win32`?he(t):ge(t),process.env.STORM_DATA_DIR?n.data=process.env.STORM_DATA_DIR:process.env.STORM_CONFIG_DIR?n.config=process.env.STORM_CONFIG_DIR:process.env.STORM_CACHE_DIR?n.cache=process.env.STORM_CACHE_DIR:process.env.STORM_LOG_DIR?n.log=process.env.STORM_LOG_DIR:process.env.STORM_TEMP_DIR&&(n.temp=process.env.STORM_TEMP_DIR),e.workspaceRoot&&(n.cache??=(0,d.joinPaths)(e.workspaceRoot,`node_modules`,`.cache`,t),n.temp??=(0,d.joinPaths)(e.workspaceRoot,`tmp`,t),n.log??=(0,d.joinPaths)(n.temp,`logs`),n.config??=(0,d.joinPaths)(e.workspaceRoot,`.config`,t)),Object.keys(n).reduce((t,r)=>{if(n[r]){let i=n[r];t[r]=e.appId&&e.appId!==e.orgId&&e.appId!==e.nestedDir?(0,d.joinPaths)(i,e.appId):i,e.nestedDir&&e.nestedDir!==e.orgId&&e.nestedDir!==e.appId&&(t[r]=(0,d.joinPaths)(t[r],e.nestedDir))}return t},{})}let N;function P(){if(!N){let e=_e();N=(0,v.createJiti)((0,_.getWorkspaceRoot)(),{fsCache:(0,d.joinPaths)(e.cache,`jiti`),interopDefault:!0})}return N}async function F(){return P().import(P().esmResolve(`@prisma/internals`))}async function ve(){return P().import(P().esmResolve(`@prisma/generator-helper`))}const I=e=>{let t=[];if(e){let n=e.split(`
+`).filter(e=>!e.trimStart().startsWith(`@zod`));n.length&&(t.push(`/**`),n.forEach(e=>t.push(` * ${e}`)),t.push(` */`))}return t},L=e=>e.split(`
+`).filter(e=>e.trimStart().startsWith(`@zod`)).map(e=>e.trimStart().slice(4)).flatMap(e=>xe(y.default.parse(e),2).slice(0,-1).map(([e,t])=>`${e.replace(/\)?\./,``)}${y.default.stringify(t)})`));function R(e){let{fields:t}=e;for(let e of t)if(B(e))return!0;return!1}function z(e){let{fields:t}=e;for(let e of t)if(ye(e))return!0;return!1}function B(e){let{kind:t,relationName:n}=e;return t===`object`&&!!n}function ye(e){return B(e)&&e.isList}function be(e,t){return e.find(({name:e})=>e===t)}const V=(e,t,n=!0)=>t.forEach(t=>e.write(t).conditionalNewLine(n)),H=({modelCase:e,modelSuffix:t,relationModel:n})=>{let r=(n,r=``)=>(e===`camelCase`&&(n=n.slice(0,1).toLowerCase()+n.slice(1)),`${r}${n}${t}`);return{modelName:e=>r(e,n===`default`?`_`:``),relatedModelName:e=>r(n===`default`?e.toString():`Related${e.toString()}`)}},U=e=>{let t=e.replace(/^\\\\\?\\/,``).replace(/\\/g,`/`).replace(/\/{2,}/g,`/`);return t.includes(`/node_modules/`)?t.split(`/node_modules/`).slice(-1)[0]:t.startsWith(`../`)?t:`./${t}`},xe=(e,t)=>e.reduce((e,n,r)=>r%t===0?[...e,[n]]:[...e.slice(0,-1),[...e.slice(-1)[0],n]],[]),Se=(e,t)=>e.fields.some(e=>e.kind===`object`)&&t.relationModel!==!1,Ce=async(e,t,n,r)=>{let i=(await F()).parseEnvValue(r.generator.output),{relatedModelName:a}=H(n),o=[{kind:h.StructureKind.ImportDeclaration,namespaceImport:`z`,moduleSpecifier:`zod`}];n.imports&&o.push({kind:h.StructureKind.ImportDeclaration,namespaceImport:`imports`,moduleSpecifier:U(f.default.relative(i,f.default.resolve(f.default.dirname(r.schemaPath),n.imports)))}),n.useDecimalJs&&e.fields.some(e=>e.type===`Decimal`)&&o.push({kind:h.StructureKind.ImportDeclaration,namedImports:[`Decimal`],moduleSpecifier:`decimal.js`});let s=e.fields.filter(e=>e.kind===`enum`),c=e.fields.filter(e=>e.kind===`object`),l=r.otherGenerators.find(e=>e.provider.value===`prisma-client-js`).output.value,u=f.default.relative(i,l);if(s.length>0&&o.push({kind:h.StructureKind.ImportDeclaration,isTypeOnly:s.length===0,moduleSpecifier:U(u),namedImports:s.map(e=>e.type)}),n.relationModel!==!1&&c.length>0){let t=c.filter(t=>t.type!==e.name);t.length>0&&o.push({kind:h.StructureKind.ImportDeclaration,moduleSpecifier:`./index`,namedImports:Array.from(new Set(t.flatMap(e=>[`${e.type}`,a(e.type)])))})}t.addImportDeclarations(o)},we=e=>L(e).find(e=>e.startsWith(`custom(`))?.slice(7).slice(0,-1),Te=e=>L(e).filter(e=>!e.startsWith(`custom(`)),W=(e,t=e=>e.toString())=>{let n=`z.unknown()`,r=[``];if(e.kind===`scalar`)switch(e.type){case`String`:n=`z.string()`;break;case`Int`:n=`z.number()`,r.push(`int()`);break;case`BigInt`:n=`z.bigint()`;break;case`DateTime`:n=`z.date()`;break;case`Float`:n=`z.number()`;break;case`Decimal`:n=`z.number()`;break;case`Json`:n=`jsonSchema`;break;case`Boolean`:n=`z.boolean()`;break;case`Bytes`:n=`z.unknown()`;break}else e.kind===`enum`?n=`z.nativeEnum(${e.type})`:e.kind===`object`&&(n=t(e.type));return e.isList&&r.push(`array()`),e.documentation&&(n=we(e.documentation)??n,r.push(...Te(e.documentation))),!e.isRequired&&e.type!==`Json`&&r.push(`nullish()`),`${n}${r.join(`.`)}`},Ee=(e,t,n)=>{e.fields.some(e=>e.type===`Json`)&&t.addStatements(e=>{e.newLine(),V(e,[`// Helper schema for JSON fields`,`type Literal = boolean | number | string${n.prismaJsonNullability?``:`| null`}`,`type Json = Literal | { [key: string]: Json } | Json[]`,`const literalSchema = z.union([z.string(), z.number(), z.boolean()${n.prismaJsonNullability?``:`, z.null()`}])`,`const jsonSchema: z.ZodSchema<Json> = z.lazy(() => z.union([literalSchema, z.array(jsonSchema), z.record(jsonSchema)]))`])}),n.useDecimalJs&&e.fields.some(e=>e.type===`Decimal`)&&t.addStatements(e=>{e.newLine(),V(e,[`// Helper schema for Decimal fields`,`z`,`.instanceof(Decimal)`,`.or(z.string())`,`.or(z.number())`,`.refine((value) => {`,`  try {`,`    return new Decimal(value);`,`  } catch (error) {`,`    return false;`,`  }`,`})`,`.transform((value) => new Decimal(value));`])})},De=(e,t,n)=>{let{modelName:r}=H(n);t.addVariableStatement({declarationKind:h.VariableDeclarationKind.Const,isExported:!0,leadingTrivia:e=>e.blankLineIfLastNot(),declarations:[{name:r(e.name),initializer(t){t.write(`z.object(`).inlineBlock(()=>{e.fields.filter(e=>e.kind!==`object`).forEach(e=>{V(t,I(e.documentation)),t.write(`${e.name}: ${W(e)}`).write(`,`).newLine()})}).write(`)`)}}]})},Oe=(e,t,n)=>{let{modelName:r,relatedModelName:i}=H(n),a=e.fields.filter(e=>e.kind===`object`);t.addInterface({name:`${e.name}`,isExported:!0,extends:[`z.infer<typeof ${r(e.name)}>`],properties:a.map(e=>({hasQuestionToken:!e.isRequired,name:e.name,type:`${e.type}${e.isList?`[]`:``}${e.isRequired?``:` | null`}`}))}),t.addStatements(t=>V(t,[``,`/**`,` * ${i(e.name)} contains all relations on your model in addition to the scalars`,` *`,` * NOTE: Lazy required in case of potential circular dependencies within schema`,` */`])),t.addVariableStatement({declarationKind:h.VariableDeclarationKind.Const,isExported:!0,declarations:[{name:i(e.name),type:`z.ZodSchema<${e.name}>`,initializer(t){t.write(`z.lazy(() => ${r(e.name)}.extend(`).inlineBlock(()=>{a.forEach(e=>{V(t,I(e.documentation)),t.write(`${e.name}: ${W(e,i)}`).write(`,`).newLine()})}).write(`))`)}}]})},ke=async(e,t,n,r)=>{await Ce(e,t,n,r),Ee(e,t,n),De(e,t,n),Se(e,n)&&Oe(e,t,n)},Ae=(e,t)=>{e.forEach(e=>t.addExportDeclaration({moduleSpecifier:`./${C(e.name)}.schema`}))},G=e=>e.withShield?`shieldedProcedure`:e.withMiddleware?`protectedProcedure`:`publicProcedure`,K=({sourceFile:e,config:t})=>{let n=[`t`];t&&n.push(G(t)),e.addImportDeclaration({moduleSpecifier:`../trpc`,namedImports:n})},je=(e,t,n)=>{e.addImportDeclaration({moduleSpecifier:`./${C(n)}.router`,namedImports:[`${t}Router`]})};async function Me(e,t,n,r){t.withShield&&e.addImportDeclaration({moduleSpecifier:(0,m.relativePath)(r,(0,d.joinPaths)(r,typeof t.withShield==`string`?t.withShield:`shield`)),namedImports:[`permissions`]}),e.addStatements(`import type { Context } from '${(0,m.relativePath)(r,(0,d.joinPaths)(r,t.contextPath))}';`),t.trpcOptions&&e.addStatements(`import trpcOptions from '${typeof t.trpcOptions==`string`?(0,m.relativePath)(r,(0,d.joinPaths)(r,t.trpcOptions)):`./options`}';`),t.withNext&&e.addStatements(`import { createContext } from '${(0,m.relativePath)(r,(0,d.joinPaths)(r,t.contextPath))}';
 import { initTRPC } from '@trpc/server';
 import { createTRPCServerActionHandler } from '@stryke/trpc-next/action-handler';
-import { cookies } from "next/headers";`
-    );
-  }
-  sourceFile.addStatements(
-    /* ts */
-    `
-export const t = initTRPC.context<Context>().create(${config.trpcOptions ? "trpcOptions" : ""});`
-  );
-  const middlewares = [];
-  if (config.withMiddleware && typeof config.withMiddleware === "boolean") {
-    sourceFile.addStatements(
-      /* ts */
-      `
+import { cookies } from "next/headers";`),e.addStatements(`
+export const t = initTRPC.context<Context>().create(${t.trpcOptions?`trpcOptions`:``});`);let i=[];if(t.withMiddleware&&typeof t.withMiddleware==`boolean`&&(e.addStatements(`
 export const globalMiddleware = t.middleware(async ({ ctx, next }) => {
   console.log('inside middleware!')
   return next()
-});`
-    );
-    middlewares.push({
-      type: "global",
-      value: (
-        /* ts */
-        `.use(globalMiddleware)`
-      )
-    });
-  }
-  if (config.withMiddleware && typeof config.withMiddleware === "string") {
-    sourceFile.addStatements(
-      /* ts */
-      `
-import middleware from '${(0, import_file_path_fns.relativePath)(outputDir, (0, import_join_paths3.joinPaths)(outputDir, typeof config.withMiddleware === "string" ? config.withMiddleware : "middleware"))}';
-  `
-    );
-    sourceFile.addStatements(
-      /* ts */
-      `
-export const globalMiddleware = t.middleware(middleware);`
-    );
-    middlewares.push({
-      type: "global",
-      value: (
-        /* ts */
-        `.use(globalMiddleware)`
-      )
-    });
-  }
-  if (config.withShield) {
-    sourceFile.addStatements(
-      /* ts */
-      `
+});`),i.push({type:`global`,value:`.use(globalMiddleware)`})),t.withMiddleware&&typeof t.withMiddleware==`string`&&(e.addStatements(`
+import middleware from '${(0,m.relativePath)(r,(0,d.joinPaths)(r,typeof t.withMiddleware==`string`?t.withMiddleware:`middleware`))}';
+  `),e.addStatements(`
+export const globalMiddleware = t.middleware(middleware);`),i.push({type:`global`,value:`.use(globalMiddleware)`})),t.withShield&&(e.addStatements(`
 export const permissionsMiddleware = t.middleware(permissions);
-    `
-    );
-    middlewares.push({
-      type: "shield",
-      value: (
-        /* ts */
-        `
-      .use(permissions)`
-      )
-    });
-  }
-  sourceFile.addStatements(
-    /* ts */
-    `
+    `),i.push({type:`shield`,value:`
+      .use(permissions)`})),e.addStatements(`
 /**
  * Create a server-side caller
  * @see https://trpc.io/docs/server/server-side-calls
  */
-export const createCallerFactory = t.createCallerFactory;`
-  );
-  sourceFile.addStatements(
-    /* ts */
-    `
-export const publicProcedure = t.procedure; `
-  );
-  if (middlewares.length > 0) {
-    const procName = getProcedureName(config);
-    middlewares.forEach((middleware, i) => {
-      if (i === 0) {
-        sourceFile.addStatements(
-          /* ts */
-          `
-export const ${procName} = t.procedure`
-        );
-      }
-      sourceFile.addStatements(
-        /* ts */
-        `.use(${middleware.type === "shield" ? "permissionsMiddleware" : "globalMiddleware"})`
-      );
-    });
-  }
-  if (config.withNext) {
-    sourceFile.addStatements(
-      /* ts */
-      `
+export const createCallerFactory = t.createCallerFactory;`),e.addStatements(`
+export const publicProcedure = t.procedure; `),i.length>0){let n=G(t);i.forEach((t,r)=>{r===0&&e.addStatements(`
+export const ${n} = t.procedure`),e.addStatements(`.use(${t.type===`shield`?`permissionsMiddleware`:`globalMiddleware`})`)})}t.withNext&&e.addStatements(`
 export const createAction: ReturnType<typeof createTRPCServerActionHandler> =
   createTRPCServerActionHandler(cookies, t, createContext);
-`
-    );
-  }
-  sourceFile.formatText({
-    indentSize: 2
-  });
-}
-__name(generateTRPCExports, "generateTRPCExports");
-function generateProcedure(sourceFile, name, typeName, modelName, opType, baseOpType, config) {
-  let input = `input${!config.withZod ? " as any" : ""}`;
-  const nameWithoutModel = name.replace(modelName, "");
-  if (nameWithoutModel === "groupBy" && config.withZod) {
-    input = "{ where: input.where, orderBy: input.orderBy, by: input.by, having: input.having, take: input.take, skip: input.skip }";
-  }
-  sourceFile.addStatements(
-    /* ts */
-    `${config.showModelNameInProcedure ? name : nameWithoutModel}: ${getProcedureName(config)}
-  ${config.withZod ? `.input(${lowerCaseFirst(typeName)})` : ""}.${getProcedureTypeByOpName(baseOpType)}(async ({ ctx, input }) => {
-    const ${name} = await ctx.prisma.${lowerCaseFirst(modelName)}.${opType.replace("One", "")}(${input});
-    return ${name};
-  }),`
-  );
-}
-__name(generateProcedure, "generateProcedure");
-function generateRouterSchemaImports(sourceFile, modelName, modelActions) {
-  sourceFile.addStatements(
-    /* ts */
-    [
-      // remove any duplicate import statements
-      ...new Set(modelActions.map((opName) => getRouterSchemaImportByOpName(opName, modelName)))
-    ].join("\n")
-  );
-}
-__name(generateRouterSchemaImports, "generateRouterSchemaImports");
-var getRouterSchemaImportByOpName = /* @__PURE__ */ __name((opName, modelName) => {
-  const opType = opName.replace("OrThrow", "").replace("ManyAndReturn", "");
-  const inputType = getInputTypeByOpName(opType, modelName);
-  return inputType ? `import { ${lowerCaseFirst(inputType)} } from "../schemas/${lowerCaseFirst(opType)}${modelName}.schema"; ` : "";
-}, "getRouterSchemaImportByOpName");
-var getInputTypeByOpName = /* @__PURE__ */ __name((opName, modelName) => {
-  let inputType;
-  switch (opName) {
-    case "findUnique":
-      inputType = `${modelName}FindUniqueSchema`;
-      break;
-    case "findFirst":
-      inputType = `${modelName}FindFirstSchema`;
-      break;
-    case "findMany":
-      inputType = `${modelName}FindManySchema`;
-      break;
-    case "findRaw":
-      inputType = `${modelName}FindRawObjectSchema`;
-      break;
-    case "createOne":
-      inputType = `${modelName}CreateOneSchema`;
-      break;
-    case "createMany":
-      inputType = `${modelName}CreateManySchema`;
-      break;
-    case "createManyAndReturn":
-      inputType = `${modelName}CreateManySchema`;
-      break;
-    case "deleteOne":
-      inputType = `${modelName}DeleteOneSchema`;
-      break;
-    case "deleteMany":
-      inputType = `${modelName}DeleteManySchema`;
-      break;
-    case "updateOne":
-      inputType = `${modelName}UpdateOneSchema`;
-      break;
-    case "updateMany":
-      inputType = `${modelName}UpdateManySchema`;
-      break;
-    case "updateManyAndReturn":
-      inputType = `${modelName}UpdateManySchema`;
-      break;
-    case "upsertOne":
-      inputType = `${modelName}UpsertSchema`;
-      break;
-    case "aggregate":
-      inputType = `${modelName}AggregateSchema`;
-      break;
-    case "aggregateRaw":
-      inputType = `${modelName}AggregateRawObjectSchema`;
-      break;
-    case "groupBy":
-      inputType = `${modelName}GroupBySchema`;
-      break;
-    default:
-      console.log("getInputTypeByOpName: ", {
-        opName,
-        modelName
-      });
-  }
-  return inputType;
-}, "getInputTypeByOpName");
-var getProcedureTypeByOpName = /* @__PURE__ */ __name((opName) => {
-  let procType;
-  switch (opName) {
-    case "findUnique":
-    case "findFirst":
-    case "findMany":
-    case "findRaw":
-    case "aggregate":
-    case "aggregateRaw":
-    case "groupBy":
-      procType = "query";
-      break;
-    case "createOne":
-    case "createMany":
-    case "createManyAndReturn":
-    case "deleteOne":
-    case "updateOne":
-    case "deleteMany":
-    case "updateMany":
-    case "updateManyAndReturn":
-    case "upsertOne":
-      procType = "mutation";
-      break;
-    default:
-      console.log("getProcedureTypeByOpName: ", {
-        opName
-      });
-  }
-  return procType;
-}, "getProcedureTypeByOpName");
-function resolveModelsComments(models, hiddenModels) {
-  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(modelAttributeRegex2)?.[0];
-      const attributeName = attribute?.match(attributeNameRegex2)?.[0]?.slice(1, -1);
-      if (attributeName !== "model") continue;
-      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());
-        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);
-      }
-    }
-  }
-}
-__name(resolveModelsComments, "resolveModelsComments");
-var getImports = /* @__PURE__ */ __name((type, newPath) => {
-  let statement = "";
-  if (type === "trpc") {
-    statement = "import * as trpc from '@trpc/server';\n";
-  } else if (type === "trpc-shield") {
-    statement = "import { shield, allow } from '@stryke/trpc-next/shield';\n";
-  } else if (type === "context") {
-    statement = `import type { Context } from '${newPath}';
-`;
-  }
-  return statement;
-}, "getImports");
-var wrapWithObject = /* @__PURE__ */ __name(({ shieldItemLines }) => {
-  let wrapped = "{";
-  wrapped += "\n";
-  wrapped += Array.isArray(shieldItemLines) ? `  ${shieldItemLines.join(",\r\n")}` : `  ${shieldItemLines}`;
-  wrapped += "\n";
-  wrapped += "}";
-  return wrapped;
-}, "wrapWithObject");
-var wrapWithTrpcShieldCall = /* @__PURE__ */ __name(({ shieldObjectTextWrapped }) => {
-  let wrapped = "shield<Context>(";
-  wrapped += "\n";
-  wrapped += `  ${shieldObjectTextWrapped}`;
-  wrapped += "\n";
-  wrapped += ")";
-  return wrapped;
-}, "wrapWithTrpcShieldCall");
-var wrapWithExport = /* @__PURE__ */ __name(({ shieldObjectText }) => {
-  return `export const permissions: ReturnType<typeof shield<Context>> = ${shieldObjectText};`;
-}, "wrapWithExport");
-var constructShield = /* @__PURE__ */ __name(async ({ queries, mutations, subscriptions }, config, options, outputDir) => {
-  if (queries.length === 0 && mutations.length === 0 && subscriptions.length === 0) {
-    return "";
-  }
-  let rootItems = "";
-  if (queries.length > 0) {
-    const queryLinesWrapped = `query: ${wrapWithObject({
-      shieldItemLines: queries.map((query) => `${query}: allow`)
-    })},`;
-    rootItems += queryLinesWrapped;
-  }
-  if (mutations.length > 0) {
-    const mutationLinesWrapped = `mutation: ${wrapWithObject({
-      shieldItemLines: mutations.map((mutation) => `${mutation}: allow`)
-    })},`;
-    rootItems += mutationLinesWrapped;
-  }
-  if (subscriptions.length > 0) {
-    const subscriptionLinesWrapped = `subscription: ${wrapWithObject({
-      shieldItemLines: subscriptions.map((subscription) => `${subscription}: allow`)
-    })},`;
-    rootItems += subscriptionLinesWrapped;
-  }
-  if (rootItems.length === 0) {
-    return "";
-  }
-  let shieldText = getImports("trpc-shield");
-  shieldText += getImports("context", (0, import_file_path_fns.relativePath)(outputDir, (0, import_join_paths3.joinPaths)(outputDir, config.contextPath)));
-  shieldText += "\n\n";
-  shieldText += wrapWithExport({
-    shieldObjectText: wrapWithTrpcShieldCall({
-      shieldObjectTextWrapped: wrapWithObject({
-        shieldItemLines: rootItems
-      })
-    })
-  });
-  return shieldText;
-}, "constructShield");
-var constructDefaultOptions = /* @__PURE__ */ __name((config, options, outputDir) => {
-  return `import { ZodError } from 'zod';${config.withNext ? '\nimport { transformer } from "@stryke/trpc-next/shared";' : ""}
+`),e.formatText({indentSize:2})}function Ne(e,t,n,r,i,a,o){let s=`input${o.withZod?``:` as any`}`,c=t.replace(r,``);c===`groupBy`&&o.withZod&&(s=`{ where: input.where, orderBy: input.orderBy, by: input.by, having: input.having, take: input.take, skip: input.skip }`),e.addStatements(`${o.showModelNameInProcedure?t:c}: ${G(o)}
+  ${o.withZod?`.input(${C(n)})`:``}.${Ie(a)}(async ({ ctx, input }) => {
+    const ${t} = await ctx.prisma.${C(r)}.${i.replace(`One`,``)}(${s});
+    return ${t};
+  }),`)}function Pe(e,t,n){e.addStatements([...new Set(n.map(e=>Fe(e,t)))].join(`
+`))}const Fe=(e,t)=>{let n=e.replace(`OrThrow`,``).replace(`ManyAndReturn`,``),r=q(n,t);return r?`import { ${C(r)} } from "../schemas/${C(n)}${t}.schema"; `:``},q=(e,t)=>{let n;switch(e){case`findUnique`:n=`${t}FindUniqueSchema`;break;case`findFirst`:n=`${t}FindFirstSchema`;break;case`findMany`:n=`${t}FindManySchema`;break;case`findRaw`:n=`${t}FindRawObjectSchema`;break;case`createOne`:n=`${t}CreateOneSchema`;break;case`createMany`:n=`${t}CreateManySchema`;break;case`createManyAndReturn`:n=`${t}CreateManySchema`;break;case`deleteOne`:n=`${t}DeleteOneSchema`;break;case`deleteMany`:n=`${t}DeleteManySchema`;break;case`updateOne`:n=`${t}UpdateOneSchema`;break;case`updateMany`:n=`${t}UpdateManySchema`;break;case`updateManyAndReturn`:n=`${t}UpdateManySchema`;break;case`upsertOne`:n=`${t}UpsertSchema`;break;case`aggregate`:n=`${t}AggregateSchema`;break;case`aggregateRaw`:n=`${t}AggregateRawObjectSchema`;break;case`groupBy`:n=`${t}GroupBySchema`;break;default:console.log(`getInputTypeByOpName: `,{opName:e,modelName:t})}return n},Ie=e=>{let t;switch(e){case`findUnique`:case`findFirst`:case`findMany`:case`findRaw`:case`aggregate`:case`aggregateRaw`:case`groupBy`:t=`query`;break;case`createOne`:case`createMany`:case`createManyAndReturn`:case`deleteOne`:case`updateOne`:case`deleteMany`:case`updateMany`:case`updateManyAndReturn`:case`upsertOne`:t=`mutation`;break;default:console.log(`getProcedureTypeByOpName: `,{opName:e})}return t};function Le(e,t){let n=/(?:@@Gen\.)+[A-z]+\(.+\)/,r=/\.+[A-Z]+\(+/i,i=/\(+[A-Z]+:.+\)/i;for(let a of e)if(a.documentation){let e=a.documentation?.match(n)?.[0];if(e?.match(r)?.[0]?.slice(1,-1)!==`model`)continue;let o=e?.match(i)?.[0]?.slice(1,-1),s={};if(o){let e=o.split(`:`).map(e=>e.trim()).map(e=>e.startsWith(`[`)?e:e.split(`,`)).flat().map(e=>e.trim());for(let t=0;t<e.length;t+=2){let n=e[t],r=e[t+1];s[n]=JSON.parse(r)}}s.hide&&t.push(a.name)}}const J=(e,t)=>{let n=``;return e===`trpc`?n=`import * as trpc from '@trpc/server';
+`:e===`trpc-shield`?n=`import { shield, allow } from '@stryke/trpc-next/shield';
+`:e===`context`&&(n=`import type { Context } from '${t}';\n`),n},Y=({shieldItemLines:e})=>{let t=`{`;return t+=`
+`,t+=Array.isArray(e)?`  ${e.join(`,\r
+`)}`:`  ${e}`,t+=`
+`,t+=`}`,t},Re=({shieldObjectTextWrapped:e})=>{let t=`shield<Context>(`;return t+=`
+`,t+=`  ${e}`,t+=`
+`,t+=`)`,t},ze=({shieldObjectText:e})=>`export const permissions: ReturnType<typeof shield<Context>> = ${e};`,Be=async({queries:e,mutations:t,subscriptions:n},r,i,a)=>{if(e.length===0&&t.length===0&&n.length===0)return``;let o=``;if(e.length>0){let t=`query: ${Y({shieldItemLines:e.map(e=>`${e}: allow`)})},`;o+=t}if(t.length>0){let e=`mutation: ${Y({shieldItemLines:t.map(e=>`${e}: allow`)})},`;o+=e}if(n.length>0){let e=`subscription: ${Y({shieldItemLines:n.map(e=>`${e}: allow`)})},`;o+=e}if(o.length===0)return``;let s=J(`trpc-shield`);return s+=J(`context`,(0,m.relativePath)(a,(0,d.joinPaths)(a,r.contextPath))),s+=`
+
+`,s+=ze({shieldObjectText:Re({shieldObjectTextWrapped:Y({shieldItemLines:o})})}),s},Ve=(e,t,n)=>`import { ZodError } from 'zod';${e.withNext?`
+import { transformer } from "@stryke/trpc-next/shared";`:``}
 import type {
   DataTransformerOptions,
   RootConfig
 } from "@trpc/server/unstable-core-do-not-import";
-import type { Context } from "${(0, import_file_path_fns.relativePath)(outputDir, (0, import_join_paths3.joinPaths)(outputDir, config.contextPath))}";
+import type { Context } from "${(0,m.relativePath)(n,(0,d.joinPaths)(n,e.contextPath))}";
 
 interface RuntimeConfigOptions<
   TContext extends object,
@@ -2745,7 +67,8 @@ interface RuntimeConfigOptions<
   transformer?: DataTransformerOptions;
 }
 
-const options: RuntimeConfigOptions<Context> = {${config.withNext ? "\n transformer," : ""}
+const options: RuntimeConfigOptions<Context> = {${e.withNext?`
+ transformer,`:``}
   errorFormatter({ shape, error }) {
     return {
       ...shape,
@@ -2761,1442 +84,33 @@ const options: RuntimeConfigOptions<Context> = {${config.withNext ? "\n transfor
 };
 
 export default options;
-`;
-}, "constructDefaultOptions");
-var constructZodModels = /* @__PURE__ */ __name(async (models, outputPath, config, options) => {
-  const indexFile = project.createSourceFile(`${outputPath}/index.ts`, {}, {
-    overwrite: true
-  });
-  generateBarrelFile(models, indexFile);
-  indexFile.formatText({
-    indentSize: 2
-  });
-  await Promise.all(models.map(async (model) => {
-    const sourceFile = project.createSourceFile(`${outputPath}/${lowerCaseFirst(model.name)}.schema.ts`, {}, {
-      overwrite: true
-    });
-    await populateModelFile(model, sourceFile, config, options);
-    sourceFile.formatText({
-      indentSize: 2
-    });
-  }));
-}, "constructZodModels");
-
-// src/utils/write-file-safely.ts
-init_cjs_shims();
-var import_helpers = require("@stryke/fs/helpers");
-var import_write_file = require("@stryke/fs/write-file");
-var import_correct_path = require("@stryke/path/correct-path");
-var import_file_path_fns2 = require("@stryke/path/file-path-fns");
-var import_node_path3 = __toESM(require("node:path"), 1);
-
-// src/utils/format-file.ts
-init_cjs_shims();
-var import_prettier = __toESM(require("prettier"), 1);
-async function formatFile(content) {
-  const options = await import_prettier.default.resolveConfig(process.cwd());
-  let formatOptions = options;
-  if (!options) {
-    formatOptions = {
-      trailingComma: "all",
-      tabWidth: 2,
-      printWidth: 80,
-      bracketSpacing: true,
-      semi: true,
-      singleQuote: true,
-      useTabs: false
-    };
-  }
-  const formatted = await import_prettier.default.format(content, {
-    ...formatOptions,
-    parser: "typescript"
-  });
-  return formatted;
-}
-__name(formatFile, "formatFile");
-
-// src/utils/write-file-safely.ts
-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),
-    (0, import_helpers.createDirectory)((0, import_file_path_fns2.findFilePath)(writeLocation))
-  ]);
-  await (0, import_write_file.writeFile)(writeLocation, fileContent);
-  if (addToIndex) {
-    addIndexExport(writeLocation);
-  }
-}, "writeFileSafely");
-var writeIndexFile = /* @__PURE__ */ __name(async (indexPath) => {
-  const rows = Array.from(indexExports).map((filePath) => {
-    let relativePath2 = import_node_path3.default.relative(import_node_path3.default.dirname(indexPath), filePath);
-    if (relativePath2.endsWith(".ts")) {
-      relativePath2 = relativePath2.slice(0, relativePath2.lastIndexOf(".ts"));
-    }
-    const normalized = (0, import_correct_path.correctPath)(relativePath2);
-    return `export * from './${normalized}';`;
-  });
-  rows.push("export * from './models';");
-  await writeFileSafely(indexPath, rows.join("\n"), false);
-}, "writeIndexFile");
-
-// src/zod/aggregate-helpers.ts
-init_cjs_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/comments-helpers.ts
-init_cjs_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/generator-helpers.ts
-init_cjs_shims();
-
-// src/zod/transformer.ts
-init_cjs_shims();
-var import_node_path4 = __toESM(require("node:path"), 1);
-
-// src/zod/mongodb-helpers.ts
-init_cjs_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/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 = true;
-  static isGenerateInclude = true;
-  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 = import_node_path4.default.join(_Transformer.outputPath, "schemas/index.ts");
-    await writeIndexFile(indexPath);
-  }
-  async generateEnumSchemas() {
-    for (const enumType of this.enumTypes) {
-      const { name, values } = enumType;
-      await writeFileSafely(import_node_path4.default.join(_Transformer.outputPath, `schemas/enums/${lowerCaseFirst(name)}.schema.ts`), `${this.generateImportZodStatement()}
-${this.generateExportSchemaStatement(`${lowerCaseFirst(name)}`, `z.enum(${JSON.stringify(values)})`)}`);
-    }
-  }
-  generateImportZodStatement() {
-    return "import { z } from 'zod';\n";
-  }
-  generateExportSchemaStatement(name, schema) {
-    return `export const ${lowerCaseFirst(name)}Schema = ${schema}`;
-  }
-  async generateObjectSchema() {
-    const zodObjectSchemaFields = this.generateObjectSchemaFields();
-    const objectSchema = this.prepareObjectSchema(zodObjectSchemaFields);
-    const objectSchemaName = this.resolveObjectSchemaName();
-    await writeFileSafely(import_node_path4.default.join(_Transformer.outputPath, `schemas/objects/${lowerCaseFirst(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 if (!inputType.type.endsWith("FieldRefInput")) {
-        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) {
-    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, inputType, inputsLength) {
-    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()" : "";
-    return inputsLength === 1 ? `  ${field.name}: z.lazy(() => ${lowerCaseFirst(schema)})${arr}${opt}` : `z.lazy(() => ${lowerCaseFirst(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 (_Transformer.provider === "mongodb") {
-      if (isMongodbRawOp(name)) {
-        name = _Transformer.rawOpsMap[name];
-        exportName = name.replace("Args", "");
-      }
-    }
-    if (isAggregateInputType(name)) {
-      name = `${name}Type`;
-    }
-    const end = `export const ${lowerCaseFirst(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 = import_node_path4.default.join(_Transformer.outputPath, "schemas", "objects");
-      const toPath = _Transformer.prismaClientOutputPath;
-      const relativePathFromOutputToPrismaClient = import_node_path4.default.relative(fromPath, toPath).split(import_node_path4.default.sep).join(import_node_path4.default.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 { ${lowerCaseFirst(name)}Schema } from '../enums/${lowerCaseFirst(name)}.schema'`;
-      } else {
-        return `import { ${lowerCaseFirst(name)}ObjectSchema } from './${lowerCaseFirst(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 modelNameUncapitalized = lowerCaseFirst(modelName);
-    const queryNameCapitalized = upperCaseFirst(queryName);
-    return `${modelNameUncapitalized}${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 lowerCaseFirst(exportName);
-  }
-  async generateModelSchemas() {
-    for (const modelOperation of this.modelOperations) {
-      const {
-        findUnique,
-        findFirst,
-        findMany,
-        // @ts-ignore
-        createOne,
-        createMany,
-        createManyAndReturn,
-        // @ts-ignore
-        deleteOne,
-        // @ts-ignore
-        updateOne,
-        deleteMany,
-        updateMany,
-        updateManyAndReturn,
-        // @ts-ignore
-        upsertOne,
-        aggregate,
-        groupBy
-      } = modelOperation;
-      const model = findModelByName(this.models, modelOperation.model);
-      const modelName = lowerCaseFirst(modelOperation.model);
-      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(import_node_path4.default.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(import_node_path4.default.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(import_node_path4.default.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(import_node_path4.default.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(import_node_path4.default.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 (createManyAndReturn) {
-        const imports = [
-          `import { ${modelName}CreateManyAndReturnInputObjectSchema } from './objects/${modelName}CreateManyAndReturnInput.schema'`
-        ];
-        await writeFileSafely(import_node_path4.default.join(_Transformer.outputPath, `schemas/${createManyAndReturn}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}CreateManyAndReturn`, `z.object({ data: z.union([ ${modelName}CreateManyAndReturnInputObjectSchema, z.array(${modelName}CreateManyAndReturnInputObjectSchema) ]), ${_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(import_node_path4.default.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(import_node_path4.default.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(import_node_path4.default.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(import_node_path4.default.join(_Transformer.outputPath, `schemas/${updateMany}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}UpdateMany`, `z.object({ data: ${modelName}UpdateManyMutationInputObjectSchema, where: ${modelName}WhereInputObjectSchema.optional()  })`)}`);
-      }
-      if (updateManyAndReturn) {
-        const imports = [
-          `import { ${modelName}UpdateManyAndReturnInputObjectSchema } from './objects/${modelName}UpdateManyAndReturnInput.schema'`
-        ];
-        await writeFileSafely(import_node_path4.default.join(_Transformer.outputPath, `schemas/${updateManyAndReturn}.schema.ts`), `${this.generateImportStatements(imports)}${this.generateExportSchemaStatement(`${modelName}UpdateManyAndReturn`, `z.object({ data: z.union([ ${modelName}UpdateManyAndReturnInputObjectSchema, z.array(${modelName}UpdateManyAndReturnInputObjectSchema) ]), ${_Transformer.provider === "mongodb" || _Transformer.provider === "sqlserver" ? "" : "skipDuplicates: z.boolean().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(import_node_path4.default.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(import_node_path4.default.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(import_node_path4.default.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 { ${lowerCaseFirst(modelName)}SelectObjectSchema } from './objects/${lowerCaseFirst(modelName)}Select.schema'` : "";
-    const includeImport = _Transformer.isGenerateInclude && hasRelationToAnotherModel ? `import { ${lowerCaseFirst(modelName)}IncludeObjectSchema } from './objects/${lowerCaseFirst(modelName)}Include.schema'` : "";
-    let selectZodSchemaLine = "";
-    let includeZodSchemaLine = "";
-    let selectZodSchemaLineLazy = "";
-    let includeZodSchemaLineLazy = "";
-    if (_Transformer.isGenerateSelect) {
-      const zodSelectObjectSchema = `${lowerCaseFirst(modelName)}SelectObjectSchema.optional()`;
-      selectZodSchemaLine = `select: ${zodSelectObjectSchema},`;
-      selectZodSchemaLineLazy = `select: z.lazy(() => ${zodSelectObjectSchema}),`;
-    }
-    if (_Transformer.isGenerateInclude && hasRelationToAnotherModel) {
-      const zodIncludeObjectSchema = `${lowerCaseFirst(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 = `${lowerCaseFirst(modelName)}OrderByWithRelationAndSearchRelevanceInput`;
-    } else {
-      modelOrderBy = `${lowerCaseFirst(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/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.ts
-init_cjs_shims();
-
-// src/zod/include-helpers.ts
-init_cjs_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}DefaultArgs`,
-              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}CountOutputTypeDefaultArgs`,
-          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/modelArgs-helpers.ts
-init_cjs_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}DefaultArgs`,
-      constraints: {
-        maxNumFields: null,
-        minNumFields: null
-      },
-      fields
-    };
-    modelArgsInputObjectTypes.push(modelArgsInputObjectType);
-  }
-  return modelArgsInputObjectTypes;
-}
-__name(generateModelArgsInputObjectTypes, "generateModelArgsInputObjectTypes");
-
-// src/zod/select-helpers.ts
-init_cjs_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}DefaultArgs`,
-      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}DefaultArgs`,
-          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}CountOutputTypeDefaultArgs`,
-            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/whereUniqueInput-helpers.ts
-init_cjs_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.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) {
-  console.log("[STORM]: Running the Storm Software - Prisma tRPC generator \n");
-  const internals = await getPrismaInternals();
-  console.log(`[STORM]: Validating configuration options 
-`);
-  const outputDir = internals.parseEnvValue(options.generator.output);
-  const results = await configSchema.safeParseAsync(options.generator.config);
-  if (!results.success) {
-    throw new Error("Invalid options passed");
-  }
-  const config = results.data;
-  const consoleLog = /* @__PURE__ */ __name((message) => {
-    if (config.debug) {
-      console.log(`[STORM]: ${message} 
-`);
-    }
-  }, "consoleLog");
-  consoleLog(`Using configuration parameters: 
-${JSON.stringify(config)}`);
-  consoleLog(`Preparing output directory: ${outputDir}`);
-  await (0, import_helpers2.removeDirectory)(outputDir);
-  await (0, import_helpers2.createDirectory)(outputDir);
-  consoleLog("Finding Prisma Client generator");
-  const prismaClientProvider = options.otherGenerators.find((it) => internals.parseEnvValue(it.provider) === "prisma-client-js");
-  if (!prismaClientProvider) {
-    throw new Error("No Prisma Client generator found. Please add `prisma-client-js` to your generator list.");
-  }
-  consoleLog("Generating Prisma Client DMMF");
-  const prismaClientDmmf = await internals.getDMMF({
-    datamodel: options.datamodel,
-    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 (0, import_helpers2.createDirectory)(zodOutputPath);
-    Transformer.setOutputPath(zodOutputPath);
-    if (prismaClientProvider?.isCustomOutput) {
-      Transformer.setPrismaClientOutputPath(prismaClientProvider.output?.value);
-    }
-    await constructZodModels(models, (0, import_join_paths4.joinPaths)(zodOutputPath, "schemas", "models"), config, options);
-    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");
-  }
-  const queries = [];
-  const mutations = [];
-  const subscriptions = [];
-  prismaClientDmmf.mappings.modelOperations.forEach((modelOperation) => {
-    const { model: _model, plural: _plural, ...operations } = modelOperation;
-    for (const [opType, opNameWithModel] of Object.entries(operations)) {
-      if ([
-        "findUnique",
-        "findUniqueOrThrow",
-        "findFirst",
-        "findFirstOrThrow",
-        "findRaw",
-        "findMany",
-        "aggregateRaw",
-        "count",
-        "aggregate",
-        "groupBy"
-      ].includes(opType)) {
-        queries.push(opNameWithModel);
-      }
-      if ([
-        "createOne",
-        "createMany",
-        "createManyAndReturn",
-        "deleteOne",
-        "deleteMany",
-        "updateOne",
-        "updateMany",
-        "updateManyAndReturn",
-        "upsertOne"
-      ].includes(opType)) {
-        mutations.push(opNameWithModel);
-      }
-    }
-  });
-  queries.sort();
-  mutations.sort();
-  subscriptions.sort();
-  if (config.withShield && !(typeof config.withShield === "string" && ((0, import_exists.existsSync)((0, import_join_paths4.joinPaths)(outputDir, config.withShield)) || (0, import_exists.existsSync)((0, import_join_paths4.joinPaths)(outputDir, `./${config.withShield}.ts`)) || (0, import_exists.existsSync)((0, import_join_paths4.joinPaths)(outputDir, config.withShield, "./shield.ts"))))) {
-    consoleLog(`Generating tRPC Shield source file to ${outputDir}`);
-    await writeFileSafely((0, import_join_paths4.joinPaths)(outputDir, "./shield.ts"), await constructShield({
-      queries,
-      mutations,
-      subscriptions
-    }, config, options, outputDir));
-  } else {
-    consoleLog("Skipping tRPC Shield generation");
-  }
-  consoleLog(`Generating tRPC source code for ${models.length} models`);
-  if (config.trpcOptions && typeof config.trpcOptions === "boolean") {
-    consoleLog(`Generating tRPC options source file to ${outputDir}`);
-    await writeFileSafely((0, import_join_paths4.joinPaths)(outputDir, "./options.ts"), constructDefaultOptions(config, options, outputDir));
-  }
-  resolveModelsComments(models, hiddenModels);
-  consoleLog("Generating tRPC export file");
-  const trpcExports = project.createSourceFile(import_node_path5.default.resolve(outputDir, "trpc.ts"), void 0, {
-    overwrite: true
-  });
-  await generateTRPCExports(trpcExports, config, options, outputDir);
-  consoleLog("Generating tRPC app router");
-  const appRouter = project.createSourceFile(import_node_path5.default.resolve(outputDir, "routers", `index.ts`), void 0, {
-    overwrite: true
-  });
-  consoleLog("Generating tRPC router imports");
-  generateCreateRouterImport({
-    sourceFile: appRouter
-  });
-  const routerStatements = [];
-  for (const modelOperation of modelOperations) {
-    const { model, ...operations } = modelOperation;
-    if (hiddenModels.includes(model)) {
-      consoleLog(`Skipping model ${model} as it is hidden`);
-      continue;
-    }
-    if (!model) {
-      consoleLog(`Skipping model ${model} as it is not defined`);
-      continue;
-    }
-    const modelActions = Object.keys(operations).filter((opType) => (
-      // eslint-disable-next-line unicorn/prefer-includes
-      config.generateModelActions.some((generateModelAction) => generateModelAction === opType.replace("One", ""))
-    ));
-    if (!modelActions.length) {
-      consoleLog(`Skipping model ${model} as it has no actions to generate`);
-      continue;
-    }
-    const plural = (0, import_pluralize.default)(lowerCaseFirst(model));
-    consoleLog(`Generating tRPC router for model ${model}`);
-    generateRouterImport(appRouter, plural, model);
-    const modelRouter = project.createSourceFile(import_node_path5.default.resolve(outputDir, "routers", `${lowerCaseFirst(model)}.router.ts`), void 0, {
-      overwrite: true
-    });
-    generateCreateRouterImport({
-      sourceFile: modelRouter,
-      config
-    });
-    if (config.withZod) {
-      consoleLog("Generating Zod schemas imports");
-      generateRouterSchemaImports(modelRouter, model, modelActions);
-    }
-    modelRouter.addStatements(
-      /* ts */
-      `
-      export const ${plural}Router = t.router({`
-    );
-    for (const opType of modelActions) {
-      const opNameWithModel = operations[opType];
-      if (opNameWithModel) {
-        const baseOpType = opType.replace("OrThrow", "");
-        generateProcedure(modelRouter, opNameWithModel, getInputTypeByOpName(baseOpType, model), model, opType, baseOpType, config);
-      }
-    }
-    modelRouter.addStatements(
-      /* ts */
-      `
-    })`
-    );
-    modelRouter.formatText({
-      indentSize: 2
-    });
-    routerStatements.push(
-      /* ts */
-      `
-      ${lowerCaseFirst(model)}: ${plural}Router`
-    );
-    consoleLog(`Generated tRPC router for model ${model} with ${modelActions.length} actions`);
-  }
-  consoleLog("Generating tRPC app router");
-  appRouter.addStatements(
-    /* ts */
-    `
-export const appRouter = t.router({${routerStatements.join()}});
-
-export type AppRouter = typeof appRouter;`
-  );
-  appRouter.formatText({
-    indentSize: 2
-  });
-  consoleLog("Saving tRPC router source files to disk");
-  await project.save();
-  consoleLog("Storm Software - Prisma tRPC generator completed successfully");
-}
-__name(generate, "generate");
-
-// src/index.ts
-getPrismaGeneratorHelper().then((helpers) => {
-  helpers.generatorHandler({
-    onManifest: /* @__PURE__ */ __name(() => ({
-      defaultOutput: "./generated",
-      prettyName: "Storm Software - Prisma tRPC Generator",
-      requiresGenerators: [
-        "prisma-client-js"
-      ]
-    }), "onManifest"),
-    onGenerate: generate
-  });
-}).catch((reason) => {
-  console.error(`An error occured while generating prisma tRPC source code: ${reason}`);
-});
+`,He=async(e,t,n,r)=>{let i=O.createSourceFile(`${t}/index.ts`,{},{overwrite:!0});Ae(e,i),i.formatText({indentSize:2}),await Promise.all(e.map(async e=>{let i=O.createSourceFile(`${t}/${C(e.name)}.schema.ts`,{},{overwrite:!0});await ke(e,i,n,r),i.formatText({indentSize:2})}))};async function Ue(e){let t=await S.default.resolveConfig(process.cwd()),n=t;return t||(n={trailingComma:`all`,tabWidth:2,printWidth:80,bracketSpacing:!0,semi:!0,singleQuote:!0,useTabs:!1}),await S.default.format(e,{...n,parser:`typescript`})}const X=new Set,We=e=>{X.add(e)},Z=async(e,t,n=!0)=>{let[r]=await Promise.all([Ue(t),(0,u.createDirectory)((0,m.findFilePath)(e))]);await(0,b.writeFile)(e,r),n&&We(e)},Ge=async e=>{let t=Array.from(X).map(t=>{let n=f.default.relative(f.default.dirname(e),t);return n.endsWith(`.ts`)&&(n=n.slice(0,n.lastIndexOf(`.ts`))),`export * from './${(0,x.correctPath)(n)}';`});t.push(`export * from './models';`),await Z(e,t.join(`
+`),!1)},Ke=e=>/(?:Count|Avg|Sum|Min|Max)AggregateOutputType$/.test(e),Q=e=>e.endsWith(`CountAggregateInput`)||e.endsWith(`SumAggregateInput`)||e.endsWith(`AvgAggregateInput`)||e.endsWith(`MinAggregateInput`)||e.endsWith(`MaxAggregateInput`);function qe(e,t){let n=t.filter(({name:e})=>Ke(e));for(let t of n){let n=t.name.replace(/(?:OutputType|Output)$/,``);e.push({constraints:{maxNumFields:null,minNumFields:null},name:`${n}Input`,fields:t.fields.map(e=>({name:e.name,isNullable:!1,isRequired:!1,inputTypes:[{isList:!1,type:`True`,location:`scalar`}]}))})}}function Je(e){let t={};for(let n of e)if(Q(n.name)){let e=n.name.replace(`AggregateInput`,``);if(e.endsWith(`Count`)){let n=e.replace(`Count`,``);t[n]={...t[n],count:!0}}else if(e.endsWith(`Min`)){let n=e.replace(`Min`,``);t[n]={...t[n],min:!0}}else if(e.endsWith(`Max`)){let n=e.replace(`Max`,``);t[n]={...t[n],max:!0}}else if(e.endsWith(`Sum`)){let n=e.replace(`Sum`,``);t[n]={...t[n],sum:!0}}else if(e.endsWith(`Avg`)){let n=e.replace(`Avg`,``);t[n]={...t[n],avg:!0}}}return t}const Ye=/(?:@@Gen\.)+[A-z]+\(.+\)/,Xe=/\.+[A-Z]+\(+/i,Ze=/\(+[A-Z]+:.+\)/i;function Qe(e,t,n,r,i){e=$e(e,r),et(e,r,i),nt(e,t),tt(n,r)}function $e(e,t){return e.map(e=>{if(e.documentation){let n=e.documentation?.match(Ye)?.[0];if(n?.match(Xe)?.[0]?.slice(1,-1)!==`model`)return e;let r=n?.match(Ze)?.[0]?.slice(1,-1),i={};if(r){let e=r.split(`:`).map(e=>e.trim()).map(e=>e.startsWith(`[`)?e:e.split(`,`)).flat().map(e=>e.trim());for(let t=0;t<e.length;t+=2){let n=e[t],r=e[t+1];i[n]=JSON.parse(r)}}if(i.hide)return t.push(e.name),null}return e}).filter(Boolean)}function et(e,t,n){e.forEach(e=>{e.fields.forEach(e=>{t.includes(e.type)&&(n.push(e.name),e.relationFromFields&&e.relationFromFields.forEach(e=>n.push(e)))})})}function tt(e,t){e.prisma=e.prisma.filter(e=>!t.find(t=>e.name.startsWith(t)))}function nt(e,t){let n=t.length;for(;n>=0;){--n;let r=t[n];r&&!e.find(e=>e.name===r.model)&&t.splice(n,1)}}function rt(e,t,n){let r=e.length;for(;r>=0;){--r;let i=e[r];if(i&&(t.includes(i?.meta?.source)||t.find(e=>i.name.startsWith(e))))e.splice(r,1);else{let t=i?.fields?.length??0;for(;t>=0;){--t;let a=i?.fields?.[t];a&&n.includes(a.name)&&e[r].fields.slice(t,1)}}}}function it(e,t,n){$.rawOpsMap=at(e)??{};let r=ot(t);for(let e of r)n.push(e)}function at(e){let t={},n=[...new Set(e.reduce((e,t)=>(Object.keys(t)?.forEach(t=>{t.includes(`Raw`)&&e.push(t)}),e),[]))],r=e.map(e=>e.model);return n.forEach(e=>{r.forEach(n=>{let r=e===`findRaw`,i=`${e.replace(`Raw`,``)}${n}Raw`;t[i]=r?`${n}FindRawArgs`:`${n}AggregateRawArgs`})}),t}function ot(e){return st(e).map(e=>({name:e.name,constraints:{maxNumFields:null,minNumFields:null},fields:e.args.map(e=>({name:e.name,isRequired:e.isRequired,isNullable:e.isNullable,inputTypes:e.inputTypes}))}))}function st(e){return e.filter(e=>e.name===`Query`)?.[0].fields.filter(e=>e.name.includes(`Raw`))??[]}const ct=e=>/find[\s\S]*?Raw/.test(e)||/aggregate[\s\S]*?Raw/.test(e);var $=class e{name;fields;schemaImports=new Set;models;modelOperations;aggregateOperationSupport;enumTypes;static enumNames=[];static rawOpsMap={};static provider;static previewFeatures;static outputPath=`./generated`;hasJson=!1;static prismaClientOutputPath=`@prisma/client`;static isCustomPrismaClientOutputPath=!1;static isGenerateSelect=!0;static isGenerateInclude=!0;constructor(e){this.name=e.name??``,this.fields=e.fields??[],this.models=e.models??[],this.modelOperations=e.modelOperations??[],this.aggregateOperationSupport=e.aggregateOperationSupport??{},this.enumTypes=e.enumTypes??[]}static setOutputPath(e){this.outputPath=e}static setIsGenerateSelect(e){this.isGenerateSelect=e}static setIsGenerateInclude(e){this.isGenerateInclude=e}static getOutputPath(){return this.outputPath}static setPrismaClientOutputPath(e){this.prismaClientOutputPath=e,this.isCustomPrismaClientOutputPath=e!==`@prisma/client`}static async generateIndex(){await Ge(f.default.join(e.outputPath,`schemas/index.ts`))}async generateEnumSchemas(){for(let t of this.enumTypes){let{name:n,values:r}=t;await Z(f.default.join(e.outputPath,`schemas/enums/${C(n)}.schema.ts`),`${this.generateImportZodStatement()}\n${this.generateExportSchemaStatement(`${C(n)}`,`z.enum(${JSON.stringify(r)})`)}`)}}generateImportZodStatement(){return`import { z } from 'zod';
+`}generateExportSchemaStatement(e,t){return`export const ${C(e)}Schema = ${t}`}async generateObjectSchema(){let t=this.generateObjectSchemaFields(),n=this.prepareObjectSchema(t),r=this.resolveObjectSchemaName();await Z(f.default.join(e.outputPath,`schemas/objects/${C(r)}.schema.ts`),n)}generateObjectSchemaFields(){return this.fields.map(e=>this.generateObjectSchemaField(e)).flatMap(e=>e).map(e=>{let[t,n,r]=e;return(r?t:this.generateFieldValidators(t,n)).trim()})}generateObjectSchemaField(e){let t=e.inputTypes;if(t.length===0)return[];let n=t.reduce((n,r)=>{if(r.type===`String`)n.push(this.wrapWithZodValidators(`z.string()`,e));else if(r.type===`Int`||r.type===`Float`||r.type===`Decimal`)n.push(this.wrapWithZodValidators(`z.number()`,e));else if(r.type===`BigInt`)n.push(this.wrapWithZodValidators(`z.bigint()`,e));else if(r.type===`Boolean`)n.push(this.wrapWithZodValidators(`z.boolean()`,e));else if(r.type===`DateTime`)n.push(this.wrapWithZodValidators(`z.coerce.date()`,e));else if(r.type===`Json`)this.hasJson=!0,n.push(this.wrapWithZodValidators(`jsonSchema`,e));else if(r.type===`True`)n.push(this.wrapWithZodValidators(`z.literal(true)`,e));else if(r.type===`Bytes`)n.push(this.wrapWithZodValidators(`z.instanceof(Buffer)`,e));else if(!r.type.endsWith(`FieldRefInput`)){let i=r.location===`enumTypes`;(r.namespace===`prisma`||i)&&(r.type!==this.name&&typeof r.type==`string`&&this.addSchemaImport(r.type),n.push(this.generatePrismaStringLine(e,r,t.length)))}return n},[]);if(n.length===0)return[];n.length>1&&(n=n.map(e=>e.replace(`.optional()`,``)));let r=n.some(e=>e.includes(`:`))?``:`  ${e.name}:`,i=e.isRequired?``:`.optional()`,a=n.length===1?n.join(`,\r
+`):`z.union([${n.join(`,\r
+`)}])${i}`;return e.isNullable&&(a+=`.nullable()`),[[`  ${r} ${a} `,e,!0]]}wrapWithZodValidators(e,t){let n=``;return n=e,t.inputTypes.some(e=>e.isList)&&(n+=`.array()`),t.isRequired||(n+=`.optional()`),n}addSchemaImport(e){this.schemaImports.add(e)}generatePrismaStringLine(e,t,n){let r=t.location===`enumTypes`,i=t.type,{isModelQueryType:a,modelName:o,queryName:s}=this.checkIsModelQueryType(i),c=a?this.resolveModelQuerySchemaName(o,s):`${i}ObjectSchema`,l=`${i}Schema`,u=t.type===this.name?c:r?l:c,d=t.isList?`.array()`:``,f=e.isRequired?``:`.optional()`;return n===1?`  ${e.name}: z.lazy(() => ${C(u)})${d}${f}`:`z.lazy(() => ${C(u)})${d}${f}`}generateFieldValidators(e,t){let{isRequired:n,isNullable:r}=t;return n||(e+=`.optional()`),r&&(e+=`.nullable()`),e}prepareObjectSchema(e){let t=`${this.generateExportObjectSchemaStatement(this.addFinalWrappers({zodStringFields:e}))}\n`,n=this.generateImportPrismaStatement(),r=this.generateJsonSchemaImplementation();return`${this.generateObjectSchemaImportStatements()}${n}${r}${t}`}generateExportObjectSchemaStatement(t){let n=this.name,r=this.name;e.provider===`mongodb`&&ct(n)&&(n=e.rawOpsMap[n],r=n.replace(`Args`,``)),Q(n)&&(n=`${n}Type`);let i=`export const ${C(r)}ObjectSchema = schema`;return`const schema: z.ZodType<Prisma.${n}> = ${t};\n\n ${i}`}addFinalWrappers({zodStringFields:e}){let t=[...e];return`${this.wrapWithZodObject(t)}.strict()`}generateImportPrismaStatement(){let t;if(e.isCustomPrismaClientOutputPath){let n=f.default.join(e.outputPath,`schemas`,`objects`),r=e.prismaClientOutputPath;t=f.default.relative(n,r).split(f.default.sep).join(f.default.posix.sep)}else t=e.prismaClientOutputPath;return`import type { Prisma } from '${t}';\n\n`}generateJsonSchemaImplementation(){let e=``;return this.hasJson&&(e+=`
+`,e+=`const literalSchema = z.union([z.string(), z.number(), z.boolean()]);
+`,e+=`const jsonSchema: z.ZodType<Prisma.InputJsonValue> = z.lazy(() =>
+`,e+=`  z.union([literalSchema, z.array(jsonSchema.nullable()), z.record(jsonSchema.nullable())])
+`,e+=`);
+
+`),e}generateObjectSchemaImportStatements(){let e=this.generateImportZodStatement();return e+=this.generateSchemaImports(),e+=`
+
+`,e}generateSchemaImports(){return[...this.schemaImports].map(t=>{let{isModelQueryType:n,modelName:r,queryName:i}=this.checkIsModelQueryType(t);return n?`import { ${this.resolveModelQuerySchemaName(r,i)} } from '../${i}${r}.schema'`:e.enumNames.includes(t)?`import { ${C(t)}Schema } from '../enums/${C(t)}.schema'`:`import { ${C(t)}ObjectSchema } from './${C(t)}.schema'`}).join(`;\r
+`)}checkIsModelQueryType(e){let t={FindManyArgs:`findMany`};for(let n of[`FindManyArgs`])if(e.includes(n)){let r=e.indexOf(n);return{isModelQueryType:!0,modelName:e.substring(0,r),queryName:t[n]}}return{isModelQueryType:!1}}resolveModelQuerySchemaName(e,t){return`${C(e)}${A(t)}Schema`}wrapWithZodUnion(e){let t=``;return t+=`z.union([`,t+=`
+`,t+=`  ${e.join(`,`)}`,t+=`
+`,t+=`])`,t}wrapWithZodObject(e){let t=``;return t+=`z.object({`,t+=`
+`,t+=`  ${typeof e==`string`?e:e.join(`,
+  `)}`,t+=`
+`,t+=`})`,t}resolveObjectSchemaName(){let t=this.name,n=this.name;return ct(t)&&(t=e.rawOpsMap[t],n=t.replace(`Args`,``)),C(n)}async generateModelSchemas(){for(let t of this.modelOperations){let{findUnique:n,findFirst:r,findMany:i,createOne:a,createMany:o,createManyAndReturn:s,deleteOne:c,updateOne:l,deleteMany:u,updateMany:d,updateManyAndReturn:p,upsertOne:m,aggregate:h,groupBy:g}=t,_=be(this.models,t.model),v=C(t.model),{selectImport:y,includeImport:b,selectZodSchemaLine:x,includeZodSchemaLine:S,selectZodSchemaLineLazy:w,includeZodSchemaLineLazy:ee}=this.resolveSelectIncludeImportAndZodSchemaLine(_),{orderByImport:T,orderByZodSchemaLine:E}=this.resolveOrderByWithRelationImportAndZodSchemaLine(_);if(n){let t=[y,b,`import { ${v}WhereUniqueInputObjectSchema } from './objects/${v}WhereUniqueInput.schema'`];await Z(f.default.join(e.outputPath,`schemas/${n}.schema.ts`),`${this.generateImportStatements(t)}${this.generateExportSchemaStatement(`${v}FindUnique`,`z.object({ ${x} ${S} where: ${v}WhereUniqueInputObjectSchema })`)}`)}if(r){let t=[y,b,T,`import { ${v}WhereInputObjectSchema } from './objects/${v}WhereInput.schema'`,`import { ${v}WhereUniqueInputObjectSchema } from './objects/${v}WhereUniqueInput.schema'`,`import { ${v}ScalarFieldEnumSchema } from './enums/${v}ScalarFieldEnum.schema'`];await Z(f.default.join(e.outputPath,`schemas/${r}.schema.ts`),`${this.generateImportStatements(t)}${this.generateExportSchemaStatement(`${v}FindFirst`,`z.object({ ${x} ${S} ${E} where: ${v}WhereInputObjectSchema.optional(), cursor: ${v}WhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.array(${v}ScalarFieldEnumSchema).optional() })`)}`)}if(i){let t=[y,b,T,`import { ${v}WhereInputObjectSchema } from './objects/${v}WhereInput.schema'`,`import { ${v}WhereUniqueInputObjectSchema } from './objects/${v}WhereUniqueInput.schema'`,`import { ${v}ScalarFieldEnumSchema } from './enums/${v}ScalarFieldEnum.schema'`];await Z(f.default.join(e.outputPath,`schemas/${i}.schema.ts`),`${this.generateImportStatements(t)}${this.generateExportSchemaStatement(`${v}FindMany`,`z.object({ ${w} ${ee} ${E} where: ${v}WhereInputObjectSchema.optional(), cursor: ${v}WhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), distinct: z.array(${v}ScalarFieldEnumSchema).optional()  })`)}`)}if(a){let t=[y,b,`import { ${v}CreateInputObjectSchema } from './objects/${v}CreateInput.schema'`,`import { ${v}UncheckedCreateInputObjectSchema } from './objects/${v}UncheckedCreateInput.schema'`];await Z(f.default.join(e.outputPath,`schemas/${a}.schema.ts`),`${this.generateImportStatements(t)}${this.generateExportSchemaStatement(`${v}CreateOne`,`z.object({ ${x} ${S} data: z.union([${v}CreateInputObjectSchema, ${v}UncheckedCreateInputObjectSchema])  })`)}`)}if(o){let t=[`import { ${v}CreateManyInputObjectSchema } from './objects/${v}CreateManyInput.schema'`];await Z(f.default.join(e.outputPath,`schemas/${o}.schema.ts`),`${this.generateImportStatements(t)}${this.generateExportSchemaStatement(`${v}CreateMany`,`z.object({ data: z.union([ ${v}CreateManyInputObjectSchema, z.array(${v}CreateManyInputObjectSchema) ]), ${e.provider===`mongodb`||e.provider===`sqlserver`?``:`skipDuplicates: z.boolean().optional()`} })`)}`)}if(s){let t=[`import { ${v}CreateManyAndReturnInputObjectSchema } from './objects/${v}CreateManyAndReturnInput.schema'`];await Z(f.default.join(e.outputPath,`schemas/${s}.schema.ts`),`${this.generateImportStatements(t)}${this.generateExportSchemaStatement(`${v}CreateManyAndReturn`,`z.object({ data: z.union([ ${v}CreateManyAndReturnInputObjectSchema, z.array(${v}CreateManyAndReturnInputObjectSchema) ]), ${e.provider===`mongodb`||e.provider===`sqlserver`?``:`skipDuplicates: z.boolean().optional()`} })`)}`)}if(c){let t=[y,b,`import { ${v}WhereUniqueInputObjectSchema } from './objects/${v}WhereUniqueInput.schema'`];await Z(f.default.join(e.outputPath,`schemas/${c}.schema.ts`),`${this.generateImportStatements(t)}${this.generateExportSchemaStatement(`${v}DeleteOne`,`z.object({ ${x} ${S} where: ${v}WhereUniqueInputObjectSchema  })`)}`)}if(u){let t=[`import { ${v}WhereInputObjectSchema } from './objects/${v}WhereInput.schema'`];await Z(f.default.join(e.outputPath,`schemas/${u}.schema.ts`),`${this.generateImportStatements(t)}${this.generateExportSchemaStatement(`${v}DeleteMany`,`z.object({ where: ${v}WhereInputObjectSchema.optional()  })`)}`)}if(l){let t=[y,b,`import { ${v}UpdateInputObjectSchema } from './objects/${v}UpdateInput.schema'`,`import { ${v}UncheckedUpdateInputObjectSchema } from './objects/${v}UncheckedUpdateInput.schema'`,`import { ${v}WhereUniqueInputObjectSchema } from './objects/${v}WhereUniqueInput.schema'`];await Z(f.default.join(e.outputPath,`schemas/${l}.schema.ts`),`${this.generateImportStatements(t)}${this.generateExportSchemaStatement(`${v}UpdateOne`,`z.object({ ${x} ${S} data: z.union([${v}UpdateInputObjectSchema, ${v}UncheckedUpdateInputObjectSchema]), where: ${v}WhereUniqueInputObjectSchema  })`)}`)}if(d){let t=[`import { ${v}UpdateManyMutationInputObjectSchema } from './objects/${v}UpdateManyMutationInput.schema'`,`import { ${v}WhereInputObjectSchema } from './objects/${v}WhereInput.schema'`];await Z(f.default.join(e.outputPath,`schemas/${d}.schema.ts`),`${this.generateImportStatements(t)}${this.generateExportSchemaStatement(`${v}UpdateMany`,`z.object({ data: ${v}UpdateManyMutationInputObjectSchema, where: ${v}WhereInputObjectSchema.optional()  })`)}`)}if(p){let t=[`import { ${v}UpdateManyAndReturnInputObjectSchema } from './objects/${v}UpdateManyAndReturnInput.schema'`];await Z(f.default.join(e.outputPath,`schemas/${p}.schema.ts`),`${this.generateImportStatements(t)}${this.generateExportSchemaStatement(`${v}UpdateManyAndReturn`,`z.object({ data: z.union([ ${v}UpdateManyAndReturnInputObjectSchema, z.array(${v}UpdateManyAndReturnInputObjectSchema) ]), ${e.provider===`mongodb`||e.provider===`sqlserver`?``:`skipDuplicates: z.boolean().optional()`} })`)}`)}if(m){let t=[y,b,`import { ${v}WhereUniqueInputObjectSchema } from './objects/${v}WhereUniqueInput.schema'`,`import { ${v}CreateInputObjectSchema } from './objects/${v}CreateInput.schema'`,`import { ${v}UncheckedCreateInputObjectSchema } from './objects/${v}UncheckedCreateInput.schema'`,`import { ${v}UpdateInputObjectSchema } from './objects/${v}UpdateInput.schema'`,`import { ${v}UncheckedUpdateInputObjectSchema } from './objects/${v}UncheckedUpdateInput.schema'`];await Z(f.default.join(e.outputPath,`schemas/${m}.schema.ts`),`${this.generateImportStatements(t)}${this.generateExportSchemaStatement(`${v}Upsert`,`z.object({ ${x} ${S} where: ${v}WhereUniqueInputObjectSchema, create: z.union([ ${v}CreateInputObjectSchema, ${v}UncheckedCreateInputObjectSchema ]), update: z.union([ ${v}UpdateInputObjectSchema, ${v}UncheckedUpdateInputObjectSchema ])  })`)}`)}if(h){let t=[T,`import { ${v}WhereInputObjectSchema } from './objects/${v}WhereInput.schema'`,`import { ${v}WhereUniqueInputObjectSchema } from './objects/${v}WhereUniqueInput.schema'`],n=[];this.aggregateOperationSupport[v]&&(this.aggregateOperationSupport[v].count&&(t.push(`import { ${v}CountAggregateInputObjectSchema } from './objects/${v}CountAggregateInput.schema'`),n.push(`_count: z.union([ z.literal(true), ${v}CountAggregateInputObjectSchema ]).optional()`)),this.aggregateOperationSupport[v].min&&(t.push(`import { ${v}MinAggregateInputObjectSchema } from './objects/${v}MinAggregateInput.schema'`),n.push(`_min: ${v}MinAggregateInputObjectSchema.optional()`)),this.aggregateOperationSupport[v].max&&(t.push(`import { ${v}MaxAggregateInputObjectSchema } from './objects/${v}MaxAggregateInput.schema'`),n.push(`_max: ${v}MaxAggregateInputObjectSchema.optional()`)),this.aggregateOperationSupport[v].avg&&(t.push(`import { ${v}AvgAggregateInputObjectSchema } from './objects/${v}AvgAggregateInput.schema'`),n.push(`_avg: ${v}AvgAggregateInputObjectSchema.optional()`)),this.aggregateOperationSupport[v].sum&&(t.push(`import { ${v}SumAggregateInputObjectSchema } from './objects/${v}SumAggregateInput.schema'`),n.push(`_sum: ${v}SumAggregateInputObjectSchema.optional()`))),await Z(f.default.join(e.outputPath,`schemas/${h}.schema.ts`),`${this.generateImportStatements(t)}${this.generateExportSchemaStatement(`${v}Aggregate`,`z.object({ ${E} where: ${v}WhereInputObjectSchema.optional(), cursor: ${v}WhereUniqueInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), ${n.join(`, `)} })`)}`)}if(g){let t=[`import { ${v}WhereInputObjectSchema } from './objects/${v}WhereInput.schema'`,`import { ${v}OrderByWithAggregationInputObjectSchema } from './objects/${v}OrderByWithAggregationInput.schema'`,`import { ${v}ScalarWhereWithAggregatesInputObjectSchema } from './objects/${v}ScalarWhereWithAggregatesInput.schema'`,`import { ${v}ScalarFieldEnumSchema } from './enums/${v}ScalarFieldEnum.schema'`];await Z(f.default.join(e.outputPath,`schemas/${g}.schema.ts`),`${this.generateImportStatements(t)}${this.generateExportSchemaStatement(`${v}GroupBy`,`z.object({ where: ${v}WhereInputObjectSchema.optional(), orderBy: z.union([${v}OrderByWithAggregationInputObjectSchema, ${v}OrderByWithAggregationInputObjectSchema.array()]).optional(), having: ${v}ScalarWhereWithAggregatesInputObjectSchema.optional(), take: z.number().optional(), skip: z.number().optional(), by: z.array(${v}ScalarFieldEnumSchema)  })`)}`)}}}generateImportStatements(e){let t=this.generateImportZodStatement();return t+=e?.filter(e=>!!e).join(`;\r
+`)??``,t+=`
+
+`,t}resolveSelectIncludeImportAndZodSchemaLine(t){let{name:n}=t,r=R(t),i=e.isGenerateSelect?`import { ${C(n)}SelectObjectSchema } from './objects/${C(n)}Select.schema'`:``,a=e.isGenerateInclude&&r?`import { ${C(n)}IncludeObjectSchema } from './objects/${C(n)}Include.schema'`:``,o=``,s=``,c=``,l=``;if(e.isGenerateSelect){let e=`${C(n)}SelectObjectSchema.optional()`;o=`select: ${e},`,c=`select: z.lazy(() => ${e}),`}if(e.isGenerateInclude&&r){let e=`${C(n)}IncludeObjectSchema.optional()`;s=`include: ${e},`,l=`include: z.lazy(() => ${e}),`}return{selectImport:i,includeImport:a,selectZodSchemaLine:o,includeZodSchemaLine:s,selectZodSchemaLineLazy:c,includeZodSchemaLineLazy:l}}resolveOrderByWithRelationImportAndZodSchemaLine(t){let{name:n}=t,r=``;return r=[`postgresql`,`mysql`].includes(e.provider)&&e.previewFeatures?.includes(`fullTextSearch`)?`${C(n)}OrderByWithRelationAndSearchRelevanceInput`:`${C(n)}OrderByWithRelationInput`,{orderByImport:`import { ${r}ObjectSchema } from './objects/${r}.schema'`,orderByZodSchemaLine:`orderBy: z.union([${r}ObjectSchema, ${r}ObjectSchema.array()]).optional(),`}}};async function lt(e,t){let n=[...e,...t];$.enumNames=n.map(e=>e.name)??[],await new $({enumTypes:n}).generateEnumSchemas()}async function ut(e){for(let t=0;t<e.length;t+=1){let n=e[t]?.fields,r=e[t]?.name;await new $({name:r,fields:n}).generateObjectSchema()}}async function dt(e,t,n){await new $({models:e,modelOperations:t,aggregateOperationSupport:n}).generateModelSchemas()}async function ft(){await $.generateIndex()}function pt(e,t,n){let r=mt(t,n);for(let t of r)e.push(t)}function mt(e,t){let n=[];for(let r of e){let{name:e,fields:i}=r,a=[];for(let e of i){let{name:t,isList:n,type:r}=e;if(B(e)){let e={name:t,isRequired:!1,isNullable:!1,inputTypes:[{isList:!1,type:`Boolean`,location:`scalar`},{isList:!1,type:n?`${r}FindManyArgs`:`${r}DefaultArgs`,location:`inputObjectTypes`,namespace:`prisma`}]};a.push(e)}}if(!R(r))continue;if(z(r)){let n=[{isList:!1,type:`Boolean`,location:`scalar`}];t&&n.push({isList:!1,type:`${e}CountOutputTypeDefaultArgs`,location:`inputObjectTypes`,namespace:`prisma`});let r={name:`_count`,isRequired:!1,isNullable:!1,inputTypes:n};a.push(r)}let o={name:`${e}Include`,constraints:{maxNumFields:null,minNumFields:null},fields:a};n.push(o)}return n}function ht(e,t,n,r){let i=gt(t,n,r);for(let t of i)e.push(t)}function gt(e,t,n){let r=[];for(let i of e){let{name:e}=i,a=[];if(t){let t={name:`select`,isRequired:!1,isNullable:!1,inputTypes:[{isList:!1,type:`${e}Select`,location:`inputObjectTypes`,namespace:`prisma`}]};a.push(t)}let o=R(i);if(n&&o){let t={name:`include`,isRequired:!1,isNullable:!1,inputTypes:[{isList:!1,type:`${e}Include`,location:`inputObjectTypes`,namespace:`prisma`}]};a.push(t)}let s={name:`${e}DefaultArgs`,constraints:{maxNumFields:null,minNumFields:null},fields:a};r.push(s)}return r}function _t(e,t,n){let r=vt(t),i=[yt(r),bt(r),xt(n)].flat();for(let t of i)e.push(t)}function vt(e){return e.filter(({name:e})=>e.includes(`CountOutputType`))}function yt(e){let t=[];for(let n of e){let{name:e,fields:r}=n,i={name:`${e}Select`,constraints:{maxNumFields:null,minNumFields:null},fields:r.map(({name:e})=>({name:e,isRequired:!1,isNullable:!1,inputTypes:[{isList:!1,type:`Boolean`,location:`scalar`}]}))};t.push(i)}return t}function bt(e){let t=[];for(let n of e){let{name:e}=n,r={name:`${e}DefaultArgs`,constraints:{maxNumFields:null,minNumFields:null},fields:[{name:`select`,isRequired:!1,isNullable:!1,inputTypes:[{isList:!1,type:`${e}Select`,location:`inputObjectTypes`,namespace:`prisma`}]}]};t.push(r)}return t}function xt(e){let t=[];for(let n of e){let{name:e,fields:r}=n,i=[];for(let e of r){let{name:t,isList:n,type:r}=e,a=B(e),o={name:t,isRequired:!1,isNullable:!1,inputTypes:[{isList:!1,type:`Boolean`,location:`scalar`}]};if(a){let e={isList:!1,type:n?`${r}FindManyArgs`:`${r}DefaultArgs`,location:`inputObjectTypes`,namespace:`prisma`};o.inputTypes.push(e)}i.push(o)}if(z(n)){let t={name:`_count`,isRequired:!1,isNullable:!1,inputTypes:[{isList:!1,type:`Boolean`,location:`scalar`},{isList:!1,type:`${e}CountOutputTypeDefaultArgs`,location:`inputObjectTypes`,namespace:`prisma`}]};i.push(t)}let a={name:`${e}Select`,constraints:{maxNumFields:null,minNumFields:null},fields:i};t.push(a)}return t}function St(e){e.map(e=>(e.name.includes(`WhereUniqueInput`)&&e.constraints.fields?.length>0&&(e.fields=e.fields.map(t=>(e.constraints.fields?.includes(t.name)&&(t.isRequired=!0),t))),e))}function Ct(e,t,n,r,i,a){i===`mongodb`&&it(r,t,e),qe(e,t),a.isGenerateSelect&&(_t(e,t,n),$.setIsGenerateSelect(!0)),(a.isGenerateSelect||a.isGenerateInclude)&&ht(e,n,a.isGenerateSelect,a.isGenerateInclude),a.isGenerateInclude&&(pt(e,n,a.isGenerateSelect),$.setIsGenerateInclude(!0)),St(e)}async function wt(e){console.log(`[STORM]: Running the Storm Software - Prisma tRPC generator 
+`);let t=await F();console.log(`[STORM]: Validating configuration options 
+`);let n=t.parseEnvValue(e.generator.output),r=await te.safeParseAsync(e.generator.config);if(!r.success)throw Error(`Invalid options passed`);let i=r.data,a=e=>{i.debug&&console.log(`[STORM]: ${e} \n`)};a(`Using configuration parameters: \n${JSON.stringify(i)}`),a(`Preparing output directory: ${n}`),await(0,u.removeDirectory)(n),await(0,u.createDirectory)(n),a(`Finding Prisma Client generator`);let o=e.otherGenerators.find(e=>t.parseEnvValue(e.provider)===`prisma-client-js`);if(!o)throw Error("No Prisma Client generator found. Please add `prisma-client-js` to your generator list.");a(`Generating Prisma Client DMMF`);let s=await t.getDMMF({datamodel:e.datamodel,previewFeatures:o?.previewFeatures}),c=s.mappings.modelOperations,p=s.schema.inputObjectTypes.prisma,m=s.schema.outputObjectTypes.prisma,h=s.schema.enumTypes,g=s.datamodel.models,_=[],v=[];if(i.withZod!==!1){a(`Generating Zod schemas`);let n=t.parseEnvValue(e.generator.output);await(0,u.createDirectory)(n),$.setOutputPath(n),o?.isCustomOutput&&$.setPrismaClientOutputPath(o.output?.value),await He(g,(0,d.joinPaths)(n,`schemas`,`models`),i,e),Qe(g,c,h,_,v),await lt(h.prisma,h.model);let r=e.datasources?.[0];if(!r)throw Error(`No datasource found`);let s=o?.previewFeatures;$.provider=r.provider,$.previewFeatures=s,Ct(p,m,g,c,r.provider,{isGenerateSelect:!0,isGenerateInclude:!0});let l=Je(p);rt(p,_,v),await ut(p),await dt(g,c,l),await ft()}else a(`Skipping Zod schemas generation`);let y=[],b=[],x=[];s.mappings.modelOperations.forEach(e=>{let{model:t,plural:n,...r}=e;for(let[e,t]of Object.entries(r))[`findUnique`,`findUniqueOrThrow`,`findFirst`,`findFirstOrThrow`,`findRaw`,`findMany`,`aggregateRaw`,`count`,`aggregate`,`groupBy`].includes(e)&&y.push(t),[`createOne`,`createMany`,`createManyAndReturn`,`deleteOne`,`deleteMany`,`updateOne`,`updateMany`,`updateManyAndReturn`,`upsertOne`].includes(e)&&b.push(t)}),y.sort(),b.sort(),x.sort(),i.withShield&&!(typeof i.withShield==`string`&&((0,l.existsSync)((0,d.joinPaths)(n,i.withShield))||(0,l.existsSync)((0,d.joinPaths)(n,`./${i.withShield}.ts`))||(0,l.existsSync)((0,d.joinPaths)(n,i.withShield,`./shield.ts`))))?(a(`Generating tRPC Shield source file to ${n}`),await Z((0,d.joinPaths)(n,`./shield.ts`),await Be({queries:y,mutations:b,subscriptions:x},i,e,n))):a(`Skipping tRPC Shield generation`),a(`Generating tRPC source code for ${g.length} models`),i.trpcOptions&&typeof i.trpcOptions==`boolean`&&(a(`Generating tRPC options source file to ${n}`),await Z((0,d.joinPaths)(n,`./options.ts`),Ve(i,e,n))),Le(g,_),a(`Generating tRPC export file`),await Me(O.createSourceFile(f.default.resolve(n,`trpc.ts`),void 0,{overwrite:!0}),i,e,n),a(`Generating tRPC app router`);let S=O.createSourceFile(f.default.resolve(n,`routers`,`index.ts`),void 0,{overwrite:!0});a(`Generating tRPC router imports`),K({sourceFile:S});let w=[];for(let e of c){let{model:t,...r}=e;if(_.includes(t)){a(`Skipping model ${t} as it is hidden`);continue}if(!t){a(`Skipping model ${t} as it is not defined`);continue}let o=Object.keys(r).filter(e=>i.generateModelActions.some(t=>t===e.replace(`One`,``)));if(!o.length){a(`Skipping model ${t} as it has no actions to generate`);continue}let s=(0,ee.default)(C(t));a(`Generating tRPC router for model ${t}`),je(S,s,t);let c=O.createSourceFile(f.default.resolve(n,`routers`,`${C(t)}.router.ts`),void 0,{overwrite:!0});K({sourceFile:c,config:i}),i.withZod&&(a(`Generating Zod schemas imports`),Pe(c,t,o)),c.addStatements(`
+      export const ${s}Router = t.router({`);for(let e of o){let n=r[e];if(n){let r=e.replace(`OrThrow`,``);Ne(c,n,q(r,t),t,e,r,i)}}c.addStatements(`
+    })`),c.formatText({indentSize:2}),w.push(`
+      ${C(t)}: ${s}Router`),a(`Generated tRPC router for model ${t} with ${o.length} actions`)}a(`Generating tRPC app router`),S.addStatements(`
+export const appRouter = t.router({${w.join()}});
+
+export type AppRouter = typeof appRouter;`),S.formatText({indentSize:2}),a(`Saving tRPC router source files to disk`),await O.save(),a(`Storm Software - Prisma tRPC generator completed successfully`)}ve().then(e=>{e.generatorHandler({onManifest:()=>({defaultOutput:`./generated`,prettyName:`Storm Software - Prisma tRPC Generator`,requiresGenerators:[`prisma-client-js`]}),onGenerate:wt})}).catch(e=>{console.error(`An error occured while generating prisma tRPC source code: ${e}`)});