prisma 5.20.0-dev.2 → 5.20.0-dev.21

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

@@ -33,18 +33,18 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// ../../node_modules/.pnpm/@prisma+engines-version@5.20.0-1.822529594b56e11c17f1eb082b674bf54c8e602e/node_modules/@prisma/engines-version/package.json
+// ../../node_modules/.pnpm/@prisma+engines-version@5.20.0-12.06fc58a368dc7be9fbbbe894adf8d445d208c284/node_modules/@prisma/engines-version/package.json
 var require_package = __commonJS({
-  "../../node_modules/.pnpm/@prisma+engines-version@5.20.0-1.822529594b56e11c17f1eb082b674bf54c8e602e/node_modules/@prisma/engines-version/package.json"(exports2, module2) {
+  "../../node_modules/.pnpm/@prisma+engines-version@5.20.0-12.06fc58a368dc7be9fbbbe894adf8d445d208c284/node_modules/@prisma/engines-version/package.json"(exports2, module2) {
     module2.exports = {
       name: "@prisma/engines-version",
-      version: "5.20.0-1.822529594b56e11c17f1eb082b674bf54c8e602e",
+      version: "5.20.0-12.06fc58a368dc7be9fbbbe894adf8d445d208c284",
       main: "index.js",
       types: "index.d.ts",
       license: "Apache-2.0",
       author: "Tim Suchanek <suchanek@prisma.io>",
       prisma: {
-        enginesVersion: "822529594b56e11c17f1eb082b674bf54c8e602e"
+        enginesVersion: "06fc58a368dc7be9fbbbe894adf8d445d208c284"
       },
       repository: {
         type: "git",
@@ -66,9 +66,9 @@ var require_package = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/@prisma+engines-version@5.20.0-1.822529594b56e11c17f1eb082b674bf54c8e602e/node_modules/@prisma/engines-version/index.js
+// ../../node_modules/.pnpm/@prisma+engines-version@5.20.0-12.06fc58a368dc7be9fbbbe894adf8d445d208c284/node_modules/@prisma/engines-version/index.js
 var require_engines_version = __commonJS({
-  "../../node_modules/.pnpm/@prisma+engines-version@5.20.0-1.822529594b56e11c17f1eb082b674bf54c8e602e/node_modules/@prisma/engines-version/index.js"(exports2) {
+  "../../node_modules/.pnpm/@prisma+engines-version@5.20.0-12.06fc58a368dc7be9fbbbe894adf8d445d208c284/node_modules/@prisma/engines-version/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.enginesVersion = void 0;
@@ -3166,7 +3166,7 @@ var require_package2 = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@prisma/client",
-      version: "5.20.0-dev.2",
+      version: "5.20.0-dev.21",
       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",
@@ -3365,7 +3365,7 @@ var require_package2 = __commonJS({
         "@prisma/debug": "workspace:*",
         "@prisma/driver-adapter-utils": "workspace:*",
         "@prisma/engines": "workspace:*",
-        "@prisma/engines-version": "5.20.0-1.822529594b56e11c17f1eb082b674bf54c8e602e",
+        "@prisma/engines-version": "5.20.0-12.06fc58a368dc7be9fbbbe894adf8d445d208c284",
         "@prisma/fetch-engine": "workspace:*",
         "@prisma/generator-helper": "workspace:*",
         "@prisma/get-platform": "workspace:*",
@@ -3374,7 +3374,7 @@ var require_package2 = __commonJS({
         "@prisma/migrate": "workspace:*",
         "@prisma/mini-proxy": "0.9.5",
         "@prisma/pg-worker": "workspace:*",
-        "@prisma/query-engine-wasm": "5.20.0-1.822529594b56e11c17f1eb082b674bf54c8e602e",
+        "@prisma/query-engine-wasm": "5.20.0-12.06fc58a368dc7be9fbbbe894adf8d445d208c284",
         "@snaplet/copycat": "0.17.3",
         "@swc-node/register": "1.10.9",
         "@swc/core": "1.6.13",
@@ -5789,21 +5789,163 @@ function wellKnownSymbol(name) {
 }
 var toStringTag = wellKnownSymbol("toStringTag");
 
+// src/generation/utils.ts
+function getSelectName(modelName) {
+  return `${modelName}Select`;
+}
+function getSelectCreateManyAndReturnName(modelName) {
+  return `${modelName}SelectCreateManyAndReturn`;
+}
+function getIncludeName(modelName) {
+  return `${modelName}Include`;
+}
+function getIncludeCreateManyAndReturnName(modelName) {
+  return `${modelName}IncludeCreateManyAndReturn`;
+}
+function getCreateManyAndReturnOutputType(modelName) {
+  return `CreateMany${modelName}AndReturnOutputType`;
+}
+function getOmitName(modelName) {
+  return `${modelName}Omit`;
+}
+function getAggregateName(modelName) {
+  return `Aggregate${capitalize2(modelName)}`;
+}
+function getGroupByName(modelName) {
+  return `${capitalize2(modelName)}GroupByOutputType`;
+}
+function getAvgAggregateName(modelName) {
+  return `${capitalize2(modelName)}AvgAggregateOutputType`;
+}
+function getSumAggregateName(modelName) {
+  return `${capitalize2(modelName)}SumAggregateOutputType`;
+}
+function getMinAggregateName(modelName) {
+  return `${capitalize2(modelName)}MinAggregateOutputType`;
+}
+function getMaxAggregateName(modelName) {
+  return `${capitalize2(modelName)}MaxAggregateOutputType`;
+}
+function getCountAggregateInputName(modelName) {
+  return `${capitalize2(modelName)}CountAggregateInputType`;
+}
+function getCountAggregateOutputName(modelName) {
+  return `${capitalize2(modelName)}CountAggregateOutputType`;
+}
+function getAggregateInputType(aggregateOutputType) {
+  return aggregateOutputType.replace(/OutputType$/, "InputType");
+}
+function getGroupByArgsName(modelName) {
+  return `${modelName}GroupByArgs`;
+}
+function getGroupByPayloadName(modelName) {
+  return `Get${capitalize2(modelName)}GroupByPayload`;
+}
+function getAggregateArgsName(modelName) {
+  return `${capitalize2(modelName)}AggregateArgs`;
+}
+function getAggregateGetName(modelName) {
+  return `Get${capitalize2(modelName)}AggregateType`;
+}
+function getFieldArgName(field, modelName) {
+  if (field.args.length) {
+    return getModelFieldArgsName(field, modelName);
+  }
+  return getModelArgName(field.outputType.type);
+}
+function getModelFieldArgsName(field, modelName) {
+  return `${modelName}$${field.name}Args`;
+}
+function getLegacyModelArgName(modelName) {
+  return `${modelName}Args`;
+}
+function getModelArgName(modelName, action) {
+  if (!action) {
+    return `${modelName}DefaultArgs`;
+  }
+  switch (action) {
+    case DMMF.ModelAction.findMany:
+      return `${modelName}FindManyArgs`;
+    case DMMF.ModelAction.findUnique:
+      return `${modelName}FindUniqueArgs`;
+    case DMMF.ModelAction.findUniqueOrThrow:
+      return `${modelName}FindUniqueOrThrowArgs`;
+    case DMMF.ModelAction.findFirst:
+      return `${modelName}FindFirstArgs`;
+    case DMMF.ModelAction.findFirstOrThrow:
+      return `${modelName}FindFirstOrThrowArgs`;
+    case DMMF.ModelAction.upsert:
+      return `${modelName}UpsertArgs`;
+    case DMMF.ModelAction.update:
+      return `${modelName}UpdateArgs`;
+    case DMMF.ModelAction.updateMany:
+      return `${modelName}UpdateManyArgs`;
+    case DMMF.ModelAction.delete:
+      return `${modelName}DeleteArgs`;
+    case DMMF.ModelAction.create:
+      return `${modelName}CreateArgs`;
+    case DMMF.ModelAction.createMany:
+      return `${modelName}CreateManyArgs`;
+    case DMMF.ModelAction.createManyAndReturn:
+      return `${modelName}CreateManyAndReturnArgs`;
+    case DMMF.ModelAction.deleteMany:
+      return `${modelName}DeleteManyArgs`;
+    case DMMF.ModelAction.groupBy:
+      return getGroupByArgsName(modelName);
+    case DMMF.ModelAction.aggregate:
+      return getAggregateArgsName(modelName);
+    case DMMF.ModelAction.count:
+      return `${modelName}CountArgs`;
+    case DMMF.ModelAction.findRaw:
+      return `${modelName}FindRawArgs`;
+    case DMMF.ModelAction.aggregateRaw:
+      return `${modelName}AggregateRawArgs`;
+    default:
+      assertNever(action, `Unknown action: ${action}`);
+  }
+}
+function getPayloadName(modelName, namespace2 = true) {
+  if (namespace2) {
+    return `Prisma.${getPayloadName(modelName, false)}`;
+  }
+  return `$${modelName}Payload`;
+}
+function getFieldRefsTypeName(name) {
+  return `${name}FieldRefs`;
+}
+function capitalize2(str) {
+  return str[0].toUpperCase() + str.slice(1);
+}
+function getRefAllowedTypeName(type) {
+  let typeName = type.type;
+  if (type.isList) {
+    typeName += "[]";
+  }
+  return `'${typeName}'`;
+}
+function appendSkipType(context, type) {
+  if (context.isPreviewFeatureOn("strictUndefinedChecks")) {
+    return unionType([type, namedType("$Types.Skip")]);
+  }
+  return type;
+}
+var extArgsParam = genericParameter("ExtArgs").extends(namedType("$Extensions.InternalArgs")).default(namedType("$Extensions.DefaultArgs"));
+
 // src/generation/TSClient/Input.ts
 var InputField = class {
-  constructor(field, genericsInfo, source) {
+  constructor(field, context, source) {
     this.field = field;
-    this.genericsInfo = genericsInfo;
+    this.context = context;
     this.source = source;
   }
   toTS() {
-    const property2 = buildInputField(this.field, this.genericsInfo, this.source);
+    const property2 = buildInputField(this.field, this.context, this.source);
     return stringify(property2);
   }
 };
-function buildInputField(field, genericsInfo, source) {
-  const tsType = buildAllFieldTypes(field.inputTypes, genericsInfo, source);
-  const tsProperty = property(field.name, tsType);
+function buildInputField(field, context, source) {
+  const tsType = buildAllFieldTypes(field.inputTypes, context, source);
+  const tsProperty = property(field.name, field.isRequired ? tsType : appendSkipType(context, tsType));
   if (!field.isRequired) {
     tsProperty.optional();
   }
@@ -5850,11 +5992,11 @@ function buildSingleFieldType(t, genericsInfo, source) {
 function namedInputType(typeName) {
   return namedType(JSOutputTypeToInputType[typeName] ?? typeName);
 }
-function buildAllFieldTypes(inputTypes, genericsInfo, source) {
+function buildAllFieldTypes(inputTypes, context, source) {
   const inputObjectTypes = inputTypes.filter((t) => t.location === "inputObjectTypes" && !t.isList);
   const otherTypes = inputTypes.filter((t) => t.location !== "inputObjectTypes" || t.isList);
-  const tsInputObjectTypes = inputObjectTypes.map((type) => buildSingleFieldType(type, genericsInfo, source));
-  const tsOtherTypes = otherTypes.map((type) => buildSingleFieldType(type, genericsInfo, source));
+  const tsInputObjectTypes = inputObjectTypes.map((type) => buildSingleFieldType(type, context.genericArgsInfo, source));
+  const tsOtherTypes = otherTypes.map((type) => buildSingleFieldType(type, context.genericArgsInfo, source));
   if (tsOtherTypes.length === 0) {
     return xorTypes(tsInputObjectTypes);
   }
@@ -5867,9 +6009,9 @@ function xorTypes(types) {
   return types.reduce((prev, curr) => namedType("XOR").addGenericArgument(prev).addGenericArgument(curr));
 }
 var InputType = class {
-  constructor(type, genericsInfo) {
+  constructor(type, context) {
     this.type = type;
-    this.genericsInfo = genericsInfo;
+    this.context = context;
     this.generatedName = type.name;
   }
   toTS() {
@@ -5879,7 +6021,7 @@ var InputType = class {
     const body = `{
 ${(0, import_indent_string2.default)(
       fields.map((arg) => {
-        return new InputField(arg, this.genericsInfo, source).toTS();
+        return new InputField(arg, this.context, source).toTS();
       }).join("\n"),
       TAB_SIZE
     )}
@@ -5892,7 +6034,7 @@ export type ${this.getTypeName()} = ${wrapWithAtLeast(body, type)}`;
     return this;
   }
   getTypeName() {
-    if (this.genericsInfo.typeNeedsGenericModelArg(this.type)) {
+    if (this.context.genericArgsInfo.typeNeedsGenericModelArg(this.type)) {
       return `${this.generatedName}<$PrismaModel = never>`;
     }
     return this.generatedName;
@@ -5979,142 +6121,6 @@ function klona(x) {
   return x;
 }
 
-// src/generation/utils.ts
-function getSelectName(modelName) {
-  return `${modelName}Select`;
-}
-function getSelectCreateManyAndReturnName(modelName) {
-  return `${modelName}SelectCreateManyAndReturn`;
-}
-function getIncludeName(modelName) {
-  return `${modelName}Include`;
-}
-function getIncludeCreateManyAndReturnName(modelName) {
-  return `${modelName}IncludeCreateManyAndReturn`;
-}
-function getCreateManyAndReturnOutputType(modelName) {
-  return `CreateMany${modelName}AndReturnOutputType`;
-}
-function getOmitName(modelName) {
-  return `${modelName}Omit`;
-}
-function getAggregateName(modelName) {
-  return `Aggregate${capitalize2(modelName)}`;
-}
-function getGroupByName(modelName) {
-  return `${capitalize2(modelName)}GroupByOutputType`;
-}
-function getAvgAggregateName(modelName) {
-  return `${capitalize2(modelName)}AvgAggregateOutputType`;
-}
-function getSumAggregateName(modelName) {
-  return `${capitalize2(modelName)}SumAggregateOutputType`;
-}
-function getMinAggregateName(modelName) {
-  return `${capitalize2(modelName)}MinAggregateOutputType`;
-}
-function getMaxAggregateName(modelName) {
-  return `${capitalize2(modelName)}MaxAggregateOutputType`;
-}
-function getCountAggregateInputName(modelName) {
-  return `${capitalize2(modelName)}CountAggregateInputType`;
-}
-function getCountAggregateOutputName(modelName) {
-  return `${capitalize2(modelName)}CountAggregateOutputType`;
-}
-function getAggregateInputType(aggregateOutputType) {
-  return aggregateOutputType.replace(/OutputType$/, "InputType");
-}
-function getGroupByArgsName(modelName) {
-  return `${modelName}GroupByArgs`;
-}
-function getGroupByPayloadName(modelName) {
-  return `Get${capitalize2(modelName)}GroupByPayload`;
-}
-function getAggregateArgsName(modelName) {
-  return `${capitalize2(modelName)}AggregateArgs`;
-}
-function getAggregateGetName(modelName) {
-  return `Get${capitalize2(modelName)}AggregateType`;
-}
-function getFieldArgName(field, modelName) {
-  if (field.args.length) {
-    return getModelFieldArgsName(field, modelName);
-  }
-  return getModelArgName(field.outputType.type);
-}
-function getModelFieldArgsName(field, modelName) {
-  return `${modelName}$${field.name}Args`;
-}
-function getLegacyModelArgName(modelName) {
-  return `${modelName}Args`;
-}
-function getModelArgName(modelName, action) {
-  if (!action) {
-    return `${modelName}DefaultArgs`;
-  }
-  switch (action) {
-    case DMMF.ModelAction.findMany:
-      return `${modelName}FindManyArgs`;
-    case DMMF.ModelAction.findUnique:
-      return `${modelName}FindUniqueArgs`;
-    case DMMF.ModelAction.findUniqueOrThrow:
-      return `${modelName}FindUniqueOrThrowArgs`;
-    case DMMF.ModelAction.findFirst:
-      return `${modelName}FindFirstArgs`;
-    case DMMF.ModelAction.findFirstOrThrow:
-      return `${modelName}FindFirstOrThrowArgs`;
-    case DMMF.ModelAction.upsert:
-      return `${modelName}UpsertArgs`;
-    case DMMF.ModelAction.update:
-      return `${modelName}UpdateArgs`;
-    case DMMF.ModelAction.updateMany:
-      return `${modelName}UpdateManyArgs`;
-    case DMMF.ModelAction.delete:
-      return `${modelName}DeleteArgs`;
-    case DMMF.ModelAction.create:
-      return `${modelName}CreateArgs`;
-    case DMMF.ModelAction.createMany:
-      return `${modelName}CreateManyArgs`;
-    case DMMF.ModelAction.createManyAndReturn:
-      return `${modelName}CreateManyAndReturnArgs`;
-    case DMMF.ModelAction.deleteMany:
-      return `${modelName}DeleteManyArgs`;
-    case DMMF.ModelAction.groupBy:
-      return getGroupByArgsName(modelName);
-    case DMMF.ModelAction.aggregate:
-      return getAggregateArgsName(modelName);
-    case DMMF.ModelAction.count:
-      return `${modelName}CountArgs`;
-    case DMMF.ModelAction.findRaw:
-      return `${modelName}FindRawArgs`;
-    case DMMF.ModelAction.aggregateRaw:
-      return `${modelName}AggregateRawArgs`;
-    default:
-      assertNever(action, `Unknown action: ${action}`);
-  }
-}
-function getPayloadName(modelName, namespace2 = true) {
-  if (namespace2) {
-    return `Prisma.${getPayloadName(modelName, false)}`;
-  }
-  return `$${modelName}Payload`;
-}
-function getFieldRefsTypeName(name) {
-  return `${name}FieldRefs`;
-}
-function capitalize2(str) {
-  return str[0].toUpperCase() + str.slice(1);
-}
-function getRefAllowedTypeName(type) {
-  let typeName = type.type;
-  if (type.isList) {
-    typeName += "[]";
-  }
-  return `'${typeName}'`;
-}
-var extArgsParam = genericParameter("ExtArgs").extends(namedType("$Extensions.InternalArgs")).default(namedType("$Extensions.DefaultArgs"));
-
 // src/generation/TSClient/helpers.ts
 var import_pluralize2 = __toESM(require_pluralize());
 
@@ -6552,7 +6558,7 @@ var ArgsTypeBuilder = class {
   }
   addSchemaArgs(args) {
     for (const arg of args) {
-      const inputField = buildInputField(arg, this.context.genericArgsInfo);
+      const inputField = buildInputField(arg, this.context);
       const docComment2 = getArgFieldJSDoc(this.type, this.action, arg);
       if (docComment2) {
         inputField.setDocComment(docComment(docComment2));
@@ -6740,37 +6746,46 @@ function buildModelPayload(model, context) {
 function buildIncludeType({
   modelName,
   typeName = getIncludeName(modelName),
-  dmmf,
+  context,
   fields
 }) {
-  const type = buildSelectOrIncludeObject(modelName, getIncludeFields(fields, dmmf));
+  const type = buildSelectOrIncludeObject(modelName, getIncludeFields(fields, context.dmmf), context);
   return buildExport(typeName, type);
 }
-function buildOmitType({ modelName, fields, dmmf }) {
+function buildOmitType({ modelName, fields, context }) {
   const keysType = unionType(
     fields.filter(
-      (field) => field.outputType.location === "scalar" || field.outputType.location === "enumTypes" || dmmf.isComposite(field.outputType.type)
+      (field) => field.outputType.location === "scalar" || field.outputType.location === "enumTypes" || context.dmmf.isComposite(field.outputType.type)
     ).map((field) => stringLiteral(field.name))
   );
   const omitType = namedType("$Extensions.GetOmit").addGenericArgument(keysType).addGenericArgument(modelResultExtensionsType(modelName));
+  if (context.isPreviewFeatureOn("strictUndefinedChecks")) {
+    omitType.addGenericArgument(namedType("$Types.Skip"));
+  }
   return buildExport(getOmitName(modelName), omitType);
 }
-function buildSelectType({ modelName, typeName = getSelectName(modelName), fields }) {
-  const objectType2 = buildSelectOrIncludeObject(modelName, fields);
+function buildSelectType({
+  modelName,
+  typeName = getSelectName(modelName),
+  fields,
+  context
+}) {
+  const objectType2 = buildSelectOrIncludeObject(modelName, fields, context);
   const selectType = namedType("$Extensions.GetSelect").addGenericArgument(objectType2).addGenericArgument(modelResultExtensionsType(modelName));
   return buildExport(typeName, selectType);
 }
 function modelResultExtensionsType(modelName) {
   return extArgsParam.toArgument().subKey("result").subKey(lowerCase(modelName));
 }
-function buildScalarSelectType({ modelName, fields }) {
+function buildScalarSelectType({ modelName, fields, context }) {
   const object = buildSelectOrIncludeObject(
     modelName,
-    fields.filter((field) => field.outputType.location === "scalar" || field.outputType.location === "enumTypes")
+    fields.filter((field) => field.outputType.location === "scalar" || field.outputType.location === "enumTypes"),
+    context
   );
   return moduleExport(typeDeclaration(`${getSelectName(modelName)}Scalar`, object));
 }
-function buildSelectOrIncludeObject(modelName, fields) {
+function buildSelectOrIncludeObject(modelName, fields, context) {
   const objectType2 = objectType();
   for (const field of fields) {
     const fieldType = unionType(booleanType);
@@ -6779,7 +6794,7 @@ function buildSelectOrIncludeObject(modelName, fields) {
       subSelectType.addGenericArgument(extArgsParam.toArgument());
       fieldType.addVariant(subSelectType);
     }
-    objectType2.add(property(field.name, fieldType).optional());
+    objectType2.add(property(field.name, appendSkipType(context, fieldType)).optional());
   }
   return objectType2;
 }
@@ -6814,7 +6829,6 @@ var Model = class {
     this.model = model;
     this.context = context;
     this.dmmf = context.dmmf;
-    this.genericsInfo = context.genericArgsInfo;
     this.type = this.context.dmmf.outputTypeMap.model[model.name];
     this.createManyAndReturnType = this.context.dmmf.outputTypeMap.model[getCreateManyAndReturnOutputType(model.name)];
     this.mapping = this.context.dmmf.mappings.modelOperations.find((m) => m.model === model.name);
@@ -6888,7 +6902,7 @@ export type ${groupByArgsName}<ExtArgs extends $Extensions.InternalArgs = $Exten
 ${(0, import_indent_string3.default)(
       groupByRootField.args.map((arg) => {
         const updatedArg = { ...arg, comment: getArgFieldJSDoc(this.type, DMMF.ModelAction.groupBy, arg) };
-        return new InputField(updatedArg, this.genericsInfo).toTS();
+        return new InputField(updatedArg, this.context).toTS();
       }).concat(
         groupByType.fields.filter((f) => f.outputType.location === "outputObjectTypes").map((f) => {
           if (f.outputType.location === "outputObjectTypes") {
@@ -6975,14 +6989,14 @@ ${aggregateTypes.length > 1 ? aggregateTypes.slice(1).map((type) => {
           ]
         }))
       };
-      return new InputType(newType, this.genericsInfo).toTS();
+      return new InputType(newType, this.context).toTS();
     }).join("\n") : ""}
 
 export type ${aggregateArgsName}<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
 ${(0, import_indent_string3.default)(
       aggregateRootField.args.map((arg) => {
         const updatedArg = { ...arg, comment: getArgFieldJSDoc(this.type, DMMF.ModelAction.aggregate, arg) };
-        return new InputField(updatedArg, this.genericsInfo).toTS();
+        return new InputField(updatedArg, this.context).toTS();
       }).concat(
         aggregateType.fields.map((f) => {
           let data = "";
@@ -7025,18 +7039,21 @@ export type ${getAggregateGetName(model.name)}<T extends ${getAggregateArgsName(
   toTS() {
     const { model } = this;
     const isComposite = this.dmmf.isComposite(model.name);
-    const omitType = this.context.isPreviewFeatureOn("omitApi") ? stringify(buildOmitType({ modelName: this.model.name, dmmf: this.dmmf, fields: this.type.fields }), {
+    const omitType = this.context.isPreviewFeatureOn("omitApi") ? stringify(buildOmitType({ modelName: this.model.name, context: this.context, fields: this.type.fields }), {
       newLine: "leading"
     }) : "";
     const hasRelationField = model.fields.some((f) => f.kind === "object");
-    const includeType = hasRelationField ? stringify(buildIncludeType({ modelName: this.model.name, dmmf: this.dmmf, fields: this.type.fields }), {
-      newLine: "leading"
-    }) : "";
+    const includeType = hasRelationField ? stringify(
+      buildIncludeType({ modelName: this.model.name, context: this.context, fields: this.type.fields }),
+      {
+        newLine: "leading"
+      }
+    ) : "";
     const createManyAndReturnIncludeType = hasRelationField && this.createManyAndReturnType ? stringify(
       buildIncludeType({
         typeName: getIncludeCreateManyAndReturnName(this.model.name),
         modelName: this.model.name,
-        dmmf: this.dmmf,
+        context: this.context,
         fields: this.createManyAndReturnType.fields
       }),
       {
@@ -7052,16 +7069,17 @@ ${!isComposite ? this.getAggregationTypes() : ""}
 
 ${!isComposite ? this.getGroupByTypes() : ""}
 
-${stringify(buildSelectType({ modelName: this.model.name, fields: this.type.fields }))}
+${stringify(buildSelectType({ modelName: this.model.name, fields: this.type.fields, context: this.context }))}
 ${this.createManyAndReturnType ? stringify(
       buildSelectType({
         modelName: this.model.name,
         fields: this.createManyAndReturnType.fields,
+        context: this.context,
         typeName: getSelectCreateManyAndReturnName(this.model.name)
       }),
       { newLine: "leading" }
     ) : ""}
-${stringify(buildScalarSelectType({ modelName: this.model.name, fields: this.type.fields }), {
+${stringify(buildScalarSelectType({ modelName: this.model.name, fields: this.type.fields, context: this.context }), {
       newLine: "leading"
     })}
 ${omitType}${includeType}${createManyAndReturnIncludeType}
@@ -7839,6 +7857,7 @@ var commonCodeJS = ({
   browser,
   clientVersion: clientVersion2,
   engineVersion,
+  generator,
   deno
 }) => `${deno ? "const exports = {}" : ""}
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -7862,14 +7881,16 @@ import {
   Extensions,
   defineDmmfProperty,
   Public,
-  getRuntime
+  getRuntime,
+  skip
 } from '${runtimeBase}/${runtimeNameJs}.js'` : browser ? `
 const {
   Decimal,
   objectEnumValues,
   makeStrictEnum,
   Public,
-  getRuntime
+  getRuntime,
+  skip
 } = require('${runtimeBase}/${runtimeNameJs}.js')
 ` : `
 const {
@@ -7884,6 +7905,7 @@ const {
   empty,
   join,
   raw,
+  skip,
   Decimal,
   Debug,
   objectEnumValues,
@@ -7945,6 +7967,8 @@ Prisma.NullTypes = {
   JsonNull: objectEnumValues.classes.JsonNull,
   AnyNull: objectEnumValues.classes.AnyNull
 }
+
+${buildPrismaSkipJs(generator.previewFeatures)}
 `;
 var notSupportOnBrowser = (fnc, browser) => {
   if (browser) {
@@ -7956,7 +7980,13 @@ In case this error is unexpected for you, please report it in https://pris.ly/pr
   }
   return fnc;
 };
-var commonCodeTS = ({ runtimeBase, runtimeNameTs, clientVersion: clientVersion2, engineVersion }) => ({
+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
@@ -7994,6 +8024,8 @@ export import join = runtime.join
 export import raw = runtime.raw
 export import Sql = runtime.Sql
 
+${buildPrismaSkipTs(generator.previewFeatures)}
+
 /**
  * Decimal.js
  */
@@ -8386,6 +8418,25 @@ class ${name} {
 }`;
   return (0, import_indent_string4.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/Count.ts
 var import_indent_string5 = __toESM(require_indent_string());
@@ -9290,14 +9341,14 @@ ${this.dmmf.inputObjectTypes.prisma?.reduce((acc, inputType) => {
       ${baseName}
     >
   | OptionalFlat<Omit<${baseName}, 'path'>>`);
-          acc.push(new InputType(inputType, this.genericsInfo).overrideName(`${inputType.name}Base`).toTS());
+          acc.push(new InputType(inputType, context).overrideName(`${inputType.name}Base`).toTS());
         } else {
-          acc.push(new InputType(inputType, this.genericsInfo).toTS());
+          acc.push(new InputType(inputType, context).toTS());
         }
         return acc;
       }, []).join("\n")}
 
-${this.dmmf.inputObjectTypes.model?.map((inputType) => new InputType(inputType, this.genericsInfo).toTS()).join("\n") ?? ""}
+${this.dmmf.inputObjectTypes.model?.map((inputType) => new InputType(inputType, context).toTS()).join("\n") ?? ""}
 
 /**
  * Aliases for legacy arg types
@@ -9391,22 +9442,43 @@ var DbEnumsList = class {
   hasEnum(name) {
     return Boolean(this.enums.find((dbEnum) => dbEnum.name === name));
   }
-  *[Symbol.iterator]() {
+  *validJsIdentifiers() {
     for (const dbEnum of this.enums) {
-      yield dbEnum;
+      if (isValidJsIdentifier(dbEnum.name)) {
+        yield dbEnum;
+      }
+    }
+  }
+  *invalidJsIdentifiers() {
+    for (const dbEnum of this.enums) {
+      if (!isValidJsIdentifier(dbEnum.name)) {
+        yield dbEnum;
+      }
     }
   }
 };
 function buildDbEnums(list) {
   const file2 = file();
-  for (const dbEntry of list) {
-    file2.add(buildDbEnum(dbEntry));
-  }
+  file2.add(buildInvalidIdentifierEnums(list));
+  file2.add(buildValidIdentifierEnums(list));
   return stringify(file2);
 }
-function buildDbEnum(dbEnum) {
-  const type = unionType(dbEnum.values.map(stringLiteral));
-  return moduleExport(typeDeclaration(dbEnum.name, type));
+function buildValidIdentifierEnums(list) {
+  const namespace2 = namespace("$DbEnums");
+  for (const dbEnum of list.validJsIdentifiers()) {
+    namespace2.add(typeDeclaration(dbEnum.name, enumToUnion(dbEnum)));
+  }
+  return moduleExport(namespace2);
+}
+function buildInvalidIdentifierEnums(list) {
+  const iface = interfaceDeclaration("$DbEnums");
+  for (const dbEnum of list.invalidJsIdentifiers()) {
+    iface.add(property(dbEnum.name, enumToUnion(dbEnum)));
+  }
+  return moduleExport(iface);
+}
+function enumToUnion(dbEnum) {
+  return unionType(dbEnum.values.map(stringLiteral));
 }
 function queryUsesEnums(query, enums) {
   if (enums.isEmpty()) {
@@ -9419,7 +9491,7 @@ function queryUsesEnums(query, enums) {
 function buildIndexTs(queries, enums) {
   const file2 = file();
   if (!enums.isEmpty()) {
-    file2.add(moduleExportFrom("./$DbEnums").asNamespace("$DbEnums"));
+    file2.add(moduleExportFrom("./$DbEnums").named("$DbEnums"));
   }
   for (const query of queries) {
     file2.add(moduleExportFrom(`./${query.name}`));
@@ -9526,7 +9598,7 @@ function getMappingConfig(introspectionType, enums) {
   const config = typeMappings[introspectionType];
   if (!config) {
     if (enums.hasEnum(introspectionType)) {
-      const type = namedType(`$DbEnums.${introspectionType}`);
+      const type = getEnumType(introspectionType);
       return { in: type, out: type };
     }
     throw new Error("Unknown type");
@@ -9536,13 +9608,19 @@ function getMappingConfig(introspectionType, enums) {
   }
   return config;
 }
+function getEnumType(name) {
+  if (isValidJsIdentifier(name)) {
+    return namedType(`$DbEnums.${name}`);
+  }
+  return namedType("$DbEnums").subKey(name);
+}
 
 // src/generation/typedSql/buildTypedQuery.ts
 function buildTypedQueryTs({ query, runtimeBase, runtimeName, enums }) {
   const file2 = file();
   file2.addImport(moduleImport(`${runtimeBase}/${runtimeName}`).asNamespace("$runtime"));
   if (queryUsesEnums(query, enums)) {
-    file2.addImport(moduleImport("./$DbEnums").asNamespace("$DbEnums"));
+    file2.addImport(moduleImport("./$DbEnums").named("$DbEnums"));
   }
   const doc = docComment(query.documentation ?? void 0);
   const factoryType = functionType();