prisma 6.4.0-dev.13 → 6.4.0-dev.15

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

@@ -3946,7 +3946,7 @@ var require_package2 = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@prisma/client",
-      version: "6.4.0-dev.13",
+      version: "6.4.0-dev.15",
       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",
@@ -4130,10 +4130,10 @@ var require_package2 = __commonJS({
         "@libsql/client": "0.8.0",
         "@neondatabase/serverless": "0.10.2",
         "@opentelemetry/api": "1.9.0",
-        "@opentelemetry/context-async-hooks": "1.30.1",
-        "@opentelemetry/instrumentation": "0.57.1",
-        "@opentelemetry/resources": "1.30.1",
-        "@opentelemetry/sdk-trace-base": "1.30.1",
+        "@opentelemetry/context-async-hooks": "1.29.0",
+        "@opentelemetry/instrumentation": "0.56.0",
+        "@opentelemetry/resources": "1.29.0",
+        "@opentelemetry/sdk-trace-base": "1.29.0",
         "@opentelemetry/semantic-conventions": "1.28.0",
         "@planetscale/database": "1.18.0",
         "@prisma/adapter-d1": "workspace:*",
@@ -4171,7 +4171,7 @@ var require_package2 = __commonJS({
         arg: "5.0.2",
         benchmark: "2.1.4",
         "ci-info": "4.0.0",
-        "decimal.js": "10.5.0",
+        "decimal.js": "10.4.3",
         "detect-runtime": "1.0.4",
         "env-paths": "2.2.1",
         esbuild: "0.24.2",
@@ -4191,7 +4191,7 @@ var require_package2 = __commonJS({
         kleur: "4.1.5",
         klona: "2.0.6",
         mariadb: "3.3.1",
-        memfs: "4.17.0",
+        memfs: "4.15.0",
         mssql: "11.0.1",
         "new-github-issue-url": "0.2.1",
         "node-fetch": "3.3.2",
@@ -4212,7 +4212,7 @@ var require_package2 = __commonJS({
         "ts-pattern": "5.6.2",
         tsd: "0.31.2",
         typescript: "5.4.5",
-        undici: "7.3.0",
+        undici: "7.2.3",
         wrangler: "3.91.0",
         zx: "7.2.3"
       },
@@ -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>` : ""}
 /**
@@ -8123,7 +8137,7 @@ function getNonAggregateMethodArgs(modelName, actionName) {
   if (actionName === DMMF.ModelAction.findRaw || actionName === DMMF.ModelAction.aggregateRaw) {
     return makeParameter(namedType(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);
@@ -8158,7 +8172,7 @@ function getReturnType({
     return prismaPromise(namedType("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,1442 @@ 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
-
-/**
- * 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
-
-/**
- * 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 SelectAndInclude = {
-  select: any
-  include: any
+// 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));
 }
-
-type SelectAndOmit = {
-  select: any
-  omit: any
+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("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 | 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']>
 }
 
-/**
- * Get the type of the value, that the Promise holds.
- */
-export type PromiseType<T extends PromiseLike<any>> = T extends PromiseLike<infer U> ? U : T;
-
-/**
- * Get the return type of a function which returns a Promise.
- */
-export type PromiseReturnType<T extends (...args: any) => $Utils.JsPromise<any>> = PromiseType<ReturnType<T>>
-
-/**
- * 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];
-};
-
+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' } }),
+        ])
+        \`\`\`
 
-export type Enumerable<T> = T | Array<T>;
+        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 RequiredKeys<T> = {
-  [K in keyof T]-?: {} extends Prisma__Pick<T, K> ? never : K
-}[keyof T]
+  /**
+   * 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>;
 
-export type TruthyKeys<T> = keyof {
-  [K in keyof T as T[K] extends false | undefined | null ? never : K]: K
+  /**
+   * 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'
 
-export type TrueKeys<T> = TruthyKeys<Prisma__Pick<T, RequiredKeys<T>>>
-
-/**
- * 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;
-};
+        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.
 
-/**
- * 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\`.'
-      : {})
+        @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,
+      })
+      \`\`\`
 
-/**
- * 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
+      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 `
+import * as runtime from './runtime/library.js'
+import $Utils = runtime.Types.Utils
+import $Extensions = runtime.Types.Extensions
 
-type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };
+import type * as Prisma from './common'
 
-/**
- * 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
+${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)}
 
-/**
- * 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
+  constructor(optionsArg ?: Prisma.Subset<ClientOptions, Prisma.PrismaClientOptions>);
+  ${eventRegistrationMethodDeclaration(this.runtimeNameTs)}
 
+  /**
+   * Connect with the database
+   */
+  $connect(): $Utils.JsPromise<void>;
 
-/**
- * If it's T[], return T
- */
-export type UnEnumerate<T extends unknown> = T extends Array<infer U> ? U : T
+  /**
+   * Disconnect from the database
+   */
+  $disconnect(): $Utils.JsPromise<void>;
 
-/**
- * From ts-toolbelt
- */
+  /**
+   * 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
 
-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]
+${[
+      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()}
 
-type EitherStrict<O extends object, K extends Key> = Strict<__Either<O, K>>
+    ${(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))}
 
-type EitherLoose<O extends object, K extends Key> = ComputeRaw<__Either<O, K>>
+/* Types for Logging */
+export type LogLevel = 'info' | 'query' | 'warn' | 'error'
+export type LogDefinition = {
+  level: LogLevel
+  emit: 'stdout' | 'event'
+}
 
-type _Either<
-  O extends object,
-  K extends Key,
-  strict extends Boolean
-> = {
-  1: EitherStrict<O, K>
-  0: EitherLoose<O, K>
-}[strict]
+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
 
-type Either<
-  O extends object,
-  K extends Key,
-  strict extends Boolean = 1
-> = O extends unknown ? _Either<O, K, strict> : never
+export type QueryEvent = {
+  timestamp: Date
+  query: string
+  params: string
+  duration: number
+  target: string
+}
 
-export type Union = any
+export type LogEvent = {
+  timestamp: Date
+  message: string
+  target: string
+}
+/* End Types for Logging */
 
-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 PrismaAction =
+  | 'findUnique'
+  | 'findUniqueOrThrow'
+  | 'findMany'
+  | 'findFirst'
+  | 'findFirstOrThrow'
+  | 'create'
+  | 'createMany'
+  | 'createManyAndReturn'
+  | 'update'
+  | 'updateMany'
+  | 'updateManyAndReturn'
+  | 'upsert'
+  | 'delete'
+  | 'deleteMany'
+  | 'executeRaw'
+  | 'queryRaw'
+  | 'aggregate'
+  | 'count'
+  | 'runCommandRaw'
+  | 'findRaw'
+  | 'groupBy'
 
-export type Overwrite<O extends object, O1 extends object> = {
-    [K in keyof O]: K extends keyof O1 ? O1[K] : O[K];
-} & {};
+/**
+ * These options are being passed into the middleware as "params"
+ */
+export type MiddlewareParams = {
+  model?: ModelName
+  action: PrismaAction
+  args: any
+  dataPath: string[]
+  runInTransaction: boolean
+}
 
-type _Merge<U extends object> = IntersectOf<Overwrite<U, {
-    [K in keyof U]-?: At<U, K>;
-}>>;
+/**
+ * The \`T\` type makes sure, that the \`return proceed\` is not forgotten in the middleware implementation
+ */
+export type Middleware<T = any> = (
+  params: MiddlewareParams,
+  next: (params: MiddlewareParams) => $Utils.JsPromise<T>,
+) => $Utils.JsPromise<T>
 
-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];
+// tested in getLogLevel.test.ts
+export function getLogLevel(log: Array<LogLevel | LogDefinition>): LogLevel | undefined;
 
-export type ComputeRaw<A extends any> = A extends Function ? A : {
-  [K in keyof A]: A[K];
-} & {};
+/**
+ * \`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']
 
-export type OptionalFlat<O> = {
-  [K in keyof O]?: O[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 _Record<K extends keyof any, T> = {
-  [P in K]: T;
+        @example
+        \`\`\`
+        const prisma = new PrismaClient({
+          omit: {
+            user: {
+              password: true
+            }
+          }
+        })
+        \`\`\`
+      `)
+    );
+    return clientOptions;
+  }
 };
 
-// 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
-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>;
+// src/generation/TSClient/ClientFile.ts
+function createClientFile(context, options) {
+  const prismaClientClass = new PrismaClientClass(
+    context,
+    options.datasources,
+    options.outputDir,
+    options.runtimeNameTs,
+    options.browser
+  );
+  return prismaClientClass.toTSWithoutNamespace();
+}
 
-type _Strict<U, _U = U> = U extends unknown ? U & OptionalFlat<_Record<Exclude<Keys<_U>, keyof U>, never>> : 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 Strict<U extends object> = ComputeRaw<_Strict<U>>;
-/** End Helper Types for "Merge" **/
+const Prisma = {}
 
-export type Merge<U extends object> = ComputeRaw<_Merge<Strict<U>>>;
+exports.Prisma = Prisma
+exports.$Enums = {}
 
 /**
-A [[Boolean]]
-*/
-export type Boolean = True | False
+ * Prisma Client JS version: ${clientVersion2}
+ * Query Engine version: ${engineVersion}
+ */
+Prisma.prismaVersion = {
+  client: "${clientVersion2}",
+  engine: "${engineVersion}"
+}
 
-// /**
-// 1
-// */
-export type True = 1
+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
 
 /**
-0
-*/
-export type False = 0
+ * 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
 
-export type Not<B extends Boolean> = {
-  0: 1
-  1: 0
-}[B]
+/**
+* Extensions
+*/
+Prisma.getExtensionContext = ${notSupportOnBrowser("Extensions.getExtensionContext", browser)}
+Prisma.defineExtension = ${notSupportOnBrowser("Extensions.defineExtension", browser)}
 
-export type Extends<A1 extends any, A2 extends any> = [A1] extends [never]
-  ? 0 // anything \`never\` is false
-  : A1 extends A2
-  ? 1
-  : 0
+/**
+ * Shorthand utilities for JSON filtering
+ */
+Prisma.DbNull = objectEnumValues.instances.DbNull
+Prisma.JsonNull = objectEnumValues.instances.JsonNull
+Prisma.AnyNull = objectEnumValues.instances.AnyNull
 
-export type Has<U extends Union, U1 extends Union> = Not<
-  Extends<Exclude<U1, U>, U1>
->
+Prisma.NullTypes = {
+  DbNull: objectEnumValues.classes.DbNull,
+  JsonNull: objectEnumValues.classes.JsonNull,
+  AnyNull: objectEnumValues.classes.AnyNull
+}
 
-export type Or<B1 extends Boolean, B2 extends Boolean> = {
-  0: {
-    0: 0
-    1: 1
-  }
-  1: {
-    0: 1
-    1: 1
+${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\`,
+)}`;
   }
-}[B1][B2]
-
-export type Keys<U extends Union> = U extends unknown ? keyof U : never
-
-type Cast<A, B> = A extends B ? A : B;
+  return fnc;
+};
+var commonCodeTS = ({ clientVersion: clientVersion2, engineVersion, generator }) => ({
+  ts: () => `export import DMMF = runtime.DMMF
 
-export const type: unique symbol;
+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
 
 /**
- * Used by group by
+ * 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 GetScalarType<T, O> = O extends object ? {
-  [P in keyof T]: P extends keyof O
-    ? O[P]
-    : never
-} : never
+${buildPrismaSkipTs(generator.previewFeatures)}
 
-type FieldPaths<
-  T,
-  U = Omit<T, '_avg' | '_sum' | '_count' | '_min' | '_max'>
-> = IsObject<T> extends True ? U : T
+/**
+ * Decimal.js
+ */
+export import Decimal = runtime.Decimal
 
-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]
+export type DecimalJsLike = runtime.DecimalJsLike
 
 /**
- * Convert tuple to union
+ * Metrics
  */
-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 Metrics = runtime.Metrics
+export type Metric<T> = runtime.Metric<T>
+export type MetricHistogram = runtime.MetricHistogram
+export type MetricHistogramBucket = runtime.MetricHistogramBucket
 
 /**
- * Like \`Pick\`, but additionally can also accept an array of keys
+* 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}
  */
-type PickEnumerable<T, K extends Enumerable<keyof T> | keyof T> = Prisma__Pick<T, MaybeTupleToUnion<K>>
+export type PrismaVersion = {
+  client: string
+}
+
+export const prismaVersion: PrismaVersion
 
 /**
- * Exclude all keys with underscores
+ * Utility Types
  */
-type ExcludeUnderscoreKeys<T extends string> = T extends \`_\${string}\` ? never : T
 
 
-export type FieldRef<Model, FieldType> = runtime.FieldRef<Model, FieldType>
+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
 
-type FieldRefInputType<Model, FieldType> = Model extends never ? never : FieldRef<Model, FieldType>
+/**
+ * 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
+ */
+declare namespace NullTypes {
+${buildNullClass("DbNull")}
 
-`
-});
-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);
+${buildNullClass("JsonNull")}
+
+${buildNullClass("AnyNull")}
 }
-function buildPrismaSkipTs(previewFeatures) {
-  if (previewFeatures.includes("strictUndefinedChecks")) {
-    return `
+
 /**
- * Prisma.skip
+ * 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 import skip = runtime.skip
-`;
-  }
-  return "";
-}
-function buildPrismaSkipJs(previewFeatures) {
-  if (previewFeatures.includes("strictUndefinedChecks")) {
-    return `
-Prisma.skip = skip
-`;
-  }
-  return "";
-}
+export const DbNull: NullTypes.DbNull
 
-// 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}
+ * 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
 
-${stringify(outputType)}
+/**
+ * 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
 
-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
-    )}
+type SelectAndInclude = {
+  select: any
+  include: any
 }
 
-// Custom InputTypes
-${this.argsTypes.map((typeExport) => stringify(typeExport)).join("\n\n")}
-`;
-  }
-};
-function getCountArgsType(typeName, fieldName) {
-  return `${typeName}Count${capitalize2(fieldName)}Args`;
+type SelectAndOmit = {
+  select: any
+  omit: any
 }
 
-// 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}
+ * Get the type of the value, that the Promise holds.
  */
-export type ${this.type.name}<$PrismaModel> = FieldRefInputType<$PrismaModel, ${allowedTypes}>
-    `;
-  }
-  getAllowedTypes() {
-    return this.type.allowTypes.map(getRefAllowedTypeName).join(" | ");
-  }
-};
+export type PromiseType<T extends PromiseLike<any>> = T extends PromiseLike<infer U> ? U : T;
 
-// 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;
-  }
+/**
+ * Get the return type of a function which returns a Promise.
+ */
+export type PromiseReturnType<T extends (...args: any) => $Utils.JsPromise<any>> = PromiseType<ReturnType<T>>
+
+/**
+ * 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];
 };
 
-// src/generation/TSClient/PrismaClient.ts
-var import_indent_string7 = __toESM(require_indent_string());
 
-// src/generation/utils/runtimeImport.ts
-function runtimeImport(name) {
-  return name;
-}
-function runtimeImportedType(name) {
-  return namedType(`runtime.${name}`);
-}
+export type Enumerable<T> = T | Array<T>;
 
-// 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)}
-}`;
-  }
-};
+export type RequiredKeys<T> = {
+  [K in keyof T]-?: {} extends Prisma__Pick<T, K> ? never : K
+}[keyof T]
 
-// 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));
+export type TruthyKeys<T> = keyof {
+  [K in keyof T as T[K] extends false | undefined | null ? never : K]: 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']>
-}
+export type TrueKeys<T> = TruthyKeys<Prisma__Pick<T, RequiredKeys<T>>>
 
-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' } }),
-        ])
-        \`\`\`
+/**
+ * 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;
+};
 
-        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>;
+/**
+ * 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\`.'
+      : {})
 
-  /**
-   * 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>;
+/**
+ * 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
 
-  /**
-   * 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'
+export type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };
 
-        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.
+/**
+ * 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
 
-        @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,
-      })
-      \`\`\`
 
-      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;
+/**
+ * Is T a Record?
+ */
+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
+
+
+/**
+ * If it's T[], return T
+ */
+export type UnEnumerate<T extends unknown> = T extends Array<infer U> ? U : T
+
+/**
+ * From ts-toolbelt
+ */
+
+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]
+
+type EitherStrict<O extends object, K extends Key> = Strict<__Either<O, K>>
+
+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 ComputeRaw<A extends any> = A extends Function ? A : {
+  [K in keyof A]: A[K];
+} & {};
+
+export type OptionalFlat<O> = {
+  [K in keyof O]?: O[K];
+} & {};
+
+type _Record<K extends keyof any, T> = {
+  [P in K]: T;
+};
+
+// 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
   }
-  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).
- */`;
+  1: {
+    0: 1
+    1: 1
   }
-  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'] }
+}[B1][B2]
 
-  ${(0, import_indent_string7.default)(this.jsDoc, TAB_SIZE)}
+export type Keys<U extends Union> = U extends unknown ? keyof U : never
 
-  constructor(optionsArg ?: Prisma.Subset<ClientOptions, Prisma.PrismaClientOptions>);
-  ${eventRegistrationMethodDeclaration(this.runtimeNameTs)}
+type Cast<A, B> = A extends B ? A : B;
 
-  /**
-   * Connect with the database
-   */
-  $connect(): $Utils.JsPromise<void>;
+export const type: unique symbol;
 
-  /**
-   * Disconnect from the database
-   */
-  $disconnect(): $Utils.JsPromise<void>;
 
-  /**
-   * 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
 
-${[
-      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()}
+/**
+ * Used by group by
+ */
 
-    ${(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
-    )}
+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]
+
+/**
+ * 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 buildPrismaSkipTs(previewFeatures) {
+  if (previewFeatures.includes("strictUndefinedChecks")) {
+    return `
+/**
+ * Prisma.skip
+ */
+export import skip = runtime.skip
+`;
+  }
+  return "";
+}
+function buildPrismaSkipJs(previewFeatures) {
+  if (previewFeatures.includes("strictUndefinedChecks")) {
+    return `
+Prisma.skip = skip
+`;
+  }
+  return "";
+}
+
+// src/generation/TSClient/FieldRefInput.ts
+var FieldRefInput = class {
+  constructor(type) {
+    this.type = type;
   }
   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))}
+    const allowedTypes = this.getAllowedTypes();
+    return `
+/**
+ * Reference to a field of type ${allowedTypes}
+ */
+export type ${this.type.name}<$PrismaModel> = FieldRefInputType<$PrismaModel, ${allowedTypes}>
+    `;
+  }
+  getAllowedTypes() {
+    return this.type.allowTypes.map(getRefAllowedTypeName).join(" | ");
+  }
+};
 
-/* Types for Logging */
-export type LogLevel = 'info' | 'query' | 'warn' | 'error'
-export type LogDefinition = {
-  level: LogLevel
-  emit: 'stdout' | 'event'
-}
+// 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
 
-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
+import type * as Prisma from './models';
+import type { PrismaClient } from './client';
 
-export type QueryEvent = {
-  timestamp: Date
-  query: string
-  params: string
-  duration: number
-  target: string
-}
+export type * from './models';
+    
+${commonCode.ts()}
+${new Enum(
+    {
+      name: "ModelName",
+      values: context.dmmf.mappings.modelOperations.map((m) => m.model)
+    },
+    true
+  ).toTS()}
 
-export type LogEvent = {
-  timestamp: Date
-  message: string
-  target: string
+${prismaClientClass.toTS()}
+export type Datasource = {
+  url?: string
 }
-/* End Types for Logging */
 
+/**
+ * Enums
+ */
 
-export type PrismaAction =
-  | 'findUnique'
-  | 'findUniqueOrThrow'
-  | 'findMany'
-  | 'findFirst'
-  | 'findFirstOrThrow'
-  | 'create'
-  | 'createMany'
-  | 'createManyAndReturn'
-  | 'update'
-  | 'updateMany'
-  | 'updateManyAndReturn'
-  | 'upsert'
-  | 'delete'
-  | 'deleteMany'
-  | 'executeRaw'
-  | 'queryRaw'
-  | 'aggregate'
-  | 'count'
-  | 'runCommandRaw'
-  | 'findRaw'
-  | 'groupBy'
+${prismaEnums?.join("\n\n")}
+
+${fieldRefs.length > 0 ? `
+/**
+ * Field references 
+ */
 
+${fieldRefs.join("\n\n")}` : ""}
 /**
- * These options are being passed into the middleware as "params"
+ * Deep Input Types
  */
-export type MiddlewareParams = {
-  model?: ModelName
-  action: PrismaAction
-  args: any
-  dataPath: string[]
-  runInTransaction: boolean
-}
+
+${context.dmmf.inputObjectTypes.model?.map((inputType) => new InputType(inputType, context).toTS()).join("\n") ?? ""}
 
 /**
- * The \`T\` type makes sure, that the \`return proceed\` is not forgotten in the middleware implementation
+ * Batch Payload for updateMany & deleteMany & createMany
  */
-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;
+export type BatchPayload = {
+  count: number
+}
 
 /**
- * \`PrismaClient\` proxy available in interactive transactions.
+ * DMMF
  */
-export type TransactionClient = Omit<Prisma.DefaultPrismaClient, runtime.ITXClientDenyList>
+export const dmmf: runtime.BaseDMMF
 `;
-  }
-  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']
+}
 
-             // 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).
-          `)
+// 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()
     );
-    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());
+    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()
+        );
+      }
     }
-    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`")
-        )
-      );
+    return argsTypes;
+  }
+  toTS() {
+    const { type } = this;
+    const { name } = type;
+    const outputType = buildOutputType(type);
+    return `
+/**
+ * Count Type ${name}
+ */
+
+${stringify(outputType)}
+
+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")}
+`;
+  }
+};
+function getCountArgsType(typeName, fieldName) {
+  return `${typeName}Count${capitalize2(fieldName)}Args`;
+}
+
+// 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
+
+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
+
+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 +10271,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';
+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 type * as Prisma from './common';
+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 +10359,25 @@ 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 = 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 +10749,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);