prisma 6.4.0-dev.20 → 6.4.0-dev.22

package/prisma-client/generator-build/index.js

@@ -33,18 +33,18 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// ../../node_modules/.pnpm/@prisma+engines-version@6.3.0-17.acc0b9dd43eb689cbd20c9470515d719db10d0b0/node_modules/@prisma/engines-version/package.json
+// ../../node_modules/.pnpm/@prisma+engines-version@6.4.0-4.e2a33755136ec1c2b3a5d7d322f86a8fb1205a40/node_modules/@prisma/engines-version/package.json
 var require_package = __commonJS({
-  "../../node_modules/.pnpm/@prisma+engines-version@6.3.0-17.acc0b9dd43eb689cbd20c9470515d719db10d0b0/node_modules/@prisma/engines-version/package.json"(exports2, module2) {
+  "../../node_modules/.pnpm/@prisma+engines-version@6.4.0-4.e2a33755136ec1c2b3a5d7d322f86a8fb1205a40/node_modules/@prisma/engines-version/package.json"(exports2, module2) {
     module2.exports = {
       name: "@prisma/engines-version",
-      version: "6.3.0-17.acc0b9dd43eb689cbd20c9470515d719db10d0b0",
+      version: "6.4.0-4.e2a33755136ec1c2b3a5d7d322f86a8fb1205a40",
       main: "index.js",
       types: "index.d.ts",
       license: "Apache-2.0",
       author: "Tim Suchanek <suchanek@prisma.io>",
       prisma: {
-        enginesVersion: "acc0b9dd43eb689cbd20c9470515d719db10d0b0"
+        enginesVersion: "e2a33755136ec1c2b3a5d7d322f86a8fb1205a40"
       },
       repository: {
         type: "git",
@@ -66,9 +66,9 @@ var require_package = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/@prisma+engines-version@6.3.0-17.acc0b9dd43eb689cbd20c9470515d719db10d0b0/node_modules/@prisma/engines-version/index.js
+// ../../node_modules/.pnpm/@prisma+engines-version@6.4.0-4.e2a33755136ec1c2b3a5d7d322f86a8fb1205a40/node_modules/@prisma/engines-version/index.js
 var require_engines_version = __commonJS({
-  "../../node_modules/.pnpm/@prisma+engines-version@6.3.0-17.acc0b9dd43eb689cbd20c9470515d719db10d0b0/node_modules/@prisma/engines-version/index.js"(exports2) {
+  "../../node_modules/.pnpm/@prisma+engines-version@6.4.0-4.e2a33755136ec1c2b3a5d7d322f86a8fb1205a40/node_modules/@prisma/engines-version/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.enginesVersion = void 0;
@@ -3946,7 +3946,7 @@ var require_package2 = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@prisma/client",
-      version: "6.4.0-dev.20",
+      version: "6.4.0-dev.22",
       description: "Prisma Client is an auto-generated, type-safe and modern JavaScript/TypeScript ORM for Node.js that's tailored to your data. Supports PostgreSQL, CockroachDB, MySQL, MariaDB, SQL Server, SQLite & MongoDB databases.",
       keywords: [
         "ORM",
@@ -4145,7 +4145,7 @@ var require_package2 = __commonJS({
         "@prisma/debug": "workspace:*",
         "@prisma/driver-adapter-utils": "workspace:*",
         "@prisma/engines": "workspace:*",
-        "@prisma/engines-version": "6.3.0-17.acc0b9dd43eb689cbd20c9470515d719db10d0b0",
+        "@prisma/engines-version": "6.4.0-4.e2a33755136ec1c2b3a5d7d322f86a8fb1205a40",
         "@prisma/fetch-engine": "workspace:*",
         "@prisma/generator-helper": "workspace:*",
         "@prisma/get-platform": "workspace:*",
@@ -4154,11 +4154,11 @@ var require_package2 = __commonJS({
         "@prisma/migrate": "workspace:*",
         "@prisma/mini-proxy": "0.9.5",
         "@prisma/pg-worker": "workspace:*",
-        "@prisma/query-compiler-wasm": "6.3.0-17.acc0b9dd43eb689cbd20c9470515d719db10d0b0",
-        "@prisma/query-engine-wasm": "6.3.0-17.acc0b9dd43eb689cbd20c9470515d719db10d0b0",
+        "@prisma/query-compiler-wasm": "6.4.0-4.e2a33755136ec1c2b3a5d7d322f86a8fb1205a40",
+        "@prisma/query-engine-wasm": "6.4.0-4.e2a33755136ec1c2b3a5d7d322f86a8fb1205a40",
         "@snaplet/copycat": "0.17.3",
         "@swc-node/register": "1.10.9",
-        "@swc/core": "1.10.9",
+        "@swc/core": "1.10.11",
         "@swc/jest": "0.2.37",
         "@timsuchanek/copy": "1.4.5",
         "@types/debug": "4.1.12",
@@ -5016,7 +5016,7 @@ var Debug = new Proxy(debugCreate, {
   get: (_, prop) => topProps[prop],
   set: (_, prop, value) => topProps[prop] = value
 });
-function safeStringify(value, indent9 = 2) {
+function safeStringify(value, indent8 = 2) {
   const cache = /* @__PURE__ */ new Set();
   return JSON.stringify(
     value,
@@ -5031,7 +5031,7 @@ function safeStringify(value, indent9 = 2) {
       }
       return value2;
     },
-    indent9
+    indent8
   );
 }
 var src_default = Debug;
@@ -5696,9 +5696,9 @@ function docCommentTag(strings, args) {
   if (lines.length === 0) {
     return docComment2;
   }
-  const indent9 = getIndent(lines[0]);
+  const indent8 = getIndent(lines[0]);
   for (const line of lines) {
-    docComment2.addText(line.slice(indent9));
+    docComment2.addText(line.slice(indent8));
   }
   return docComment2;
 }
@@ -5724,11 +5724,11 @@ function isEmptyLine(line) {
   return line.trim().length === 0;
 }
 function getIndent(line) {
-  let indent9 = 0;
-  while (line[indent9] === " ") {
-    indent9++;
+  let indent8 = 0;
+  while (line[indent8] === " ") {
+    indent8++;
   }
-  return indent9;
+  return indent8;
 }
 
 // src/generation/ts-builders/Export.ts
@@ -6786,6 +6786,8 @@ function buildSingleFieldType(t, genericsInfo, source) {
       return union.mapVariants((variant) => array(variant));
     }
     return union;
+  } else if (t.namespace === "prisma") {
+    type = namedInputType(`Prisma.${t.type}`);
   } else {
     type = namedInputType(scalarType ?? t.type);
   }
@@ -6818,7 +6820,7 @@ function buildAllFieldTypes(inputTypes, context, source) {
   return unionType(xorTypes(tsInputObjectTypes)).addVariants(tsOtherTypes);
 }
 function xorTypes(types) {
-  return types.reduce((prev, curr) => namedType("XOR").addGenericArgument(prev).addGenericArgument(curr));
+  return types.reduce((prev, curr) => namedType("Prisma.XOR").addGenericArgument(prev).addGenericArgument(curr));
 }
 var InputType = class {
   constructor(type, context) {
@@ -7420,8 +7422,14 @@ var ArgsTypeBuilder = class {
     this.addProperty(
       property(
         "select",
-        unionType([namedType(selectTypeName).addGenericArgument(extArgsParam.toArgument()), nullType])
-      ).optional().setDocComment(docComment(`Select specific fields to fetch from the ${this.type.name}`))
+        unionType([
+          namedType(`Prisma.${selectTypeName}`).addGenericArgument(extArgsParam.toArgument()),
+          nullType
+        ])
+      ).optional().setDocComment(
+        docComment(`Select specific fields to fetch
+                         from the ${this.type.name}`)
+      )
     );
     return this;
   }
@@ -7433,7 +7441,10 @@ var ArgsTypeBuilder = class {
     this.addProperty(
       property(
         "include",
-        unionType([namedType(includeTypeName).addGenericArgument(extArgsParam.toArgument()), nullType])
+        unionType([
+          namedType(`Prisma.${includeTypeName}`).addGenericArgument(extArgsParam.toArgument()),
+          nullType
+        ])
       ).optional().setDocComment(docComment("Choose, which related nodes to fetch as well"))
     );
     return this;
@@ -7443,7 +7454,7 @@ var ArgsTypeBuilder = class {
       property(
         "omit",
         unionType([
-          namedType(getOmitName(this.type.name)).addGenericArgument(extArgsParam.toArgument()),
+          namedType(`Prisma.${getOmitName(this.type.name)}`).addGenericArgument(extArgsParam.toArgument()),
           nullType
         ])
       ).optional().setDocComment(docComment(`Omit specific fields from the ${this.type.name}`))
@@ -7486,7 +7497,7 @@ ${this.stringifyFields()}
     return this.outputType.fields.filter((field) => field.outputType.location !== "outputObjectTypes").map((field) => {
       const fieldOutput = field.outputType;
       const refTypeName = getRefAllowedTypeName(fieldOutput);
-      return `  readonly ${field.name}: FieldRef<"${name}", ${refTypeName}>`;
+      return `  readonly ${field.name}: Prisma.FieldRef<"${name}", ${refTypeName}>`;
     }).join("\n");
   }
 };
@@ -7629,7 +7640,7 @@ function buildSelectOrIncludeObject(modelName, fields, context) {
   for (const field of fields) {
     const fieldType = unionType(booleanType);
     if (field.outputType.location === "outputObjectTypes") {
-      const subSelectType = namedType(getFieldArgName(field, modelName));
+      const subSelectType = namedType(`Prisma.${getFieldArgName(field, modelName)}`);
       subSelectType.addGenericArgument(extArgsParam.toArgument());
       fieldType.addVariant(subSelectType);
     }
@@ -7767,13 +7778,13 @@ ${stringify(buildOutputType(groupByType))}
 
 type ${getGroupByPayloadName(model.name)}<T extends ${groupByArgsName}> = Prisma.PrismaPromise<
   Array<
-    PickEnumerable<${groupByType.name}, T['by']> &
+    Prisma.PickEnumerable<${groupByType.name}, T['by']> &
       {
         [P in ((keyof T) & (keyof ${groupByType.name}))]: P extends '_count'
           ? T[P] extends boolean
             ? number
-            : GetScalarType<T[P], ${groupByType.name}[P]>
-          : GetScalarType<T[P], ${groupByType.name}[P]>
+            : Prisma.GetScalarType<T[P], ${groupByType.name}[P]>
+          : Prisma.GetScalarType<T[P], ${groupByType.name}[P]>
       }
     >
   >
@@ -7865,10 +7876,13 @@ export type ${getAggregateGetName(model.name)}<T extends ${getAggregateArgsName(
       [P in keyof T & keyof ${aggregateName}]: P extends '_count' | 'count'
     ? T[P] extends true
       ? number
-      : GetScalarType<T[P], ${aggregateName}[P]>
-    : GetScalarType<T[P], ${aggregateName}[P]>
+      : Prisma.GetScalarType<T[P], ${aggregateName}[P]>
+    : Prisma.GetScalarType<T[P], ${aggregateName}[P]>
 }`;
   }
+  fileName() {
+    return `${this.model.name}.d.ts`;
+  }
   toTSWithoutNamespace() {
     const { model } = this;
     const docLines = model.documentation ?? "";
@@ -8016,39 +8030,39 @@ ${nonAggregateActions.map((action) => {
 
 ${availableActions.includes(DMMF.ModelAction.aggregate) ? `${(0, import_indent_string3.default)(getMethodJSDoc(DMMF.ModelAction.count, mapping, modelOrType), TAB_SIZE)}
   count<T extends ${countArgsName}>(
-    args?: Subset<T, ${countArgsName}>,
+    args?: Prisma.Subset<T, ${countArgsName}>,
   ): Prisma.PrismaPromise<
     T extends $Utils.Record<'select', any>
       ? T['select'] extends true
         ? number
-        : GetScalarType<T['select'], ${getCountAggregateOutputName(name)}>
+        : Prisma.GetScalarType<T['select'], ${getCountAggregateOutputName(name)}>
       : number
   >
 ` : ""}
 ${availableActions.includes(DMMF.ModelAction.aggregate) ? `${(0, import_indent_string3.default)(getMethodJSDoc(DMMF.ModelAction.aggregate, mapping, modelOrType), TAB_SIZE)}
-  aggregate<T extends ${getAggregateArgsName(name)}>(args: Subset<T, ${getAggregateArgsName(
+  aggregate<T extends ${getAggregateArgsName(name)}>(args: Prisma.Subset<T, ${getAggregateArgsName(
       name
     )}>): Prisma.PrismaPromise<${getAggregateGetName(name)}<T>>
 ` : ""}
 ${availableActions.includes(DMMF.ModelAction.groupBy) ? `${(0, import_indent_string3.default)(getMethodJSDoc(DMMF.ModelAction.groupBy, mapping, modelOrType), TAB_SIZE)}
   groupBy<
     T extends ${groupByArgsName},
-    HasSelectOrTake extends Or<
-      Extends<'skip', Keys<T>>,
-      Extends<'take', Keys<T>>
+    HasSelectOrTake extends Prisma.Or<
+      Prisma.Extends<'skip', Prisma.Keys<T>>,
+      Prisma.Extends<'take', Prisma.Keys<T>>
     >,
-    OrderByArg extends True extends HasSelectOrTake
+    OrderByArg extends Prisma.True extends HasSelectOrTake
       ? { orderBy: ${groupByArgsName}['orderBy'] }
       : { orderBy?: ${groupByArgsName}['orderBy'] },
-    OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
-    ByFields extends MaybeTupleToUnion<T['by']>,
-    ByValid extends Has<ByFields, OrderFields>,
-    HavingFields extends GetHavingFields<T['having']>,
-    HavingValid extends Has<ByFields, HavingFields>,
-    ByEmpty extends T['by'] extends never[] ? True : False,
-    InputErrors extends ByEmpty extends True
+    OrderFields extends Prisma.ExcludeUnderscoreKeys<Prisma.Keys<Prisma.MaybeTupleToUnion<T['orderBy']>>>,
+    ByFields extends Prisma.MaybeTupleToUnion<T['by']>,
+    ByValid extends Prisma.Has<ByFields, OrderFields>,
+    HavingFields extends Prisma.GetHavingFields<T['having']>,
+    HavingValid extends Prisma.Has<ByFields, HavingFields>,
+    ByEmpty extends T['by'] extends never[] ? Prisma.True : Prisma.False,
+    InputErrors extends ByEmpty extends Prisma.True
     ? \`Error: "by" must not be empty.\`
-    : HavingValid extends False
+    : HavingValid extends Prisma.False
     ? {
         [P in HavingFields]: P extends ByFields
           ? never
@@ -8061,9 +8075,9 @@ ${availableActions.includes(DMMF.ModelAction.groupBy) ? `${(0, import_indent_str
               \` in "having" needs to be provided in "by"\`,
             ]
       }[HavingFields]
-    : 'take' extends Keys<T>
-    ? 'orderBy' extends Keys<T>
-      ? ByValid extends True
+    : 'take' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
         ? {}
         : {
             [P in OrderFields]: P extends ByFields
@@ -8071,9 +8085,9 @@ ${availableActions.includes(DMMF.ModelAction.groupBy) ? `${(0, import_indent_str
               : \`Error: Field "\${P}" in "orderBy" needs to be provided in "by"\`
           }[OrderFields]
       : 'Error: If you provide "take", you also need to provide "orderBy"'
-    : 'skip' extends Keys<T>
-    ? 'orderBy' extends Keys<T>
-      ? ByValid extends True
+    : 'skip' extends Prisma.Keys<T>
+    ? 'orderBy' extends Prisma.Keys<T>
+      ? ByValid extends Prisma.True
         ? {}
         : {
             [P in OrderFields]: P extends ByFields
@@ -8081,14 +8095,14 @@ ${availableActions.includes(DMMF.ModelAction.groupBy) ? `${(0, import_indent_str
               : \`Error: Field "\${P}" in "orderBy" needs to be provided in "by"\`
           }[OrderFields]
       : 'Error: If you provide "skip", you also need to provide "orderBy"'
-    : ByValid extends True
+    : ByValid extends Prisma.True
     ? {}
     : {
         [P in OrderFields]: P extends ByFields
           ? never
           : \`Error: Field "\${P}" in "orderBy" needs to be provided in "by"\`
       }[OrderFields]
-  >(args: SubsetIntersection<T, ${groupByArgsName}, OrderByArg> & InputErrors): {} extends InputErrors ? ${getGroupByPayloadName(
+  >(args: Prisma.SubsetIntersection<T, ${groupByArgsName}, OrderByArg> & InputErrors): {} extends InputErrors ? ${getGroupByPayloadName(
       name
     )}<T> : Prisma.PrismaPromise<InputErrors>` : ""}
 /**
@@ -8121,9 +8135,9 @@ function getNonAggregateMethodArgs(modelName, actionName) {
     return makeParameter(type2).optional();
   }
   if (actionName === DMMF.ModelAction.findRaw || actionName === DMMF.ModelAction.aggregateRaw) {
-    return makeParameter(namedType(getModelArgName(modelName, actionName))).optional();
+    return makeParameter(namedType(`Prisma.${getModelArgName(modelName, actionName)}`)).optional();
   }
-  const type = namedType("SelectSubset").addGenericArgument(namedType("T")).addGenericArgument(
+  const type = namedType("Prisma.SelectSubset").addGenericArgument(namedType("T")).addGenericArgument(
     namedType(getModelArgName(modelName, actionName)).addGenericArgument(extArgsParam.toArgument())
   );
   const param = makeParameter(type);
@@ -8155,10 +8169,10 @@ function getReturnType({
     return promise(namedType(getAggregateGetName(modelName)).addGenericArgument(namedType("T")));
   }
   if (actionName === DMMF.ModelAction.findRaw || actionName === DMMF.ModelAction.aggregateRaw) {
-    return prismaPromise(namedType("JsonObject"));
+    return prismaPromise(namedType("Prisma.JsonObject"));
   }
   if (actionName === DMMF.ModelAction.deleteMany || actionName === DMMF.ModelAction.updateMany || actionName === DMMF.ModelAction.createMany) {
-    return prismaPromise(namedType("BatchPayload"));
+    return prismaPromise(namedType("Prisma.BatchPayload"));
   }
   const isList = actionName === DMMF.ModelAction.findMany || actionName === DMMF.ModelAction.createManyAndReturn || actionName === DMMF.ModelAction.updateManyAndReturn;
   if (isList) {
@@ -8180,7 +8194,7 @@ function getReturnType({
   return getFluentWrapper(modelName, getResultType(modelName, actionName));
 }
 function getFluentWrapper(modelName, resultType, nullType2 = neverType) {
-  return namedType(fluentWrapperName(modelName)).addGenericArgument(resultType).addGenericArgument(nullType2).addGenericArgument(extArgsParam.toArgument()).addGenericArgument(namedType("ClientOptions"));
+  return namedType(`Prisma.${fluentWrapperName(modelName)}`).addGenericArgument(resultType).addGenericArgument(nullType2).addGenericArgument(extArgsParam.toArgument()).addGenericArgument(namedType("ClientOptions"));
 }
 function getResultType(modelName, actionName) {
   return namedType("$Result.GetResult").addGenericArgument(namedType(getPayloadName(modelName)).addGenericArgument(extArgsParam.toArgument())).addGenericArgument(namedType("T")).addGenericArgument(stringLiteral(actionName)).addGenericArgument(namedType("ClientOptions"));
@@ -8193,7 +8207,7 @@ function buildFluentWrapperDefinition(modelName, outputType, context) {
     outputType.fields.filter(
       (field) => field.outputType.location === "outputObjectTypes" && !context.dmmf.isComposite(field.outputType.type) && field.name !== "_count"
     ).map((field) => {
-      const fieldArgType = namedType(getFieldArgName(field, modelName)).addGenericArgument(extArgsParam.toArgument());
+      const fieldArgType = namedType(`Prisma.${getFieldArgName(field, modelName)}`).addGenericArgument(extArgsParam.toArgument());
       const argsParam = genericParameter("T").extends(fieldArgType).default(objectType());
       return method(field.name).addGenericParameter(argsParam).addParameter(parameter("args", subset(argsParam.toArgument(), fieldArgType)).optional()).setReturnType(
         getReturnType({
@@ -8257,7 +8271,7 @@ function typeOrPromiseLike(type) {
   return unionType([type, namedType("PromiseLike").addGenericArgument(type)]);
 }
 function subset(arg, baseType) {
-  return namedType("Subset").addGenericArgument(arg).addGenericArgument(baseType);
+  return namedType("Prisma.Subset").addGenericArgument(arg).addGenericArgument(baseType);
 }
 function fluentWrapperName(modelName) {
   return `Prisma__${modelName}Client`;
@@ -8266,7 +8280,6 @@ function fluentWrapperName(modelName) {
 // src/generation/TSClient/TSClient.ts
 var import_ci_info = __toESM(require_ci_info());
 var import_crypto = __toESM(require("crypto"));
-var import_indent_string8 = __toESM(require_indent_string());
 var import_path4 = __toESM(require("path"));
 
 // src/generation/dmmf.ts
@@ -8726,1256 +8739,1435 @@ warnEnvConflicts({
 })`;
 }
 
-// src/generation/TSClient/common.ts
-var import_indent_string4 = __toESM(require_indent_string());
-var commonCodeJS = ({
-  runtimeBase,
-  runtimeNameJs,
-  browser,
-  clientVersion: clientVersion2,
-  engineVersion,
-  generator,
-  deno
-}) => `${deno ? "const exports = {}" : ""}
-Object.defineProperty(exports, "__esModule", { value: true });
-${deno ? `
-import {
-  PrismaClientKnownRequestError,
-  PrismaClientUnknownRequestError,
-  PrismaClientRustPanicError,
-  PrismaClientInitializationError,
-  PrismaClientValidationError,
-  getPrismaClient,
-  sqltag,
-  empty,
-  join,
-  raw,
-  Decimal,
-  Debug,
-  objectEnumValues,
-  makeStrictEnum,
-  Extensions,
-  defineDmmfProperty,
-  Public,
-  getRuntime,
-  skip
-} from '${runtimeBase}/${runtimeNameJs}.js'` : browser ? `
-const {
-  Decimal,
-  objectEnumValues,
-  makeStrictEnum,
-  Public,
-  getRuntime,
-  skip
-} = require('${runtimeBase}/${runtimeNameJs}.js')
-` : `
-const {
-  PrismaClientKnownRequestError,
-  PrismaClientUnknownRequestError,
-  PrismaClientRustPanicError,
-  PrismaClientInitializationError,
-  PrismaClientValidationError,
-  getPrismaClient,
-  sqltag,
-  empty,
-  join,
-  raw,
-  skip,
-  Decimal,
-  Debug,
-  objectEnumValues,
-  makeStrictEnum,
-  Extensions,
-  warnOnce,
-  defineDmmfProperty,
-  Public,
-  getRuntime,
-  createParam,
-} = require('${runtimeBase}/${runtimeNameJs}.js')
-`}
-
-const Prisma = {}
-
-exports.Prisma = Prisma
-exports.$Enums = {}
+// src/generation/TSClient/PrismaClient.ts
+var import_indent_string5 = __toESM(require_indent_string());
 
-/**
- * Prisma Client JS version: ${clientVersion2}
- * Query Engine version: ${engineVersion}
- */
-Prisma.prismaVersion = {
-  client: "${clientVersion2}",
-  engine: "${engineVersion}"
+// src/generation/utils/runtimeImport.ts
+function runtimeImport(name) {
+  return name;
 }
-
-Prisma.PrismaClientKnownRequestError = ${notSupportOnBrowser("PrismaClientKnownRequestError", browser)};
-Prisma.PrismaClientUnknownRequestError = ${notSupportOnBrowser("PrismaClientUnknownRequestError", browser)}
-Prisma.PrismaClientRustPanicError = ${notSupportOnBrowser("PrismaClientRustPanicError", browser)}
-Prisma.PrismaClientInitializationError = ${notSupportOnBrowser("PrismaClientInitializationError", browser)}
-Prisma.PrismaClientValidationError = ${notSupportOnBrowser("PrismaClientValidationError", browser)}
-Prisma.Decimal = Decimal
-
-/**
- * Re-export of sql-template-tag
- */
-Prisma.sql = ${notSupportOnBrowser("sqltag", browser)}
-Prisma.empty = ${notSupportOnBrowser("empty", browser)}
-Prisma.join = ${notSupportOnBrowser("join", browser)}
-Prisma.raw = ${notSupportOnBrowser("raw", browser)}
-Prisma.validator = Public.validator
-
-/**
-* Extensions
-*/
-Prisma.getExtensionContext = ${notSupportOnBrowser("Extensions.getExtensionContext", browser)}
-Prisma.defineExtension = ${notSupportOnBrowser("Extensions.defineExtension", browser)}
-
-/**
- * Shorthand utilities for JSON filtering
- */
-Prisma.DbNull = objectEnumValues.instances.DbNull
-Prisma.JsonNull = objectEnumValues.instances.JsonNull
-Prisma.AnyNull = objectEnumValues.instances.AnyNull
-
-Prisma.NullTypes = {
-  DbNull: objectEnumValues.classes.DbNull,
-  JsonNull: objectEnumValues.classes.JsonNull,
-  AnyNull: objectEnumValues.classes.AnyNull
+function runtimeImportedType(name) {
+  return namedType(`runtime.${name}`);
 }
 
-${buildPrismaSkipJs(generator.previewFeatures)}
-`;
-var notSupportOnBrowser = (fnc, browser) => {
-  if (browser) {
-    return `() => {
-  const runtimeName = getRuntime().prettyName;
-  throw new Error(\`${fnc} is unable to run in this browser environment, or has been bundled for the browser (running in \${runtimeName}).
-In case this error is unexpected for you, please report it in https://pris.ly/prisma-prisma-bug-report\`,
-)}`;
+// src/generation/TSClient/Datasources.ts
+var import_indent_string4 = __toESM(require_indent_string());
+var Datasources = class {
+  constructor(internalDatasources) {
+    this.internalDatasources = internalDatasources;
+  }
+  toTS() {
+    const sources = this.internalDatasources;
+    return `export type Datasources = {
+${(0, import_indent_string4.default)(sources.map((s) => `${s.name}?: Datasource`).join("\n"), 2)}
+}`;
   }
-  return fnc;
 };
-var commonCodeTS = ({
-  runtimeBase,
-  runtimeNameTs,
-  clientVersion: clientVersion2,
-  engineVersion,
-  generator
-}) => ({
-  tsWithoutNamespace: () => `import * as runtime from '${runtimeBase}/${runtimeNameTs}';
-import $Types = runtime.Types // general types
-import $Public = runtime.Types.Public
-import $Utils = runtime.Types.Utils
-import $Extensions = runtime.Types.Extensions
-import $Result = runtime.Types.Result
-
-export type PrismaPromise<T> = $Public.PrismaPromise<T>
-`,
-  ts: () => `export import DMMF = runtime.DMMF
-
-export type PrismaPromise<T> = $Public.PrismaPromise<T>
-
-/**
- * Validator
- */
-export import validator = runtime.Public.validator
-
-/**
- * Prisma Errors
- */
-export import PrismaClientKnownRequestError = runtime.PrismaClientKnownRequestError
-export import PrismaClientUnknownRequestError = runtime.PrismaClientUnknownRequestError
-export import PrismaClientRustPanicError = runtime.PrismaClientRustPanicError
-export import PrismaClientInitializationError = runtime.PrismaClientInitializationError
-export import PrismaClientValidationError = runtime.PrismaClientValidationError
-
-/**
- * Re-export of sql-template-tag
- */
-export import sql = runtime.sqltag
-export import empty = runtime.empty
-export import join = runtime.join
-export import raw = runtime.raw
-export import Sql = runtime.Sql
-
-${buildPrismaSkipTs(generator.previewFeatures)}
-
-/**
- * Decimal.js
- */
-export import Decimal = runtime.Decimal
 
-export type DecimalJsLike = runtime.DecimalJsLike
-
-/**
- * Metrics
- */
-export type Metrics = runtime.Metrics
-export type Metric<T> = runtime.Metric<T>
-export type MetricHistogram = runtime.MetricHistogram
-export type MetricHistogramBucket = runtime.MetricHistogramBucket
-
-/**
-* Extensions
-*/
-export import Extension = $Extensions.UserArgs
-export import getExtensionContext = runtime.Extensions.getExtensionContext
-export import Args = $Public.Args
-export import Payload = $Public.Payload
-export import Result = $Public.Result
-export import Exact = $Public.Exact
-
-/**
- * Prisma Client JS version: ${clientVersion2}
- * Query Engine version: ${engineVersion}
- */
-export type PrismaVersion = {
-  client: string
-}
-
-export const prismaVersion: PrismaVersion
-
-/**
- * Utility Types
- */
-
-
-export import JsonObject = runtime.JsonObject
-export import JsonArray = runtime.JsonArray
-export import JsonValue = runtime.JsonValue
-export import InputJsonObject = runtime.InputJsonObject
-export import InputJsonArray = runtime.InputJsonArray
-export import InputJsonValue = runtime.InputJsonValue
-
-/**
- * Types of the values used to represent different kinds of \`null\` values when working with JSON fields.
- *
- * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
- */
-namespace NullTypes {
-${buildNullClass("DbNull")}
-
-${buildNullClass("JsonNull")}
-
-${buildNullClass("AnyNull")}
+// src/generation/TSClient/globalOmit.ts
+function globalOmitConfig(dmmf) {
+  const objectType2 = objectType().addMultiple(
+    dmmf.datamodel.models.map((model) => {
+      const type = namedType(`Prisma.${getOmitName(model.name)}`);
+      return property(lowerCase(model.name), type).optional();
+    })
+  );
+  return moduleExport(typeDeclaration("GlobalOmitConfig", objectType2));
 }
 
-/**
- * Helper for filtering JSON entries that have \`null\` on the database (empty on the db)
- *
- * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
- */
-export const DbNull: NullTypes.DbNull
+// src/generation/TSClient/PrismaClient.ts
+function clientTypeMapModelsDefinition(context) {
+  const meta = objectType();
+  const modelNames = context.dmmf.datamodel.models.map((m) => m.name);
+  if (modelNames.length === 0) {
+    meta.add(property("modelProps", neverType));
+  } else {
+    meta.add(property("modelProps", unionType(modelNames.map((name) => stringLiteral(lowerCase(name))))));
+  }
+  const isolationLevel = context.dmmf.hasEnumInNamespace("TransactionIsolationLevel", "prisma") ? namedType("TransactionIsolationLevel") : neverType;
+  meta.add(property("txIsolationLevel", isolationLevel));
+  const model = objectType();
+  model.addMultiple(
+    modelNames.map((modelName) => {
+      const entry = objectType();
+      entry.add(
+        property("payload", namedType(getPayloadName(modelName)).addGenericArgument(extArgsParam.toArgument()))
+      );
+      entry.add(property("fields", namedType(`Prisma.${getFieldRefsTypeName(modelName)}`)));
+      const actions = getModelActions(context.dmmf, modelName);
+      const operations = objectType();
+      operations.addMultiple(
+        actions.map((action) => {
+          const operationType = objectType();
+          const argsType = `Prisma.${getModelArgName(modelName, action)}`;
+          operationType.add(property("args", namedType(argsType).addGenericArgument(extArgsParam.toArgument())));
+          operationType.add(property("result", clientTypeMapModelsResultDefinition(modelName, action)));
+          return property(action, operationType);
+        })
+      );
+      entry.add(property("operations", operations));
+      return property(modelName, entry);
+    })
+  );
+  return objectType().add(property("meta", meta)).add(property("model", model));
+}
+function clientTypeMapModelsResultDefinition(modelName, action) {
+  if (action === "count")
+    return unionType([optional(namedType(`Prisma.${getCountAggregateOutputName(modelName)}`)), numberType]);
+  if (action === "groupBy") return array(optional(namedType(`Prisma.${getGroupByName(modelName)}`)));
+  if (action === "aggregate") return optional(namedType(`Prisma.${getAggregateName(modelName)}`));
+  if (action === "findRaw") return namedType("Prisma.JsonObject");
+  if (action === "aggregateRaw") return namedType("Prisma.JsonObject");
+  if (action === "deleteMany") return namedType("BatchPayload");
+  if (action === "createMany") return namedType("BatchPayload");
+  if (action === "createManyAndReturn") return array(payloadToResult(modelName));
+  if (action === "updateMany") return namedType("BatchPayload");
+  if (action === "updateManyAndReturn") return array(payloadToResult(modelName));
+  if (action === "findMany") return array(payloadToResult(modelName));
+  if (action === "findFirst") return unionType([payloadToResult(modelName), nullType]);
+  if (action === "findUnique") return unionType([payloadToResult(modelName), nullType]);
+  if (action === "findFirstOrThrow") return payloadToResult(modelName);
+  if (action === "findUniqueOrThrow") return payloadToResult(modelName);
+  if (action === "create") return payloadToResult(modelName);
+  if (action === "update") return payloadToResult(modelName);
+  if (action === "upsert") return payloadToResult(modelName);
+  if (action === "delete") return payloadToResult(modelName);
+  assertNever(action, `Unknown action: ${action}`);
+}
+function payloadToResult(modelName) {
+  return namedType("$Utils.PayloadToResult").addGenericArgument(namedType(getPayloadName(modelName)));
+}
+function clientTypeMapOthersDefinition(context) {
+  const otherOperationsNames = context.dmmf.getOtherOperationNames().flatMap((name) => {
+    const results = [`$${name}`];
+    if (name === "executeRaw" || name === "queryRaw") {
+      results.push(`$${name}Unsafe`);
+    }
+    if (name === "queryRaw" && context.isPreviewFeatureOn("typedSql")) {
+      results.push(`$queryRawTyped`);
+    }
+    return results;
+  });
+  const argsResultMap = {
+    $executeRaw: { args: "[query: TemplateStringsArray | Sql, ...values: any[]]", result: "any" },
+    $queryRaw: { args: "[query: TemplateStringsArray | Sql, ...values: any[]]", result: "any" },
+    $executeRawUnsafe: { args: "[query: string, ...values: any[]]", result: "any" },
+    $queryRawUnsafe: { args: "[query: string, ...values: any[]]", result: "any" },
+    $runCommandRaw: { args: "Prisma.InputJsonObject", result: "Prisma.JsonObject" },
+    $queryRawTyped: { args: "runtime.UnknownTypedSql", result: "Prisma.JsonObject" }
+  };
+  return `{
+  other: {
+    payload: any
+    operations: {${otherOperationsNames.reduce((acc, action) => {
+    return `${acc}
+      ${action}: {
+        args: ${argsResultMap[action].args},
+        result: ${argsResultMap[action].result}
+      }`;
+  }, "")}
+    }
+  }
+}`;
+}
+function clientTypeMapDefinition(context) {
+  const typeMap = `${stringify(clientTypeMapModelsDefinition(context))} & ${clientTypeMapOthersDefinition(context)}`;
+  return `
+export interface TypeMapCb extends $Utils.Fn<{extArgs: $Extensions.InternalArgs, clientOptions: PrismaClientOptions }, $Utils.Record<string, any>> {
+  returns: TypeMap<this['params']['extArgs'], this['params']['clientOptions']>
+}
 
-/**
- * Helper for filtering JSON entries that have JSON \`null\` values (not empty on the db)
- *
- * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
- */
-export const JsonNull: NullTypes.JsonNull
+export type TypeMap<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, ClientOptions = {}> = ${typeMap}`;
+}
+function clientExtensionsDefinitions(context) {
+  const typeMap = clientTypeMapDefinition(context);
+  const define2 = moduleExport(
+    constDeclaration(
+      "defineExtension",
+      namedType("$Extensions.ExtendsHook").addGenericArgument(stringLiteral("define")).addGenericArgument(namedType("TypeMapCb")).addGenericArgument(namedType("$Extensions.DefaultArgs"))
+    )
+  );
+  return [typeMap, stringify(define2)].join("\n");
+}
+function extendsPropertyDefinition() {
+  const extendsDefinition = namedType("$Extensions.ExtendsHook").addGenericArgument(stringLiteral("extends")).addGenericArgument(namedType("Prisma.TypeMapCb")).addGenericArgument(namedType("ExtArgs")).addGenericArgument(
+    namedType("$Utils.Call").addGenericArgument(namedType("Prisma.TypeMapCb")).addGenericArgument(objectType().add(property("extArgs", namedType("ExtArgs"))))
+  ).addGenericArgument(namedType("ClientOptions"));
+  return stringify(property("$extends", extendsDefinition), { indentLevel: 1 });
+}
+function batchingTransactionDefinition(context) {
+  const method2 = method("$transaction").setDocComment(
+    docComment`
+        Allows the running of a sequence of read/write operations that are guaranteed to either succeed or fail as a whole.
+        @example
+        \`\`\`
+        const [george, bob, alice] = await prisma.$transaction([
+          prisma.user.create({ data: { name: 'George' } }),
+          prisma.user.create({ data: { name: 'Bob' } }),
+          prisma.user.create({ data: { name: 'Alice' } }),
+        ])
+        \`\`\`
 
-/**
- * Helper for filtering JSON entries that are \`Prisma.DbNull\` or \`Prisma.JsonNull\`
- *
- * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
- */
-export const AnyNull: NullTypes.AnyNull
+        Read more in our [docs](https://www.prisma.io/docs/concepts/components/prisma-client/transactions).
+      `
+  ).addGenericParameter(genericParameter("P").extends(array(prismaPromise(anyType)))).addParameter(parameter("arg", arraySpread(namedType("P")))).setReturnType(promise(namedType("runtime.Types.Utils.UnwrapTuple").addGenericArgument(namedType("P"))));
+  if (context.dmmf.hasEnumInNamespace("TransactionIsolationLevel", "prisma")) {
+    const options = objectType().formatInline().add(property("isolationLevel", namedType("Prisma.TransactionIsolationLevel")).optional());
+    method2.addParameter(parameter("options", options).optional());
+  }
+  return stringify(method2, { indentLevel: 1, newLine: "leading" });
+}
+function interactiveTransactionDefinition(context) {
+  const options = objectType().formatInline().add(property("maxWait", numberType).optional()).add(property("timeout", numberType).optional());
+  if (context.dmmf.hasEnumInNamespace("TransactionIsolationLevel", "prisma")) {
+    const isolationLevel = property("isolationLevel", namedType("Prisma.TransactionIsolationLevel")).optional();
+    options.add(isolationLevel);
+  }
+  const returnType = promise(namedType("R"));
+  const callbackType = functionType().addParameter(
+    parameter("prisma", omit(namedType("PrismaClient"), namedType("runtime.ITXClientDenyList")))
+  ).setReturnType(returnType);
+  const method2 = method("$transaction").addGenericParameter(genericParameter("R")).addParameter(parameter("fn", callbackType)).addParameter(parameter("options", options).optional()).setReturnType(returnType);
+  return stringify(method2, { indentLevel: 1, newLine: "leading" });
+}
+function queryRawDefinition(context) {
+  if (!context.dmmf.mappings.otherOperations.write.includes("queryRaw")) {
+    return "";
+  }
+  return `
+  /**
+   * Performs a prepared raw query and returns the \`SELECT\` data.
+   * @example
+   * \`\`\`
+   * const result = await prisma.$queryRaw\`SELECT * FROM User WHERE id = \${1} OR email = \${'user@email.com'};\`
+   * \`\`\`
+   *
+   * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
+   */
+  $queryRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<T>;
 
-type SelectAndInclude = {
-  select: any
-  include: any
+  /**
+   * Performs a raw query and returns the \`SELECT\` data.
+   * Susceptible to SQL injections, see documentation.
+   * @example
+   * \`\`\`
+   * const result = await prisma.$queryRawUnsafe('SELECT * FROM User WHERE id = $1 OR email = $2;', 1, 'user@email.com')
+   * \`\`\`
+   *
+   * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
+   */
+  $queryRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<T>;`;
 }
+function executeRawDefinition(context) {
+  if (!context.dmmf.mappings.otherOperations.write.includes("executeRaw")) {
+    return "";
+  }
+  return `
+  /**
+   * Executes a prepared raw query and returns the number of affected rows.
+   * @example
+   * \`\`\`
+   * const result = await prisma.$executeRaw\`UPDATE User SET cool = \${true} WHERE email = \${'user@email.com'};\`
+   * \`\`\`
+   *
+   * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
+   */
+  $executeRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<number>;
 
-type SelectAndOmit = {
-  select: any
-  omit: any
+  /**
+   * Executes a raw query and returns the number of affected rows.
+   * Susceptible to SQL injections, see documentation.
+   * @example
+   * \`\`\`
+   * const result = await prisma.$executeRawUnsafe('UPDATE User SET cool = $1 WHERE email = $2 ;', true, 'user@email.com')
+   * \`\`\`
+   *
+   * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
+   */
+  $executeRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<number>;`;
 }
+function queryRawTypedDefinition(context) {
+  if (!context.isPreviewFeatureOn("typedSql")) {
+    return "";
+  }
+  if (!context.dmmf.mappings.otherOperations.write.includes("queryRaw")) {
+    return "";
+  }
+  const param = genericParameter("T");
+  const method2 = method("$queryRawTyped").setDocComment(
+    docComment`
+        Executes a typed SQL query and returns a typed result
+        @example
+        \`\`\`
+        import { myQuery } from '@prisma/client/sql'
 
-/**
- * Get the type of the value, that the Promise holds.
- */
-export type PromiseType<T extends PromiseLike<any>> = T extends PromiseLike<infer U> ? U : T;
+        const result = await prisma.$queryRawTyped(myQuery())
+        \`\`\`
+      `
+  ).addGenericParameter(param).addParameter(
+    parameter(
+      "typedSql",
+      runtimeImportedType("TypedSql").addGenericArgument(array(unknownType)).addGenericArgument(param.toArgument())
+    )
+  ).setReturnType(prismaPromise(array(param.toArgument())));
+  return stringify(method2, { indentLevel: 1, newLine: "leading" });
+}
+function metricDefinition(context) {
+  if (!context.isPreviewFeatureOn("metrics")) {
+    return "";
+  }
+  const property2 = property("$metrics", namedType(`runtime.${runtimeImport("MetricsClient")}`)).setDocComment(
+    docComment`
+        Gives access to the client metrics in json or prometheus format.
 
-/**
- * Get the return type of a function which returns a Promise.
- */
-export type PromiseReturnType<T extends (...args: any) => $Utils.JsPromise<any>> = PromiseType<ReturnType<T>>
+        @example
+        \`\`\`
+        const metrics = await prisma.$metrics.json()
+        // or
+        const metrics = await prisma.$metrics.prometheus()
+        \`\`\`
+    `
+  ).readonly();
+  return stringify(property2, { indentLevel: 1, newLine: "leading" });
+}
+function runCommandRawDefinition(context) {
+  if (!context.dmmf.mappings.otherOperations.write.includes("runCommandRaw")) {
+    return "";
+  }
+  const method2 = method("$runCommandRaw").addParameter(parameter("command", namedType("Prisma.InputJsonObject"))).setReturnType(prismaPromise(namedType("Prisma.JsonObject"))).setDocComment(docComment`
+      Executes a raw MongoDB command and returns the result of it.
+      @example
+      \`\`\`
+      const user = await prisma.$runCommandRaw({
+        aggregate: 'User',
+        pipeline: [{ $match: { name: 'Bob' } }, { $project: { email: true, _id: false } }],
+        explain: false,
+      })
+      \`\`\`
 
-/**
- * From T, pick a set of properties whose keys are in the union K
- */
-type Prisma__Pick<T, K extends keyof T> = {
-    [P in K]: T[P];
-};
+      Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
+    `);
+  return stringify(method2, { indentLevel: 1, newLine: "leading" });
+}
+function applyPendingMigrationsDefinition() {
+  if (this.runtimeNameTs !== "react-native") {
+    return null;
+  }
+  const method2 = method("$applyPendingMigrations").setReturnType(promise(voidType)).setDocComment(
+    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 stringify(method2, { indentLevel: 1, newLine: "leading" });
+}
+function eventRegistrationMethodDeclaration(runtimeNameTs) {
+  if (runtimeNameTs === "binary.js") {
+    return `$on<V extends (U | 'beforeExit')>(eventType: V, callback: (event: V extends 'query' ? Prisma.QueryEvent : V extends 'beforeExit' ? () => $Utils.JsPromise<void> : Prisma.LogEvent) => void): void;`;
+  } else {
+    return `$on<V extends U>(eventType: V, callback: (event: V extends 'query' ? Prisma.QueryEvent : Prisma.LogEvent) => void): void;`;
+  }
+}
+var PrismaClientClass = class {
+  constructor(context, internalDatasources, outputDir, runtimeNameTs, browser) {
+    this.context = context;
+    this.internalDatasources = internalDatasources;
+    this.outputDir = outputDir;
+    this.runtimeNameTs = runtimeNameTs;
+    this.browser = browser;
+  }
+  get jsDoc() {
+    const { dmmf } = this.context;
+    let example;
+    if (dmmf.mappings.modelOperations.length) {
+      example = dmmf.mappings.modelOperations[0];
+    } else {
+      example = {
+        model: "User",
+        plural: "users"
+      };
+    }
+    return `/**
+ * ##  Prisma Client \u02B2\u02E2
+ *
+ * Type-safe database client for TypeScript & Node.js
+ * @example
+ * \`\`\`
+ * const prisma = new PrismaClient()
+ * // Fetch zero or more ${capitalize2(example.plural)}
+ * const ${lowerCase(example.plural)} = await prisma.${lowerCase(example.model)}.findMany()
+ * \`\`\`
+ *
+ *
+ * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client).
+ */`;
+  }
+  toTSWithoutNamespace() {
+    const { dmmf } = this.context;
+    return `${this.jsDoc}
+export class PrismaClient<
+  ClientOptions extends Prisma.PrismaClientOptions = Prisma.PrismaClientOptions,
+  U = 'log' extends keyof ClientOptions ? ClientOptions['log'] extends Array<Prisma.LogLevel | Prisma.LogDefinition> ? Prisma.GetEvents<ClientOptions['log']> : never : never,
+  ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs
+> {
+  [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['other'] }
 
+  ${(0, import_indent_string5.default)(this.jsDoc, TAB_SIZE)}
 
-export type Enumerable<T> = T | Array<T>;
+  constructor(optionsArg ?: Prisma.Subset<ClientOptions, Prisma.PrismaClientOptions>);
+  ${eventRegistrationMethodDeclaration(this.runtimeNameTs)}
 
-export type RequiredKeys<T> = {
-  [K in keyof T]-?: {} extends Prisma__Pick<T, K> ? never : K
-}[keyof T]
+  /**
+   * Connect with the database
+   */
+  $connect(): $Utils.JsPromise<void>;
 
-export type TruthyKeys<T> = keyof {
-  [K in keyof T as T[K] extends false | undefined | null ? never : K]: K
-}
+  /**
+   * Disconnect from the database
+   */
+  $disconnect(): $Utils.JsPromise<void>;
 
-export type TrueKeys<T> = TruthyKeys<Prisma__Pick<T, RequiredKeys<T>>>
+  /**
+   * Add a middleware
+   * @deprecated since 4.16.0. For new code, prefer client extensions instead.
+   * @see https://pris.ly/d/extensions
+   */
+  $use(cb: Prisma.Middleware): void
 
-/**
- * Subset
- * @desc From \`T\` pick properties that exist in \`U\`. Simple version of Intersection
- */
-export type Subset<T, U> = {
-  [key in keyof T]: key extends keyof U ? T[key] : never;
-};
+${[
+      executeRawDefinition(this.context),
+      queryRawDefinition(this.context),
+      queryRawTypedDefinition(this.context),
+      batchingTransactionDefinition(this.context),
+      interactiveTransactionDefinition(this.context),
+      runCommandRawDefinition(this.context),
+      metricDefinition(this.context),
+      applyPendingMigrationsDefinition.bind(this)(),
+      extendsPropertyDefinition()
+    ].filter((d) => d !== null).join("\n").trim()}
 
-/**
- * SelectSubset
- * @desc From \`T\` pick properties that exist in \`U\`. Simple version of Intersection.
- * Additionally, it validates, if both select and include are present. If the case, it errors.
- */
-export type SelectSubset<T, U> = {
-  [key in keyof T]: key extends keyof U ? T[key] : never
-} &
-  (T extends SelectAndInclude
-    ? 'Please either choose \`select\` or \`include\`.'
-    : T extends SelectAndOmit
-      ? 'Please either choose \`select\` or \`omit\`.'
-      : {})
+    ${(0, import_indent_string5.default)(
+      dmmf.mappings.modelOperations.filter((m) => m.findMany).map((m) => {
+        let methodName = lowerCase(m.model);
+        if (methodName === "constructor") {
+          methodName = '["constructor"]';
+        }
+        const generics = ["ExtArgs", "ClientOptions"];
+        return `/**
+ * \`prisma.${methodName}\`: Exposes CRUD operations for the **${m.model}** model.
+  * Example usage:
+  * \`\`\`ts
+  * // Fetch zero or more ${capitalize2(m.plural)}
+  * const ${lowerCase(m.plural)} = await prisma.${methodName}.findMany()
+  * \`\`\`
+  */
+get ${methodName}(): Prisma.${m.model}Delegate<${generics.join(", ")}>;`;
+      }).join("\n\n"),
+      2
+    )}
+}`;
+  }
+  toTS() {
+    const clientOptions = this.buildClientOptions();
+    return `${new Datasources(this.internalDatasources).toTS()}
+${clientExtensionsDefinitions(this.context)}
+export type DefaultPrismaClient = PrismaClient
+export type ErrorFormat = 'pretty' | 'colorless' | 'minimal'
+${stringify(moduleExport(clientOptions))}
+${stringify(globalOmitConfig(this.context.dmmf))}
 
-/**
- * Subset + Intersection
- * @desc From \`T\` pick properties that exist in \`U\` and intersect \`K\`
- */
-export type SubsetIntersection<T, U, K> = {
-  [key in keyof T]: key extends keyof U ? T[key] : never
-} &
-  K
+/* Types for Logging */
+export type LogLevel = 'info' | 'query' | 'warn' | 'error'
+export type LogDefinition = {
+  level: LogLevel
+  emit: 'stdout' | 'event'
+}
 
-type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };
+export type GetLogType<T extends LogLevel | LogDefinition> = T extends LogDefinition ? T['emit'] extends 'event' ? T['level'] : never : never
+export type GetEvents<T extends any> = T extends Array<LogLevel | LogDefinition> ?
+  GetLogType<T[0]> | GetLogType<T[1]> | GetLogType<T[2]> | GetLogType<T[3]>
+  : never
 
-/**
- * XOR is needed to have a real mutually exclusive union type
- * https://stackoverflow.com/questions/42123407/does-typescript-support-mutually-exclusive-types
- */
-type XOR<T, U> =
-  T extends object ?
-  U extends object ?
-    (Without<T, U> & U) | (Without<U, T> & T)
-  : U : T
+export type QueryEvent = {
+  timestamp: Date
+  query: string
+  params: string
+  duration: number
+  target: string
+}
 
+export type LogEvent = {
+  timestamp: Date
+  message: string
+  target: string
+}
+/* End Types for Logging */
 
-/**
- * Is T a Record?
- */
-type IsObject<T extends any> = T extends Array<any>
-? False
-: T extends Date
-? False
-: T extends Uint8Array
-? False
-: T extends BigInt
-? False
-: T extends object
-? True
-: False
 
+export type PrismaAction =
+  | 'findUnique'
+  | 'findUniqueOrThrow'
+  | 'findMany'
+  | 'findFirst'
+  | 'findFirstOrThrow'
+  | 'create'
+  | 'createMany'
+  | 'createManyAndReturn'
+  | 'update'
+  | 'updateMany'
+  | 'updateManyAndReturn'
+  | 'upsert'
+  | 'delete'
+  | 'deleteMany'
+  | 'executeRaw'
+  | 'queryRaw'
+  | 'aggregate'
+  | 'count'
+  | 'runCommandRaw'
+  | 'findRaw'
+  | 'groupBy'
+
+/**
+ * These options are being passed into the middleware as "params"
+ */
+export type MiddlewareParams = {
+  model?: ModelName
+  action: PrismaAction
+  args: any
+  dataPath: string[]
+  runInTransaction: boolean
+}
 
 /**
- * If it's T[], return T
+ * The \`T\` type makes sure, that the \`return proceed\` is not forgotten in the middleware implementation
  */
-export type UnEnumerate<T extends unknown> = T extends Array<infer U> ? U : T
+export type Middleware<T = any> = (
+  params: MiddlewareParams,
+  next: (params: MiddlewareParams) => $Utils.JsPromise<T>,
+) => $Utils.JsPromise<T>
+
+// tested in getLogLevel.test.ts
+export function getLogLevel(log: Array<LogLevel | LogDefinition>): LogLevel | undefined;
 
 /**
- * From ts-toolbelt
+ * \`PrismaClient\` proxy available in interactive transactions.
  */
+export type TransactionClient = Omit<DefaultPrismaClient, runtime.ITXClientDenyList>
+`;
+  }
+  buildClientOptions() {
+    const clientOptions = interfaceDeclaration("PrismaClientOptions").add(
+      property("datasources", namedType("Datasources")).optional().setDocComment(docComment("Overwrites the datasource url from your schema.prisma file"))
+    ).add(
+      property("datasourceUrl", stringType).optional().setDocComment(docComment("Overwrites the datasource url from your schema.prisma file"))
+    ).add(
+      property("errorFormat", namedType("ErrorFormat")).optional().setDocComment(docComment('@default "colorless"'))
+    ).add(
+      property("log", array(unionType([namedType("LogLevel"), namedType("LogDefinition")]))).optional().setDocComment(docComment`
+             @example
+             \`\`\`
+             // Defaults to stdout
+             log: ['query', 'info', 'warn', 'error']
 
-type __Either<O extends object, K extends Key> = Omit<O, K> &
-  {
-    // Merge all but K
-    [P in K]: Prisma__Pick<O, P & keyof O> // With K possibilities
-  }[K]
+             // Emit as events
+             log: [
+               { emit: 'stdout', level: 'query' },
+               { emit: 'stdout', level: 'info' },
+               { emit: 'stdout', level: 'warn' }
+               { emit: 'stdout', level: 'error' }
+             ]
+             \`\`\`
+             Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/logging#the-log-option).
+          `)
+    );
+    const transactionOptions = objectType().add(property("maxWait", numberType).optional()).add(property("timeout", numberType).optional());
+    if (this.context.dmmf.hasEnumInNamespace("TransactionIsolationLevel", "prisma")) {
+      transactionOptions.add(property("isolationLevel", namedType("TransactionIsolationLevel")).optional());
+    }
+    clientOptions.add(
+      property("transactionOptions", transactionOptions).optional().setDocComment(docComment`
+             The default values for transactionOptions
+             maxWait ?= 2000
+             timeout ?= 5000
+          `)
+    );
+    if (["library.js", "client.js"].includes(this.runtimeNameTs) && this.context.isPreviewFeatureOn("driverAdapters")) {
+      clientOptions.add(
+        property("adapter", unionType([namedType("runtime.DriverAdapter"), namedType("null")])).optional().setDocComment(
+          docComment("Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-planetscale`")
+        )
+      );
+    }
+    clientOptions.add(
+      property("omit", namedType("GlobalOmitConfig")).optional().setDocComment(docComment`
+        Global configuration for omitting model fields by default.
 
-type EitherStrict<O extends object, K extends Key> = Strict<__Either<O, K>>
+        @example
+        \`\`\`
+        const prisma = new PrismaClient({
+          omit: {
+            user: {
+              password: true
+            }
+          }
+        })
+        \`\`\`
+      `)
+    );
+    return clientOptions;
+  }
+};
 
-type EitherLoose<O extends object, K extends Key> = ComputeRaw<__Either<O, K>>
+// src/generation/TSClient/ClientFile.ts
+function createClientFile(context, options) {
+  const prismaClientClass = new PrismaClientClass(
+    context,
+    options.datasources,
+    options.outputDir,
+    options.runtimeNameTs,
+    options.browser
+  );
+  return `import * as runtime from '${context.runtimeJsPath}'
+import $Utils = runtime.Types.Utils
+import $Extensions = runtime.Types.Extensions
 
-type _Either<
-  O extends object,
-  K extends Key,
-  strict extends Boolean
-> = {
-  1: EitherStrict<O, K>
-  0: EitherLoose<O, K>
-}[strict]
+import type * as Prisma from './common'
+  
+${prismaClientClass.toTSWithoutNamespace()}
+`;
+}
 
-type Either<
-  O extends object,
-  K extends Key,
-  strict extends Boolean = 1
-> = O extends unknown ? _Either<O, K, strict> : never
+// src/generation/TSClient/common.ts
+var import_indent_string6 = __toESM(require_indent_string());
+var commonCodeJS = ({
+  runtimeBase,
+  runtimeNameJs,
+  browser,
+  clientVersion: clientVersion2,
+  engineVersion,
+  generator,
+  deno
+}) => `${deno ? "const exports = {}" : ""}
+Object.defineProperty(exports, "__esModule", { value: true });
+${deno ? `
+import {
+  PrismaClientKnownRequestError,
+  PrismaClientUnknownRequestError,
+  PrismaClientRustPanicError,
+  PrismaClientInitializationError,
+  PrismaClientValidationError,
+  getPrismaClient,
+  sqltag,
+  empty,
+  join,
+  raw,
+  Decimal,
+  Debug,
+  objectEnumValues,
+  makeStrictEnum,
+  Extensions,
+  defineDmmfProperty,
+  Public,
+  getRuntime,
+  skip
+} from '${runtimeBase}/${runtimeNameJs}.js'` : browser ? `
+const {
+  Decimal,
+  objectEnumValues,
+  makeStrictEnum,
+  Public,
+  getRuntime,
+  skip
+} = require('${runtimeBase}/${runtimeNameJs}.js')
+` : `
+const {
+  PrismaClientKnownRequestError,
+  PrismaClientUnknownRequestError,
+  PrismaClientRustPanicError,
+  PrismaClientInitializationError,
+  PrismaClientValidationError,
+  getPrismaClient,
+  sqltag,
+  empty,
+  join,
+  raw,
+  skip,
+  Decimal,
+  Debug,
+  objectEnumValues,
+  makeStrictEnum,
+  Extensions,
+  warnOnce,
+  defineDmmfProperty,
+  Public,
+  getRuntime,
+  createParam,
+} = require('${runtimeBase}/${runtimeNameJs}.js')
+`}
 
-export type Union = any
+const Prisma = {}
 
-type PatchUndefined<O extends object, O1 extends object> = {
-  [K in keyof O]: O[K] extends undefined ? At<O1, K> : O[K]
-} & {}
+exports.Prisma = Prisma
+exports.$Enums = {}
 
-/** Helper Types for "Merge" **/
-export type IntersectOf<U extends Union> = (
-  U extends unknown ? (k: U) => void : never
-) extends (k: infer I) => void
-  ? I
-  : never
+/**
+ * Prisma Client JS version: ${clientVersion2}
+ * Query Engine version: ${engineVersion}
+ */
+Prisma.prismaVersion = {
+  client: "${clientVersion2}",
+  engine: "${engineVersion}"
+}
 
-export type Overwrite<O extends object, O1 extends object> = {
-    [K in keyof O]: K extends keyof O1 ? O1[K] : O[K];
-} & {};
+Prisma.PrismaClientKnownRequestError = ${notSupportOnBrowser("PrismaClientKnownRequestError", browser)};
+Prisma.PrismaClientUnknownRequestError = ${notSupportOnBrowser("PrismaClientUnknownRequestError", browser)}
+Prisma.PrismaClientRustPanicError = ${notSupportOnBrowser("PrismaClientRustPanicError", browser)}
+Prisma.PrismaClientInitializationError = ${notSupportOnBrowser("PrismaClientInitializationError", browser)}
+Prisma.PrismaClientValidationError = ${notSupportOnBrowser("PrismaClientValidationError", browser)}
+Prisma.Decimal = Decimal
 
-type _Merge<U extends object> = IntersectOf<Overwrite<U, {
-    [K in keyof U]-?: At<U, K>;
-}>>;
+/**
+ * Re-export of sql-template-tag
+ */
+Prisma.sql = ${notSupportOnBrowser("sqltag", browser)}
+Prisma.empty = ${notSupportOnBrowser("empty", browser)}
+Prisma.join = ${notSupportOnBrowser("join", browser)}
+Prisma.raw = ${notSupportOnBrowser("raw", browser)}
+Prisma.validator = Public.validator
 
-type Key = string | number | symbol;
-type AtBasic<O extends object, K extends Key> = K extends keyof O ? O[K] : never;
-type AtStrict<O extends object, K extends Key> = O[K & keyof O];
-type AtLoose<O extends object, K extends Key> = O extends unknown ? AtStrict<O, K> : never;
-export type At<O extends object, K extends Key, strict extends Boolean = 1> = {
-    1: AtStrict<O, K>;
-    0: AtLoose<O, K>;
-}[strict];
+/**
+* Extensions
+*/
+Prisma.getExtensionContext = ${notSupportOnBrowser("Extensions.getExtensionContext", browser)}
+Prisma.defineExtension = ${notSupportOnBrowser("Extensions.defineExtension", browser)}
 
-export type ComputeRaw<A extends any> = A extends Function ? A : {
-  [K in keyof A]: A[K];
-} & {};
+/**
+ * Shorthand utilities for JSON filtering
+ */
+Prisma.DbNull = objectEnumValues.instances.DbNull
+Prisma.JsonNull = objectEnumValues.instances.JsonNull
+Prisma.AnyNull = objectEnumValues.instances.AnyNull
 
-export type OptionalFlat<O> = {
-  [K in keyof O]?: O[K];
-} & {};
+Prisma.NullTypes = {
+  DbNull: objectEnumValues.classes.DbNull,
+  JsonNull: objectEnumValues.classes.JsonNull,
+  AnyNull: objectEnumValues.classes.AnyNull
+}
 
-type _Record<K extends keyof any, T> = {
-  [P in K]: T;
+${buildPrismaSkipJs(generator.previewFeatures)}
+`;
+var notSupportOnBrowser = (fnc, browser) => {
+  if (browser) {
+    return `() => {
+  const runtimeName = getRuntime().prettyName;
+  throw new Error(\`${fnc} is unable to run in this browser environment, or has been bundled for the browser (running in \${runtimeName}).
+In case this error is unexpected for you, please report it in https://pris.ly/prisma-prisma-bug-report\`,
+)}`;
+  }
+  return fnc;
 };
+var commonCodeTS = ({ clientVersion: clientVersion2, engineVersion, generator }) => ({
+  ts: () => `export import DMMF = runtime.DMMF
 
-// cause typescript not to expand types and preserve names
-type NoExpand<T> = T extends unknown ? T : never;
+export type PrismaPromise<T> = $Public.PrismaPromise<T>
 
-// this type assumes the passed object is entirely optional
-type AtLeast<O extends object, K extends string> = NoExpand<
-  O extends unknown
-  ? | (K extends keyof O ? { [P in K]: O[P] } & O : O)
-    | {[P in keyof O as P extends K ? K : never]-?: O[P]} & O
-  : never>;
+/**
+ * Validator
+ */
+export import validator = runtime.Public.validator
 
-type _Strict<U, _U = U> = U extends unknown ? U & OptionalFlat<_Record<Exclude<Keys<_U>, keyof U>, never>> : never;
+/**
+ * Prisma Errors
+ */
+export import PrismaClientKnownRequestError = runtime.PrismaClientKnownRequestError
+export import PrismaClientUnknownRequestError = runtime.PrismaClientUnknownRequestError
+export import PrismaClientRustPanicError = runtime.PrismaClientRustPanicError
+export import PrismaClientInitializationError = runtime.PrismaClientInitializationError
+export import PrismaClientValidationError = runtime.PrismaClientValidationError
 
-export type Strict<U extends object> = ComputeRaw<_Strict<U>>;
-/** End Helper Types for "Merge" **/
+/**
+ * Re-export of sql-template-tag
+ */
+export import sql = runtime.sqltag
+export import empty = runtime.empty
+export import join = runtime.join
+export import raw = runtime.raw
+export import Sql = runtime.Sql
 
-export type Merge<U extends object> = ComputeRaw<_Merge<Strict<U>>>;
+${buildPrismaSkipTs(generator.previewFeatures)}
 
 /**
-A [[Boolean]]
-*/
-export type Boolean = True | False
+ * Decimal.js
+ */
+export import Decimal = runtime.Decimal
 
-// /**
-// 1
-// */
-export type True = 1
+export type DecimalJsLike = runtime.DecimalJsLike
 
 /**
-0
-*/
-export type False = 0
-
-export type Not<B extends Boolean> = {
-  0: 1
-  1: 0
-}[B]
+ * Metrics
+ */
+export type Metrics = runtime.Metrics
+export type Metric<T> = runtime.Metric<T>
+export type MetricHistogram = runtime.MetricHistogram
+export type MetricHistogramBucket = runtime.MetricHistogramBucket
 
-export type Extends<A1 extends any, A2 extends any> = [A1] extends [never]
-  ? 0 // anything \`never\` is false
-  : A1 extends A2
-  ? 1
-  : 0
+/**
+* Extensions
+*/
+export import Extension = $Extensions.UserArgs
+export import getExtensionContext = runtime.Extensions.getExtensionContext
+export import Args = $Public.Args
+export import Payload = $Public.Payload
+export import Result = $Public.Result
+export import Exact = $Public.Exact
 
-export type Has<U extends Union, U1 extends Union> = Not<
-  Extends<Exclude<U1, U>, U1>
->
+/**
+ * Prisma Client JS version: ${clientVersion2}
+ * Query Engine version: ${engineVersion}
+ */
+export type PrismaVersion = {
+  client: string
+}
 
-export type Or<B1 extends Boolean, B2 extends Boolean> = {
-  0: {
-    0: 0
-    1: 1
-  }
-  1: {
-    0: 1
-    1: 1
-  }
-}[B1][B2]
+export const prismaVersion: PrismaVersion
 
-export type Keys<U extends Union> = U extends unknown ? keyof U : never
+/**
+ * Utility Types
+ */
 
-type Cast<A, B> = A extends B ? A : B;
+/**
+ * Types of the values used to represent different kinds of \`null\` values when working with JSON fields.
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+export namespace NullTypes {
+${buildNullClass("DbNull")}
 
-export const type: unique symbol;
+${buildNullClass("JsonNull")}
 
+${buildNullClass("AnyNull")}
+}
 
+/**
+ * Helper for filtering JSON entries that have \`null\` on the database (empty on the db)
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+export const DbNull: NullTypes.DbNull
 
 /**
- * Used by group by
+ * Helper for filtering JSON entries that have JSON \`null\` values (not empty on the db)
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
  */
+export const JsonNull: NullTypes.JsonNull
 
-export type GetScalarType<T, O> = O extends object ? {
-  [P in keyof T]: P extends keyof O
-    ? O[P]
-    : never
-} : never
+/**
+ * Helper for filtering JSON entries that are \`Prisma.DbNull\` or \`Prisma.JsonNull\`
+ *
+ * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+ */
+export const AnyNull: NullTypes.AnyNull
 
-type FieldPaths<
-  T,
-  U = Omit<T, '_avg' | '_sum' | '_count' | '_min' | '_max'>
-> = IsObject<T> extends True ? U : T
+type SelectAndInclude = {
+  select: any
+  include: any
+}
 
-type GetHavingFields<T> = {
-  [K in keyof T]: Or<
-    Or<Extends<'OR', K>, Extends<'AND', K>>,
-    Extends<'NOT', K>
-  > extends True
-    ? // infer is only needed to not hit TS limit
-      // based on the brilliant idea of Pierre-Antoine Mills
-      // https://github.com/microsoft/TypeScript/issues/30188#issuecomment-478938437
-      T[K] extends infer TK
-      ? GetHavingFields<UnEnumerate<TK> extends object ? Merge<UnEnumerate<TK>> : never>
-      : never
-    : {} extends FieldPaths<T[K]>
-    ? never
-    : K
-}[keyof T]
+type SelectAndOmit = {
+  select: any
+  omit: any
+}
 
 /**
- * Convert tuple to union
+ * Get the type of the value, that the Promise holds.
  */
-type _TupleToUnion<T> = T extends (infer E)[] ? E : never
-type TupleToUnion<K extends readonly any[]> = _TupleToUnion<K>
-type MaybeTupleToUnion<T> = T extends any[] ? TupleToUnion<T> : T
+export type PromiseType<T extends PromiseLike<any>> = T extends PromiseLike<infer U> ? U : T;
 
 /**
- * Like \`Pick\`, but additionally can also accept an array of keys
+ * Get the return type of a function which returns a Promise.
  */
-type PickEnumerable<T, K extends Enumerable<keyof T> | keyof T> = Prisma__Pick<T, MaybeTupleToUnion<K>>
+export type PromiseReturnType<T extends (...args: any) => $Utils.JsPromise<any>> = PromiseType<ReturnType<T>>
 
 /**
- * Exclude all keys with underscores
+ * From T, pick a set of properties whose keys are in the union K
  */
-type ExcludeUnderscoreKeys<T extends string> = T extends \`_\${string}\` ? never : T
+type Prisma__Pick<T, K extends keyof T> = {
+    [P in K]: T[P];
+};
 
 
-export type FieldRef<Model, FieldType> = runtime.FieldRef<Model, FieldType>
+export type Enumerable<T> = T | Array<T>;
 
-type FieldRefInputType<Model, FieldType> = Model extends never ? never : FieldRef<Model, FieldType>
+export type RequiredKeys<T> = {
+  [K in keyof T]-?: {} extends Prisma__Pick<T, K> ? never : K
+}[keyof T]
 
-`
-});
-function buildNullClass(name) {
-  const source = `/**
-* Type of \`Prisma.${name}\`.
-*
-* You cannot use other instances of this class. Please use the \`Prisma.${name}\` value.
-*
-* @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
-*/
-class ${name} {
-  private ${name}: never
-  private constructor()
-}`;
-  return (0, import_indent_string4.default)(source, TAB_SIZE);
+export type TruthyKeys<T> = keyof {
+  [K in keyof T as T[K] extends false | undefined | null ? never : K]: K
 }
-function buildPrismaSkipTs(previewFeatures) {
-  if (previewFeatures.includes("strictUndefinedChecks")) {
-    return `
+
+export type TrueKeys<T> = TruthyKeys<Prisma__Pick<T, RequiredKeys<T>>>
+
 /**
- * Prisma.skip
+ * Subset
+ * @desc From \`T\` pick properties that exist in \`U\`. Simple version of Intersection
  */
-export import skip = runtime.skip
-`;
-  }
-  return "";
-}
-function buildPrismaSkipJs(previewFeatures) {
-  if (previewFeatures.includes("strictUndefinedChecks")) {
-    return `
-Prisma.skip = skip
-`;
-  }
-  return "";
-}
+export type Subset<T, U> = {
+  [key in keyof T]: key extends keyof U ? T[key] : never;
+};
+
+/**
+ * SelectSubset
+ * @desc From \`T\` pick properties that exist in \`U\`. Simple version of Intersection.
+ * Additionally, it validates, if both select and include are present. If the case, it errors.
+ */
+export type SelectSubset<T, U> = {
+  [key in keyof T]: key extends keyof U ? T[key] : never
+} &
+  (T extends SelectAndInclude
+    ? 'Please either choose \`select\` or \`include\`.'
+    : T extends SelectAndOmit
+      ? 'Please either choose \`select\` or \`omit\`.'
+      : {})
 
-// src/generation/TSClient/Count.ts
-var import_indent_string5 = __toESM(require_indent_string());
-var Count = class {
-  constructor(type, context) {
-    this.type = type;
-    this.context = context;
-  }
-  get argsTypes() {
-    const argsTypes = [];
-    argsTypes.push(
-      new ArgsTypeBuilder(this.type, this.context).addSelectArg().addIncludeArgIfHasRelations().createExport()
-    );
-    for (const field of this.type.fields) {
-      if (field.args.length > 0) {
-        argsTypes.push(
-          new ArgsTypeBuilder(this.type, this.context).addSchemaArgs(field.args).setGeneratedName(getCountArgsType(this.type.name, field.name)).createExport()
-        );
-      }
-    }
-    return argsTypes;
-  }
-  toTS() {
-    const { type } = this;
-    const { name } = type;
-    const outputType = buildOutputType(type);
-    return `
 /**
- * Count Type ${name}
+ * Subset + Intersection
+ * @desc From \`T\` pick properties that exist in \`U\` and intersect \`K\`
  */
+export type SubsetIntersection<T, U, K> = {
+  [key in keyof T]: key extends keyof U ? T[key] : never
+} &
+  K
 
-${stringify(outputType)}
+export type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };
 
-export type ${getSelectName(name)}<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
-${(0, import_indent_string5.default)(
-      type.fields.map((field) => {
-        const types = ["boolean"];
-        if (field.outputType.location === "outputObjectTypes") {
-          types.push(getFieldArgName(field, this.type.name));
-        }
-        if (field.args.length > 0) {
-          types.push(getCountArgsType(name, field.name));
-        }
-        return `${field.name}?: ${types.join(" | ")}`;
-      }).join("\n"),
-      TAB_SIZE
-    )}
-}
+/**
+ * XOR is needed to have a real mutually exclusive union type
+ * https://stackoverflow.com/questions/42123407/does-typescript-support-mutually-exclusive-types
+ */
+export type XOR<T, U> =
+  T extends object ?
+  U extends object ?
+    (Without<T, U> & U) | (Without<U, T> & T)
+  : U : T
 
-// Custom InputTypes
-${this.argsTypes.map((typeExport) => stringify(typeExport)).join("\n\n")}
-`;
-  }
-};
-function getCountArgsType(typeName, fieldName) {
-  return `${typeName}Count${capitalize2(fieldName)}Args`;
-}
 
-// src/generation/TSClient/FieldRefInput.ts
-var FieldRefInput = class {
-  constructor(type) {
-    this.type = type;
-  }
-  toTS() {
-    const allowedTypes = this.getAllowedTypes();
-    return `
 /**
- * Reference to a field of type ${allowedTypes}
+ * Is T a Record?
  */
-export type ${this.type.name}<$PrismaModel> = FieldRefInputType<$PrismaModel, ${allowedTypes}>
-    `;
-  }
-  getAllowedTypes() {
-    return this.type.allowTypes.map(getRefAllowedTypeName).join(" | ");
-  }
-};
+export type IsObject<T extends any> = T extends Array<any>
+? False
+: T extends Date
+? False
+: T extends Uint8Array
+? False
+: T extends BigInt
+? False
+: T extends object
+? True
+: False
 
-// src/generation/TSClient/GenerateContext.ts
-var GenerateContext = class {
-  constructor({ dmmf, genericArgsInfo, generator }) {
-    this.dmmf = dmmf;
-    this.genericArgsInfo = genericArgsInfo;
-    this.generator = generator;
-  }
-  isPreviewFeatureOn(previewFeature) {
-    return this.generator?.previewFeatures?.includes(previewFeature) ?? false;
-  }
-};
 
-// src/generation/TSClient/PrismaClient.ts
-var import_indent_string7 = __toESM(require_indent_string());
+/**
+ * If it's T[], return T
+ */
+export type UnEnumerate<T extends unknown> = T extends Array<infer U> ? U : T
 
-// src/generation/utils/runtimeImport.ts
-function runtimeImport(name) {
-  return name;
-}
-function runtimeImportedType(name) {
-  return namedType(`runtime.${name}`);
-}
+/**
+ * From ts-toolbelt
+ */
 
-// src/generation/TSClient/Datasources.ts
-var import_indent_string6 = __toESM(require_indent_string());
-var Datasources = class {
-  constructor(internalDatasources) {
-    this.internalDatasources = internalDatasources;
-  }
-  toTS() {
-    const sources = this.internalDatasources;
-    return `export type Datasources = {
-${(0, import_indent_string6.default)(sources.map((s) => `${s.name}?: Datasource`).join("\n"), 2)}
-}`;
-  }
-};
+type __Either<O extends object, K extends Key> = Omit<O, K> &
+  {
+    // Merge all but K
+    [P in K]: Prisma__Pick<O, P & keyof O> // With K possibilities
+  }[K]
 
-// src/generation/TSClient/globalOmit.ts
-function globalOmitConfig(dmmf) {
-  const objectType2 = objectType().addMultiple(
-    dmmf.datamodel.models.map((model) => {
-      const type = namedType(getOmitName(model.name));
-      return property(lowerCase(model.name), type).optional();
-    })
-  );
-  return moduleExport(typeDeclaration("GlobalOmitConfig", objectType2));
-}
+type EitherStrict<O extends object, K extends Key> = Strict<__Either<O, K>>
 
-// src/generation/TSClient/PrismaClient.ts
-function clientTypeMapModelsDefinition(context) {
-  const meta = objectType();
-  const modelNames = context.dmmf.datamodel.models.map((m) => m.name);
-  if (modelNames.length === 0) {
-    meta.add(property("modelProps", neverType));
-  } else {
-    meta.add(property("modelProps", unionType(modelNames.map((name) => stringLiteral(lowerCase(name))))));
-  }
-  const isolationLevel = context.dmmf.hasEnumInNamespace("TransactionIsolationLevel", "prisma") ? namedType("Prisma.TransactionIsolationLevel") : neverType;
-  meta.add(property("txIsolationLevel", isolationLevel));
-  const model = objectType();
-  model.addMultiple(
-    modelNames.map((modelName) => {
-      const entry = objectType();
-      entry.add(
-        property("payload", namedType(getPayloadName(modelName)).addGenericArgument(extArgsParam.toArgument()))
-      );
-      entry.add(property("fields", namedType(`Prisma.${getFieldRefsTypeName(modelName)}`)));
-      const actions = getModelActions(context.dmmf, modelName);
-      const operations = objectType();
-      operations.addMultiple(
-        actions.map((action) => {
-          const operationType = objectType();
-          const argsType = `Prisma.${getModelArgName(modelName, action)}`;
-          operationType.add(property("args", namedType(argsType).addGenericArgument(extArgsParam.toArgument())));
-          operationType.add(property("result", clientTypeMapModelsResultDefinition(modelName, action)));
-          return property(action, operationType);
-        })
-      );
-      entry.add(property("operations", operations));
-      return property(modelName, entry);
-    })
-  );
-  return objectType().add(property("meta", meta)).add(property("model", model));
-}
-function clientTypeMapModelsResultDefinition(modelName, action) {
-  if (action === "count")
-    return unionType([optional(namedType(getCountAggregateOutputName(modelName))), numberType]);
-  if (action === "groupBy") return array(optional(namedType(getGroupByName(modelName))));
-  if (action === "aggregate") return optional(namedType(getAggregateName(modelName)));
-  if (action === "findRaw") return namedType("JsonObject");
-  if (action === "aggregateRaw") return namedType("JsonObject");
-  if (action === "deleteMany") return namedType("BatchPayload");
-  if (action === "createMany") return namedType("BatchPayload");
-  if (action === "createManyAndReturn") return array(payloadToResult(modelName));
-  if (action === "updateMany") return namedType("BatchPayload");
-  if (action === "updateManyAndReturn") return array(payloadToResult(modelName));
-  if (action === "findMany") return array(payloadToResult(modelName));
-  if (action === "findFirst") return unionType([payloadToResult(modelName), nullType]);
-  if (action === "findUnique") return unionType([payloadToResult(modelName), nullType]);
-  if (action === "findFirstOrThrow") return payloadToResult(modelName);
-  if (action === "findUniqueOrThrow") return payloadToResult(modelName);
-  if (action === "create") return payloadToResult(modelName);
-  if (action === "update") return payloadToResult(modelName);
-  if (action === "upsert") return payloadToResult(modelName);
-  if (action === "delete") return payloadToResult(modelName);
-  assertNever(action, `Unknown action: ${action}`);
-}
-function payloadToResult(modelName) {
-  return namedType("$Utils.PayloadToResult").addGenericArgument(namedType(getPayloadName(modelName)));
-}
-function clientTypeMapOthersDefinition(context) {
-  const otherOperationsNames = context.dmmf.getOtherOperationNames().flatMap((name) => {
-    const results = [`$${name}`];
-    if (name === "executeRaw" || name === "queryRaw") {
-      results.push(`$${name}Unsafe`);
-    }
-    if (name === "queryRaw" && context.isPreviewFeatureOn("typedSql")) {
-      results.push(`$queryRawTyped`);
-    }
-    return results;
-  });
-  const argsResultMap = {
-    $executeRaw: { args: "[query: TemplateStringsArray | Prisma.Sql, ...values: any[]]", result: "any" },
-    $queryRaw: { args: "[query: TemplateStringsArray | Prisma.Sql, ...values: any[]]", result: "any" },
-    $executeRawUnsafe: { args: "[query: string, ...values: any[]]", result: "any" },
-    $queryRawUnsafe: { args: "[query: string, ...values: any[]]", result: "any" },
-    $runCommandRaw: { args: "Prisma.InputJsonObject", result: "Prisma.JsonObject" },
-    $queryRawTyped: { args: "runtime.UnknownTypedSql", result: "Prisma.JsonObject" }
-  };
-  return `{
-  other: {
-    payload: any
-    operations: {${otherOperationsNames.reduce((acc, action) => {
-    return `${acc}
-      ${action}: {
-        args: ${argsResultMap[action].args},
-        result: ${argsResultMap[action].result}
-      }`;
-  }, "")}
-    }
-  }
-}`;
-}
-function clientTypeMapDefinition(context) {
-  const typeMap = `${stringify(clientTypeMapModelsDefinition(context))} & ${clientTypeMapOthersDefinition(context)}`;
-  return `
-interface TypeMapCb extends $Utils.Fn<{extArgs: $Extensions.InternalArgs, clientOptions: PrismaClientOptions }, $Utils.Record<string, any>> {
-  returns: Prisma.TypeMap<this['params']['extArgs'], this['params']['clientOptions']>
-}
+type EitherLoose<O extends object, K extends Key> = ComputeRaw<__Either<O, K>>
+
+type _Either<
+  O extends object,
+  K extends Key,
+  strict extends Boolean
+> = {
+  1: EitherStrict<O, K>
+  0: EitherLoose<O, K>
+}[strict]
+
+export type Either<
+  O extends object,
+  K extends Key,
+  strict extends Boolean = 1
+> = O extends unknown ? _Either<O, K, strict> : never
+
+export type Union = any
+
+export type PatchUndefined<O extends object, O1 extends object> = {
+  [K in keyof O]: O[K] extends undefined ? At<O1, K> : O[K]
+} & {}
+
+/** Helper Types for "Merge" **/
+export type IntersectOf<U extends Union> = (
+  U extends unknown ? (k: U) => void : never
+) extends (k: infer I) => void
+  ? I
+  : never
+
+export type Overwrite<O extends object, O1 extends object> = {
+    [K in keyof O]: K extends keyof O1 ? O1[K] : O[K];
+} & {};
+
+type _Merge<U extends object> = IntersectOf<Overwrite<U, {
+    [K in keyof U]-?: At<U, K>;
+}>>;
+
+type Key = string | number | symbol;
+type AtBasic<O extends object, K extends Key> = K extends keyof O ? O[K] : never;
+type AtStrict<O extends object, K extends Key> = O[K & keyof O];
+type AtLoose<O extends object, K extends Key> = O extends unknown ? AtStrict<O, K> : never;
+export type At<O extends object, K extends Key, strict extends Boolean = 1> = {
+    1: AtStrict<O, K>;
+    0: AtLoose<O, K>;
+}[strict];
 
-export type TypeMap<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, ClientOptions = {}> = ${typeMap}`;
-}
-function clientExtensionsDefinitions(context) {
-  const typeMap = clientTypeMapDefinition(context);
-  const define2 = moduleExport(
-    constDeclaration(
-      "defineExtension",
-      namedType("$Extensions.ExtendsHook").addGenericArgument(stringLiteral("define")).addGenericArgument(namedType("Prisma.TypeMapCb")).addGenericArgument(namedType("$Extensions.DefaultArgs"))
-    )
-  );
-  return [typeMap, stringify(define2)].join("\n");
-}
-function extendsPropertyDefinition() {
-  const extendsDefinition = namedType("$Extensions.ExtendsHook").addGenericArgument(stringLiteral("extends")).addGenericArgument(namedType("Prisma.TypeMapCb")).addGenericArgument(namedType("ExtArgs")).addGenericArgument(
-    namedType("$Utils.Call").addGenericArgument(namedType("Prisma.TypeMapCb")).addGenericArgument(objectType().add(property("extArgs", namedType("ExtArgs"))))
-  ).addGenericArgument(namedType("ClientOptions"));
-  return stringify(property("$extends", extendsDefinition), { indentLevel: 1 });
-}
-function batchingTransactionDefinition(context) {
-  const method2 = method("$transaction").setDocComment(
-    docComment`
-        Allows the running of a sequence of read/write operations that are guaranteed to either succeed or fail as a whole.
-        @example
-        \`\`\`
-        const [george, bob, alice] = await prisma.$transaction([
-          prisma.user.create({ data: { name: 'George' } }),
-          prisma.user.create({ data: { name: 'Bob' } }),
-          prisma.user.create({ data: { name: 'Alice' } }),
-        ])
-        \`\`\`
+export type ComputeRaw<A extends any> = A extends Function ? A : {
+  [K in keyof A]: A[K];
+} & {};
 
-        Read more in our [docs](https://www.prisma.io/docs/concepts/components/prisma-client/transactions).
-      `
-  ).addGenericParameter(genericParameter("P").extends(array(prismaPromise(anyType)))).addParameter(parameter("arg", arraySpread(namedType("P")))).setReturnType(promise(namedType("runtime.Types.Utils.UnwrapTuple").addGenericArgument(namedType("P"))));
-  if (context.dmmf.hasEnumInNamespace("TransactionIsolationLevel", "prisma")) {
-    const options = objectType().formatInline().add(property("isolationLevel", namedType("Prisma.TransactionIsolationLevel")).optional());
-    method2.addParameter(parameter("options", options).optional());
-  }
-  return stringify(method2, { indentLevel: 1, newLine: "leading" });
-}
-function interactiveTransactionDefinition(context) {
-  const options = objectType().formatInline().add(property("maxWait", numberType).optional()).add(property("timeout", numberType).optional());
-  if (context.dmmf.hasEnumInNamespace("TransactionIsolationLevel", "prisma")) {
-    const isolationLevel = property("isolationLevel", namedType("Prisma.TransactionIsolationLevel")).optional();
-    options.add(isolationLevel);
-  }
-  const returnType = promise(namedType("R"));
-  const callbackType = functionType().addParameter(
-    parameter("prisma", omit(namedType("PrismaClient"), namedType("runtime.ITXClientDenyList")))
-  ).setReturnType(returnType);
-  const method2 = method("$transaction").addGenericParameter(genericParameter("R")).addParameter(parameter("fn", callbackType)).addParameter(parameter("options", options).optional()).setReturnType(returnType);
-  return stringify(method2, { indentLevel: 1, newLine: "leading" });
-}
-function queryRawDefinition(context) {
-  if (!context.dmmf.mappings.otherOperations.write.includes("queryRaw")) {
-    return "";
-  }
-  return `
-  /**
-   * Performs a prepared raw query and returns the \`SELECT\` data.
-   * @example
-   * \`\`\`
-   * const result = await prisma.$queryRaw\`SELECT * FROM User WHERE id = \${1} OR email = \${'user@email.com'};\`
-   * \`\`\`
-   *
-   * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
-   */
-  $queryRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<T>;
+export type OptionalFlat<O> = {
+  [K in keyof O]?: O[K];
+} & {};
 
-  /**
-   * Performs a raw query and returns the \`SELECT\` data.
-   * Susceptible to SQL injections, see documentation.
-   * @example
-   * \`\`\`
-   * const result = await prisma.$queryRawUnsafe('SELECT * FROM User WHERE id = $1 OR email = $2;', 1, 'user@email.com')
-   * \`\`\`
-   *
-   * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
-   */
-  $queryRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<T>;`;
-}
-function executeRawDefinition(context) {
-  if (!context.dmmf.mappings.otherOperations.write.includes("executeRaw")) {
-    return "";
-  }
-  return `
-  /**
-   * Executes a prepared raw query and returns the number of affected rows.
-   * @example
-   * \`\`\`
-   * const result = await prisma.$executeRaw\`UPDATE User SET cool = \${true} WHERE email = \${'user@email.com'};\`
-   * \`\`\`
-   *
-   * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
-   */
-  $executeRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<number>;
+type _Record<K extends keyof any, T> = {
+  [P in K]: T;
+};
 
-  /**
-   * Executes a raw query and returns the number of affected rows.
-   * Susceptible to SQL injections, see documentation.
-   * @example
-   * \`\`\`
-   * const result = await prisma.$executeRawUnsafe('UPDATE User SET cool = $1 WHERE email = $2 ;', true, 'user@email.com')
-   * \`\`\`
-   *
-   * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
-   */
-  $executeRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<number>;`;
-}
-function queryRawTypedDefinition(context) {
-  if (!context.isPreviewFeatureOn("typedSql")) {
-    return "";
+// cause typescript not to expand types and preserve names
+type NoExpand<T> = T extends unknown ? T : never;
+
+// this type assumes the passed object is entirely optional
+export type AtLeast<O extends object, K extends string> = NoExpand<
+  O extends unknown
+  ? | (K extends keyof O ? { [P in K]: O[P] } & O : O)
+    | {[P in keyof O as P extends K ? K : never]-?: O[P]} & O
+  : never>;
+
+type _Strict<U, _U = U> = U extends unknown ? U & OptionalFlat<_Record<Exclude<Keys<_U>, keyof U>, never>> : never;
+
+export type Strict<U extends object> = ComputeRaw<_Strict<U>>;
+/** End Helper Types for "Merge" **/
+
+export type Merge<U extends object> = ComputeRaw<_Merge<Strict<U>>>;
+
+/**
+A [[Boolean]]
+*/
+export type Boolean = True | False
+
+// /**
+// 1
+// */
+export type True = 1
+
+/**
+0
+*/
+export type False = 0
+
+export type Not<B extends Boolean> = {
+  0: 1
+  1: 0
+}[B]
+
+export type Extends<A1 extends any, A2 extends any> = [A1] extends [never]
+  ? 0 // anything \`never\` is false
+  : A1 extends A2
+  ? 1
+  : 0
+
+export type Has<U extends Union, U1 extends Union> = Not<
+  Extends<Exclude<U1, U>, U1>
+>
+
+export type Or<B1 extends Boolean, B2 extends Boolean> = {
+  0: {
+    0: 0
+    1: 1
   }
-  if (!context.dmmf.mappings.otherOperations.write.includes("queryRaw")) {
-    return "";
+  1: {
+    0: 1
+    1: 1
   }
-  const param = genericParameter("T");
-  const method2 = method("$queryRawTyped").setDocComment(
-    docComment`
-        Executes a typed SQL query and returns a typed result
-        @example
-        \`\`\`
-        import { myQuery } from '@prisma/client/sql'
+}[B1][B2]
 
-        const result = await prisma.$queryRawTyped(myQuery())
-        \`\`\`
-      `
-  ).addGenericParameter(param).addParameter(
-    parameter(
-      "typedSql",
-      runtimeImportedType("TypedSql").addGenericArgument(array(unknownType)).addGenericArgument(param.toArgument())
-    )
-  ).setReturnType(prismaPromise(array(param.toArgument())));
-  return stringify(method2, { indentLevel: 1, newLine: "leading" });
-}
-function metricDefinition(context) {
-  if (!context.isPreviewFeatureOn("metrics")) {
-    return "";
-  }
-  const property2 = property("$metrics", namedType(`runtime.${runtimeImport("MetricsClient")}`)).setDocComment(
-    docComment`
-        Gives access to the client metrics in json or prometheus format.
+export type Keys<U extends Union> = U extends unknown ? keyof U : never
 
-        @example
-        \`\`\`
-        const metrics = await prisma.$metrics.json()
-        // or
-        const metrics = await prisma.$metrics.prometheus()
-        \`\`\`
-    `
-  ).readonly();
-  return stringify(property2, { indentLevel: 1, newLine: "leading" });
-}
-function runCommandRawDefinition(context) {
-  if (!context.dmmf.mappings.otherOperations.write.includes("runCommandRaw")) {
-    return "";
-  }
-  const method2 = method("$runCommandRaw").addParameter(parameter("command", namedType("Prisma.InputJsonObject"))).setReturnType(prismaPromise(namedType("Prisma.JsonObject"))).setDocComment(docComment`
-      Executes a raw MongoDB command and returns the result of it.
-      @example
-      \`\`\`
-      const user = await prisma.$runCommandRaw({
-        aggregate: 'User',
-        pipeline: [{ $match: { name: 'Bob' } }, { $project: { email: true, _id: false } }],
-        explain: false,
-      })
-      \`\`\`
+type Cast<A, B> = A extends B ? A : B;
+
+export const type: unique symbol;
+
+
+
+/**
+ * Used by group by
+ */
+
+export type GetScalarType<T, O> = O extends object ? {
+  [P in keyof T]: P extends keyof O
+    ? O[P]
+    : never
+} : never
+
+type FieldPaths<
+  T,
+  U = Omit<T, '_avg' | '_sum' | '_count' | '_min' | '_max'>
+> = IsObject<T> extends True ? U : T
+
+export type GetHavingFields<T> = {
+  [K in keyof T]: Or<
+    Or<Extends<'OR', K>, Extends<'AND', K>>,
+    Extends<'NOT', K>
+  > extends True
+    ? // infer is only needed to not hit TS limit
+      // based on the brilliant idea of Pierre-Antoine Mills
+      // https://github.com/microsoft/TypeScript/issues/30188#issuecomment-478938437
+      T[K] extends infer TK
+      ? GetHavingFields<UnEnumerate<TK> extends object ? Merge<UnEnumerate<TK>> : never>
+      : never
+    : {} extends FieldPaths<T[K]>
+    ? never
+    : K
+}[keyof T]
 
-      Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
-    `);
-  return stringify(method2, { indentLevel: 1, newLine: "leading" });
+/**
+ * Convert tuple to union
+ */
+type _TupleToUnion<T> = T extends (infer E)[] ? E : never
+type TupleToUnion<K extends readonly any[]> = _TupleToUnion<K>
+export type MaybeTupleToUnion<T> = T extends any[] ? TupleToUnion<T> : T
+
+/**
+ * Like \`Pick\`, but additionally can also accept an array of keys
+ */
+export type PickEnumerable<T, K extends Enumerable<keyof T> | keyof T> = Prisma__Pick<T, MaybeTupleToUnion<K>>
+
+/**
+ * Exclude all keys with underscores
+ */
+export type ExcludeUnderscoreKeys<T extends string> = T extends \`_\${string}\` ? never : T
+
+
+export type FieldRef<Model, FieldType> = runtime.FieldRef<Model, FieldType>
+
+type FieldRefInputType<Model, FieldType> = Model extends never ? never : FieldRef<Model, FieldType>
+
+`
+});
+function buildNullClass(name) {
+  const source = `/**
+* Type of \`Prisma.${name}\`.
+*
+* You cannot use other instances of this class. Please use the \`Prisma.${name}\` value.
+*
+* @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field
+*/
+class ${name} {
+  private ${name}: never
+  private constructor()
+}`;
+  return (0, import_indent_string6.default)(source, TAB_SIZE);
 }
-function applyPendingMigrationsDefinition() {
-  if (this.runtimeNameTs !== "react-native") {
-    return null;
+function buildPrismaSkipTs(previewFeatures) {
+  if (previewFeatures.includes("strictUndefinedChecks")) {
+    return `
+/**
+ * Prisma.skip
+ */
+export import skip = runtime.skip
+`;
   }
-  const method2 = method("$applyPendingMigrations").setReturnType(promise(voidType)).setDocComment(
-    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 stringify(method2, { indentLevel: 1, newLine: "leading" });
+  return "";
 }
-function eventRegistrationMethodDeclaration(runtimeNameTs) {
-  if (runtimeNameTs === "binary.js") {
-    return `$on<V extends (U | 'beforeExit')>(eventType: V, callback: (event: V extends 'query' ? Prisma.QueryEvent : V extends 'beforeExit' ? () => $Utils.JsPromise<void> : Prisma.LogEvent) => void): void;`;
-  } else {
-    return `$on<V extends U>(eventType: V, callback: (event: V extends 'query' ? Prisma.QueryEvent : Prisma.LogEvent) => void): void;`;
+function buildPrismaSkipJs(previewFeatures) {
+  if (previewFeatures.includes("strictUndefinedChecks")) {
+    return `
+Prisma.skip = skip
+`;
   }
+  return "";
 }
-var PrismaClientClass = class {
-  constructor(context, internalDatasources, outputDir, runtimeNameTs, browser) {
-    this.context = context;
-    this.internalDatasources = internalDatasources;
-    this.outputDir = outputDir;
-    this.runtimeNameTs = runtimeNameTs;
-    this.browser = browser;
+
+// src/generation/TSClient/FieldRefInput.ts
+var FieldRefInput = class {
+  constructor(type) {
+    this.type = type;
   }
-  get jsDoc() {
-    const { dmmf } = this.context;
-    let example;
-    if (dmmf.mappings.modelOperations.length) {
-      example = dmmf.mappings.modelOperations[0];
-    } else {
-      example = {
-        model: "User",
-        plural: "users"
-      };
-    }
-    return `/**
- * ##  Prisma Client \u02B2\u02E2
- *
- * Type-safe database client for TypeScript & Node.js
- * @example
- * \`\`\`
- * const prisma = new PrismaClient()
- * // Fetch zero or more ${capitalize2(example.plural)}
- * const ${lowerCase(example.plural)} = await prisma.${lowerCase(example.model)}.findMany()
- * \`\`\`
- *
- *
- * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client).
- */`;
+  toTS() {
+    const allowedTypes = this.getAllowedTypes();
+    return `
+/**
+ * Reference to a field of type ${allowedTypes}
+ */
+export type ${this.type.name}<$PrismaModel> = FieldRefInputType<$PrismaModel, ${allowedTypes}>
+    `;
   }
-  toTSWithoutNamespace() {
-    const { dmmf } = this.context;
-    return `${this.jsDoc}
-export class PrismaClient<
-  ClientOptions extends Prisma.PrismaClientOptions = Prisma.PrismaClientOptions,
-  U = 'log' extends keyof ClientOptions ? ClientOptions['log'] extends Array<Prisma.LogLevel | Prisma.LogDefinition> ? Prisma.GetEvents<ClientOptions['log']> : never : never,
-  ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs
-> {
-  [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['other'] }
-
-  ${(0, import_indent_string7.default)(this.jsDoc, TAB_SIZE)}
-
-  constructor(optionsArg ?: Prisma.Subset<ClientOptions, Prisma.PrismaClientOptions>);
-  ${eventRegistrationMethodDeclaration(this.runtimeNameTs)}
+  getAllowedTypes() {
+    return this.type.allowTypes.map(getRefAllowedTypeName).join(" | ");
+  }
+};
 
-  /**
-   * Connect with the database
-   */
-  $connect(): $Utils.JsPromise<void>;
+// src/generation/TSClient/CommonFile.ts
+function createCommonFile(context, options) {
+  const prismaClientClass = new PrismaClientClass(
+    context,
+    options.datasources,
+    options.outputDir,
+    options.runtimeNameTs,
+    options.browser
+  );
+  const commonCode = commonCodeTS(options);
+  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 `
+import * as runtime from '${context.runtimeJsPath}';
+import $Types = runtime.Types // general types
+import $Public = runtime.Types.Public
+import $Utils = runtime.Types.Utils
+import $Extensions = runtime.Types.Extensions
+import $Result = runtime.Types.Result
 
-  /**
-   * Disconnect from the database
-   */
-  $disconnect(): $Utils.JsPromise<void>;
+import type * as Prisma from './models';
+import type { PrismaClient } from './client';
 
-  /**
-   * Add a middleware
-   * @deprecated since 4.16.0. For new code, prefer client extensions instead.
-   * @see https://pris.ly/d/extensions
-   */
-  $use(cb: Prisma.Middleware): void
+export type * from './models';
+    
+${commonCode.ts()}
+${new Enum(
+    {
+      name: "ModelName",
+      values: context.dmmf.mappings.modelOperations.map((m) => m.model)
+    },
+    true
+  ).toTS()}
 
-${[
-      executeRawDefinition(this.context),
-      queryRawDefinition(this.context),
-      queryRawTypedDefinition(this.context),
-      batchingTransactionDefinition(this.context),
-      interactiveTransactionDefinition(this.context),
-      runCommandRawDefinition(this.context),
-      metricDefinition(this.context),
-      applyPendingMigrationsDefinition.bind(this)(),
-      extendsPropertyDefinition()
-    ].filter((d) => d !== null).join("\n").trim()}
+${prismaClientClass.toTS()}
+export type Datasource = {
+  url?: string
+}
 
-    ${(0, import_indent_string7.default)(
-      dmmf.mappings.modelOperations.filter((m) => m.findMany).map((m) => {
-        let methodName = lowerCase(m.model);
-        if (methodName === "constructor") {
-          methodName = '["constructor"]';
-        }
-        const generics = ["ExtArgs", "ClientOptions"];
-        return `/**
- * \`prisma.${methodName}\`: Exposes CRUD operations for the **${m.model}** model.
-  * Example usage:
-  * \`\`\`ts
-  * // Fetch zero or more ${capitalize2(m.plural)}
-  * const ${lowerCase(m.plural)} = await prisma.${methodName}.findMany()
-  * \`\`\`
-  */
-get ${methodName}(): Prisma.${m.model}Delegate<${generics.join(", ")}>;`;
-      }).join("\n\n"),
-      2
-    )}
-}`;
-  }
-  toTS() {
-    const clientOptions = this.buildClientOptions();
-    return `${new Datasources(this.internalDatasources).toTS()}
-${clientExtensionsDefinitions(this.context)}
-export type DefaultPrismaClient = PrismaClient
-export type ErrorFormat = 'pretty' | 'colorless' | 'minimal'
-${stringify(moduleExport(clientOptions))}
-${stringify(globalOmitConfig(this.context.dmmf))}
+/**
+ * Enums
+ */
 
-/* Types for Logging */
-export type LogLevel = 'info' | 'query' | 'warn' | 'error'
-export type LogDefinition = {
-  level: LogLevel
-  emit: 'stdout' | 'event'
-}
+${prismaEnums?.join("\n\n")}
 
-export type GetLogType<T extends LogLevel | LogDefinition> = T extends LogDefinition ? T['emit'] extends 'event' ? T['level'] : never : never
-export type GetEvents<T extends any> = T extends Array<LogLevel | LogDefinition> ?
-  GetLogType<T[0]> | GetLogType<T[1]> | GetLogType<T[2]> | GetLogType<T[3]>
-  : never
+${fieldRefs.length > 0 ? `
+/**
+ * Field references 
+ */
 
-export type QueryEvent = {
-  timestamp: Date
-  query: string
-  params: string
-  duration: number
-  target: string
-}
+${fieldRefs.join("\n\n")}` : ""}
+/**
+ * Deep Input Types
+ */
 
-export type LogEvent = {
-  timestamp: Date
-  message: string
-  target: string
-}
-/* End Types for Logging */
+${context.dmmf.inputObjectTypes.model?.map((inputType) => new InputType(inputType, context).toTS()).join("\n") ?? ""}
 
+/**
+ * Batch Payload for updateMany & deleteMany & createMany
+ */
 
-export type PrismaAction =
-  | 'findUnique'
-  | 'findUniqueOrThrow'
-  | 'findMany'
-  | 'findFirst'
-  | 'findFirstOrThrow'
-  | 'create'
-  | 'createMany'
-  | 'createManyAndReturn'
-  | 'update'
-  | 'updateMany'
-  | 'updateManyAndReturn'
-  | 'upsert'
-  | 'delete'
-  | 'deleteMany'
-  | 'executeRaw'
-  | 'queryRaw'
-  | 'aggregate'
-  | 'count'
-  | 'runCommandRaw'
-  | 'findRaw'
-  | 'groupBy'
+export type BatchPayload = {
+  count: number
+}
 
 /**
- * These options are being passed into the middleware as "params"
+ * DMMF
  */
-export type MiddlewareParams = {
-  model?: ModelName
-  action: PrismaAction
-  args: any
-  dataPath: string[]
-  runInTransaction: boolean
+export const dmmf: runtime.BaseDMMF
+`;
 }
 
+// src/generation/TSClient/Count.ts
+var import_indent_string7 = __toESM(require_indent_string());
+var Count = class {
+  constructor(type, context) {
+    this.type = type;
+    this.context = context;
+  }
+  get argsTypes() {
+    const argsTypes = [];
+    argsTypes.push(
+      new ArgsTypeBuilder(this.type, this.context).addSelectArg().addIncludeArgIfHasRelations().createExport()
+    );
+    for (const field of this.type.fields) {
+      if (field.args.length > 0) {
+        argsTypes.push(
+          new ArgsTypeBuilder(this.type, this.context).addSchemaArgs(field.args).setGeneratedName(getCountArgsType(this.type.name, field.name)).createExport()
+        );
+      }
+    }
+    return argsTypes;
+  }
+  toTS() {
+    const { type } = this;
+    const { name } = type;
+    const outputType = buildOutputType(type);
+    return `
 /**
- * The \`T\` type makes sure, that the \`return proceed\` is not forgotten in the middleware implementation
+ * Count Type ${name}
  */
-export type Middleware<T = any> = (
-  params: MiddlewareParams,
-  next: (params: MiddlewareParams) => $Utils.JsPromise<T>,
-) => $Utils.JsPromise<T>
 
-// tested in getLogLevel.test.ts
-export function getLogLevel(log: Array<LogLevel | LogDefinition>): LogLevel | undefined;
+${stringify(outputType)}
 
-/**
- * \`PrismaClient\` proxy available in interactive transactions.
- */
-export type TransactionClient = Omit<Prisma.DefaultPrismaClient, runtime.ITXClientDenyList>
+export type ${getSelectName(name)}<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+${(0, import_indent_string7.default)(
+      type.fields.map((field) => {
+        const types = ["boolean"];
+        if (field.outputType.location === "outputObjectTypes") {
+          types.push(getFieldArgName(field, this.type.name));
+        }
+        if (field.args.length > 0) {
+          types.push(getCountArgsType(name, field.name));
+        }
+        return `${field.name}?: ${types.join(" | ")}`;
+      }).join("\n"),
+      TAB_SIZE
+    )}
+}
+
+// Custom InputTypes
+${this.argsTypes.map((typeExport) => stringify(typeExport)).join("\n\n")}
 `;
   }
-  buildClientOptions() {
-    const clientOptions = interfaceDeclaration("PrismaClientOptions").add(
-      property("datasources", namedType("Datasources")).optional().setDocComment(docComment("Overwrites the datasource url from your schema.prisma file"))
-    ).add(
-      property("datasourceUrl", stringType).optional().setDocComment(docComment("Overwrites the datasource url from your schema.prisma file"))
-    ).add(
-      property("errorFormat", namedType("ErrorFormat")).optional().setDocComment(docComment('@default "colorless"'))
-    ).add(
-      property("log", array(unionType([namedType("LogLevel"), namedType("LogDefinition")]))).optional().setDocComment(docComment`
-             @example
-             \`\`\`
-             // Defaults to stdout
-             log: ['query', 'info', 'warn', 'error']
+};
+function getCountArgsType(typeName, fieldName) {
+  return `${typeName}Count${capitalize2(fieldName)}Args`;
+}
 
-             // Emit as events
-             log: [
-               { emit: 'stdout', level: 'query' },
-               { emit: 'stdout', level: 'info' },
-               { emit: 'stdout', level: 'warn' }
-               { emit: 'stdout', level: 'error' }
-             ]
-             \`\`\`
-             Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/logging#the-log-option).
-          `)
-    );
-    const transactionOptions = objectType().add(property("maxWait", numberType).optional()).add(property("timeout", numberType).optional());
-    if (this.context.dmmf.hasEnumInNamespace("TransactionIsolationLevel", "prisma")) {
-      transactionOptions.add(property("isolationLevel", namedType("Prisma.TransactionIsolationLevel")).optional());
-    }
-    clientOptions.add(
-      property("transactionOptions", transactionOptions).optional().setDocComment(docComment`
-             The default values for transactionOptions
-             maxWait ?= 2000
-             timeout ?= 5000
-          `)
-    );
-    if (["library.js", "client.js"].includes(this.runtimeNameTs) && this.context.isPreviewFeatureOn("driverAdapters")) {
-      clientOptions.add(
-        property("adapter", unionType([namedType("runtime.DriverAdapter"), namedType("null")])).optional().setDocComment(
-          docComment("Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-planetscale`")
-        )
-      );
+// src/generation/TSClient/CountTypesFile.ts
+function createCountTypesFile(context) {
+  const countTypes = context.dmmf.schema.outputObjectTypes.prisma?.filter((t) => t.name.endsWith("CountOutputType")).map((t) => new Count(t, context));
+  return `import * as runtime from '${context.nestedRuntimeJsPath}';
+import $Types = runtime.Types // general types
+import $Public = runtime.Types.Public
+import $Utils = runtime.Types.Utils
+import $Extensions = runtime.Types.Extensions
+import $Result = runtime.Types.Result
+import Decimal = runtime.Decimal
+import DecimalJsLike = runtime.DecimalJsLike
+
+import type * as Prisma from '../common'
+
+${countTypes.map((t) => t.toTS()).join("\n")}
+`;
+}
+
+// src/generation/TSClient/DeepInputTypesFile.ts
+function createDeepInputTypesFile(context) {
+  return `
+import * as runtime from '${context.nestedRuntimeJsPath}';
+import $Types = runtime.Types // general types
+import $Public = runtime.Types.Public
+import $Utils = runtime.Types.Utils
+import $Extensions = runtime.Types.Extensions
+import $Result = runtime.Types.Result
+import Decimal = runtime.Decimal
+import DecimalJsLike = runtime.DecimalJsLike
+import JsonObject = runtime.JsonObject
+import JsonArray = runtime.JsonArray
+import JsonValue = runtime.JsonValue
+import InputJsonObject = runtime.InputJsonObject
+import InputJsonArray = runtime.InputJsonArray
+import InputJsonValue = runtime.InputJsonValue
+
+${context.dmmf.datamodel.enums.length > 0 ? `import type * as $Enums from '../enums'` : ""}
+import type * as Prisma from '../common';
+    
+    ${context.dmmf.inputObjectTypes.prisma?.reduce((acc, inputType) => {
+    if (inputType.name.includes("Json") && inputType.name.includes("Filter")) {
+      const needsGeneric = context.genericArgsInfo.typeNeedsGenericModelArg(inputType);
+      const innerName = needsGeneric ? `${inputType.name}Base<$PrismaModel>` : `${inputType.name}Base`;
+      const typeName = needsGeneric ? `${inputType.name}<$PrismaModel = never>` : inputType.name;
+      const baseName = `Required<${innerName}>`;
+      acc.push(`export type ${typeName} = 
+  | Prisma.PatchUndefined<
+      Prisma.Either<${baseName}, Exclude<keyof ${baseName}, 'path'>>,
+      ${baseName}
+    >
+  | Prisma.OptionalFlat<Omit<${baseName}, 'path'>>`);
+      acc.push(new InputType(inputType, context).overrideName(`${inputType.name}Base`).toTS());
+    } else {
+      acc.push(new InputType(inputType, context).toTS());
     }
-    clientOptions.add(
-      property("omit", namedType("Prisma.GlobalOmitConfig")).optional().setDocComment(docComment`
-        Global configuration for omitting model fields by default.
+    return acc;
+  }, []).join("\n")}
+    `;
+}
 
-        @example
-        \`\`\`
-        const prisma = new PrismaClient({
-          omit: {
-            user: {
-              password: true
-            }
-          }
-        })
-        \`\`\`
-      `)
-    );
-    return clientOptions;
+// src/generation/TSClient/EnumsFile.ts
+function createEnumsFile(context) {
+  const modelEnums = [];
+  for (const datamodelEnum of context.dmmf.datamodel.enums) {
+    modelEnums.push(new Enum(datamodelEnumToSchemaEnum(datamodelEnum), false).toTS());
+  }
+  return modelEnums.join("\n\n");
+}
+
+// src/generation/TSClient/GenerateContext.ts
+var GenerateContext = class {
+  constructor({ dmmf, genericArgsInfo, generator, runtimeJsPath }) {
+    this.dmmf = dmmf;
+    this.genericArgsInfo = genericArgsInfo;
+    this.generator = generator;
+    this.runtimeJsPath = runtimeJsPath;
+  }
+  isPreviewFeatureOn(previewFeature) {
+    return this.generator?.previewFeatures?.includes(previewFeature) ?? false;
+  }
+  get nestedRuntimeJsPath() {
+    if (!this.runtimeJsPath.startsWith(".")) {
+      return this.runtimeJsPath;
+    }
+    if (this.runtimeJsPath.startsWith("./")) {
+      return `.${this.runtimeJsPath}`;
+    }
+    return `../${this.runtimeJsPath}`;
   }
 };
 
+// src/generation/TSClient/ModelFiles.ts
+function createModelFiles(context) {
+  const importStatements = `import * as runtime from '${context.nestedRuntimeJsPath}';
+import $Types = runtime.Types // general types
+import $Public = runtime.Types.Public
+import $Utils = runtime.Types.Utils
+import $Extensions = runtime.Types.Extensions
+import $Result = runtime.Types.Result
+import Decimal = runtime.Decimal
+import DecimalJsLike = runtime.DecimalJsLike
+import JsonObject = runtime.JsonObject
+import JsonArray = runtime.JsonArray
+import JsonValue = runtime.JsonValue
+import InputJsonObject = runtime.InputJsonObject
+import InputJsonArray = runtime.InputJsonArray
+import InputJsonValue = runtime.InputJsonValue
+
+${context.dmmf.datamodel.enums.length > 0 ? `import type * as $Enums from '../enums'` : ""}
+
+import type * as Prisma from '../common'`;
+  const modelAndTypes = Object.values(context.dmmf.typeAndModelMap).filter((modelOrType) => context.dmmf.outputTypeMap.model[modelOrType.name]).map((modelOrType) => new Model(modelOrType, context));
+  const modelsFileMap = {};
+  modelAndTypes.forEach((m) => {
+    return modelsFileMap[m.fileName()] = `
+${importStatements}
+
+${m.toTS()}
+`;
+  });
+  return modelsFileMap;
+}
+
 // src/generation/TSClient/TSClient.ts
 var TSClient = class {
   constructor(options) {
@@ -10072,137 +10264,39 @@ ${buildNFTAnnotations(edge || !copyEngine, clientEngineType, binaryTargets, rela
     const context = new GenerateContext({
       dmmf: this.dmmf,
       genericArgsInfo: this.genericsInfo,
-      generator: this.options.generator
+      generator: this.options.generator,
+      runtimeJsPath: `${this.options.runtimeBase}/${this.options.runtimeNameTs}`
     });
-    const prismaClientClass = new PrismaClientClass(
-      context,
-      this.options.datasources,
-      this.options.outputDir,
-      this.options.runtimeNameTs,
-      this.options.browser
-    );
-    const commonCode = commonCodeTS(this.options);
-    const modelAndTypes = Object.values(this.dmmf.typeAndModelMap).reduce((acc, modelOrType) => {
-      if (this.dmmf.outputTypeMap.model[modelOrType.name]) {
-        acc.push(new Model(modelOrType, context));
-      }
-      return acc;
-    }, []);
-    const prismaEnums = this.dmmf.schema.enumTypes.prisma?.map((type) => new Enum(type, true).toTS());
-    const modelEnums = [];
-    const modelEnumsAliases = [];
-    for (const datamodelEnum of this.dmmf.datamodel.enums) {
-      modelEnums.push(new Enum(datamodelEnumToSchemaEnum(datamodelEnum), false).toTS());
-      modelEnumsAliases.push(
+    const modelAndTypes = Object.values(context.dmmf.typeAndModelMap).filter((modelOrType) => context.dmmf.outputTypeMap.model[modelOrType.name]).map((modelOrType) => new Model(modelOrType, context));
+    const modelEnumsAliases = this.dmmf.datamodel.enums.map((datamodelEnum) => {
+      return [
         stringify(
           moduleExport(typeDeclaration(datamodelEnum.name, namedType(`$Enums.${datamodelEnum.name}`)))
         ),
         stringify(
           moduleExport(constDeclaration(datamodelEnum.name, namedType(`typeof $Enums.${datamodelEnum.name}`)))
         )
-      );
-    }
-    const fieldRefs = this.dmmf.schema.fieldRefTypes.prisma?.map((type) => new FieldRefInput(type).toTS()) ?? [];
-    const countTypes = this.dmmf.schema.outputObjectTypes.prisma?.filter((t) => t.name.endsWith("CountOutputType")).map((t) => new Count(t, context));
-    const code = `
-/**
- * Client
-**/
-
-${commonCode.tsWithoutNamespace()}
-
-${modelAndTypes.map((m) => m.toTSWithoutNamespace()).join("\n")}
-${modelEnums.length > 0 ? `
-/**
- * Enums
- */
-export namespace $Enums {
-  ${modelEnums.join("\n\n")}
-}
-
-${modelEnumsAliases.join("\n\n")}
-` : ""}
-${prismaClientClass.toTSWithoutNamespace()}
-
-export namespace Prisma {
-${(0, import_indent_string8.default)(
-      `${commonCode.ts()}
-${new Enum(
-        {
-          name: "ModelName",
-          values: this.dmmf.mappings.modelOperations.map((m) => m.model)
-        },
-        true
-      ).toTS()}
-
-${prismaClientClass.toTS()}
-export type Datasource = {
-  url?: string
-}
-
-/**
- * Count Types
- */
-
-${countTypes.map((t) => t.toTS()).join("\n")}
-
-/**
- * Models
- */
-${modelAndTypes.map((model) => model.toTS()).join("\n")}
-
-/**
- * Enums
- */
-
-${prismaEnums?.join("\n\n")}
-${fieldRefs.length > 0 ? `
-/**
- * Field references 
- */
+      ].join("\n");
+    });
+    return `
+import * as runtime from '${context.runtimeJsPath}'
+import $Public = runtime.Types.Public
+import $Result = runtime.Types.Result
 
-${fieldRefs.join("\n\n")}` : ""}
-/**
- * Deep Input Types
- */
+import type * as Prisma from './common'
+${context.dmmf.datamodel.enums.length > 0 ? `import type * as $Enums from './enums'` : ""}
 
-${this.dmmf.inputObjectTypes.prisma?.reduce((acc, inputType) => {
-        if (inputType.name.includes("Json") && inputType.name.includes("Filter")) {
-          const needsGeneric = this.genericsInfo.typeNeedsGenericModelArg(inputType);
-          const innerName = needsGeneric ? `${inputType.name}Base<$PrismaModel>` : `${inputType.name}Base`;
-          const typeName = needsGeneric ? `${inputType.name}<$PrismaModel = never>` : inputType.name;
-          const baseName = `Required<${innerName}>`;
-          acc.push(`export type ${typeName} = 
-  | PatchUndefined<
-      Either<${baseName}, Exclude<keyof ${baseName}, 'path'>>,
-      ${baseName}
-    >
-  | OptionalFlat<Omit<${baseName}, 'path'>>`);
-          acc.push(new InputType(inputType, context).overrideName(`${inputType.name}Base`).toTS());
-        } else {
-          acc.push(new InputType(inputType, context).toTS());
-        }
-        return acc;
-      }, []).join("\n")}
+export * as Prisma from './common'
+${context.dmmf.datamodel.enums.length > 0 ? `export type * as $Enums from './enums'` : ""}
 
-${this.dmmf.inputObjectTypes.model?.map((inputType) => new InputType(inputType, context).toTS()).join("\n") ?? ""}
+export { PrismaClient } from './client'
 
-/**
- * Batch Payload for updateMany & deleteMany & createMany
- */
+export type PrismaPromise<T> = $Public.PrismaPromise<T>
 
-export type BatchPayload = {
-  count: number
-}
+${modelAndTypes.map((m) => m.toTSWithoutNamespace()).join("\n")}
 
-/**
- * DMMF
- */
-export const dmmf: runtime.BaseDMMF
-`,
-      2
-    )}}`;
-    return code;
+${modelEnumsAliases.length > 0 ? `${modelEnumsAliases.join("\n\n")}` : ""}
+`;
   }
   toBrowserJS() {
     const code = `${commonCodeJS({
@@ -10258,6 +10352,36 @@ Object.assign(exports, Prisma)
 `;
     return code;
   }
+  generateModelAndHelperFiles() {
+    const context = new GenerateContext({
+      dmmf: this.dmmf,
+      genericArgsInfo: this.genericsInfo,
+      generator: this.options.generator,
+      runtimeJsPath: `${this.options.runtimeBase}/${this.options.runtimeNameTs}`
+    });
+    const modelsFileMap = createModelFiles(context);
+    modelsFileMap["deepInputTypes.d.ts"] = createDeepInputTypesFile(context);
+    modelsFileMap["countTypes.d.ts"] = createCountTypesFile(context);
+    const modelsBarrelFileContent = `
+import * as runtime from '${context.runtimeJsPath}'
+
+export import JsonObject = runtime.JsonObject
+export import JsonArray = runtime.JsonArray
+export import JsonValue = runtime.JsonValue
+export import InputJsonObject = runtime.InputJsonObject
+export import InputJsonArray = runtime.InputJsonArray
+export import InputJsonValue = runtime.InputJsonValue
+
+${Object.keys(modelsFileMap).map((m) => `export type * from './models/${m}'`).join("\n")}
+`;
+    return {
+      "models.d.ts": modelsBarrelFileContent,
+      "common.d.ts": createCommonFile(context, this.options),
+      "client.d.ts": createClientFile(context, this.options),
+      "enums.d.ts": createEnumsFile(context),
+      models: modelsFileMap
+    };
+  }
 };
 
 // src/generation/typedSql/buildDbEnums.ts
@@ -10629,7 +10753,7 @@ async function buildClient({
     version: clientVersion2,
     sideEffects: false
   };
-  const fileMap = {};
+  const fileMap = nodeClient.generateModelAndHelperFiles();
   fileMap["index.js"] = JS(nodeClient);
   fileMap["index.d.ts"] = TS(nodeClient);
   fileMap["default.js"] = JS(defaultClient);