@prisma/client-generator-ts 6.16.0-dev.35 → 6.16.0-dev.37

package/dist/index.js

@@ -1850,7 +1850,7 @@ var require_ensure = __commonJS({
 var require_utils2 = __commonJS({
   "../../node_modules/.pnpm/jsonfile@6.1.0/node_modules/jsonfile/utils.js"(exports2, module2) {
     "use strict";
-    function stringify14(obj, { EOL = "\n", finalEOL = true, replacer = null, spaces } = {}) {
+    function stringify16(obj, { EOL = "\n", finalEOL = true, replacer = null, spaces } = {}) {
       const EOF = finalEOL ? EOL : "";
       const str = JSON.stringify(obj, replacer, spaces);
       return str.replace(/\n/g, EOL) + EOF;
@@ -1859,7 +1859,7 @@ var require_utils2 = __commonJS({
       if (Buffer.isBuffer(content)) content = content.toString("utf8");
       return content.replace(/^\uFEFF/, "");
     }
-    module2.exports = { stringify: stringify14, stripBom };
+    module2.exports = { stringify: stringify16, stripBom };
   }
 });
 
@@ -1874,7 +1874,7 @@ var require_jsonfile = __commonJS({
       _fs = require("fs");
     }
     var universalify = require_universalify();
-    var { stringify: stringify14, stripBom } = require_utils2();
+    var { stringify: stringify16, stripBom } = require_utils2();
     async function _readFile(file4, options = {}) {
       if (typeof options === "string") {
         options = { encoding: options };
@@ -1918,13 +1918,13 @@ var require_jsonfile = __commonJS({
     }
     async function _writeFile(file4, obj, options = {}) {
       const fs3 = options.fs || _fs;
-      const str = stringify14(obj, options);
+      const str = stringify16(obj, options);
       await universalify.fromCallback(fs3.writeFile)(file4, str, options);
     }
     var writeFile = universalify.fromPromise(_writeFile);
     function writeFileSync(file4, obj, options = {}) {
       const fs3 = options.fs || _fs;
-      const str = stringify14(obj, options);
+      const str = stringify16(obj, options);
       return fs3.writeFileSync(file4, str, options);
     }
     var jsonfile = {
@@ -1986,10 +1986,10 @@ var require_output_file = __commonJS({
 var require_output_json = __commonJS({
   "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/json/output-json.js"(exports2, module2) {
     "use strict";
-    var { stringify: stringify14 } = require_utils2();
+    var { stringify: stringify16 } = require_utils2();
     var { outputFile } = require_output_file();
     async function outputJson(file4, data, options = {}) {
-      const str = stringify14(data, options);
+      const str = stringify16(data, options);
       await outputFile(file4, str, options);
     }
     module2.exports = outputJson;
@@ -2000,10 +2000,10 @@ var require_output_json = __commonJS({
 var require_output_json_sync = __commonJS({
   "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/json/output-json-sync.js"(exports2, module2) {
     "use strict";
-    var { stringify: stringify14 } = require_utils2();
+    var { stringify: stringify16 } = require_utils2();
     var { outputFileSync } = require_output_file();
     function outputJsonSync(file4, data, options) {
-      const str = stringify14(data, options);
+      const str = stringify16(data, options);
       outputFileSync(file4, str, options);
     }
     module2.exports = outputJsonSync;
@@ -2225,7 +2225,7 @@ function getMappings(mappings, datamodel) {
 var import_promises = __toESM(require("node:fs/promises"));
 var import_node_path4 = __toESM(require("node:path"));
 var import_fetch_engine = require("@prisma/fetch-engine");
-var import_internals9 = require("@prisma/internals");
+var import_internals10 = require("@prisma/internals");
 var import_fast_glob = require("fast-glob");
 var import_fs_extra = __toESM(require_lib());
 
@@ -2898,11 +2898,51 @@ var GenericArgsInfo = class {
   }
 };
 
+// src/TSClient/file-generators/BrowserFile.ts
+var import_internals3 = require("@prisma/internals");
+
+// src/TSClient/ModelExports.ts
+var ts3 = __toESM(require("@prisma/ts-builders"));
+function modelExports(context) {
+  return Object.values(context.dmmf.typeAndModelMap).filter((model) => context.dmmf.outputTypeMap.model[model.name]).map((model) => {
+    const docLines = model.documentation ?? "";
+    const modelLine = `Model ${model.name}
+`;
+    const docs = `${modelLine}${docLines}`;
+    const suffix = "Model";
+    const modelTypeExport = ts3.moduleExport(ts3.typeDeclaration(model.name, ts3.namedType(`Prisma.${model.name}${suffix}`))).setDocComment(ts3.docComment(docs));
+    return ts3.stringify(modelTypeExport);
+  });
+}
+
+// src/TSClient/file-generators/BrowserFile.ts
+var jsDocHeader = `/*
+ * This file should be your main import to use Prisma-related types and utilities in a browser. 
+ * Use it to get access to models, enums, and input types.
+ * 
+ * This file does not contain a \`PrismaClient\` class, nor several other helpers that are intended as server-side only.
+ * See \`client.ts\` for the standard, server-side entry point.
+ *
+ * \u{1F7E2} You can import this file directly.
+ */
+`;
+function createBrowserFile(context, options) {
+  const clientEngineType = (0, import_internals3.getClientEngineType)(options.generator);
+  options.generator.config.engineType = clientEngineType;
+  return `${jsDocHeader}
+import * as Prisma from '${context.importFileName("./internal/prismaNamespaceBrowser")}'
+export { Prisma }
+export * as $Enums from '${context.importFileName("./enums")}'
+export * from '${context.importFileName("./enums")}';
+${modelExports(context).join("\n")}
+`;
+}
+
 // src/TSClient/file-generators/ClassFile.ts
 var import_node_crypto = __toESM(require("node:crypto"));
 var import_node_path2 = __toESM(require("node:path"));
-var import_internals3 = require("@prisma/internals");
-var ts5 = __toESM(require("@prisma/ts-builders"));
+var import_internals4 = require("@prisma/internals");
+var ts6 = __toESM(require("@prisma/ts-builders"));
 var import_ci_info = __toESM(require("ci-info"));
 
 // src/utils/buildInjectableEdgeEnv.ts
@@ -3539,16 +3579,16 @@ function buildWasmFileMap({ activeProvider, runtimeName }) {
 
 // src/TSClient/PrismaClient.ts
 var import_client_common12 = require("@prisma/client-common");
-var ts4 = __toESM(require("@prisma/ts-builders"));
+var ts5 = __toESM(require("@prisma/ts-builders"));
 var import_indent_string3 = __toESM(require("indent-string"));
 
 // src/utils/runtimeImport.ts
-var ts3 = __toESM(require("@prisma/ts-builders"));
+var ts4 = __toESM(require("@prisma/ts-builders"));
 function runtimeImport(name) {
   return name;
 }
 function runtimeImportedType(name) {
-  return ts3.namedType(`runtime.${name}`);
+  return ts4.namedType(`runtime.${name}`);
 }
 
 // src/TSClient/utils/type-builders.ts
@@ -3568,14 +3608,14 @@ function optional(innerType) {
 
 // src/TSClient/PrismaClient.ts
 function extendsPropertyDefinition() {
-  const extendsDefinition = ts4.namedType("runtime.Types.Extensions.ExtendsHook").addGenericArgument(ts4.stringLiteral("extends")).addGenericArgument(ts4.namedType("Prisma.TypeMapCb").addGenericArgument(ts4.namedType("OmitOpts"))).addGenericArgument(ts4.namedType("ExtArgs")).addGenericArgument(
-    ts4.namedType("runtime.Types.Utils.Call").addGenericArgument(ts4.namedType("Prisma.TypeMapCb").addGenericArgument(ts4.namedType("OmitOpts"))).addGenericArgument(ts4.objectType().add(ts4.property("extArgs", ts4.namedType("ExtArgs"))))
+  const extendsDefinition = ts5.namedType("runtime.Types.Extensions.ExtendsHook").addGenericArgument(ts5.stringLiteral("extends")).addGenericArgument(ts5.namedType("Prisma.TypeMapCb").addGenericArgument(ts5.namedType("OmitOpts"))).addGenericArgument(ts5.namedType("ExtArgs")).addGenericArgument(
+    ts5.namedType("runtime.Types.Utils.Call").addGenericArgument(ts5.namedType("Prisma.TypeMapCb").addGenericArgument(ts5.namedType("OmitOpts"))).addGenericArgument(ts5.objectType().add(ts5.property("extArgs", ts5.namedType("ExtArgs"))))
   );
-  return ts4.stringify(ts4.property("$extends", extendsDefinition), { indentLevel: 1 });
+  return ts5.stringify(ts5.property("$extends", extendsDefinition), { indentLevel: 1 });
 }
 function batchingTransactionDefinition(context) {
-  const method3 = ts4.method("$transaction").setDocComment(
-    ts4.docComment`
+  const method3 = ts5.method("$transaction").setDocComment(
+    ts5.docComment`
         Allows the running of a sequence of read/write operations that are guaranteed to either succeed or fail as a whole.
         @example
         \`\`\`
@@ -3588,25 +3628,25 @@ function batchingTransactionDefinition(context) {
 
         Read more in our [docs](https://www.prisma.io/docs/concepts/components/prisma-client/transactions).
       `
-  ).addGenericParameter(ts4.genericParameter("P").extends(ts4.array(prismaPromise(ts4.anyType)))).addParameter(ts4.parameter("arg", ts4.arraySpread(ts4.namedType("P")))).setReturnType(promise(ts4.namedType("runtime.Types.Utils.UnwrapTuple").addGenericArgument(ts4.namedType("P"))));
+  ).addGenericParameter(ts5.genericParameter("P").extends(ts5.array(prismaPromise(ts5.anyType)))).addParameter(ts5.parameter("arg", ts5.arraySpread(ts5.namedType("P")))).setReturnType(promise(ts5.namedType("runtime.Types.Utils.UnwrapTuple").addGenericArgument(ts5.namedType("P"))));
   if (context.dmmf.hasEnumInNamespace("TransactionIsolationLevel", "prisma")) {
-    const options = ts4.objectType().formatInline().add(ts4.property("isolationLevel", ts4.namedType("Prisma.TransactionIsolationLevel")).optional());
-    method3.addParameter(ts4.parameter("options", options).optional());
+    const options = ts5.objectType().formatInline().add(ts5.property("isolationLevel", ts5.namedType("Prisma.TransactionIsolationLevel")).optional());
+    method3.addParameter(ts5.parameter("options", options).optional());
   }
-  return ts4.stringify(method3, { indentLevel: 1, newLine: "leading" });
+  return ts5.stringify(method3, { indentLevel: 1, newLine: "leading" });
 }
 function interactiveTransactionDefinition(context) {
-  const options = ts4.objectType().formatInline().add(ts4.property("maxWait", ts4.numberType).optional()).add(ts4.property("timeout", ts4.numberType).optional());
+  const options = ts5.objectType().formatInline().add(ts5.property("maxWait", ts5.numberType).optional()).add(ts5.property("timeout", ts5.numberType).optional());
   if (context.dmmf.hasEnumInNamespace("TransactionIsolationLevel", "prisma")) {
-    const isolationLevel = ts4.property("isolationLevel", ts4.namedType("Prisma.TransactionIsolationLevel")).optional();
+    const isolationLevel = ts5.property("isolationLevel", ts5.namedType("Prisma.TransactionIsolationLevel")).optional();
     options.add(isolationLevel);
   }
-  const returnType = promise(ts4.namedType("R"));
-  const callbackType = ts4.functionType().addParameter(
-    ts4.parameter("prisma", omit(ts4.namedType("PrismaClient"), ts4.namedType("runtime.ITXClientDenyList")))
+  const returnType = promise(ts5.namedType("R"));
+  const callbackType = ts5.functionType().addParameter(
+    ts5.parameter("prisma", omit(ts5.namedType("PrismaClient"), ts5.namedType("runtime.ITXClientDenyList")))
   ).setReturnType(returnType);
-  const method3 = ts4.method("$transaction").addGenericParameter(ts4.genericParameter("R")).addParameter(ts4.parameter("fn", callbackType)).addParameter(ts4.parameter("options", options).optional()).setReturnType(returnType);
-  return ts4.stringify(method3, { indentLevel: 1, newLine: "leading" });
+  const method3 = ts5.method("$transaction").addGenericParameter(ts5.genericParameter("R")).addParameter(ts5.parameter("fn", callbackType)).addParameter(ts5.parameter("options", options).optional()).setReturnType(returnType);
+  return ts5.stringify(method3, { indentLevel: 1, newLine: "leading" });
 }
 function queryRawDefinition(context) {
   if (!context.dmmf.mappings.otherOperations.write.includes("queryRaw")) {
@@ -3671,9 +3711,9 @@ function queryRawTypedDefinition(context) {
   if (!context.dmmf.mappings.otherOperations.write.includes("queryRaw")) {
     return "";
   }
-  const param = ts4.genericParameter("T");
-  const method3 = ts4.method("$queryRawTyped").setDocComment(
-    ts4.docComment`
+  const param = ts5.genericParameter("T");
+  const method3 = ts5.method("$queryRawTyped").setDocComment(
+    ts5.docComment`
         Executes a typed SQL query and returns a typed result
         @example
         \`\`\`
@@ -3683,19 +3723,19 @@ function queryRawTypedDefinition(context) {
         \`\`\`
       `
   ).addGenericParameter(param).addParameter(
-    ts4.parameter(
+    ts5.parameter(
       "typedSql",
-      runtimeImportedType("TypedSql").addGenericArgument(ts4.array(ts4.unknownType)).addGenericArgument(param.toArgument())
+      runtimeImportedType("TypedSql").addGenericArgument(ts5.array(ts5.unknownType)).addGenericArgument(param.toArgument())
     )
-  ).setReturnType(prismaPromise(ts4.array(param.toArgument())));
-  return ts4.stringify(method3, { indentLevel: 1, newLine: "leading" });
+  ).setReturnType(prismaPromise(ts5.array(param.toArgument())));
+  return ts5.stringify(method3, { indentLevel: 1, newLine: "leading" });
 }
 function metricDefinition(context) {
   if (!context.isPreviewFeatureOn("metrics")) {
     return "";
   }
-  const property13 = ts4.property("$metrics", ts4.namedType(`runtime.${runtimeImport("MetricsClient")}`)).setDocComment(
-    ts4.docComment`
+  const property13 = ts5.property("$metrics", ts5.namedType(`runtime.${runtimeImport("MetricsClient")}`)).setDocComment(
+    ts5.docComment`
         Gives access to the client metrics in json or prometheus format.
 
         @example
@@ -3706,13 +3746,13 @@ function metricDefinition(context) {
         \`\`\`
     `
   ).readonly();
-  return ts4.stringify(property13, { indentLevel: 1, newLine: "leading" });
+  return ts5.stringify(property13, { indentLevel: 1, newLine: "leading" });
 }
 function runCommandRawDefinition(context) {
   if (!context.dmmf.mappings.otherOperations.write.includes("runCommandRaw")) {
     return "";
   }
-  const method3 = ts4.method("$runCommandRaw").addParameter(ts4.parameter("command", ts4.namedType("Prisma.InputJsonObject"))).setReturnType(prismaPromise(ts4.namedType("Prisma.JsonObject"))).setDocComment(ts4.docComment`
+  const method3 = ts5.method("$runCommandRaw").addParameter(ts5.parameter("command", ts5.namedType("Prisma.InputJsonObject"))).setReturnType(prismaPromise(ts5.namedType("Prisma.JsonObject"))).setDocComment(ts5.docComment`
       Executes a raw MongoDB command and returns the result of it.
       @example
       \`\`\`
@@ -3725,7 +3765,7 @@ function runCommandRawDefinition(context) {
 
       Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
     `);
-  return ts4.stringify(method3, { indentLevel: 1, newLine: "leading" });
+  return ts5.stringify(method3, { indentLevel: 1, newLine: "leading" });
 }
 function eventRegistrationMethodDeclaration(runtimeName) {
   if (runtimeName === "binary") {
@@ -3744,7 +3784,7 @@ function getPrismaClientClassDocComment({ dmmf }) {
       plural: "users"
     };
   }
-  return ts4.docComment`
+  return ts5.docComment`
     ## Prisma Client
 
     Type-safe database client for TypeScript
@@ -3764,7 +3804,7 @@ var PrismaClientClass = class {
     this.runtimeName = runtimeName;
   }
   get jsDoc() {
-    return ts4.stringify(getPrismaClientClassDocComment(this.context));
+    return ts5.stringify(getPrismaClientClassDocComment(this.context));
   }
   toTS() {
     const { dmmf } = this.context;
@@ -3838,15 +3878,15 @@ get ${methodName}(): Prisma.${m.model}Delegate<${generics.join(", ")}>;`;
     if (this.runtimeName !== "react-native") {
       return null;
     }
-    const method3 = ts4.method("$applyPendingMigrations").setReturnType(promise(ts4.voidType)).setDocComment(
-      ts4.docComment`Tries to apply pending migrations one by one. If a migration fails to apply, the function will stop and throw an error. You are responsible for informing the user and possibly blocking the app as we cannot guarantee the state of the database.`
+    const method3 = ts5.method("$applyPendingMigrations").setReturnType(promise(ts5.voidType)).setDocComment(
+      ts5.docComment`Tries to apply pending migrations one by one. If a migration fails to apply, the function will stop and throw an error. You are responsible for informing the user and possibly blocking the app as we cannot guarantee the state of the database.`
     );
-    return ts4.stringify(method3, { indentLevel: 1, newLine: "leading" });
+    return ts5.stringify(method3, { indentLevel: 1, newLine: "leading" });
   }
 };
 
 // src/TSClient/file-generators/ClassFile.ts
-var jsDocHeader = `/*
+var jsDocHeader2 = `/*
  * WARNING: This is an internal file that is subject to change!
  *
  * \u{1F6D1} Under no circumstances should you import this file directly! \u{1F6D1}
@@ -3856,12 +3896,12 @@ var jsDocHeader = `/*
 `;
 function createClassFile(context, options) {
   const imports = [
-    ts5.moduleImport(context.runtimeImport).asNamespace("runtime"),
-    ts5.moduleImport(context.importFileName(`./prismaNamespace`)).asNamespace("Prisma").typeOnly()
+    ts6.moduleImport(context.runtimeImport).asNamespace("runtime"),
+    ts6.moduleImport(context.importFileName(`./prismaNamespace`)).asNamespace("Prisma").typeOnly()
   ];
-  const stringifiedImports = imports.map((i) => ts5.stringify(i));
+  const stringifiedImports = imports.map((i) => ts6.stringify(i));
   const prismaClientClass = new PrismaClientClass(context, options.runtimeName);
-  return `${jsDocHeader}
+  return `${jsDocHeader2}
 ${stringifiedImports.join("\n")}
 
 ${clientConfig(context, options)}
@@ -3888,13 +3928,13 @@ function clientConfig(context, options) {
     activeProvider,
     moduleFormat
   } = options;
-  const clientEngineType = (0, import_internals3.getClientEngineType)(generator);
+  const clientEngineType = (0, import_internals4.getClientEngineType)(generator);
   generator.config.engineType = clientEngineType;
   const inlineSchemaHash = import_node_crypto.default.createHash("sha256").update(Buffer.from(inlineSchema, "utf8").toString("base64")).digest("hex");
   const datasourceFilePath = datasources[0].sourceFilePath;
   const config = {
     generator,
-    relativePath: (0, import_internals3.pathToPosix)(import_node_path2.default.relative(outputDir, import_node_path2.default.dirname(datasourceFilePath))),
+    relativePath: (0, import_internals4.pathToPosix)(import_node_path2.default.relative(outputDir, import_node_path2.default.dirname(datasourceFilePath))),
     clientVersion: options.clientVersion,
     engineVersion: options.engineVersion,
     datasourceNames: datasources.map((d) => d.name),
@@ -3920,12 +3960,12 @@ ${buildDebugInitialization(edge)}
 
 // src/TSClient/file-generators/ClientFile.ts
 var import_node_path3 = __toESM(require("node:path"));
-var import_internals5 = require("@prisma/internals");
-var ts6 = __toESM(require("@prisma/ts-builders"));
+var import_internals6 = require("@prisma/internals");
+var ts7 = __toESM(require("@prisma/ts-builders"));
 
 // src/utils/buildNFTAnnotations.ts
 var import_get_platform = require("@prisma/get-platform");
-var import_internals4 = require("@prisma/internals");
+var import_internals5 = require("@prisma/internals");
 var import_path = __toESM(require("path"));
 function buildNFTAnnotations(noEngine, engineType, binaryTargets, relativeOutdir) {
   if (noEngine === true) return "";
@@ -3934,7 +3974,7 @@ function buildNFTAnnotations(noEngine, engineType, binaryTargets, relativeOutdir
   }
   if (process.env.NETLIFY) {
     const isNodeMajor20OrUp = parseInt(process.versions.node.split(".")[0]) >= 20;
-    const awsRuntimeVersion = (0, import_internals4.parseAWSNodejsRuntimeEnvVarVersion)();
+    const awsRuntimeVersion = (0, import_internals5.parseAWSNodejsRuntimeEnvVarVersion)();
     const isRuntimeEnvVar20OrUp = awsRuntimeVersion && awsRuntimeVersion >= 20;
     const isRuntimeEnvVar18OrDown = awsRuntimeVersion && awsRuntimeVersion <= 18;
     if ((isNodeMajor20OrUp || isRuntimeEnvVar20OrUp) && !isRuntimeEnvVar18OrDown) {
@@ -3950,10 +3990,10 @@ function buildNFTAnnotations(noEngine, engineType, binaryTargets, relativeOutdir
   return `${engineAnnotations}`;
 }
 function getQueryEngineFilename(engineType, binaryTarget) {
-  if (engineType === import_internals4.ClientEngineType.Library) {
+  if (engineType === import_internals5.ClientEngineType.Library) {
     return (0, import_get_platform.getNodeAPIName)(binaryTarget, "fs");
   }
-  if (engineType === import_internals4.ClientEngineType.Binary) {
+  if (engineType === import_internals5.ClientEngineType.Binary) {
     return `query-engine-${binaryTarget}`;
   }
   return void 0;
@@ -3962,56 +4002,49 @@ function buildNFTAnnotation(fileName, relativeOutdir) {
   const relativeFilePath = import_path.default.join(relativeOutdir, fileName);
   return `
 // file annotations for bundling tools to include these files
-path.join(__dirname, ${JSON.stringify((0, import_internals4.pathToPosix)(fileName))})
-path.join(process.cwd(), ${JSON.stringify((0, import_internals4.pathToPosix)(relativeFilePath))})`;
+path.join(__dirname, ${JSON.stringify((0, import_internals5.pathToPosix)(fileName))})
+path.join(process.cwd(), ${JSON.stringify((0, import_internals5.pathToPosix)(relativeFilePath))})`;
 }
 
 // src/TSClient/file-generators/ClientFile.ts
-var jsDocHeader2 = `/*
+var jsDocHeader3 = `/*
  * This file should be your main import to use Prisma. Through it you get access to all the models, enums, and input types.
- *
+ * If you're looking for something you can import in the client-side of your application, please refer to the \`browser.ts\` file instead.
+ * 
  * \u{1F7E2} You can import this file directly.
  */
 `;
 function createClientFile(context, options) {
-  const clientEngineType = (0, import_internals5.getClientEngineType)(options.generator);
+  const clientEngineType = (0, import_internals6.getClientEngineType)(options.generator);
   options.generator.config.engineType = clientEngineType;
   const imports = [
-    ts6.moduleImport(context.runtimeImport).asNamespace("runtime"),
-    ts6.moduleImport(context.importFileName("./enums")).asNamespace("$Enums"),
-    ts6.moduleImport(context.importFileName("./internal/class")).asNamespace("$Class"),
-    ts6.moduleImport(context.importFileName("./internal/prismaNamespace")).asNamespace("Prisma")
-  ].map((i) => ts6.stringify(i));
+    ts7.moduleImport(context.runtimeImport).asNamespace("runtime"),
+    ts7.moduleImport(context.importFileName("./enums")).asNamespace("$Enums"),
+    ts7.moduleImport(context.importFileName("./internal/class")).asNamespace("$Class"),
+    ts7.moduleImport(context.importFileName("./internal/prismaNamespace")).asNamespace("Prisma")
+  ].map((i) => ts7.stringify(i));
   const exports2 = [
-    ts6.moduleExportFrom(context.importFileName("./enums")).asNamespace("$Enums"),
-    ts6.moduleExportFrom(context.importFileName("./enums")),
-    ts6.moduleExport(
-      ts6.constDeclaration("PrismaClient").setValue(ts6.functionCall("$Class.getPrismaClientClass", [ts6.namedValue("__dirname")]))
+    ts7.moduleExportFrom(context.importFileName("./enums")).asNamespace("$Enums"),
+    ts7.moduleExportFrom(context.importFileName("./enums")),
+    ts7.moduleExport(
+      ts7.constDeclaration("PrismaClient").setValue(ts7.functionCall("$Class.getPrismaClientClass", [ts7.namedValue("__dirname")]))
     ).setDocComment(getPrismaClientClassDocComment(context)),
-    ts6.moduleExport(
-      ts6.typeDeclaration(
+    ts7.moduleExport(
+      ts7.typeDeclaration(
         "PrismaClient",
-        ts6.namedType("$Class.PrismaClient").addGenericArgument(ts6.namedType("LogOpts")).addGenericArgument(ts6.namedType("OmitOpts")).addGenericArgument(ts6.namedType("ExtArgs"))
+        ts7.namedType("$Class.PrismaClient").addGenericArgument(ts7.namedType("LogOpts")).addGenericArgument(ts7.namedType("OmitOpts")).addGenericArgument(ts7.namedType("ExtArgs"))
       ).addGenericParameter(
-        ts6.genericParameter("LogOpts").extends(ts6.namedType("Prisma.LogLevel")).default(ts6.neverType)
+        ts7.genericParameter("LogOpts").extends(ts7.namedType("Prisma.LogLevel")).default(ts7.neverType)
       ).addGenericParameter(
-        ts6.genericParameter("OmitOpts").extends(ts6.namedType("Prisma.PrismaClientOptions").subKey("omit")).default(ts6.namedType("Prisma.PrismaClientOptions").subKey("omit"))
+        ts7.genericParameter("OmitOpts").extends(ts7.namedType("Prisma.PrismaClientOptions").subKey("omit")).default(ts7.namedType("Prisma.PrismaClientOptions").subKey("omit"))
       ).addGenericParameter(
-        ts6.genericParameter("ExtArgs").extends(ts6.namedType("runtime.Types.Extensions.InternalArgs")).default(ts6.namedType("runtime.Types.Extensions.DefaultArgs"))
+        ts7.genericParameter("ExtArgs").extends(ts7.namedType("runtime.Types.Extensions.InternalArgs")).default(ts7.namedType("runtime.Types.Extensions.DefaultArgs"))
       )
     )
-  ].map((e) => ts6.stringify(e));
-  const modelExports = Object.values(context.dmmf.typeAndModelMap).filter((model) => context.dmmf.outputTypeMap.model[model.name]).map((model) => {
-    const docLines = model.documentation ?? "";
-    const modelLine = `Model ${model.name}
-`;
-    const docs = `${modelLine}${docLines}`;
-    const modelTypeExport = ts6.moduleExport(ts6.typeDeclaration(model.name, ts6.namedType(`Prisma.${model.name}Model`))).setDocComment(ts6.docComment(docs));
-    return ts6.stringify(modelTypeExport);
-  });
-  const binaryTargets = clientEngineType === import_internals5.ClientEngineType.Library ? Object.keys(options.binaryPaths.libqueryEngine ?? {}) : Object.keys(options.binaryPaths.queryEngine ?? {});
+  ].map((e) => ts7.stringify(e));
+  const binaryTargets = clientEngineType === import_internals6.ClientEngineType.Library ? Object.keys(options.binaryPaths.libqueryEngine ?? {}) : Object.keys(options.binaryPaths.queryEngine ?? {});
   const relativeOutdir = import_node_path3.default.relative(process.cwd(), options.outputDir);
-  return `${jsDocHeader2}
+  return `${jsDocHeader3}
 ${buildPreamble(options.edge, options.moduleFormat)}
 ${imports.join("\n")}
 
@@ -4020,7 +4053,7 @@ export { Prisma }
 
 ${buildNFTAnnotations(options.edge || !options.copyEngine, clientEngineType, binaryTargets, relativeOutdir)}
 
-${modelExports.join("\n")}
+${modelExports(context).join("\n")}
 `;
 }
 function buildPreamble(edge, moduleFormat) {
@@ -4040,8 +4073,8 @@ globalThis['__dirname'] = path.dirname(fileURLToPath(import.meta.url))
 }
 
 // src/TSClient/file-generators/CommonInputTypesFile.ts
-var ts7 = __toESM(require("@prisma/ts-builders"));
-var jsDocHeader3 = `/*
+var ts8 = __toESM(require("@prisma/ts-builders"));
+var jsDocHeader4 = `/*
  * This file exports various common sort, input & filter types that are not directly linked to a particular model.
  *
  * \u{1F7E2} You can import this file directly.
@@ -4049,12 +4082,12 @@ var jsDocHeader3 = `/*
 `;
 function createCommonInputTypeFiles(context) {
   const imports = [
-    ts7.moduleImport(context.runtimeImport).asNamespace("runtime"),
-    ts7.moduleImport(context.importFileName(`./enums`)).asNamespace("$Enums"),
-    ts7.moduleImport(context.importFileName(`./internal/prismaNamespace`)).asNamespace("Prisma").typeOnly()
-  ].map((i) => ts7.stringify(i));
+    ts8.moduleImport(context.runtimeImport).asNamespace("runtime").typeOnly(),
+    ts8.moduleImport(context.importFileName(`./enums`)).asNamespace("$Enums"),
+    ts8.moduleImport(context.importFileName(`./internal/prismaNamespace`)).asNamespace("Prisma").typeOnly()
+  ].map((i) => ts8.stringify(i));
   const genericInputTypes = context.dmmf.inputObjectTypes.prisma?.filter((i) => !i.meta?.grouping)?.map((inputType) => new InputType(inputType, context).toTS()) ?? [];
-  return `${jsDocHeader3}
+  return `${jsDocHeader4}
 ${imports.join("\n")}
 
 ${genericInputTypes.join("\n")}
@@ -4065,7 +4098,7 @@ ${context.dmmf.inputObjectTypes.model?.map((inputType) => new InputType(inputTyp
 
 // src/TSClient/file-generators/EnumsFile.ts
 var import_dmmf = require("@prisma/dmmf");
-var jsDocHeader4 = `/*
+var jsDocHeader5 = `/*
 * This file exports all enum related types from the schema.
 *
 * \u{1F7E2} You can import this file directly.
@@ -4078,35 +4111,35 @@ function createEnumsFile(context) {
     modelEnums.push(new Enum((0, import_dmmf.datamodelEnumToSchemaEnum)(datamodelEnum), false).toTS());
   }
   if (modelEnums.length === 0) {
-    return `${jsDocHeader4}
+    return `${jsDocHeader5}
 
 // This file is empty because there are no enums in the schema.
 export {}
 `;
   }
-  return jsDocHeader4 + modelEnums.join("\n\n");
+  return jsDocHeader5 + modelEnums.join("\n\n");
 }
 
 // src/TSClient/file-generators/ModelFile.ts
-var ts14 = __toESM(require("@prisma/ts-builders"));
+var ts15 = __toESM(require("@prisma/ts-builders"));
 
 // src/TSClient/Model.ts
 var import_client_common16 = require("@prisma/client-common");
 var DMMF2 = __toESM(require("@prisma/dmmf"));
-var ts13 = __toESM(require("@prisma/ts-builders"));
+var ts14 = __toESM(require("@prisma/ts-builders"));
 var import_indent_string5 = __toESM(require("indent-string"));
 var import_klona = require("klona");
 
 // src/TSClient/Args.ts
-var ts8 = __toESM(require("@prisma/ts-builders"));
+var ts9 = __toESM(require("@prisma/ts-builders"));
 var ArgsTypeBuilder = class {
   constructor(type, context, action) {
     this.type = type;
     this.context = context;
     this.action = action;
-    this.moduleExport = ts8.moduleExport(
-      ts8.typeDeclaration(getModelArgName(type.name, action), ts8.objectType()).addGenericParameter(extArgsParam)
-    ).setDocComment(ts8.docComment(`${type.name} ${action ?? "without action"}`));
+    this.moduleExport = ts9.moduleExport(
+      ts9.typeDeclaration(getModelArgName(type.name, action), ts9.objectType()).addGenericParameter(extArgsParam)
+    ).setDocComment(ts9.docComment(`${type.name} ${action ?? "without action"}`));
   }
   moduleExport;
   addProperty(prop) {
@@ -4117,7 +4150,7 @@ var ArgsTypeBuilder = class {
       const inputField = buildInputField(arg, this.context);
       const docComment9 = getArgFieldJSDoc(this.type, this.action, arg);
       if (docComment9) {
-        inputField.setDocComment(ts8.docComment(docComment9));
+        inputField.setDocComment(ts9.docComment(docComment9));
       }
       this.addProperty(inputField);
     }
@@ -4125,13 +4158,13 @@ var ArgsTypeBuilder = class {
   }
   addSelectArg(selectTypeName = getSelectName(this.type.name)) {
     this.addProperty(
-      ts8.property(
+      ts9.property(
         "select",
-        ts8.unionType([
-          ts8.namedType(`Prisma.${selectTypeName}`).addGenericArgument(extArgsParam.toArgument()),
-          ts8.nullType
+        ts9.unionType([
+          ts9.namedType(`Prisma.${selectTypeName}`).addGenericArgument(extArgsParam.toArgument()),
+          ts9.nullType
         ])
-      ).optional().setDocComment(ts8.docComment(`Select specific fields to fetch from the ${this.type.name}`))
+      ).optional().setDocComment(ts9.docComment(`Select specific fields to fetch from the ${this.type.name}`))
     );
     return this;
   }
@@ -4141,25 +4174,25 @@ var ArgsTypeBuilder = class {
       return this;
     }
     this.addProperty(
-      ts8.property(
+      ts9.property(
         "include",
-        ts8.unionType([
-          ts8.namedType(`Prisma.${includeTypeName}`).addGenericArgument(extArgsParam.toArgument()),
-          ts8.nullType
+        ts9.unionType([
+          ts9.namedType(`Prisma.${includeTypeName}`).addGenericArgument(extArgsParam.toArgument()),
+          ts9.nullType
         ])
-      ).optional().setDocComment(ts8.docComment("Choose, which related nodes to fetch as well"))
+      ).optional().setDocComment(ts9.docComment("Choose, which related nodes to fetch as well"))
     );
     return this;
   }
   addOmitArg() {
     this.addProperty(
-      ts8.property(
+      ts9.property(
         "omit",
-        ts8.unionType([
-          ts8.namedType(`Prisma.${getOmitName(this.type.name)}`).addGenericArgument(extArgsParam.toArgument()),
-          ts8.nullType
+        ts9.unionType([
+          ts9.namedType(`Prisma.${getOmitName(this.type.name)}`).addGenericArgument(extArgsParam.toArgument()),
+          ts9.nullType
         ])
-      ).optional().setDocComment(ts8.docComment(`Omit specific fields from the ${this.type.name}`))
+      ).optional().setDocComment(ts9.docComment(`Omit specific fields from the ${this.type.name}`))
     );
     return this;
   }
@@ -4168,7 +4201,7 @@ var ArgsTypeBuilder = class {
     return this;
   }
   setComment(comment) {
-    this.moduleExport.setDocComment(ts8.docComment(comment));
+    this.moduleExport.setDocComment(ts9.docComment(comment));
     return this;
   }
   createExport() {
@@ -4178,60 +4211,60 @@ var ArgsTypeBuilder = class {
 
 // src/TSClient/Count.ts
 var import_client_common13 = require("@prisma/client-common");
-var ts10 = __toESM(require("@prisma/ts-builders"));
+var ts11 = __toESM(require("@prisma/ts-builders"));
 var import_indent_string4 = __toESM(require("indent-string"));
 
 // src/TSClient/Output.ts
-var import_internals6 = require("@prisma/internals");
-var ts9 = __toESM(require("@prisma/ts-builders"));
+var import_internals7 = require("@prisma/internals");
+var ts10 = __toESM(require("@prisma/ts-builders"));
 function buildModelOutputProperty(field, dmmf) {
-  let fieldTypeName = (0, import_internals6.hasOwnProperty)(GraphQLScalarToJSTypeTable, field.type) ? GraphQLScalarToJSTypeTable[field.type] : field.type;
+  let fieldTypeName = (0, import_internals7.hasOwnProperty)(GraphQLScalarToJSTypeTable, field.type) ? GraphQLScalarToJSTypeTable[field.type] : field.type;
   if (Array.isArray(fieldTypeName)) {
     fieldTypeName = fieldTypeName[0];
   }
   let fieldType;
   if (field.kind === "object") {
-    const payloadType = ts9.namedType(getPayloadName(field.type));
+    const payloadType = ts10.namedType(getPayloadName(field.type));
     if (!dmmf.isComposite(field.type)) {
-      payloadType.addGenericArgument(ts9.namedType("ExtArgs"));
+      payloadType.addGenericArgument(ts10.namedType("ExtArgs"));
     }
     fieldType = payloadType;
   } else if (field.kind === "enum") {
-    fieldType = ts9.namedType(`$Enums.${fieldTypeName}`);
+    fieldType = ts10.namedType(`$Enums.${fieldTypeName}`);
   } else {
-    fieldType = ts9.namedType(fieldTypeName);
+    fieldType = ts10.namedType(fieldTypeName);
   }
   if (field.isList) {
-    fieldType = ts9.array(fieldType);
+    fieldType = ts10.array(fieldType);
   } else if (!field.isRequired) {
-    fieldType = ts9.unionType(fieldType).addVariant(ts9.nullType);
+    fieldType = ts10.unionType(fieldType).addVariant(ts10.nullType);
   }
-  const property13 = ts9.property(field.name, fieldType);
+  const property13 = ts10.property(field.name, fieldType);
   if (field.documentation) {
-    property13.setDocComment(ts9.docComment(field.documentation));
+    property13.setDocComment(ts10.docComment(field.documentation));
   }
   return property13;
 }
 function buildOutputType(type) {
-  return ts9.moduleExport(ts9.typeDeclaration(type.name, ts9.objectType().addMultiple(type.fields.map(buildOutputField))));
+  return ts10.moduleExport(ts10.typeDeclaration(type.name, ts10.objectType().addMultiple(type.fields.map(buildOutputField))));
 }
 function buildOutputField(field) {
   let fieldType;
   if (field.outputType.location === "enumTypes" && field.outputType.namespace === "model") {
-    fieldType = ts9.namedType(enumTypeName(field.outputType));
+    fieldType = ts10.namedType(enumTypeName(field.outputType));
   } else {
     const typeNames = GraphQLScalarToJSTypeTable[field.outputType.type] ?? field.outputType.type;
-    fieldType = Array.isArray(typeNames) ? ts9.namedType(typeNames[0]) : ts9.namedType(typeNames);
+    fieldType = Array.isArray(typeNames) ? ts10.namedType(typeNames[0]) : ts10.namedType(typeNames);
   }
   if (field.outputType.isList) {
-    fieldType = ts9.array(fieldType);
+    fieldType = ts10.array(fieldType);
   } else if (field.isNullable) {
-    fieldType = ts9.unionType(fieldType).addVariant(ts9.nullType);
+    fieldType = ts10.unionType(fieldType).addVariant(ts10.nullType);
   }
-  const property13 = ts9.property(field.name, fieldType);
+  const property13 = ts10.property(field.name, fieldType);
   if (field.deprecation) {
     property13.setDocComment(
-      ts9.docComment(`@deprecated since ${field.deprecation.sinceVersion} because ${field.deprecation.reason}`)
+      ts10.docComment(`@deprecated since ${field.deprecation.sinceVersion} because ${field.deprecation.reason}`)
     );
   }
   return property13;
@@ -4271,7 +4304,7 @@ var Count = class {
  * Count Type ${name}
  */
 
-${ts10.stringify(outputType)}
+${ts11.stringify(outputType)}
 
 export type ${getSelectName(
       name
@@ -4291,7 +4324,7 @@ ${(0, import_indent_string4.default)(
     )}
 }
 
-${this.argsTypes.map((typeExport) => ts10.stringify(typeExport)).join("\n\n")}
+${this.argsTypes.map((typeExport) => ts11.stringify(typeExport)).join("\n\n")}
 `;
   }
 };
@@ -4328,12 +4361,12 @@ ${this.stringifyFields()}
 
 // src/TSClient/Payload.ts
 var import_client_common14 = require("@prisma/client-common");
-var ts11 = __toESM(require("@prisma/ts-builders"));
+var ts12 = __toESM(require("@prisma/ts-builders"));
 function buildModelPayload(model, context) {
   const isComposite = context.dmmf.isComposite(model.name);
-  const objects = ts11.objectType();
-  const scalars = ts11.objectType();
-  const composites = ts11.objectType();
+  const objects = ts12.objectType();
+  const scalars = ts12.objectType();
+  const composites = ts12.objectType();
   for (const field of model.fields) {
     if (field.kind === "object") {
       if (context.dmmf.isComposite(field.type)) {
@@ -4345,20 +4378,20 @@ function buildModelPayload(model, context) {
       scalars.add(buildModelOutputProperty(field, context.dmmf));
     }
   }
-  const scalarsType = isComposite ? scalars : ts11.namedType("runtime.Types.Extensions.GetPayloadResult").addGenericArgument(scalars).addGenericArgument(ts11.namedType("ExtArgs").subKey("result").subKey((0, import_client_common14.uncapitalize)(model.name)));
-  const payloadTypeDeclaration = ts11.typeDeclaration(
+  const scalarsType = isComposite ? scalars : ts12.namedType("runtime.Types.Extensions.GetPayloadResult").addGenericArgument(scalars).addGenericArgument(ts12.namedType("ExtArgs").subKey("result").subKey((0, import_client_common14.uncapitalize)(model.name)));
+  const payloadTypeDeclaration = ts12.typeDeclaration(
     getPayloadName(model.name, false),
-    ts11.objectType().add(ts11.property("name", ts11.stringLiteral(model.name))).add(ts11.property("objects", objects)).add(ts11.property("scalars", scalarsType)).add(ts11.property("composites", composites))
+    ts12.objectType().add(ts12.property("name", ts12.stringLiteral(model.name))).add(ts12.property("objects", objects)).add(ts12.property("scalars", scalarsType)).add(ts12.property("composites", composites))
   );
   if (!isComposite) {
     payloadTypeDeclaration.addGenericParameter(extArgsParam);
   }
-  return ts11.moduleExport(payloadTypeDeclaration);
+  return ts12.moduleExport(payloadTypeDeclaration);
 }
 
 // src/TSClient/SelectIncludeOmit.ts
 var import_client_common15 = require("@prisma/client-common");
-var ts12 = __toESM(require("@prisma/ts-builders"));
+var ts13 = __toESM(require("@prisma/ts-builders"));
 function buildIncludeType({
   modelName,
   typeName = getIncludeName(modelName),
@@ -4369,14 +4402,14 @@ function buildIncludeType({
   return buildExport(typeName, type);
 }
 function buildOmitType({ modelName, fields, context }) {
-  const keysType = ts12.unionType(
+  const keysType = ts13.unionType(
     fields.filter(
       (field) => field.outputType.location === "scalar" || field.outputType.location === "enumTypes" || context.dmmf.isComposite(field.outputType.type)
-    ).map((field) => ts12.stringLiteral(field.name))
+    ).map((field) => ts13.stringLiteral(field.name))
   );
-  const omitType = ts12.namedType("runtime.Types.Extensions.GetOmit").addGenericArgument(keysType).addGenericArgument(modelResultExtensionsType(modelName));
+  const omitType = ts13.namedType("runtime.Types.Extensions.GetOmit").addGenericArgument(keysType).addGenericArgument(modelResultExtensionsType(modelName));
   if (context.isPreviewFeatureOn("strictUndefinedChecks")) {
-    omitType.addGenericArgument(ts12.namedType("runtime.Types.Skip"));
+    omitType.addGenericArgument(ts13.namedType("runtime.Types.Skip"));
   }
   return buildExport(getOmitName(modelName), omitType);
 }
@@ -4387,7 +4420,7 @@ function buildSelectType({
   context
 }) {
   const objectType11 = buildSelectOrIncludeObject(modelName, fields, context);
-  const selectType = ts12.namedType("runtime.Types.Extensions.GetSelect").addGenericArgument(objectType11).addGenericArgument(modelResultExtensionsType(modelName));
+  const selectType = ts13.namedType("runtime.Types.Extensions.GetSelect").addGenericArgument(objectType11).addGenericArgument(modelResultExtensionsType(modelName));
   return buildExport(typeName, selectType);
 }
 function modelResultExtensionsType(modelName) {
@@ -4399,24 +4432,24 @@ function buildScalarSelectType({ modelName, fields, context }) {
     fields.filter((field) => field.outputType.location === "scalar" || field.outputType.location === "enumTypes"),
     context
   );
-  return ts12.moduleExport(ts12.typeDeclaration(`${getSelectName(modelName)}Scalar`, object));
+  return ts13.moduleExport(ts13.typeDeclaration(`${getSelectName(modelName)}Scalar`, object));
 }
 function buildSelectOrIncludeObject(modelName, fields, context) {
-  const objectType11 = ts12.objectType();
+  const objectType11 = ts13.objectType();
   for (const field of fields) {
-    const fieldType = ts12.unionType(ts12.booleanType);
+    const fieldType = ts13.unionType(ts13.booleanType);
     if (field.outputType.location === "outputObjectTypes") {
-      const subSelectType = ts12.namedType(`Prisma.${getFieldArgName(field, modelName)}`);
+      const subSelectType = ts13.namedType(`Prisma.${getFieldArgName(field, modelName)}`);
       subSelectType.addGenericArgument(extArgsParam.toArgument());
       fieldType.addVariant(subSelectType);
     }
-    objectType11.add(ts12.property(field.name, appendSkipType(context, fieldType)).optional());
+    objectType11.add(ts13.property(field.name, appendSkipType(context, fieldType)).optional());
   }
   return objectType11;
 }
 function buildExport(typeName, type) {
-  const declaration = ts12.typeDeclaration(typeName, type);
-  return ts12.moduleExport(declaration.addGenericParameter(extArgsParam));
+  const declaration = ts13.typeDeclaration(typeName, type);
+  return ts13.moduleExport(declaration.addGenericParameter(extArgsParam));
 }
 function getIncludeFields(fields, dmmf) {
   return fields.filter((field) => {
@@ -4545,7 +4578,7 @@ ${(0, import_indent_string5.default)(
     )}
 }
 
-${ts13.stringify(buildOutputType(groupByType))}
+${ts14.stringify(buildOutputType(groupByType))}
 
 type ${getGroupByPayloadName(model.name)}<T extends ${groupByArgsName}> = Prisma.PrismaPromise<
   Array<
@@ -4595,7 +4628,7 @@ type ${getGroupByPayloadName(model.name)}<T extends ${groupByArgsName}> = Prisma
     }
     const aggregateArgsName = getAggregateArgsName(model.name);
     const aggregateName = getAggregateName(model.name);
-    return `${aggregateTypes.map(buildOutputType).map((type) => ts13.stringify(type)).join("\n\n")}
+    return `${aggregateTypes.map(buildOutputType).map((type) => ts14.stringify(type)).join("\n\n")}
 
 ${aggregateTypes.length > 1 ? aggregateTypes.slice(1).map((type) => {
       const newType = {
@@ -4663,31 +4696,31 @@ export type ${getAggregateGetName(model.name)}<T extends ${getAggregateArgsName(
     const modelLine = `Model ${this.model.name}
 `;
     const docs = `${modelLine}${docLines}`;
-    const modelTypeExport = ts13.moduleExport(
-      ts13.typeDeclaration(
+    const modelTypeExport = ts14.moduleExport(
+      ts14.typeDeclaration(
         `${this.model.name}Model`,
-        ts13.namedType(`runtime.Types.Result.DefaultSelection`).addGenericArgument(ts13.namedType(getPayloadName(this.model.name)))
+        ts14.namedType(`runtime.Types.Result.DefaultSelection`).addGenericArgument(ts14.namedType(getPayloadName(this.model.name)))
       )
-    ).setDocComment(ts13.docComment(docs));
-    return ts13.stringify(modelTypeExport);
+    ).setDocComment(ts14.docComment(docs));
+    return ts14.stringify(modelTypeExport);
   }
   toTS() {
     const { model } = this;
     const isComposite = this.dmmf.isComposite(model.name);
-    const omitType = ts13.stringify(
+    const omitType = ts14.stringify(
       buildOmitType({ modelName: this.model.name, context: this.context, fields: this.type.fields }),
       {
         newLine: "leading"
       }
     );
     const hasRelationField = model.fields.some((f) => f.kind === "object");
-    const includeType = hasRelationField ? ts13.stringify(
+    const includeType = hasRelationField ? ts14.stringify(
       buildIncludeType({ modelName: this.model.name, context: this.context, fields: this.type.fields }),
       {
         newLine: "leading"
       }
     ) : "";
-    const createManyAndReturnIncludeType = hasRelationField && this.createManyAndReturnType ? ts13.stringify(
+    const createManyAndReturnIncludeType = hasRelationField && this.createManyAndReturnType ? ts14.stringify(
       buildIncludeType({
         typeName: getIncludeCreateManyAndReturnName(this.model.name),
         modelName: this.model.name,
@@ -4698,7 +4731,7 @@ export type ${getAggregateGetName(model.name)}<T extends ${getAggregateArgsName(
         newLine: "leading"
       }
     ) : "";
-    const updateManyAndReturnIncludeType = hasRelationField && this.updateManyAndReturnType ? ts13.stringify(
+    const updateManyAndReturnIncludeType = hasRelationField && this.updateManyAndReturnType ? ts14.stringify(
       buildIncludeType({
         typeName: getIncludeUpdateManyAndReturnName(this.model.name),
         modelName: this.model.name,
@@ -4720,8 +4753,8 @@ ${this.getDeepInputTypes()}
 
 ${this.getCountTypes()}
 
-${ts13.stringify(buildSelectType({ modelName: this.model.name, fields: this.type.fields, context: this.context }))}
-${this.createManyAndReturnType ? ts13.stringify(
+${ts14.stringify(buildSelectType({ modelName: this.model.name, fields: this.type.fields, context: this.context }))}
+${this.createManyAndReturnType ? ts14.stringify(
       buildSelectType({
         modelName: this.model.name,
         fields: this.createManyAndReturnType.fields,
@@ -4730,7 +4763,7 @@ ${this.createManyAndReturnType ? ts13.stringify(
       }),
       { newLine: "leading" }
     ) : ""}
-${this.updateManyAndReturnType ? ts13.stringify(
+${this.updateManyAndReturnType ? ts14.stringify(
       buildSelectType({
         modelName: this.model.name,
         fields: this.updateManyAndReturnType.fields,
@@ -4739,12 +4772,12 @@ ${this.updateManyAndReturnType ? ts13.stringify(
       }),
       { newLine: "leading" }
     ) : ""}
-${ts13.stringify(buildScalarSelectType({ modelName: this.model.name, fields: this.type.fields, context: this.context }), {
+${ts14.stringify(buildScalarSelectType({ modelName: this.model.name, fields: this.type.fields, context: this.context }), {
       newLine: "leading"
     })}
 ${omitType}${includeType}${createManyAndReturnIncludeType}${updateManyAndReturnIncludeType}
 
-${ts13.stringify(buildModelPayload(this.model, this.context), { newLine: "none" })}
+${ts14.stringify(buildModelPayload(this.model, this.context), { newLine: "none" })}
 
 export type ${model.name}GetPayload<S extends boolean | null | undefined | ${getModelArgName(
       model.name
@@ -4755,7 +4788,7 @@ ${isComposite ? "" : new ModelDelegate(this.type, this.context).toTS()}
 ${new ModelFieldRefs(this.type).toTS()}
 
 // Custom InputTypes
-${this.argsTypes.map((type) => ts13.stringify(type)).join("\n\n")}
+${this.argsTypes.map((type) => ts14.stringify(type)).join("\n\n")}
 `;
   }
 };
@@ -4786,7 +4819,7 @@ var ModelDelegate = class {
     const nonAggregateActions = this.getNonAggregateActions(availableActions);
     const groupByArgsName = getGroupByArgsName(name);
     const countArgsName = getModelArgName(name, DMMF2.ModelAction.count);
-    const genericDelegateParams = [extArgsParam, ts13.genericParameter("GlobalOmitOptions").default(ts13.objectType())];
+    const genericDelegateParams = [extArgsParam, ts14.genericParameter("GlobalOmitOptions").default(ts14.objectType())];
     const excludedArgsForCount = ["select", "include", "distinct", "omit"];
     if (this.context.isPreviewFeatureOn("relationJoins")) {
       excludedArgsForCount.push("relationLoadStrategy");
@@ -4797,11 +4830,11 @@ var ModelDelegate = class {
     select?: ${getCountAggregateInputName(name)} | true
   }
 ` : ""}
-export interface ${name}Delegate<${genericDelegateParams.map((param) => ts13.stringify(param)).join(", ")}> {
+export interface ${name}Delegate<${genericDelegateParams.map((param) => ts14.stringify(param)).join(", ")}> {
 ${(0, import_indent_string5.default)(`[K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['${name}'], meta: { name: '${name}' } }`, TAB_SIZE)}
 ${nonAggregateActions.map((action) => {
       const method3 = buildModelDelegateMethod(name, action, this.context);
-      return ts13.stringify(method3, { indentLevel: 1, newLine: "trailing" });
+      return ts14.stringify(method3, { indentLevel: 1, newLine: "trailing" });
     }).join("\n")}
 
 ${availableActions.includes(DMMF2.ModelAction.aggregate) ? `${(0, import_indent_string5.default)(getMethodJSDoc(DMMF2.ModelAction.count, mapping, modelOrType), TAB_SIZE)}
@@ -4887,7 +4920,7 @@ ${availableActions.includes(DMMF2.ModelAction.groupBy) ? `${(0, import_indent_st
 readonly fields: ${getFieldRefsTypeName(name)};
 }
 
-${ts13.stringify(buildFluentWrapperDefinition(name, this.outputType, this.context))}
+${ts14.stringify(buildFluentWrapperDefinition(name, this.outputType, this.context))}
 `;
   }
 };
@@ -4895,7 +4928,7 @@ function buildModelDelegateMethod(modelName, actionName, context) {
   const mapping = context.dmmf.mappingsMap[modelName] ?? { model: modelName, plural: `${modelName}s` };
   const modelOrType = context.dmmf.typeAndModelMap[modelName];
   const dependencyValidators = getNonAggregateMethodDependencyValidations(mapping, actionName, context);
-  const method3 = ts13.method(actionName).setDocComment(ts13.docComment(getMethodJSDocBody(actionName, mapping, modelOrType))).addParameter(getNonAggregateMethodArgs(modelName, actionName, dependencyValidators)).setReturnType(getReturnType({ modelName, actionName }));
+  const method3 = ts14.method(actionName).setDocComment(ts14.docComment(getMethodJSDocBody(actionName, mapping, modelOrType))).addParameter(getNonAggregateMethodArgs(modelName, actionName, dependencyValidators)).setReturnType(getReturnType({ modelName, actionName }));
   const generic = getNonAggregateMethodGenericParam(modelName, actionName);
   if (generic) {
     method3.addGenericParameter(generic);
@@ -4908,22 +4941,22 @@ function buildModelDelegateMethod(modelName, actionName, context) {
 function getNonAggregateMethodArgs(modelName, actionName, dependencyValidators) {
   const makeParameter = (type2) => {
     if (dependencyValidators.length > 0) {
-      type2 = ts13.intersectionType([type2, ...dependencyValidators.map((validator) => ts13.namedType(validator.name))]);
+      type2 = ts14.intersectionType([type2, ...dependencyValidators.map((validator) => ts14.namedType(validator.name))]);
     }
-    return ts13.parameter("args", type2);
+    return ts14.parameter("args", type2);
   };
   if (actionName === DMMF2.ModelAction.count) {
     const type2 = omit(
-      ts13.namedType(getModelArgName(modelName, DMMF2.ModelAction.findMany)),
-      ts13.unionType(ts13.stringLiteral("select")).addVariant(ts13.stringLiteral("include")).addVariant(ts13.stringLiteral("distinct"))
+      ts14.namedType(getModelArgName(modelName, DMMF2.ModelAction.findMany)),
+      ts14.unionType(ts14.stringLiteral("select")).addVariant(ts14.stringLiteral("include")).addVariant(ts14.stringLiteral("distinct"))
     );
     return makeParameter(type2).optional();
   }
   if (actionName === DMMF2.ModelAction.findRaw || actionName === DMMF2.ModelAction.aggregateRaw) {
-    return makeParameter(ts13.namedType(`Prisma.${getModelArgName(modelName, actionName)}`)).optional();
+    return makeParameter(ts14.namedType(`Prisma.${getModelArgName(modelName, actionName)}`)).optional();
   }
-  const type = ts13.namedType("Prisma.SelectSubset").addGenericArgument(ts13.namedType("T")).addGenericArgument(
-    ts13.namedType(getModelArgName(modelName, actionName)).addGenericArgument(extArgsParam.toArgument())
+  const type = ts14.namedType("Prisma.SelectSubset").addGenericArgument(ts14.namedType("T")).addGenericArgument(
+    ts14.namedType(getModelArgName(modelName, actionName)).addGenericArgument(extArgsParam.toArgument())
   );
   const param = makeParameter(type);
   if (actionName === DMMF2.ModelAction.findMany || actionName === DMMF2.ModelAction.findFirst || actionName === DMMF2.ModelAction.deleteMany || actionName === DMMF2.ModelAction.createMany || actionName === DMMF2.ModelAction.createManyAndReturn || actionName === DMMF2.ModelAction.findFirstOrThrow) {
@@ -4935,11 +4968,11 @@ function getNonAggregateMethodGenericParam(modelName, actionName) {
   if (actionName === DMMF2.ModelAction.count || actionName === DMMF2.ModelAction.findRaw || actionName === DMMF2.ModelAction.aggregateRaw) {
     return null;
   }
-  const arg = ts13.genericParameter("T");
+  const arg = ts14.genericParameter("T");
   if (actionName === DMMF2.ModelAction.aggregate) {
-    return arg.extends(ts13.namedType(getAggregateArgsName(modelName)));
+    return arg.extends(ts14.namedType(getAggregateArgsName(modelName)));
   }
-  return arg.extends(ts13.namedType(getModelArgName(modelName, actionName)));
+  return arg.extends(ts14.namedType(getModelArgName(modelName, actionName)));
 }
 function getNonAggregateMethodDependencyValidations(modelMapping, actionName, context) {
   const outputFieldName = modelMapping[actionName];
@@ -4955,13 +4988,13 @@ function getNonAggregateMethodDependencyValidations(modelMapping, actionName, co
     if (args.requiresOtherFields === void 0) {
       continue;
     }
-    const objectType11 = ts13.objectType();
+    const objectType11 = ts14.objectType();
     for (const reqArg of args.requiresOtherFields) {
-      objectType11.add(ts13.property(reqArg, ts13.objectType()));
+      objectType11.add(ts14.property(reqArg, ts14.objectType()));
     }
     validators.push(
-      ts13.genericParameter(`${(0, import_client_common16.capitalize)(args.name)}DependenciesValidator`).extends(
-        ts13.conditionalType().check(ts13.stringLiteral(args.name)).extends(ts13.namedType("Prisma.Keys<T>")).then(objectType11).else(ts13.objectType())
+      ts14.genericParameter(`${(0, import_client_common16.capitalize)(args.name)}DependenciesValidator`).extends(
+        ts14.conditionalType().check(ts14.stringLiteral(args.name)).extends(ts14.namedType("Prisma.Keys<T>")).then(objectType11).else(ts14.objectType())
       )
     );
   }
@@ -4974,53 +5007,53 @@ function getReturnType({
   isNullable = false
 }) {
   if (actionName === DMMF2.ModelAction.count) {
-    return promise(ts13.numberType);
+    return promise(ts14.numberType);
   }
   if (actionName === DMMF2.ModelAction.aggregate) {
-    return promise(ts13.namedType(getAggregateGetName(modelName)).addGenericArgument(ts13.namedType("T")));
+    return promise(ts14.namedType(getAggregateGetName(modelName)).addGenericArgument(ts14.namedType("T")));
   }
   if (actionName === DMMF2.ModelAction.findRaw || actionName === DMMF2.ModelAction.aggregateRaw) {
-    return prismaPromise(ts13.namedType("Prisma.JsonObject"));
+    return prismaPromise(ts14.namedType("Prisma.JsonObject"));
   }
   if (actionName === DMMF2.ModelAction.deleteMany || actionName === DMMF2.ModelAction.updateMany || actionName === DMMF2.ModelAction.createMany) {
-    return prismaPromise(ts13.namedType("Prisma.BatchPayload"));
+    return prismaPromise(ts14.namedType("Prisma.BatchPayload"));
   }
   const isList = actionName === DMMF2.ModelAction.findMany || actionName === DMMF2.ModelAction.createManyAndReturn || actionName === DMMF2.ModelAction.updateManyAndReturn;
   if (isList) {
     let result = getResultType(modelName, actionName);
     if (isChaining) {
-      result = ts13.unionType(result).addVariant(ts13.namedType("Null"));
+      result = ts14.unionType(result).addVariant(ts14.namedType("Null"));
     }
     return prismaPromise(result);
   }
   if (isChaining && actionName === DMMF2.ModelAction.findUniqueOrThrow) {
-    const nullType7 = isNullable ? ts13.nullType : ts13.namedType("Null");
-    const result = ts13.unionType(getResultType(modelName, actionName)).addVariant(nullType7);
+    const nullType7 = isNullable ? ts14.nullType : ts14.namedType("Null");
+    const result = ts14.unionType(getResultType(modelName, actionName)).addVariant(nullType7);
     return getFluentWrapper(modelName, result, nullType7);
   }
   if (actionName === DMMF2.ModelAction.findFirst || actionName === DMMF2.ModelAction.findUnique) {
-    const result = ts13.unionType(getResultType(modelName, actionName)).addVariant(ts13.nullType);
-    return getFluentWrapper(modelName, result, ts13.nullType);
+    const result = ts14.unionType(getResultType(modelName, actionName)).addVariant(ts14.nullType);
+    return getFluentWrapper(modelName, result, ts14.nullType);
   }
   return getFluentWrapper(modelName, getResultType(modelName, actionName));
 }
-function getFluentWrapper(modelName, resultType, nullType7 = ts13.neverType) {
-  return ts13.namedType(`Prisma.${fluentWrapperName(modelName)}`).addGenericArgument(resultType).addGenericArgument(nullType7).addGenericArgument(extArgsParam.toArgument()).addGenericArgument(ts13.namedType("GlobalOmitOptions"));
+function getFluentWrapper(modelName, resultType, nullType7 = ts14.neverType) {
+  return ts14.namedType(`Prisma.${fluentWrapperName(modelName)}`).addGenericArgument(resultType).addGenericArgument(nullType7).addGenericArgument(extArgsParam.toArgument()).addGenericArgument(ts14.namedType("GlobalOmitOptions"));
 }
 function getResultType(modelName, actionName) {
-  return ts13.namedType("runtime.Types.Result.GetResult").addGenericArgument(ts13.namedType(getPayloadName(modelName)).addGenericArgument(extArgsParam.toArgument())).addGenericArgument(ts13.namedType("T")).addGenericArgument(ts13.stringLiteral(actionName)).addGenericArgument(ts13.namedType("GlobalOmitOptions"));
+  return ts14.namedType("runtime.Types.Result.GetResult").addGenericArgument(ts14.namedType(getPayloadName(modelName)).addGenericArgument(extArgsParam.toArgument())).addGenericArgument(ts14.namedType("T")).addGenericArgument(ts14.stringLiteral(actionName)).addGenericArgument(ts14.namedType("GlobalOmitOptions"));
 }
 function buildFluentWrapperDefinition(modelName, outputType, context) {
-  const definition = ts13.interfaceDeclaration(fluentWrapperName(modelName));
-  definition.addGenericParameter(ts13.genericParameter("T")).addGenericParameter(ts13.genericParameter("Null").default(ts13.neverType)).addGenericParameter(extArgsParam).addGenericParameter(ts13.genericParameter("GlobalOmitOptions").default(ts13.objectType())).extends(prismaPromise(ts13.namedType("T")));
-  definition.add(ts13.property(ts13.toStringTag, ts13.stringLiteral("PrismaPromise")).readonly());
+  const definition = ts14.interfaceDeclaration(fluentWrapperName(modelName));
+  definition.addGenericParameter(ts14.genericParameter("T")).addGenericParameter(ts14.genericParameter("Null").default(ts14.neverType)).addGenericParameter(extArgsParam).addGenericParameter(ts14.genericParameter("GlobalOmitOptions").default(ts14.objectType())).extends(prismaPromise(ts14.namedType("T")));
+  definition.add(ts14.property(ts14.toStringTag, ts14.stringLiteral("PrismaPromise")).readonly());
   definition.addMultiple(
     outputType.fields.filter(
       (field) => field.outputType.location === "outputObjectTypes" && !context.dmmf.isComposite(field.outputType.type) && field.name !== "_count"
     ).map((field) => {
-      const fieldArgType = ts13.namedType(`Prisma.${getFieldArgName(field, modelName)}`).addGenericArgument(extArgsParam.toArgument());
-      const argsParam = ts13.genericParameter("T").extends(fieldArgType).default(ts13.objectType());
-      return ts13.method(field.name).addGenericParameter(argsParam).addParameter(ts13.parameter("args", subset(argsParam.toArgument(), fieldArgType)).optional()).setReturnType(
+      const fieldArgType = ts14.namedType(`Prisma.${getFieldArgName(field, modelName)}`).addGenericArgument(extArgsParam.toArgument());
+      const argsParam = ts14.genericParameter("T").extends(fieldArgType).default(ts14.objectType());
+      return ts14.method(field.name).addGenericParameter(argsParam).addParameter(ts14.parameter("args", subset(argsParam.toArgument(), fieldArgType)).optional()).setReturnType(
         getReturnType({
           modelName: field.outputType.type,
           actionName: field.outputType.isList ? DMMF2.ModelAction.findMany : DMMF2.ModelAction.findUniqueOrThrow,
@@ -5031,37 +5064,37 @@ function buildFluentWrapperDefinition(modelName, outputType, context) {
     })
   );
   definition.add(
-    ts13.method("then").setDocComment(
-      ts13.docComment`
+    ts14.method("then").setDocComment(
+      ts14.docComment`
           Attaches callbacks for the resolution and/or rejection of the Promise.
           @param onfulfilled The callback to execute when the Promise is resolved.
           @param onrejected The callback to execute when the Promise is rejected.
           @returns A Promise for the completion of which ever callback is executed.
         `
-    ).addGenericParameter(ts13.genericParameter("TResult1").default(ts13.namedType("T"))).addGenericParameter(ts13.genericParameter("TResult2").default(ts13.neverType)).addParameter(promiseCallback("onfulfilled", ts13.parameter("value", ts13.namedType("T")), ts13.namedType("TResult1"))).addParameter(promiseCallback("onrejected", ts13.parameter("reason", ts13.anyType), ts13.namedType("TResult2"))).setReturnType(promise(ts13.unionType([ts13.namedType("TResult1"), ts13.namedType("TResult2")])))
+    ).addGenericParameter(ts14.genericParameter("TResult1").default(ts14.namedType("T"))).addGenericParameter(ts14.genericParameter("TResult2").default(ts14.neverType)).addParameter(promiseCallback("onfulfilled", ts14.parameter("value", ts14.namedType("T")), ts14.namedType("TResult1"))).addParameter(promiseCallback("onrejected", ts14.parameter("reason", ts14.anyType), ts14.namedType("TResult2"))).setReturnType(promise(ts14.unionType([ts14.namedType("TResult1"), ts14.namedType("TResult2")])))
   );
   definition.add(
-    ts13.method("catch").setDocComment(
-      ts13.docComment`
+    ts14.method("catch").setDocComment(
+      ts14.docComment`
           Attaches a callback for only the rejection of the Promise.
           @param onrejected The callback to execute when the Promise is rejected.
           @returns A Promise for the completion of the callback.
         `
-    ).addGenericParameter(ts13.genericParameter("TResult").default(ts13.neverType)).addParameter(promiseCallback("onrejected", ts13.parameter("reason", ts13.anyType), ts13.namedType("TResult"))).setReturnType(promise(ts13.unionType([ts13.namedType("T"), ts13.namedType("TResult")])))
+    ).addGenericParameter(ts14.genericParameter("TResult").default(ts14.neverType)).addParameter(promiseCallback("onrejected", ts14.parameter("reason", ts14.anyType), ts14.namedType("TResult"))).setReturnType(promise(ts14.unionType([ts14.namedType("T"), ts14.namedType("TResult")])))
   );
   definition.add(
-    ts13.method("finally").setDocComment(
-      ts13.docComment`
+    ts14.method("finally").setDocComment(
+      ts14.docComment`
           Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
           resolved value cannot be modified from the callback.
           @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
           @returns A Promise for the completion of the callback.
       `
     ).addParameter(
-      ts13.parameter("onfinally", ts13.unionType([ts13.functionType(), ts13.undefinedType, ts13.nullType])).optional()
-    ).setReturnType(promise(ts13.namedType("T")))
+      ts14.parameter("onfinally", ts14.unionType([ts14.functionType(), ts14.undefinedType, ts14.nullType])).optional()
+    ).setReturnType(promise(ts14.namedType("T")))
   );
-  return ts13.moduleExport(definition).setDocComment(ts13.docComment`
+  return ts14.moduleExport(definition).setDocComment(ts14.docComment`
       The delegate class that acts as a "Promise-like" for ${modelName}.
       Why is this prefixed with \`Prisma__\`?
       Because we want to prevent naming conflicts as mentioned in
@@ -5069,20 +5102,20 @@ function buildFluentWrapperDefinition(modelName, outputType, context) {
     `);
 }
 function promiseCallback(name, callbackParam, returnType) {
-  return ts13.parameter(
+  return ts14.parameter(
     name,
-    ts13.unionType([
-      ts13.functionType().addParameter(callbackParam).setReturnType(typeOrPromiseLike(returnType)),
-      ts13.undefinedType,
-      ts13.nullType
+    ts14.unionType([
+      ts14.functionType().addParameter(callbackParam).setReturnType(typeOrPromiseLike(returnType)),
+      ts14.undefinedType,
+      ts14.nullType
     ])
   ).optional();
 }
 function typeOrPromiseLike(type) {
-  return ts13.unionType([type, ts13.namedType("PromiseLike").addGenericArgument(type)]);
+  return ts14.unionType([type, ts14.namedType("PromiseLike").addGenericArgument(type)]);
 }
 function subset(arg, baseType) {
-  return ts13.namedType("Prisma.Subset").addGenericArgument(arg).addGenericArgument(baseType);
+  return ts14.namedType("Prisma.Subset").addGenericArgument(arg).addGenericArgument(baseType);
 }
 function fluentWrapperName(modelName) {
   return `Prisma__${modelName}Client`;
@@ -5090,24 +5123,24 @@ function fluentWrapperName(modelName) {
 
 // src/TSClient/file-generators/ModelFile.ts
 function createModelFile(context, modelName) {
-  const jsDocHeader7 = `/*
+  const jsDocHeader9 = `/*
  * This file exports the \`${modelName}\` model and its related types.
  *
  * \u{1F7E2} You can import this file directly.
  */
 `;
   const imports = [
-    ts14.moduleImport(context.runtimeImport).asNamespace("runtime"),
-    ts14.moduleImport(context.importFileName(`../enums`)).asNamespace("$Enums").typeOnly(),
-    ts14.moduleImport(context.importFileName(`../internal/prismaNamespace`)).asNamespace("Prisma").typeOnly()
+    ts15.moduleImport(context.runtimeImport).asNamespace("runtime").typeOnly(),
+    ts15.moduleImport(context.importFileName(`../enums`)).asNamespace("$Enums").typeOnly(),
+    ts15.moduleImport(context.importFileName(`../internal/prismaNamespace`)).asNamespace("Prisma").typeOnly()
   ];
-  const importsString = imports.map((i) => ts14.stringify(i)).join("\n");
+  const importsString = imports.map((i) => ts15.stringify(i)).join("\n");
   const model = context.dmmf.typeAndModelMap[modelName];
-  return jsDocHeader7 + importsString + "\n" + new Model(model, context).toTS();
+  return jsDocHeader9 + importsString + "\n" + new Model(model, context).toTS();
 }
 
 // src/TSClient/file-generators/ModelsFile.ts
-var jsDocHeader5 = `/*
+var jsDocHeader6 = `/*
  * This is a barrel export file for all models and their related types.
  *
  * \u{1F7E2} You can import this file directly.
@@ -5116,11 +5149,46 @@ var jsDocHeader5 = `/*
 function createModelsFile(context, modelsNames) {
   const exports2 = modelsNames.map((m) => `export type * from './models/${context.importFileName(m)}'`);
   exports2.push(`export type * from './${context.importFileName("commonInputTypes")}'`);
-  return jsDocHeader5 + exports2.join("\n");
+  return jsDocHeader6 + exports2.join("\n");
+}
+
+// src/TSClient/file-generators/PrismaNamespaceBrowserFile.ts
+var ts16 = __toESM(require("@prisma/ts-builders"));
+var jsDocHeader7 = `/*
+ * WARNING: This is an internal file that is subject to change!
+ *
+ * \u{1F6D1} Under no circumstances should you import this file directly! \u{1F6D1}
+ *
+ * All exports from this file are wrapped under a \`Prisma\` namespace object in the browser.ts file.
+ * While this enables partial backward compatibility, it is not part of the stable public API.
+ *
+ * If you are looking for your Models, Enums, and Input Types, please import them from the respective
+ * model files in the \`model\` directory!
+ */
+`;
+function createPrismaNamespaceBrowserFile(context) {
+  const prismaEnums = context.dmmf.schema.enumTypes.prisma?.map((type) => new Enum(type, true).toTS());
+  return `${jsDocHeader7}
+${ts16.stringify(ts16.moduleImport(`${context.runtimeBase}/index-browser`).asNamespace("runtime"))}
+export type * from '${context.importFileName(`../models`)}'
+export type * from '${context.importFileName(`./prismaNamespace`)}'
+export const Decimal = runtime.Decimal
+${new Enum(
+    {
+      name: "ModelName",
+      values: context.dmmf.mappings.modelOperations.map((m) => m.model)
+    },
+    true
+  ).toTS()}
+/**
+ * Enums
+ */
+${prismaEnums?.join("\n\n")}
+`;
 }
 
 // src/TSClient/file-generators/PrismaNamespaceFile.ts
-var ts17 = __toESM(require("@prisma/ts-builders"));
+var ts19 = __toESM(require("@prisma/ts-builders"));
 
 // src/TSClient/common.ts
 var commonCodeTS = ({ clientVersion, engineVersion, generator }) => {
@@ -5545,23 +5613,23 @@ export type ${this.type.name}<$PrismaModel> = FieldRefInputType<$PrismaModel, ${
 
 // src/TSClient/globalOmit.ts
 var import_client_common17 = require("@prisma/client-common");
-var ts15 = __toESM(require("@prisma/ts-builders"));
+var ts17 = __toESM(require("@prisma/ts-builders"));
 function globalOmitConfig(dmmf) {
-  const objectType11 = ts15.objectType().addMultiple(
+  const objectType11 = ts17.objectType().addMultiple(
     dmmf.datamodel.models.map((model) => {
-      const type = ts15.namedType(`Prisma.${getOmitName(model.name)}`);
-      return ts15.property((0, import_client_common17.uncapitalize)(model.name), type).optional();
+      const type = ts17.namedType(`Prisma.${getOmitName(model.name)}`);
+      return ts17.property((0, import_client_common17.uncapitalize)(model.name), type).optional();
     })
   );
-  return ts15.moduleExport(ts15.typeDeclaration("GlobalOmitConfig", objectType11));
+  return ts17.moduleExport(ts17.typeDeclaration("GlobalOmitConfig", objectType11));
 }
 
 // src/TSClient/TypeMap.ts
 var import_client_common18 = require("@prisma/client-common");
-var import_internals7 = require("@prisma/internals");
-var ts16 = __toESM(require("@prisma/ts-builders"));
+var import_internals8 = require("@prisma/internals");
+var ts18 = __toESM(require("@prisma/ts-builders"));
 function clientTypeMapDefinition(context) {
-  const typeMap = `${ts16.stringify(clientTypeMapModelsDefinition(context))} & ${clientTypeMapOthersDefinition(context)}`;
+  const typeMap = `${ts18.stringify(clientTypeMapModelsDefinition(context))} & ${clientTypeMapOthersDefinition(context)}`;
   return `
 export interface TypeMapCb<GlobalOmitOptions = {}> extends runtime.Types.Utils.Fn<{extArgs: runtime.Types.Extensions.InternalArgs }, runtime.Types.Utils.Record<string, any>> {
   returns: TypeMap<this['params']['extArgs'], GlobalOmitOptions>
@@ -5570,39 +5638,39 @@ export interface TypeMapCb<GlobalOmitOptions = {}> extends runtime.Types.Utils.F
 export type TypeMap<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> = ${typeMap}`;
 }
 function clientTypeMapModelsDefinition(context) {
-  const meta = ts16.objectType();
+  const meta = ts18.objectType();
   const modelNames = context.dmmf.datamodel.models.map((m) => m.name);
   if (modelNames.length === 0) {
-    meta.add(ts16.property("modelProps", ts16.neverType));
+    meta.add(ts18.property("modelProps", ts18.neverType));
   } else {
-    meta.add(ts16.property("modelProps", ts16.unionType(modelNames.map((name) => ts16.stringLiteral((0, import_client_common18.uncapitalize)(name))))));
+    meta.add(ts18.property("modelProps", ts18.unionType(modelNames.map((name) => ts18.stringLiteral((0, import_client_common18.uncapitalize)(name))))));
   }
-  const isolationLevel = context.dmmf.hasEnumInNamespace("TransactionIsolationLevel", "prisma") ? ts16.namedType("TransactionIsolationLevel") : ts16.neverType;
-  meta.add(ts16.property("txIsolationLevel", isolationLevel));
-  const model = ts16.objectType();
+  const isolationLevel = context.dmmf.hasEnumInNamespace("TransactionIsolationLevel", "prisma") ? ts18.namedType("TransactionIsolationLevel") : ts18.neverType;
+  meta.add(ts18.property("txIsolationLevel", isolationLevel));
+  const model = ts18.objectType();
   model.addMultiple(
     modelNames.map((modelName) => {
-      const entry = ts16.objectType();
+      const entry = ts18.objectType();
       entry.add(
-        ts16.property("payload", ts16.namedType(getPayloadName(modelName)).addGenericArgument(extArgsParam.toArgument()))
+        ts18.property("payload", ts18.namedType(getPayloadName(modelName)).addGenericArgument(extArgsParam.toArgument()))
       );
-      entry.add(ts16.property("fields", ts16.namedType(`Prisma.${getFieldRefsTypeName(modelName)}`)));
+      entry.add(ts18.property("fields", ts18.namedType(`Prisma.${getFieldRefsTypeName(modelName)}`)));
       const actions = getModelActions(context.dmmf, modelName);
-      const operations = ts16.objectType();
+      const operations = ts18.objectType();
       operations.addMultiple(
         actions.map((action) => {
-          const operationType = ts16.objectType();
+          const operationType = ts18.objectType();
           const argsType = `Prisma.${getModelArgName(modelName, action)}`;
-          operationType.add(ts16.property("args", ts16.namedType(argsType).addGenericArgument(extArgsParam.toArgument())));
-          operationType.add(ts16.property("result", clientTypeMapModelsResultDefinition(modelName, action)));
-          return ts16.property(action, operationType);
+          operationType.add(ts18.property("args", ts18.namedType(argsType).addGenericArgument(extArgsParam.toArgument())));
+          operationType.add(ts18.property("result", clientTypeMapModelsResultDefinition(modelName, action)));
+          return ts18.property(action, operationType);
         })
       );
-      entry.add(ts16.property("operations", operations));
-      return ts16.property(modelName, entry);
+      entry.add(ts18.property("operations", operations));
+      return ts18.property(modelName, entry);
     })
   );
-  return ts16.objectType().add(ts16.property("globalOmitOptions", ts16.objectType().add(ts16.property("omit", ts16.namedType("GlobalOmitOptions"))))).add(ts16.property("meta", meta)).add(ts16.property("model", model));
+  return ts18.objectType().add(ts18.property("globalOmitOptions", ts18.objectType().add(ts18.property("omit", ts18.namedType("GlobalOmitOptions"))))).add(ts18.property("meta", meta)).add(ts18.property("model", model));
 }
 function clientTypeMapOthersDefinition(context) {
   const otherOperationsNames = context.dmmf.getOtherOperationNames().flatMap((name) => {
@@ -5639,33 +5707,33 @@ function clientTypeMapOthersDefinition(context) {
 }
 function clientTypeMapModelsResultDefinition(modelName, action) {
   if (action === "count")
-    return ts16.unionType([optional(ts16.namedType(`Prisma.${getCountAggregateOutputName(modelName)}`)), ts16.numberType]);
-  if (action === "groupBy") return ts16.array(optional(ts16.namedType(`Prisma.${getGroupByName(modelName)}`)));
-  if (action === "aggregate") return optional(ts16.namedType(`Prisma.${getAggregateName(modelName)}`));
-  if (action === "findRaw") return ts16.namedType("Prisma.JsonObject");
-  if (action === "aggregateRaw") return ts16.namedType("Prisma.JsonObject");
-  if (action === "deleteMany") return ts16.namedType("BatchPayload");
-  if (action === "createMany") return ts16.namedType("BatchPayload");
-  if (action === "createManyAndReturn") return ts16.array(payloadToResult(modelName));
-  if (action === "updateMany") return ts16.namedType("BatchPayload");
-  if (action === "updateManyAndReturn") return ts16.array(payloadToResult(modelName));
-  if (action === "findMany") return ts16.array(payloadToResult(modelName));
-  if (action === "findFirst") return ts16.unionType([payloadToResult(modelName), ts16.nullType]);
-  if (action === "findUnique") return ts16.unionType([payloadToResult(modelName), ts16.nullType]);
+    return ts18.unionType([optional(ts18.namedType(`Prisma.${getCountAggregateOutputName(modelName)}`)), ts18.numberType]);
+  if (action === "groupBy") return ts18.array(optional(ts18.namedType(`Prisma.${getGroupByName(modelName)}`)));
+  if (action === "aggregate") return optional(ts18.namedType(`Prisma.${getAggregateName(modelName)}`));
+  if (action === "findRaw") return ts18.namedType("Prisma.JsonObject");
+  if (action === "aggregateRaw") return ts18.namedType("Prisma.JsonObject");
+  if (action === "deleteMany") return ts18.namedType("BatchPayload");
+  if (action === "createMany") return ts18.namedType("BatchPayload");
+  if (action === "createManyAndReturn") return ts18.array(payloadToResult(modelName));
+  if (action === "updateMany") return ts18.namedType("BatchPayload");
+  if (action === "updateManyAndReturn") return ts18.array(payloadToResult(modelName));
+  if (action === "findMany") return ts18.array(payloadToResult(modelName));
+  if (action === "findFirst") return ts18.unionType([payloadToResult(modelName), ts18.nullType]);
+  if (action === "findUnique") return ts18.unionType([payloadToResult(modelName), ts18.nullType]);
   if (action === "findFirstOrThrow") return payloadToResult(modelName);
   if (action === "findUniqueOrThrow") return payloadToResult(modelName);
   if (action === "create") return payloadToResult(modelName);
   if (action === "update") return payloadToResult(modelName);
   if (action === "upsert") return payloadToResult(modelName);
   if (action === "delete") return payloadToResult(modelName);
-  (0, import_internals7.assertNever)(action, `Unknown action: ${action}`);
+  (0, import_internals8.assertNever)(action, `Unknown action: ${action}`);
 }
 function payloadToResult(modelName) {
-  return ts16.namedType("runtime.Types.Utils.PayloadToResult").addGenericArgument(ts16.namedType(getPayloadName(modelName)));
+  return ts18.namedType("runtime.Types.Utils.PayloadToResult").addGenericArgument(ts18.namedType(getPayloadName(modelName)));
 }
 
 // src/TSClient/file-generators/PrismaNamespaceFile.ts
-var jsDocHeader6 = `/*
+var jsDocHeader8 = `/*
  * WARNING: This is an internal file that is subject to change!
  *
  * \u{1F6D1} Under no circumstances should you import this file directly! \u{1F6D1}
@@ -5679,13 +5747,13 @@ var jsDocHeader6 = `/*
 `;
 function createPrismaNamespaceFile(context, options) {
   const imports = [
-    ts17.moduleImport(context.runtimeImport).asNamespace("runtime"),
-    ts17.moduleImport(context.importFileName(`../models`)).asNamespace("Prisma").typeOnly(),
-    ts17.moduleImport(context.importFileName(`./class`)).named(ts17.namedImport("PrismaClient").typeOnly())
-  ].map((i) => ts17.stringify(i));
+    ts19.moduleImport(context.runtimeImport).asNamespace("runtime"),
+    ts19.moduleImport(context.importFileName(`../models`)).asNamespace("Prisma").typeOnly(),
+    ts19.moduleImport(context.importFileName(`./class`)).named(ts19.namedImport("PrismaClient").typeOnly())
+  ].map((i) => ts19.stringify(i));
   const prismaEnums = context.dmmf.schema.enumTypes.prisma?.map((type) => new Enum(type, true).toTS());
   const fieldRefs = context.dmmf.schema.fieldRefTypes.prisma?.map((type) => new FieldRefInput(type).toTS()) ?? [];
-  return `${jsDocHeader6}
+  return `${jsDocHeader8}
 ${imports.join("\n")}
 
 export type * from '${context.importFileName(`../models`)}'
@@ -5725,8 +5793,8 @@ ${new Datasources(options.datasources).toTS()}
 ${clientExtensionsDefinitions()}
 export type DefaultPrismaClient = PrismaClient
 export type ErrorFormat = 'pretty' | 'colorless' | 'minimal'
-${ts17.stringify(ts17.moduleExport(buildClientOptions(context, options)))}
-${ts17.stringify(globalOmitConfig(context.dmmf))}
+${ts19.stringify(ts19.moduleExport(buildClientOptions(context, options)))}
+${ts19.stringify(globalOmitConfig(context.dmmf))}
 
 /* Types for Logging */
 export type LogLevel = 'info' | 'query' | 'warn' | 'error'
@@ -5792,24 +5860,24 @@ export type TransactionClient = Omit<DefaultPrismaClient, runtime.ITXClientDenyL
 `;
 }
 function clientExtensionsDefinitions() {
-  const define = ts17.moduleExport(
-    ts17.constDeclaration("defineExtension").setValue(
-      ts17.namedValue("runtime.Extensions.defineExtension").as(ts17.namedType("unknown")).as(
-        ts17.namedType("runtime.Types.Extensions.ExtendsHook").addGenericArgument(ts17.stringLiteral("define")).addGenericArgument(ts17.namedType("TypeMapCb")).addGenericArgument(ts17.namedType("runtime.Types.Extensions.DefaultArgs"))
+  const define = ts19.moduleExport(
+    ts19.constDeclaration("defineExtension").setValue(
+      ts19.namedValue("runtime.Extensions.defineExtension").as(ts19.namedType("unknown")).as(
+        ts19.namedType("runtime.Types.Extensions.ExtendsHook").addGenericArgument(ts19.stringLiteral("define")).addGenericArgument(ts19.namedType("TypeMapCb")).addGenericArgument(ts19.namedType("runtime.Types.Extensions.DefaultArgs"))
       )
     )
   );
-  return ts17.stringify(define);
+  return ts19.stringify(define);
 }
 function buildClientOptions(context, options) {
-  const clientOptions = ts17.interfaceDeclaration("PrismaClientOptions").add(
-    ts17.property("datasources", ts17.namedType("Datasources")).optional().setDocComment(ts17.docComment("Overwrites the datasource url from your schema.prisma file"))
+  const clientOptions = ts19.interfaceDeclaration("PrismaClientOptions").add(
+    ts19.property("datasources", ts19.namedType("Datasources")).optional().setDocComment(ts19.docComment("Overwrites the datasource url from your schema.prisma file"))
   ).add(
-    ts17.property("datasourceUrl", ts17.stringType).optional().setDocComment(ts17.docComment("Overwrites the datasource url from your schema.prisma file"))
+    ts19.property("datasourceUrl", ts19.stringType).optional().setDocComment(ts19.docComment("Overwrites the datasource url from your schema.prisma file"))
   ).add(
-    ts17.property("errorFormat", ts17.namedType("ErrorFormat")).optional().setDocComment(ts17.docComment('@default "colorless"'))
+    ts19.property("errorFormat", ts19.namedType("ErrorFormat")).optional().setDocComment(ts19.docComment('@default "colorless"'))
   ).add(
-    ts17.property("log", ts17.array(ts17.unionType([ts17.namedType("LogLevel"), ts17.namedType("LogDefinition")]))).optional().setDocComment(ts17.docComment`
+    ts19.property("log", ts19.array(ts19.unionType([ts19.namedType("LogLevel"), ts19.namedType("LogDefinition")]))).optional().setDocComment(ts19.docComment`
              @example
              \`\`\`
              // Shorthand for \`emit: 'stdout'\`
@@ -5834,12 +5902,12 @@ function buildClientOptions(context, options) {
              Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/logging#the-log-option).
           `)
   );
-  const transactionOptions = ts17.objectType().add(ts17.property("maxWait", ts17.numberType).optional()).add(ts17.property("timeout", ts17.numberType).optional());
+  const transactionOptions = ts19.objectType().add(ts19.property("maxWait", ts19.numberType).optional()).add(ts19.property("timeout", ts19.numberType).optional());
   if (context.dmmf.hasEnumInNamespace("TransactionIsolationLevel", "prisma")) {
-    transactionOptions.add(ts17.property("isolationLevel", ts17.namedType("TransactionIsolationLevel")).optional());
+    transactionOptions.add(ts19.property("isolationLevel", ts19.namedType("TransactionIsolationLevel")).optional());
   }
   clientOptions.add(
-    ts17.property("transactionOptions", transactionOptions).optional().setDocComment(ts17.docComment`
+    ts19.property("transactionOptions", transactionOptions).optional().setDocComment(ts19.docComment`
              The default values for transactionOptions
              maxWait ?= 2000
              timeout ?= 5000
@@ -5847,13 +5915,13 @@ function buildClientOptions(context, options) {
   );
   if (["library", "client", "wasm-compiler-edge", "wasm-engine-edge"].includes(options.runtimeName)) {
     clientOptions.add(
-      ts17.property("adapter", ts17.unionType([ts17.namedType("runtime.SqlDriverAdapterFactory"), ts17.namedType("null")])).optional().setDocComment(
-        ts17.docComment("Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-planetscale`")
+      ts19.property("adapter", ts19.unionType([ts19.namedType("runtime.SqlDriverAdapterFactory"), ts19.namedType("null")])).optional().setDocComment(
+        ts19.docComment("Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-planetscale`")
       )
     );
   }
   clientOptions.add(
-    ts17.property("omit", ts17.namedType("GlobalOmitConfig")).optional().setDocComment(ts17.docComment`
+    ts19.property("omit", ts19.namedType("GlobalOmitConfig")).optional().setDocComment(ts19.docComment`
         Global configuration for omitting model fields by default.
 
         @example
@@ -5875,6 +5943,7 @@ function buildClientOptions(context, options) {
 var GenerateContext = class {
   dmmf;
   genericArgsInfo;
+  runtimeBase;
   runtimeImport;
   outputFileName;
   importFileName;
@@ -5882,6 +5951,7 @@ var GenerateContext = class {
   constructor({
     dmmf,
     genericArgsInfo,
+    runtimeBase,
     runtimeImport: runtimeImport2,
     outputFileName,
     importFileName,
@@ -5889,6 +5959,7 @@ var GenerateContext = class {
   }) {
     this.dmmf = dmmf;
     this.genericArgsInfo = genericArgsInfo;
+    this.runtimeBase = runtimeBase;
     this.runtimeImport = runtimeImport2;
     this.outputFileName = outputFileName;
     this.importFileName = importFileName;
@@ -5912,6 +5983,7 @@ var TSClient = class {
     const context = new GenerateContext({
       dmmf: this.dmmf,
       genericArgsInfo: this.genericsInfo,
+      runtimeBase: this.options.runtimeBase,
       runtimeImport: `${this.options.runtimeBase}/${this.options.runtimeName}`,
       outputFileName: generatedFileNameMapper(this.options.generatedFileExtension),
       importFileName: importFileNameMapper(this.options.importFileExtension),
@@ -5924,12 +5996,14 @@ var TSClient = class {
     }, {});
     return {
       [context.outputFileName("client")]: createClientFile(context, this.options),
+      [context.outputFileName("browser")]: createBrowserFile(context, this.options),
       [context.outputFileName("enums")]: createEnumsFile(context),
       [context.outputFileName("commonInputTypes")]: createCommonInputTypeFiles(context),
       [context.outputFileName("models")]: createModelsFile(context, modelNames),
       models: modelsFileMap,
       internal: {
         [context.outputFileName("prismaNamespace")]: createPrismaNamespaceFile(context, this.options),
+        [context.outputFileName("prismaNamespaceBrowser")]: createPrismaNamespaceBrowserFile(context),
         [context.outputFileName("class")]: createClassFile(context, this.options)
       }
     };
@@ -5937,8 +6011,8 @@ var TSClient = class {
 };
 
 // src/typedSql/buildDbEnums.ts
-var import_internals8 = require("@prisma/internals");
-var ts18 = __toESM(require("@prisma/ts-builders"));
+var import_internals9 = require("@prisma/internals");
+var ts20 = __toESM(require("@prisma/ts-builders"));
 var DbEnumsList = class {
   enums;
   constructor(enums) {
@@ -5955,30 +6029,30 @@ var DbEnumsList = class {
   }
   *validJsIdentifiers() {
     for (const dbEnum of this.enums) {
-      if ((0, import_internals8.isValidJsIdentifier)(dbEnum.name)) {
+      if ((0, import_internals9.isValidJsIdentifier)(dbEnum.name)) {
         yield dbEnum;
       }
     }
   }
   *invalidJsIdentifiers() {
     for (const dbEnum of this.enums) {
-      if (!(0, import_internals8.isValidJsIdentifier)(dbEnum.name)) {
+      if (!(0, import_internals9.isValidJsIdentifier)(dbEnum.name)) {
         yield dbEnum;
       }
     }
   }
 };
 function buildDbEnums(list) {
-  const file4 = ts18.file();
-  const iface = ts18.interfaceDeclaration("$DbEnums");
+  const file4 = ts20.file();
+  const iface = ts20.interfaceDeclaration("$DbEnums");
   for (const dbEnum of list.enums) {
-    iface.add(ts18.property(dbEnum.name, enumToUnion(dbEnum)));
+    iface.add(ts20.property(dbEnum.name, enumToUnion(dbEnum)));
   }
-  file4.add(ts18.moduleExport(iface));
-  return ts18.stringify(file4);
+  file4.add(ts20.moduleExport(iface));
+  return ts20.stringify(file4);
 }
 function enumToUnion(dbEnum) {
-  return ts18.unionType(dbEnum.values.map(ts18.stringLiteral));
+  return ts20.unionType(dbEnum.values.map(ts20.stringLiteral));
 }
 function queryUsesEnums(query, enums) {
   if (enums.isEmpty()) {
@@ -5988,82 +6062,82 @@ function queryUsesEnums(query, enums) {
 }
 
 // src/typedSql/buildIndex.ts
-var ts19 = __toESM(require("@prisma/ts-builders"));
+var ts21 = __toESM(require("@prisma/ts-builders"));
 function buildIndex({ queries, enums, importName }) {
-  const file4 = ts19.file();
+  const file4 = ts21.file();
   if (!enums.isEmpty()) {
-    file4.add(ts19.moduleExportFrom(importName("./sql/$DbEnums")).named(ts19.namedExport("$DbEnums").typeOnly()));
+    file4.add(ts21.moduleExportFrom(importName("./sql/$DbEnums")).named(ts21.namedExport("$DbEnums").typeOnly()));
   }
   for (const query of queries) {
-    file4.add(ts19.moduleExportFrom(importName(`./sql/${query.name}`)));
+    file4.add(ts21.moduleExportFrom(importName(`./sql/${query.name}`)));
   }
-  return ts19.stringify(file4);
+  return ts21.stringify(file4);
 }
 
 // src/typedSql/buildTypedQuery.ts
-var ts21 = __toESM(require("@prisma/ts-builders"));
+var ts23 = __toESM(require("@prisma/ts-builders"));
 
 // src/typedSql/mapTypes.ts
-var ts20 = __toESM(require("@prisma/ts-builders"));
-var decimal = ts20.namedType("$runtime.Decimal");
-var uint8Array = ts20.namedType("Uint8Array");
-var date = ts20.namedType("Date");
-var inputJsonValue = ts20.namedType("$runtime.InputJsonObject");
-var jsonValue = ts20.namedType("$runtime.JsonValue");
-var bigintIn = ts20.unionType([ts20.numberType, ts20.bigintType]);
-var decimalIn = ts20.unionType([ts20.numberType, decimal]);
+var ts22 = __toESM(require("@prisma/ts-builders"));
+var decimal = ts22.namedType("$runtime.Decimal");
+var uint8Array = ts22.namedType("Uint8Array");
+var date = ts22.namedType("Date");
+var inputJsonValue = ts22.namedType("$runtime.InputJsonObject");
+var jsonValue = ts22.namedType("$runtime.JsonValue");
+var bigintIn = ts22.unionType([ts22.numberType, ts22.bigintType]);
+var decimalIn = ts22.unionType([ts22.numberType, decimal]);
 var typeMappings = {
-  unknown: ts20.unknownType,
-  string: ts20.stringType,
-  int: ts20.numberType,
+  unknown: ts22.unknownType,
+  string: ts22.stringType,
+  int: ts22.numberType,
   bigint: {
     in: bigintIn,
-    out: ts20.bigintType
+    out: ts22.bigintType
   },
   decimal: {
     in: decimalIn,
     out: decimal
   },
-  float: ts20.numberType,
-  double: ts20.numberType,
-  enum: ts20.stringType,
+  float: ts22.numberType,
+  double: ts22.numberType,
+  enum: ts22.stringType,
   // TODO:
   bytes: uint8Array,
-  bool: ts20.booleanType,
-  char: ts20.stringType,
+  bool: ts22.booleanType,
+  char: ts22.stringType,
   json: {
     in: inputJsonValue,
     out: jsonValue
   },
-  xml: ts20.stringType,
-  uuid: ts20.stringType,
+  xml: ts22.stringType,
+  uuid: ts22.stringType,
   date,
   datetime: date,
   time: date,
-  null: ts20.nullType,
-  "int-array": ts20.array(ts20.numberType),
-  "string-array": ts20.array(ts20.stringType),
+  null: ts22.nullType,
+  "int-array": ts22.array(ts22.numberType),
+  "string-array": ts22.array(ts22.stringType),
   "json-array": {
-    in: ts20.array(inputJsonValue),
-    out: ts20.array(jsonValue)
+    in: ts22.array(inputJsonValue),
+    out: ts22.array(jsonValue)
   },
-  "uuid-array": ts20.array(ts20.stringType),
-  "xml-array": ts20.array(ts20.stringType),
+  "uuid-array": ts22.array(ts22.stringType),
+  "xml-array": ts22.array(ts22.stringType),
   "bigint-array": {
-    in: ts20.array(bigintIn),
-    out: ts20.array(ts20.bigintType)
+    in: ts22.array(bigintIn),
+    out: ts22.array(ts22.bigintType)
   },
-  "float-array": ts20.array(ts20.numberType),
-  "double-array": ts20.array(ts20.numberType),
-  "char-array": ts20.array(ts20.stringType),
-  "bytes-array": ts20.array(uint8Array),
-  "bool-array": ts20.array(ts20.booleanType),
-  "date-array": ts20.array(date),
-  "time-array": ts20.array(date),
-  "datetime-array": ts20.array(date),
+  "float-array": ts22.array(ts22.numberType),
+  "double-array": ts22.array(ts22.numberType),
+  "char-array": ts22.array(ts22.stringType),
+  "bytes-array": ts22.array(uint8Array),
+  "bool-array": ts22.array(ts22.booleanType),
+  "date-array": ts22.array(date),
+  "time-array": ts22.array(date),
+  "datetime-array": ts22.array(date),
   "decimal-array": {
-    in: ts20.array(decimalIn),
-    out: ts20.array(decimal)
+    in: ts22.array(decimalIn),
+    out: ts22.array(decimal)
   }
 };
 function getInputType(introspectionType, nullable, enums) {
@@ -6071,7 +6145,7 @@ function getInputType(introspectionType, nullable, enums) {
   if (!nullable) {
     return inn;
   } else {
-    return new ts20.UnionType(inn).addVariant(ts20.nullType);
+    return new ts22.UnionType(inn).addVariant(ts22.nullType);
   }
 }
 function getOutputType(introspectionType, nullable, enums) {
@@ -6079,7 +6153,7 @@ function getOutputType(introspectionType, nullable, enums) {
   if (!nullable) {
     return out;
   } else {
-    return new ts20.UnionType(out).addVariant(ts20.nullType);
+    return new ts22.UnionType(out).addVariant(ts22.nullType);
   }
 }
 function getMappingConfig(introspectionType, enums) {
@@ -6091,29 +6165,29 @@ function getMappingConfig(introspectionType, enums) {
     }
     throw new Error("Unknown type");
   }
-  if (config instanceof ts20.TypeBuilder) {
+  if (config instanceof ts22.TypeBuilder) {
     return { in: config, out: config };
   }
   return config;
 }
 function getEnumType(name) {
-  return ts20.namedType("$DbEnums").subKey(name);
+  return ts22.namedType("$DbEnums").subKey(name);
 }
 
 // src/typedSql/buildTypedQuery.ts
 function buildTypedQuery({ query, runtimeBase, runtimeName, enums, importName }) {
-  const file4 = ts21.file();
-  file4.addImport(ts21.moduleImport(`${runtimeBase}/${runtimeName}`).asNamespace("$runtime"));
+  const file4 = ts23.file();
+  file4.addImport(ts23.moduleImport(`${runtimeBase}/${runtimeName}`).asNamespace("$runtime"));
   if (queryUsesEnums(query, enums)) {
-    file4.addImport(ts21.moduleImport(importName("./$DbEnums")).named(ts21.namedImport("$DbEnums").typeOnly()));
+    file4.addImport(ts23.moduleImport(importName("./$DbEnums")).named(ts23.namedImport("$DbEnums").typeOnly()));
   }
-  const doc = ts21.docComment(query.documentation ?? void 0);
-  const factoryType = ts21.functionType();
-  const parametersType = ts21.tupleType();
+  const doc = ts23.docComment(query.documentation ?? void 0);
+  const factoryType = ts23.functionType();
+  const parametersType = ts23.tupleType();
   for (const param of query.parameters) {
     const paramType = getInputType(param.typ, param.nullable, enums);
-    factoryType.addParameter(ts21.parameter(param.name, paramType));
-    parametersType.add(ts21.tupleItem(paramType).setName(param.name));
+    factoryType.addParameter(ts23.parameter(param.name, paramType));
+    parametersType.add(ts23.tupleItem(paramType).setName(param.name));
     if (param.documentation) {
       doc.addText(`@param ${param.name} ${param.documentation}`);
     } else {
@@ -6121,26 +6195,26 @@ function buildTypedQuery({ query, runtimeBase, runtimeName, enums, importName })
     }
   }
   factoryType.setReturnType(
-    ts21.namedType("$runtime.TypedSql").addGenericArgument(ts21.namedType(`${query.name}.Parameters`)).addGenericArgument(ts21.namedType(`${query.name}.Result`))
+    ts23.namedType("$runtime.TypedSql").addGenericArgument(ts23.namedType(`${query.name}.Parameters`)).addGenericArgument(ts23.namedType(`${query.name}.Result`))
   );
   file4.add(
-    ts21.moduleExport(
-      ts21.constDeclaration(query.name).setValue(
-        ts21.functionCall("$runtime.makeTypedQueryFactory").addArgument(ts21.stringLiteral(query.source).asValue()).as(factoryType)
+    ts23.moduleExport(
+      ts23.constDeclaration(query.name).setValue(
+        ts23.functionCall("$runtime.makeTypedQueryFactory").addArgument(ts23.stringLiteral(query.source).asValue()).as(factoryType)
       )
     ).setDocComment(doc)
   );
-  const namespace2 = ts21.namespace(query.name);
-  namespace2.add(ts21.moduleExport(ts21.typeDeclaration("Parameters", parametersType)));
+  const namespace2 = ts23.namespace(query.name);
+  namespace2.add(ts23.moduleExport(ts23.typeDeclaration("Parameters", parametersType)));
   namespace2.add(buildResultType(query, enums));
-  file4.add(ts21.moduleExport(namespace2));
-  return ts21.stringify(file4);
+  file4.add(ts23.moduleExport(namespace2));
+  return ts23.stringify(file4);
 }
 function buildResultType(query, enums) {
-  const type = ts21.objectType().addMultiple(
-    query.resultColumns.map((column) => ts21.property(column.name, getOutputType(column.typ, column.nullable, enums)))
+  const type = ts23.objectType().addMultiple(
+    query.resultColumns.map((column) => ts23.property(column.name, getOutputType(column.typ, column.nullable, enums)))
   );
-  return ts21.moduleExport(ts21.typeDeclaration("Result", type));
+  return ts23.moduleExport(ts23.typeDeclaration("Result", type));
 }
 
 // src/typedSql/typedSql.ts
@@ -6192,7 +6266,7 @@ var DenylistError = class extends Error {
     this.stack = void 0;
   }
 };
-(0, import_internals9.setClassName)(DenylistError, "DenylistError");
+(0, import_internals10.setClassName)(DenylistError, "DenylistError");
 function buildClient({
   schemaPath,
   runtimeBase,
@@ -6215,7 +6289,7 @@ function buildClient({
   moduleFormat,
   tsNoCheckPreamble: tsNoCheckPreamble2
 }) {
-  const clientEngineType = (0, import_internals9.getClientEngineType)(generator);
+  const clientEngineType = (0, import_internals10.getClientEngineType)(generator);
   const runtimeName = getRuntimeNameForTarget(target, clientEngineType, generator.previewFeatures);
   const outputName = generatedFileNameMapper(generatedFileExtension);
   const importName = importFileNameMapper(importFileExtension);
@@ -6308,7 +6382,7 @@ async function generateClient(options) {
     moduleFormat,
     tsNoCheckPreamble: tsNoCheckPreamble2
   } = options;
-  const clientEngineType = (0, import_internals9.getClientEngineType)(generator);
+  const clientEngineType = (0, import_internals10.getClientEngineType)(generator);
   const { runtimeBase, outputDir } = await getGenerationDirs(options);
   const { prismaClientDmmf, fileMap } = buildClient({
     datamodel,
@@ -6348,7 +6422,7 @@ To learn more about how to rename models, check out https://pris.ly/d/naming-mod
   await deleteOutputDir(outputDir);
   await (0, import_fs_extra.ensureDir)(outputDir);
   await writeFileMap(outputDir, fileMap);
-  const enginePath = clientEngineType === import_internals9.ClientEngineType.Library ? binaryPaths.libqueryEngine : binaryPaths.queryEngine;
+  const enginePath = clientEngineType === import_internals10.ClientEngineType.Library ? binaryPaths.libqueryEngine : binaryPaths.queryEngine;
   if (copyEngine && enginePath) {
     if (process.env.NETLIFY) {
       await (0, import_fs_extra.ensureDir)("/tmp/prisma-engines");
@@ -6458,7 +6532,7 @@ function validateDmmfAgainstDenylists(prismaClientDmmf) {
 }
 async function getGenerationDirs({ runtimeBase, outputDir }) {
   const normalizedOutputDir = import_node_path4.default.normalize(outputDir);
-  const normalizedRuntimeBase = (0, import_internals9.pathToPosix)(runtimeBase);
+  const normalizedRuntimeBase = (0, import_internals10.pathToPosix)(runtimeBase);
   const userPackageRoot = await (0, import_package_up.packageUp)({ cwd: import_node_path4.default.dirname(normalizedOutputDir) });
   const userProjectRoot = userPackageRoot ? import_node_path4.default.dirname(userPackageRoot) : process.cwd();
   return {
@@ -6475,27 +6549,27 @@ function getRuntimeNameForTarget(target, engineType, previewFeatures) {
     case "workerd":
     case "vercel-edge":
       if (previewFeatures.includes("driverAdapters")) {
-        return engineType === import_internals9.ClientEngineType.Client ? "wasm-compiler-edge" : "wasm-engine-edge";
+        return engineType === import_internals10.ClientEngineType.Client ? "wasm-compiler-edge" : "wasm-engine-edge";
       } else {
         return "edge";
       }
     case "react-native":
       return "react-native";
     default:
-      (0, import_internals9.assertNever)(target, "Unknown runtime target");
+      (0, import_internals10.assertNever)(target, "Unknown runtime target");
   }
 }
 function getNodeRuntimeName(engineType) {
-  if (engineType === import_internals9.ClientEngineType.Binary) {
+  if (engineType === import_internals10.ClientEngineType.Binary) {
     return "binary";
   }
-  if (engineType === import_internals9.ClientEngineType.Library) {
+  if (engineType === import_internals10.ClientEngineType.Library) {
     return "library";
   }
-  if (engineType === import_internals9.ClientEngineType.Client) {
+  if (engineType === import_internals10.ClientEngineType.Client) {
     return "client";
   }
-  (0, import_internals9.assertNever)(engineType, "Unknown engine type");
+  (0, import_internals10.assertNever)(engineType, "Unknown engine type");
 }
 async function deleteOutputDir(outputDir) {
   try {
@@ -6533,12 +6607,12 @@ async function deleteOutputDir(outputDir) {
 // src/generator.ts
 var import_debug2 = require("@prisma/debug");
 var import_engines_version = require("@prisma/engines-version");
-var import_internals10 = require("@prisma/internals");
+var import_internals11 = require("@prisma/internals");
 var import_get_tsconfig = require("get-tsconfig");
 var import_ts_pattern2 = require("ts-pattern");
 
 // package.json
-var version = "6.16.0-dev.35";
+var version = "6.16.0-dev.37";
 
 // src/module-format.ts
 function parseModuleFormat(format) {
@@ -6634,12 +6708,12 @@ function getOutputPath(config) {
   if (!config.output) {
     throw new Error(missingOutputErrorMessage);
   }
-  return (0, import_internals10.parseEnvValue)(config.output);
+  return (0, import_internals11.parseEnvValue)(config.output);
 }
 var PrismaClientTsGenerator = class {
   name = "prisma-client-ts";
   getManifest(config) {
-    const requiresEngines = (0, import_ts_pattern2.match)((0, import_internals10.getClientEngineType)(config)).with(import_internals10.ClientEngineType.Library, () => ["libqueryEngine"]).with(import_internals10.ClientEngineType.Binary, () => ["queryEngine"]).with(import_internals10.ClientEngineType.Client, () => []).exhaustive();
+    const requiresEngines = (0, import_ts_pattern2.match)((0, import_internals11.getClientEngineType)(config)).with(import_internals11.ClientEngineType.Library, () => ["libqueryEngine"]).with(import_internals11.ClientEngineType.Binary, () => ["queryEngine"]).with(import_internals11.ClientEngineType.Client, () => []).exhaustive();
     debug2("requiresEngines", requiresEngines);
     return Promise.resolve({
       defaultOutput: getOutputPath(config),