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

package/dist/index.mjs

@@ -1850,7 +1850,7 @@ var require_ensure = __commonJS({
 var require_utils2 = __commonJS({
   "../../node_modules/.pnpm/jsonfile@6.1.0/node_modules/jsonfile/utils.js"(exports, module) {
     "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/, "");
     }
-    module.exports = { stringify: stringify14, stripBom };
+    module.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"(exports, module) {
     "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);
     }
     module.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"(exports, module) {
     "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);
     }
     module.exports = outputJsonSync;
@@ -2219,7 +2219,7 @@ import { overwriteFile } from "@prisma/fetch-engine";
 import {
   assertNever as assertNever3,
   ClientEngineType as ClientEngineType3,
-  getClientEngineType as getClientEngineType3,
+  getClientEngineType as getClientEngineType4,
   pathToPosix as pathToPosix3,
   setClassName
 } from "@prisma/internals";
@@ -2894,11 +2894,51 @@ var GenericArgsInfo = class {
   }
 };
 
+// src/TSClient/file-generators/BrowserFile.ts
+import { getClientEngineType } from "@prisma/internals";
+
+// src/TSClient/ModelExports.ts
+import * as ts3 from "@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 = 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
 import crypto from "node:crypto";
 import path2 from "node:path";
-import { getClientEngineType, pathToPosix } from "@prisma/internals";
-import * as ts5 from "@prisma/ts-builders";
+import { getClientEngineType as getClientEngineType2, pathToPosix } from "@prisma/internals";
+import * as ts6 from "@prisma/ts-builders";
 import ciInfo from "ci-info";
 
 // src/utils/buildInjectableEdgeEnv.ts
@@ -3538,22 +3578,22 @@ function buildWasmFileMap({ activeProvider, runtimeName }) {
 
 // src/TSClient/PrismaClient.ts
 import { capitalize as capitalize7, uncapitalize as uncapitalize4 } from "@prisma/client-common";
-import * as ts4 from "@prisma/ts-builders";
+import * as ts5 from "@prisma/ts-builders";
 import indent3 from "indent-string";
 
 // src/utils/runtimeImport.ts
-import * as ts3 from "@prisma/ts-builders";
+import * as ts4 from "@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
-import { NamedType, namedType as namedType4 } from "@prisma/ts-builders";
+import { NamedType, namedType as namedType5 } from "@prisma/ts-builders";
 function omit(type, keyType) {
-  return namedType4("Omit").addGenericArgument(type).addGenericArgument(keyType);
+  return namedType5("Omit").addGenericArgument(type).addGenericArgument(keyType);
 }
 function promise(resultType) {
   return new NamedType("runtime.Types.Utils.JsPromise").addGenericArgument(resultType);
@@ -3567,14 +3607,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
         \`\`\`
@@ -3587,25 +3627,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")) {
@@ -3670,9 +3710,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
         \`\`\`
@@ -3682,19 +3722,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
@@ -3705,13 +3745,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
       \`\`\`
@@ -3724,7 +3764,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") {
@@ -3743,7 +3783,7 @@ function getPrismaClientClassDocComment({ dmmf }) {
       plural: "users"
     };
   }
-  return ts4.docComment`
+  return ts5.docComment`
     ## Prisma Client
 
     Type-safe database client for TypeScript
@@ -3763,7 +3803,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;
@@ -3837,15 +3877,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}
@@ -3855,12 +3895,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)}
@@ -3887,7 +3927,7 @@ function clientConfig(context, options) {
     activeProvider,
     moduleFormat
   } = options;
-  const clientEngineType = getClientEngineType(generator);
+  const clientEngineType = getClientEngineType2(generator);
   generator.config.engineType = clientEngineType;
   const inlineSchemaHash = crypto.createHash("sha256").update(Buffer.from(inlineSchema, "utf8").toString("base64")).digest("hex");
   const datasourceFilePath = datasources[0].sourceFilePath;
@@ -3919,8 +3959,8 @@ ${buildDebugInitialization(edge)}
 
 // src/TSClient/file-generators/ClientFile.ts
 import path4 from "node:path";
-import { ClientEngineType as ClientEngineType2, getClientEngineType as getClientEngineType2 } from "@prisma/internals";
-import * as ts6 from "@prisma/ts-builders";
+import { ClientEngineType as ClientEngineType2, getClientEngineType as getClientEngineType3 } from "@prisma/internals";
+import * as ts7 from "@prisma/ts-builders";
 
 // src/utils/buildNFTAnnotations.ts
 import { getNodeAPIName } from "@prisma/get-platform";
@@ -3966,51 +4006,44 @@ path.join(process.cwd(), ${JSON.stringify(pathToPosix2(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 = getClientEngineType2(options.generator);
+  const clientEngineType = getClientEngineType3(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 exports = [
-    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);
-  });
+  ].map((e) => ts7.stringify(e));
   const binaryTargets = clientEngineType === ClientEngineType2.Library ? Object.keys(options.binaryPaths.libqueryEngine ?? {}) : Object.keys(options.binaryPaths.queryEngine ?? {});
   const relativeOutdir = path4.relative(process.cwd(), options.outputDir);
-  return `${jsDocHeader2}
+  return `${jsDocHeader3}
 ${buildPreamble(options.edge, options.moduleFormat)}
 ${imports.join("\n")}
 
@@ -4019,7 +4052,7 @@ export { Prisma }
 
 ${buildNFTAnnotations(options.edge || !options.copyEngine, clientEngineType, binaryTargets, relativeOutdir)}
 
-${modelExports.join("\n")}
+${modelExports(context).join("\n")}
 `;
 }
 function buildPreamble(edge, moduleFormat) {
@@ -4039,8 +4072,8 @@ globalThis['__dirname'] = path.dirname(fileURLToPath(import.meta.url))
 }
 
 // src/TSClient/file-generators/CommonInputTypesFile.ts
-import * as ts7 from "@prisma/ts-builders";
-var jsDocHeader3 = `/*
+import * as ts8 from "@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.
@@ -4048,12 +4081,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")}
@@ -4064,7 +4097,7 @@ ${context.dmmf.inputObjectTypes.model?.map((inputType) => new InputType(inputTyp
 
 // src/TSClient/file-generators/EnumsFile.ts
 import { datamodelEnumToSchemaEnum } from "@prisma/dmmf";
-var jsDocHeader4 = `/*
+var jsDocHeader5 = `/*
 * This file exports all enum related types from the schema.
 *
 * \u{1F7E2} You can import this file directly.
@@ -4077,35 +4110,35 @@ function createEnumsFile(context) {
     modelEnums.push(new Enum(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
-import * as ts14 from "@prisma/ts-builders";
+import * as ts15 from "@prisma/ts-builders";
 
 // src/TSClient/Model.ts
 import { capitalize as capitalize9 } from "@prisma/client-common";
 import * as DMMF2 from "@prisma/dmmf";
-import * as ts13 from "@prisma/ts-builders";
+import * as ts14 from "@prisma/ts-builders";
 import indent5 from "indent-string";
 import { klona } from "klona";
 
 // src/TSClient/Args.ts
-import * as ts8 from "@prisma/ts-builders";
+import * as ts9 from "@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) {
@@ -4116,7 +4149,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);
     }
@@ -4124,13 +4157,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;
   }
@@ -4140,25 +4173,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;
   }
@@ -4167,7 +4200,7 @@ var ArgsTypeBuilder = class {
     return this;
   }
   setComment(comment) {
-    this.moduleExport.setDocComment(ts8.docComment(comment));
+    this.moduleExport.setDocComment(ts9.docComment(comment));
     return this;
   }
   createExport() {
@@ -4177,12 +4210,12 @@ var ArgsTypeBuilder = class {
 
 // src/TSClient/Count.ts
 import { capitalize as capitalize8 } from "@prisma/client-common";
-import * as ts10 from "@prisma/ts-builders";
+import * as ts11 from "@prisma/ts-builders";
 import indent4 from "indent-string";
 
 // src/TSClient/Output.ts
 import { hasOwnProperty } from "@prisma/internals";
-import * as ts9 from "@prisma/ts-builders";
+import * as ts10 from "@prisma/ts-builders";
 function buildModelOutputProperty(field, dmmf) {
   let fieldTypeName = hasOwnProperty(GraphQLScalarToJSTypeTable, field.type) ? GraphQLScalarToJSTypeTable[field.type] : field.type;
   if (Array.isArray(fieldTypeName)) {
@@ -4190,47 +4223,47 @@ function buildModelOutputProperty(field, dmmf) {
   }
   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;
@@ -4270,7 +4303,7 @@ var Count = class {
  * Count Type ${name}
  */
 
-${ts10.stringify(outputType)}
+${ts11.stringify(outputType)}
 
 export type ${getSelectName(
       name
@@ -4290,7 +4323,7 @@ ${indent4(
     )}
 }
 
-${this.argsTypes.map((typeExport) => ts10.stringify(typeExport)).join("\n\n")}
+${this.argsTypes.map((typeExport) => ts11.stringify(typeExport)).join("\n\n")}
 `;
   }
 };
@@ -4327,12 +4360,12 @@ ${this.stringifyFields()}
 
 // src/TSClient/Payload.ts
 import { uncapitalize as uncapitalize5 } from "@prisma/client-common";
-import * as ts11 from "@prisma/ts-builders";
+import * as ts12 from "@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)) {
@@ -4344,20 +4377,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(uncapitalize5(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(uncapitalize5(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
 import { uncapitalize as uncapitalize6 } from "@prisma/client-common";
-import * as ts12 from "@prisma/ts-builders";
+import * as ts13 from "@prisma/ts-builders";
 function buildIncludeType({
   modelName,
   typeName = getIncludeName(modelName),
@@ -4368,14 +4401,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);
 }
@@ -4386,7 +4419,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) {
@@ -4398,24 +4431,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) => {
@@ -4544,7 +4577,7 @@ ${indent5(
     )}
 }
 
-${ts13.stringify(buildOutputType(groupByType))}
+${ts14.stringify(buildOutputType(groupByType))}
 
 type ${getGroupByPayloadName(model.name)}<T extends ${groupByArgsName}> = Prisma.PrismaPromise<
   Array<
@@ -4594,7 +4627,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 = {
@@ -4662,31 +4695,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,
@@ -4697,7 +4730,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,
@@ -4719,8 +4752,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,
@@ -4729,7 +4762,7 @@ ${this.createManyAndReturnType ? ts13.stringify(
       }),
       { newLine: "leading" }
     ) : ""}
-${this.updateManyAndReturnType ? ts13.stringify(
+${this.updateManyAndReturnType ? ts14.stringify(
       buildSelectType({
         modelName: this.model.name,
         fields: this.updateManyAndReturnType.fields,
@@ -4738,12 +4771,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
@@ -4754,7 +4787,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")}
 `;
   }
 };
@@ -4785,7 +4818,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");
@@ -4796,11 +4829,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(", ")}> {
 ${indent5(`[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) ? `${indent5(getMethodJSDoc(DMMF2.ModelAction.count, mapping, modelOrType), TAB_SIZE)}
@@ -4886,7 +4919,7 @@ ${availableActions.includes(DMMF2.ModelAction.groupBy) ? `${indent5(getMethodJSD
 readonly fields: ${getFieldRefsTypeName(name)};
 }
 
-${ts13.stringify(buildFluentWrapperDefinition(name, this.outputType, this.context))}
+${ts14.stringify(buildFluentWrapperDefinition(name, this.outputType, this.context))}
 `;
   }
 };
@@ -4894,7 +4927,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);
@@ -4907,22 +4940,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) {
@@ -4934,11 +4967,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];
@@ -4954,13 +4987,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(`${capitalize9(args.name)}DependenciesValidator`).extends(
-        ts13.conditionalType().check(ts13.stringLiteral(args.name)).extends(ts13.namedType("Prisma.Keys<T>")).then(objectType11).else(ts13.objectType())
+      ts14.genericParameter(`${capitalize9(args.name)}DependenciesValidator`).extends(
+        ts14.conditionalType().check(ts14.stringLiteral(args.name)).extends(ts14.namedType("Prisma.Keys<T>")).then(objectType11).else(ts14.objectType())
       )
     );
   }
@@ -4973,53 +5006,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,
@@ -5030,37 +5063,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
@@ -5068,20 +5101,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`;
@@ -5089,24 +5122,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.
@@ -5115,11 +5148,46 @@ var jsDocHeader5 = `/*
 function createModelsFile(context, modelsNames) {
   const exports = modelsNames.map((m) => `export type * from './models/${context.importFileName(m)}'`);
   exports.push(`export type * from './${context.importFileName("commonInputTypes")}'`);
-  return jsDocHeader5 + exports.join("\n");
+  return jsDocHeader6 + exports.join("\n");
+}
+
+// src/TSClient/file-generators/PrismaNamespaceBrowserFile.ts
+import * as ts16 from "@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
-import * as ts17 from "@prisma/ts-builders";
+import * as ts19 from "@prisma/ts-builders";
 
 // src/TSClient/common.ts
 var commonCodeTS = ({ clientVersion, engineVersion, generator }) => {
@@ -5544,23 +5612,23 @@ export type ${this.type.name}<$PrismaModel> = FieldRefInputType<$PrismaModel, ${
 
 // src/TSClient/globalOmit.ts
 import { uncapitalize as uncapitalize7 } from "@prisma/client-common";
-import * as ts15 from "@prisma/ts-builders";
+import * as ts17 from "@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(uncapitalize7(model.name), type).optional();
+      const type = ts17.namedType(`Prisma.${getOmitName(model.name)}`);
+      return ts17.property(uncapitalize7(model.name), type).optional();
     })
   );
-  return ts15.moduleExport(ts15.typeDeclaration("GlobalOmitConfig", objectType11));
+  return ts17.moduleExport(ts17.typeDeclaration("GlobalOmitConfig", objectType11));
 }
 
 // src/TSClient/TypeMap.ts
 import { uncapitalize as uncapitalize8 } from "@prisma/client-common";
 import { assertNever as assertNever2 } from "@prisma/internals";
-import * as ts16 from "@prisma/ts-builders";
+import * as ts18 from "@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>
@@ -5569,39 +5637,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(uncapitalize8(name))))));
+    meta.add(ts18.property("modelProps", ts18.unionType(modelNames.map((name) => ts18.stringLiteral(uncapitalize8(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) => {
@@ -5638,19 +5706,19 @@ 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);
@@ -5660,11 +5728,11 @@ function clientTypeMapModelsResultDefinition(modelName, action) {
   assertNever2(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}
@@ -5678,13 +5746,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`)}'
@@ -5724,8 +5792,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'
@@ -5791,24 +5859,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'\`
@@ -5833,12 +5901,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
@@ -5846,13 +5914,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
@@ -5874,6 +5942,7 @@ function buildClientOptions(context, options) {
 var GenerateContext = class {
   dmmf;
   genericArgsInfo;
+  runtimeBase;
   runtimeImport;
   outputFileName;
   importFileName;
@@ -5881,6 +5950,7 @@ var GenerateContext = class {
   constructor({
     dmmf,
     genericArgsInfo,
+    runtimeBase,
     runtimeImport: runtimeImport2,
     outputFileName,
     importFileName,
@@ -5888,6 +5958,7 @@ var GenerateContext = class {
   }) {
     this.dmmf = dmmf;
     this.genericArgsInfo = genericArgsInfo;
+    this.runtimeBase = runtimeBase;
     this.runtimeImport = runtimeImport2;
     this.outputFileName = outputFileName;
     this.importFileName = importFileName;
@@ -5911,6 +5982,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),
@@ -5923,12 +5995,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,7 +6011,7 @@ var TSClient = class {
 
 // src/typedSql/buildDbEnums.ts
 import { isValidJsIdentifier } from "@prisma/internals";
-import * as ts18 from "@prisma/ts-builders";
+import * as ts20 from "@prisma/ts-builders";
 var DbEnumsList = class {
   enums;
   constructor(enums) {
@@ -5968,16 +6042,16 @@ var DbEnumsList = class {
   }
 };
 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()) {
@@ -5987,82 +6061,82 @@ function queryUsesEnums(query, enums) {
 }
 
 // src/typedSql/buildIndex.ts
-import * as ts19 from "@prisma/ts-builders";
+import * as ts21 from "@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
-import * as ts21 from "@prisma/ts-builders";
+import * as ts23 from "@prisma/ts-builders";
 
 // src/typedSql/mapTypes.ts
-import * as ts20 from "@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]);
+import * as ts22 from "@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) {
@@ -6070,7 +6144,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) {
@@ -6078,7 +6152,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) {
@@ -6090,29 +6164,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 {
@@ -6120,26 +6194,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
@@ -6214,7 +6288,7 @@ function buildClient({
   moduleFormat,
   tsNoCheckPreamble: tsNoCheckPreamble2
 }) {
-  const clientEngineType = getClientEngineType3(generator);
+  const clientEngineType = getClientEngineType4(generator);
   const runtimeName = getRuntimeNameForTarget(target, clientEngineType, generator.previewFeatures);
   const outputName = generatedFileNameMapper(generatedFileExtension);
   const importName = importFileNameMapper(importFileExtension);
@@ -6307,7 +6381,7 @@ async function generateClient(options) {
     moduleFormat,
     tsNoCheckPreamble: tsNoCheckPreamble2
   } = options;
-  const clientEngineType = getClientEngineType3(generator);
+  const clientEngineType = getClientEngineType4(generator);
   const { runtimeBase, outputDir } = await getGenerationDirs(options);
   const { prismaClientDmmf, fileMap } = buildClient({
     datamodel,
@@ -6532,12 +6606,12 @@ async function deleteOutputDir(outputDir) {
 // src/generator.ts
 import { Debug as Debug2 } from "@prisma/debug";
 import { enginesVersion } from "@prisma/engines-version";
-import { ClientEngineType as ClientEngineType4, getClientEngineType as getClientEngineType4, parseEnvValue } from "@prisma/internals";
+import { ClientEngineType as ClientEngineType4, getClientEngineType as getClientEngineType5, parseEnvValue } from "@prisma/internals";
 import { getTsconfig } from "get-tsconfig";
 import { match as match2 } from "ts-pattern";
 
 // package.json
-var version = "6.16.0-dev.36";
+var version = "6.16.0-dev.37";
 
 // src/module-format.ts
 function parseModuleFormat(format) {
@@ -6638,7 +6712,7 @@ function getOutputPath(config) {
 var PrismaClientTsGenerator = class {
   name = "prisma-client-ts";
   getManifest(config) {
-    const requiresEngines = match2(getClientEngineType4(config)).with(ClientEngineType4.Library, () => ["libqueryEngine"]).with(ClientEngineType4.Binary, () => ["queryEngine"]).with(ClientEngineType4.Client, () => []).exhaustive();
+    const requiresEngines = match2(getClientEngineType5(config)).with(ClientEngineType4.Library, () => ["libqueryEngine"]).with(ClientEngineType4.Binary, () => ["queryEngine"]).with(ClientEngineType4.Client, () => []).exhaustive();
     debug2("requiresEngines", requiresEngines);
     return Promise.resolve({
       defaultOutput: getOutputPath(config),