diff --git a/.changeset/lucky-bears-kiss.md b/.changeset/lucky-bears-kiss.md
new file mode 100644
index 00000000000..b1491121c11
--- /dev/null
+++ b/.changeset/lucky-bears-kiss.md
@@ -0,0 +1,6 @@
+---
+'@keystone-next/keystone': major
+'@keystone-next/types': major
+---
+
+Updated `@graphql-ts/schema`. The second type parameter of `schema.Arg` exported from `@keystone-next/types` is now a boolean that defines whether or not the arg has a default value to make it easier to define circular input objects.
diff --git a/packages/keystone/src/lib/id-field.ts b/packages/keystone/src/lib/id-field.ts
index 606f31480aa..5f3fd34136f 100644
--- a/packages/keystone/src/lib/id-field.ts
+++ b/packages/keystone/src/lib/id-field.ts
@@ -55,7 +55,7 @@ const nonCircularFields = {
 
 type IDFilterType = schema.InputObjectType<
   typeof nonCircularFields & {
-    not: schema.Arg<typeof IDFilter, undefined>;
+    not: schema.Arg<typeof IDFilter>;
   }
 >;
 
diff --git a/packages/types/package.json b/packages/types/package.json
index f8c35d64195..ac5cf78910e 100644
--- a/packages/types/package.json
+++ b/packages/types/package.json
@@ -9,7 +9,7 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.14.8",
-    "@graphql-ts/schema": "0.1.2",
+    "@graphql-ts/schema": "0.2.0",
     "@keystone-next/fields": "^13.0.0",
     "apollo-server-types": "^0.9.0",
     "cors": "^2.8.5",
diff --git a/packages/types/src/filters/enum-filter.ts b/packages/types/src/filters/enum-filter.ts
index dd29bbbaed0..c6d91228411 100644
--- a/packages/types/src/filters/enum-filter.ts
+++ b/packages/types/src/filters/enum-filter.ts
@@ -11,14 +11,14 @@ export type EnumNullableFilter<Enum extends schema.EnumType<any>> = schema.Input
   // can be null
   notIn: schema.Arg<schema.ListType<schema.NonNullType<Enum>>>;
   // can be null
-  not: schema.Arg<EnumNullableFilter<Enum>, undefined>;
+  not: schema.Arg<EnumNullableFilter<Enum>>;
 }>;
 
 export type EnumFilter<Enum extends schema.EnumType<any>> = schema.InputObjectType<{
   equals: schema.Arg<Enum>;
   in: schema.Arg<schema.ListType<schema.NonNullType<Enum>>>;
   notIn: schema.Arg<schema.ListType<schema.NonNullType<Enum>>>;
-  not: schema.Arg<EnumFilter<Enum>, undefined>;
+  not: schema.Arg<EnumFilter<Enum>>;
 }>;
 
 type EnumNullableListFilterType<Enum extends schema.EnumType<any>> = schema.InputObjectType<{
diff --git a/packages/types/src/filters/providers/postgresql.ts b/packages/types/src/filters/providers/postgresql.ts
index dd69d069c51..cac24d557da 100644
--- a/packages/types/src/filters/providers/postgresql.ts
+++ b/packages/types/src/filters/providers/postgresql.ts
@@ -7,21 +7,21 @@ import { QueryMode } from '../..';
 
 type StringNullableFilterType = schema.InputObjectType<{
   // can be null
-  equals: schema.Arg<typeof schema.String, undefined>;
+  equals: schema.Arg<typeof schema.String>;
   // can be null
-  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
+  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
   // can be null
-  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  lt: schema.Arg<typeof schema.String, undefined>;
-  lte: schema.Arg<typeof schema.String, undefined>;
-  gt: schema.Arg<typeof schema.String, undefined>;
-  gte: schema.Arg<typeof schema.String, undefined>;
-  contains: schema.Arg<typeof schema.String, undefined>;
-  startsWith: schema.Arg<typeof schema.String, undefined>;
-  endsWith: schema.Arg<typeof schema.String, undefined>;
-  mode: schema.Arg<typeof QueryMode, undefined>;
+  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  lt: schema.Arg<typeof schema.String>;
+  lte: schema.Arg<typeof schema.String>;
+  gt: schema.Arg<typeof schema.String>;
+  gte: schema.Arg<typeof schema.String>;
+  contains: schema.Arg<typeof schema.String>;
+  startsWith: schema.Arg<typeof schema.String>;
+  endsWith: schema.Arg<typeof schema.String>;
+  mode: schema.Arg<typeof QueryMode>;
   // can be null
-  not: schema.Arg<typeof NestedStringNullableFilter, undefined>;
+  not: schema.Arg<typeof NestedStringNullableFilter>;
 }>;
 
 const StringNullableFilter: StringNullableFilterType = schema.inputObject({
@@ -48,20 +48,20 @@ const StringNullableFilter: StringNullableFilterType = schema.inputObject({
 
 type NestedStringNullableFilterType = schema.InputObjectType<{
   // can be null
-  equals: schema.Arg<typeof schema.String, undefined>;
+  equals: schema.Arg<typeof schema.String>;
   // can be null
-  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
+  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
   // can be null
-  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  lt: schema.Arg<typeof schema.String, undefined>;
-  lte: schema.Arg<typeof schema.String, undefined>;
-  gt: schema.Arg<typeof schema.String, undefined>;
-  gte: schema.Arg<typeof schema.String, undefined>;
-  contains: schema.Arg<typeof schema.String, undefined>;
-  startsWith: schema.Arg<typeof schema.String, undefined>;
-  endsWith: schema.Arg<typeof schema.String, undefined>;
+  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  lt: schema.Arg<typeof schema.String>;
+  lte: schema.Arg<typeof schema.String>;
+  gt: schema.Arg<typeof schema.String>;
+  gte: schema.Arg<typeof schema.String>;
+  contains: schema.Arg<typeof schema.String>;
+  startsWith: schema.Arg<typeof schema.String>;
+  endsWith: schema.Arg<typeof schema.String>;
   // can be null
-  not: schema.Arg<typeof NestedStringNullableFilter, undefined>;
+  not: schema.Arg<typeof NestedStringNullableFilter>;
 }>;
 
 const NestedStringNullableFilter: NestedStringNullableFilterType = schema.inputObject({
@@ -86,18 +86,18 @@ const NestedStringNullableFilter: NestedStringNullableFilterType = schema.inputO
 });
 
 type StringFilterType = schema.InputObjectType<{
-  equals: schema.Arg<typeof schema.String, undefined>;
-  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  lt: schema.Arg<typeof schema.String, undefined>;
-  lte: schema.Arg<typeof schema.String, undefined>;
-  gt: schema.Arg<typeof schema.String, undefined>;
-  gte: schema.Arg<typeof schema.String, undefined>;
-  contains: schema.Arg<typeof schema.String, undefined>;
-  startsWith: schema.Arg<typeof schema.String, undefined>;
-  endsWith: schema.Arg<typeof schema.String, undefined>;
-  mode: schema.Arg<typeof QueryMode, undefined>;
-  not: schema.Arg<typeof NestedStringFilter, undefined>;
+  equals: schema.Arg<typeof schema.String>;
+  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  lt: schema.Arg<typeof schema.String>;
+  lte: schema.Arg<typeof schema.String>;
+  gt: schema.Arg<typeof schema.String>;
+  gte: schema.Arg<typeof schema.String>;
+  contains: schema.Arg<typeof schema.String>;
+  startsWith: schema.Arg<typeof schema.String>;
+  endsWith: schema.Arg<typeof schema.String>;
+  mode: schema.Arg<typeof QueryMode>;
+  not: schema.Arg<typeof NestedStringFilter>;
 }>;
 
 const StringFilter: StringFilterType = schema.inputObject({
@@ -119,17 +119,17 @@ const StringFilter: StringFilterType = schema.inputObject({
 });
 
 type NestedStringFilterType = schema.InputObjectType<{
-  equals: schema.Arg<typeof schema.String, undefined>;
-  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  lt: schema.Arg<typeof schema.String, undefined>;
-  lte: schema.Arg<typeof schema.String, undefined>;
-  gt: schema.Arg<typeof schema.String, undefined>;
-  gte: schema.Arg<typeof schema.String, undefined>;
-  contains: schema.Arg<typeof schema.String, undefined>;
-  startsWith: schema.Arg<typeof schema.String, undefined>;
-  endsWith: schema.Arg<typeof schema.String, undefined>;
-  not: schema.Arg<typeof NestedStringFilter, undefined>;
+  equals: schema.Arg<typeof schema.String>;
+  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  lt: schema.Arg<typeof schema.String>;
+  lte: schema.Arg<typeof schema.String>;
+  gt: schema.Arg<typeof schema.String>;
+  gte: schema.Arg<typeof schema.String>;
+  contains: schema.Arg<typeof schema.String>;
+  startsWith: schema.Arg<typeof schema.String>;
+  endsWith: schema.Arg<typeof schema.String>;
+  not: schema.Arg<typeof NestedStringFilter>;
 }>;
 
 const NestedStringFilter: NestedStringFilterType = schema.inputObject({
@@ -151,12 +151,12 @@ const NestedStringFilter: NestedStringFilterType = schema.inputObject({
 
 type StringNullableListFilterType = schema.InputObjectType<{
   // can be null
-  equals: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
+  equals: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
   // can be null
-  has: schema.Arg<typeof schema.String, undefined>;
-  hasEvery: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  hasSome: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  isEmpty: schema.Arg<typeof schema.Boolean, undefined>;
+  has: schema.Arg<typeof schema.String>;
+  hasEvery: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  hasSome: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  isEmpty: schema.Arg<typeof schema.Boolean>;
 }>;
 
 const StringNullableListFilter: StringNullableListFilterType = schema.inputObject({
@@ -174,9 +174,9 @@ const StringNullableListFilter: StringNullableListFilterType = schema.inputObjec
 
 type BoolNullableFilterType = schema.InputObjectType<{
   // can be null
-  equals: schema.Arg<typeof schema.Boolean, undefined>;
+  equals: schema.Arg<typeof schema.Boolean>;
   // can be null
-  not: schema.Arg<typeof BoolNullableFilter, undefined>;
+  not: schema.Arg<typeof BoolNullableFilter>;
 }>;
 
 const BoolNullableFilter: BoolNullableFilterType = schema.inputObject({
@@ -190,8 +190,8 @@ const BoolNullableFilter: BoolNullableFilterType = schema.inputObject({
 });
 
 type BoolFilterType = schema.InputObjectType<{
-  equals: schema.Arg<typeof schema.Boolean, undefined>;
-  not: schema.Arg<typeof BoolFilter, undefined>;
+  equals: schema.Arg<typeof schema.Boolean>;
+  not: schema.Arg<typeof BoolFilter>;
 }>;
 
 const BoolFilter: BoolFilterType = schema.inputObject({
@@ -204,12 +204,12 @@ const BoolFilter: BoolFilterType = schema.inputObject({
 
 type BoolNullableListFilterType = schema.InputObjectType<{
   // can be null
-  equals: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Boolean>>, undefined>;
+  equals: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Boolean>>>;
   // can be null
-  has: schema.Arg<typeof schema.Boolean, undefined>;
-  hasEvery: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Boolean>>, undefined>;
-  hasSome: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Boolean>>, undefined>;
-  isEmpty: schema.Arg<typeof schema.Boolean, undefined>;
+  has: schema.Arg<typeof schema.Boolean>;
+  hasEvery: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Boolean>>>;
+  hasSome: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Boolean>>>;
+  isEmpty: schema.Arg<typeof schema.Boolean>;
 }>;
 
 const BoolNullableListFilter: BoolNullableListFilterType = schema.inputObject({
@@ -227,17 +227,17 @@ const BoolNullableListFilter: BoolNullableListFilterType = schema.inputObject({
 
 type IntNullableFilterType = schema.InputObjectType<{
   // can be null
-  equals: schema.Arg<typeof schema.Int, undefined>;
+  equals: schema.Arg<typeof schema.Int>;
   // can be null
-  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Int>>, undefined>;
+  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Int>>>;
   // can be null
-  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Int>>, undefined>;
-  lt: schema.Arg<typeof schema.Int, undefined>;
-  lte: schema.Arg<typeof schema.Int, undefined>;
-  gt: schema.Arg<typeof schema.Int, undefined>;
-  gte: schema.Arg<typeof schema.Int, undefined>;
+  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Int>>>;
+  lt: schema.Arg<typeof schema.Int>;
+  lte: schema.Arg<typeof schema.Int>;
+  gt: schema.Arg<typeof schema.Int>;
+  gte: schema.Arg<typeof schema.Int>;
   // can be null
-  not: schema.Arg<typeof IntNullableFilter, undefined>;
+  not: schema.Arg<typeof IntNullableFilter>;
 }>;
 
 const IntNullableFilter: IntNullableFilterType = schema.inputObject({
@@ -259,14 +259,14 @@ const IntNullableFilter: IntNullableFilterType = schema.inputObject({
 });
 
 type IntFilterType = schema.InputObjectType<{
-  equals: schema.Arg<typeof schema.Int, undefined>;
-  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Int>>, undefined>;
-  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Int>>, undefined>;
-  lt: schema.Arg<typeof schema.Int, undefined>;
-  lte: schema.Arg<typeof schema.Int, undefined>;
-  gt: schema.Arg<typeof schema.Int, undefined>;
-  gte: schema.Arg<typeof schema.Int, undefined>;
-  not: schema.Arg<typeof IntFilter, undefined>;
+  equals: schema.Arg<typeof schema.Int>;
+  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Int>>>;
+  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Int>>>;
+  lt: schema.Arg<typeof schema.Int>;
+  lte: schema.Arg<typeof schema.Int>;
+  gt: schema.Arg<typeof schema.Int>;
+  gte: schema.Arg<typeof schema.Int>;
+  not: schema.Arg<typeof IntFilter>;
 }>;
 
 const IntFilter: IntFilterType = schema.inputObject({
@@ -285,12 +285,12 @@ const IntFilter: IntFilterType = schema.inputObject({
 
 type IntNullableListFilterType = schema.InputObjectType<{
   // can be null
-  equals: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Int>>, undefined>;
+  equals: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Int>>>;
   // can be null
-  has: schema.Arg<typeof schema.Int, undefined>;
-  hasEvery: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Int>>, undefined>;
-  hasSome: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Int>>, undefined>;
-  isEmpty: schema.Arg<typeof schema.Boolean, undefined>;
+  has: schema.Arg<typeof schema.Int>;
+  hasEvery: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Int>>>;
+  hasSome: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Int>>>;
+  isEmpty: schema.Arg<typeof schema.Boolean>;
 }>;
 
 const IntNullableListFilter: IntNullableListFilterType = schema.inputObject({
@@ -308,17 +308,17 @@ const IntNullableListFilter: IntNullableListFilterType = schema.inputObject({
 
 type FloatNullableFilterType = schema.InputObjectType<{
   // can be null
-  equals: schema.Arg<typeof schema.Float, undefined>;
+  equals: schema.Arg<typeof schema.Float>;
   // can be null
-  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Float>>, undefined>;
+  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Float>>>;
   // can be null
-  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Float>>, undefined>;
-  lt: schema.Arg<typeof schema.Float, undefined>;
-  lte: schema.Arg<typeof schema.Float, undefined>;
-  gt: schema.Arg<typeof schema.Float, undefined>;
-  gte: schema.Arg<typeof schema.Float, undefined>;
+  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Float>>>;
+  lt: schema.Arg<typeof schema.Float>;
+  lte: schema.Arg<typeof schema.Float>;
+  gt: schema.Arg<typeof schema.Float>;
+  gte: schema.Arg<typeof schema.Float>;
   // can be null
-  not: schema.Arg<typeof FloatNullableFilter, undefined>;
+  not: schema.Arg<typeof FloatNullableFilter>;
 }>;
 
 const FloatNullableFilter: FloatNullableFilterType = schema.inputObject({
@@ -340,14 +340,14 @@ const FloatNullableFilter: FloatNullableFilterType = schema.inputObject({
 });
 
 type FloatFilterType = schema.InputObjectType<{
-  equals: schema.Arg<typeof schema.Float, undefined>;
-  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Float>>, undefined>;
-  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Float>>, undefined>;
-  lt: schema.Arg<typeof schema.Float, undefined>;
-  lte: schema.Arg<typeof schema.Float, undefined>;
-  gt: schema.Arg<typeof schema.Float, undefined>;
-  gte: schema.Arg<typeof schema.Float, undefined>;
-  not: schema.Arg<typeof FloatFilter, undefined>;
+  equals: schema.Arg<typeof schema.Float>;
+  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Float>>>;
+  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Float>>>;
+  lt: schema.Arg<typeof schema.Float>;
+  lte: schema.Arg<typeof schema.Float>;
+  gt: schema.Arg<typeof schema.Float>;
+  gte: schema.Arg<typeof schema.Float>;
+  not: schema.Arg<typeof FloatFilter>;
 }>;
 
 const FloatFilter: FloatFilterType = schema.inputObject({
@@ -366,12 +366,12 @@ const FloatFilter: FloatFilterType = schema.inputObject({
 
 type FloatNullableListFilterType = schema.InputObjectType<{
   // can be null
-  equals: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Float>>, undefined>;
+  equals: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Float>>>;
   // can be null
-  has: schema.Arg<typeof schema.Float, undefined>;
-  hasEvery: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Float>>, undefined>;
-  hasSome: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Float>>, undefined>;
-  isEmpty: schema.Arg<typeof schema.Boolean, undefined>;
+  has: schema.Arg<typeof schema.Float>;
+  hasEvery: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Float>>>;
+  hasSome: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Float>>>;
+  isEmpty: schema.Arg<typeof schema.Boolean>;
 }>;
 
 const FloatNullableListFilter: FloatNullableListFilterType = schema.inputObject({
@@ -389,17 +389,17 @@ const FloatNullableListFilter: FloatNullableListFilterType = schema.inputObject(
 
 type DateTimeNullableFilterType = schema.InputObjectType<{
   // can be null
-  equals: schema.Arg<typeof schema.String, undefined>;
+  equals: schema.Arg<typeof schema.String>;
   // can be null
-  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
+  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
   // can be null
-  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  lt: schema.Arg<typeof schema.String, undefined>;
-  lte: schema.Arg<typeof schema.String, undefined>;
-  gt: schema.Arg<typeof schema.String, undefined>;
-  gte: schema.Arg<typeof schema.String, undefined>;
+  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  lt: schema.Arg<typeof schema.String>;
+  lte: schema.Arg<typeof schema.String>;
+  gt: schema.Arg<typeof schema.String>;
+  gte: schema.Arg<typeof schema.String>;
   // can be null
-  not: schema.Arg<typeof DateTimeNullableFilter, undefined>;
+  not: schema.Arg<typeof DateTimeNullableFilter>;
 }>;
 
 const DateTimeNullableFilter: DateTimeNullableFilterType = schema.inputObject({
@@ -421,14 +421,14 @@ const DateTimeNullableFilter: DateTimeNullableFilterType = schema.inputObject({
 });
 
 type DateTimeFilterType = schema.InputObjectType<{
-  equals: schema.Arg<typeof schema.String, undefined>;
-  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  lt: schema.Arg<typeof schema.String, undefined>;
-  lte: schema.Arg<typeof schema.String, undefined>;
-  gt: schema.Arg<typeof schema.String, undefined>;
-  gte: schema.Arg<typeof schema.String, undefined>;
-  not: schema.Arg<typeof DateTimeFilter, undefined>;
+  equals: schema.Arg<typeof schema.String>;
+  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  lt: schema.Arg<typeof schema.String>;
+  lte: schema.Arg<typeof schema.String>;
+  gt: schema.Arg<typeof schema.String>;
+  gte: schema.Arg<typeof schema.String>;
+  not: schema.Arg<typeof DateTimeFilter>;
 }>;
 
 const DateTimeFilter: DateTimeFilterType = schema.inputObject({
@@ -447,12 +447,12 @@ const DateTimeFilter: DateTimeFilterType = schema.inputObject({
 
 type DateTimeNullableListFilterType = schema.InputObjectType<{
   // can be null
-  equals: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
+  equals: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
   // can be null
-  has: schema.Arg<typeof schema.String, undefined>;
-  hasEvery: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  hasSome: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  isEmpty: schema.Arg<typeof schema.Boolean, undefined>;
+  has: schema.Arg<typeof schema.String>;
+  hasEvery: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  hasSome: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  isEmpty: schema.Arg<typeof schema.Boolean>;
 }>;
 
 const DateTimeNullableListFilter: DateTimeNullableListFilterType = schema.inputObject({
@@ -470,9 +470,9 @@ const DateTimeNullableListFilter: DateTimeNullableListFilterType = schema.inputO
 
 type JsonNullableFilterType = schema.InputObjectType<{
   // can be null
-  equals: schema.Arg<typeof schema.JSON, undefined>;
+  equals: schema.Arg<typeof schema.JSON>;
   // can be null
-  not: schema.Arg<typeof schema.JSON, undefined>;
+  not: schema.Arg<typeof schema.JSON>;
 }>;
 
 const JsonNullableFilter: JsonNullableFilterType = schema.inputObject({
@@ -486,8 +486,8 @@ const JsonNullableFilter: JsonNullableFilterType = schema.inputObject({
 });
 
 type JsonFilterType = schema.InputObjectType<{
-  equals: schema.Arg<typeof schema.JSON, undefined>;
-  not: schema.Arg<typeof schema.JSON, undefined>;
+  equals: schema.Arg<typeof schema.JSON>;
+  not: schema.Arg<typeof schema.JSON>;
 }>;
 
 const JsonFilter: JsonFilterType = schema.inputObject({
@@ -500,12 +500,12 @@ const JsonFilter: JsonFilterType = schema.inputObject({
 
 type JsonNullableListFilterType = schema.InputObjectType<{
   // can be null
-  equals: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.JSON>>, undefined>;
+  equals: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.JSON>>>;
   // can be null
-  has: schema.Arg<typeof schema.JSON, undefined>;
-  hasEvery: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.JSON>>, undefined>;
-  hasSome: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.JSON>>, undefined>;
-  isEmpty: schema.Arg<typeof schema.Boolean, undefined>;
+  has: schema.Arg<typeof schema.JSON>;
+  hasEvery: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.JSON>>>;
+  hasSome: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.JSON>>>;
+  isEmpty: schema.Arg<typeof schema.Boolean>;
 }>;
 
 const JsonNullableListFilter: JsonNullableListFilterType = schema.inputObject({
@@ -523,17 +523,17 @@ const JsonNullableListFilter: JsonNullableListFilterType = schema.inputObject({
 
 type DecimalNullableFilterType = schema.InputObjectType<{
   // can be null
-  equals: schema.Arg<typeof schema.String, undefined>;
+  equals: schema.Arg<typeof schema.String>;
   // can be null
-  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
+  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
   // can be null
-  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  lt: schema.Arg<typeof schema.String, undefined>;
-  lte: schema.Arg<typeof schema.String, undefined>;
-  gt: schema.Arg<typeof schema.String, undefined>;
-  gte: schema.Arg<typeof schema.String, undefined>;
+  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  lt: schema.Arg<typeof schema.String>;
+  lte: schema.Arg<typeof schema.String>;
+  gt: schema.Arg<typeof schema.String>;
+  gte: schema.Arg<typeof schema.String>;
   // can be null
-  not: schema.Arg<typeof DecimalNullableFilter, undefined>;
+  not: schema.Arg<typeof DecimalNullableFilter>;
 }>;
 
 const DecimalNullableFilter: DecimalNullableFilterType = schema.inputObject({
@@ -555,14 +555,14 @@ const DecimalNullableFilter: DecimalNullableFilterType = schema.inputObject({
 });
 
 type DecimalFilterType = schema.InputObjectType<{
-  equals: schema.Arg<typeof schema.String, undefined>;
-  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  lt: schema.Arg<typeof schema.String, undefined>;
-  lte: schema.Arg<typeof schema.String, undefined>;
-  gt: schema.Arg<typeof schema.String, undefined>;
-  gte: schema.Arg<typeof schema.String, undefined>;
-  not: schema.Arg<typeof DecimalFilter, undefined>;
+  equals: schema.Arg<typeof schema.String>;
+  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  lt: schema.Arg<typeof schema.String>;
+  lte: schema.Arg<typeof schema.String>;
+  gt: schema.Arg<typeof schema.String>;
+  gte: schema.Arg<typeof schema.String>;
+  not: schema.Arg<typeof DecimalFilter>;
 }>;
 
 const DecimalFilter: DecimalFilterType = schema.inputObject({
@@ -581,12 +581,12 @@ const DecimalFilter: DecimalFilterType = schema.inputObject({
 
 type DecimalNullableListFilterType = schema.InputObjectType<{
   // can be null
-  equals: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
+  equals: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
   // can be null
-  has: schema.Arg<typeof schema.String, undefined>;
-  hasEvery: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  hasSome: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  isEmpty: schema.Arg<typeof schema.Boolean, undefined>;
+  has: schema.Arg<typeof schema.String>;
+  hasEvery: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  hasSome: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  isEmpty: schema.Arg<typeof schema.Boolean>;
 }>;
 
 const DecimalNullableListFilter: DecimalNullableListFilterType = schema.inputObject({
diff --git a/packages/types/src/filters/providers/sqlite.ts b/packages/types/src/filters/providers/sqlite.ts
index 6ac15d260b8..20591155798 100644
--- a/packages/types/src/filters/providers/sqlite.ts
+++ b/packages/types/src/filters/providers/sqlite.ts
@@ -5,20 +5,20 @@ import { schema } from '../../schema';
 
 type StringNullableFilterType = schema.InputObjectType<{
   // can be null
-  equals: schema.Arg<typeof schema.String, undefined>;
+  equals: schema.Arg<typeof schema.String>;
   // can be null
-  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
+  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
   // can be null
-  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  lt: schema.Arg<typeof schema.String, undefined>;
-  lte: schema.Arg<typeof schema.String, undefined>;
-  gt: schema.Arg<typeof schema.String, undefined>;
-  gte: schema.Arg<typeof schema.String, undefined>;
-  contains: schema.Arg<typeof schema.String, undefined>;
-  startsWith: schema.Arg<typeof schema.String, undefined>;
-  endsWith: schema.Arg<typeof schema.String, undefined>;
+  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  lt: schema.Arg<typeof schema.String>;
+  lte: schema.Arg<typeof schema.String>;
+  gt: schema.Arg<typeof schema.String>;
+  gte: schema.Arg<typeof schema.String>;
+  contains: schema.Arg<typeof schema.String>;
+  startsWith: schema.Arg<typeof schema.String>;
+  endsWith: schema.Arg<typeof schema.String>;
   // can be null
-  not: schema.Arg<typeof NestedStringNullableFilter, undefined>;
+  not: schema.Arg<typeof NestedStringNullableFilter>;
 }>;
 
 const StringNullableFilter: StringNullableFilterType = schema.inputObject({
@@ -44,20 +44,20 @@ const StringNullableFilter: StringNullableFilterType = schema.inputObject({
 
 type NestedStringNullableFilterType = schema.InputObjectType<{
   // can be null
-  equals: schema.Arg<typeof schema.String, undefined>;
+  equals: schema.Arg<typeof schema.String>;
   // can be null
-  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
+  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
   // can be null
-  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  lt: schema.Arg<typeof schema.String, undefined>;
-  lte: schema.Arg<typeof schema.String, undefined>;
-  gt: schema.Arg<typeof schema.String, undefined>;
-  gte: schema.Arg<typeof schema.String, undefined>;
-  contains: schema.Arg<typeof schema.String, undefined>;
-  startsWith: schema.Arg<typeof schema.String, undefined>;
-  endsWith: schema.Arg<typeof schema.String, undefined>;
+  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  lt: schema.Arg<typeof schema.String>;
+  lte: schema.Arg<typeof schema.String>;
+  gt: schema.Arg<typeof schema.String>;
+  gte: schema.Arg<typeof schema.String>;
+  contains: schema.Arg<typeof schema.String>;
+  startsWith: schema.Arg<typeof schema.String>;
+  endsWith: schema.Arg<typeof schema.String>;
   // can be null
-  not: schema.Arg<typeof NestedStringNullableFilter, undefined>;
+  not: schema.Arg<typeof NestedStringNullableFilter>;
 }>;
 
 const NestedStringNullableFilter: NestedStringNullableFilterType = schema.inputObject({
@@ -82,17 +82,17 @@ const NestedStringNullableFilter: NestedStringNullableFilterType = schema.inputO
 });
 
 type StringFilterType = schema.InputObjectType<{
-  equals: schema.Arg<typeof schema.String, undefined>;
-  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  lt: schema.Arg<typeof schema.String, undefined>;
-  lte: schema.Arg<typeof schema.String, undefined>;
-  gt: schema.Arg<typeof schema.String, undefined>;
-  gte: schema.Arg<typeof schema.String, undefined>;
-  contains: schema.Arg<typeof schema.String, undefined>;
-  startsWith: schema.Arg<typeof schema.String, undefined>;
-  endsWith: schema.Arg<typeof schema.String, undefined>;
-  not: schema.Arg<typeof NestedStringFilter, undefined>;
+  equals: schema.Arg<typeof schema.String>;
+  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  lt: schema.Arg<typeof schema.String>;
+  lte: schema.Arg<typeof schema.String>;
+  gt: schema.Arg<typeof schema.String>;
+  gte: schema.Arg<typeof schema.String>;
+  contains: schema.Arg<typeof schema.String>;
+  startsWith: schema.Arg<typeof schema.String>;
+  endsWith: schema.Arg<typeof schema.String>;
+  not: schema.Arg<typeof NestedStringFilter>;
 }>;
 
 const StringFilter: StringFilterType = schema.inputObject({
@@ -113,17 +113,17 @@ const StringFilter: StringFilterType = schema.inputObject({
 });
 
 type NestedStringFilterType = schema.InputObjectType<{
-  equals: schema.Arg<typeof schema.String, undefined>;
-  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  lt: schema.Arg<typeof schema.String, undefined>;
-  lte: schema.Arg<typeof schema.String, undefined>;
-  gt: schema.Arg<typeof schema.String, undefined>;
-  gte: schema.Arg<typeof schema.String, undefined>;
-  contains: schema.Arg<typeof schema.String, undefined>;
-  startsWith: schema.Arg<typeof schema.String, undefined>;
-  endsWith: schema.Arg<typeof schema.String, undefined>;
-  not: schema.Arg<typeof NestedStringFilter, undefined>;
+  equals: schema.Arg<typeof schema.String>;
+  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  lt: schema.Arg<typeof schema.String>;
+  lte: schema.Arg<typeof schema.String>;
+  gt: schema.Arg<typeof schema.String>;
+  gte: schema.Arg<typeof schema.String>;
+  contains: schema.Arg<typeof schema.String>;
+  startsWith: schema.Arg<typeof schema.String>;
+  endsWith: schema.Arg<typeof schema.String>;
+  not: schema.Arg<typeof NestedStringFilter>;
 }>;
 
 const NestedStringFilter: NestedStringFilterType = schema.inputObject({
@@ -145,9 +145,9 @@ const NestedStringFilter: NestedStringFilterType = schema.inputObject({
 
 type BoolNullableFilterType = schema.InputObjectType<{
   // can be null
-  equals: schema.Arg<typeof schema.Boolean, undefined>;
+  equals: schema.Arg<typeof schema.Boolean>;
   // can be null
-  not: schema.Arg<typeof BoolNullableFilter, undefined>;
+  not: schema.Arg<typeof BoolNullableFilter>;
 }>;
 
 const BoolNullableFilter: BoolNullableFilterType = schema.inputObject({
@@ -161,8 +161,8 @@ const BoolNullableFilter: BoolNullableFilterType = schema.inputObject({
 });
 
 type BoolFilterType = schema.InputObjectType<{
-  equals: schema.Arg<typeof schema.Boolean, undefined>;
-  not: schema.Arg<typeof BoolFilter, undefined>;
+  equals: schema.Arg<typeof schema.Boolean>;
+  not: schema.Arg<typeof BoolFilter>;
 }>;
 
 const BoolFilter: BoolFilterType = schema.inputObject({
@@ -175,17 +175,17 @@ const BoolFilter: BoolFilterType = schema.inputObject({
 
 type IntNullableFilterType = schema.InputObjectType<{
   // can be null
-  equals: schema.Arg<typeof schema.Int, undefined>;
+  equals: schema.Arg<typeof schema.Int>;
   // can be null
-  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Int>>, undefined>;
+  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Int>>>;
   // can be null
-  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Int>>, undefined>;
-  lt: schema.Arg<typeof schema.Int, undefined>;
-  lte: schema.Arg<typeof schema.Int, undefined>;
-  gt: schema.Arg<typeof schema.Int, undefined>;
-  gte: schema.Arg<typeof schema.Int, undefined>;
+  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Int>>>;
+  lt: schema.Arg<typeof schema.Int>;
+  lte: schema.Arg<typeof schema.Int>;
+  gt: schema.Arg<typeof schema.Int>;
+  gte: schema.Arg<typeof schema.Int>;
   // can be null
-  not: schema.Arg<typeof IntNullableFilter, undefined>;
+  not: schema.Arg<typeof IntNullableFilter>;
 }>;
 
 const IntNullableFilter: IntNullableFilterType = schema.inputObject({
@@ -207,14 +207,14 @@ const IntNullableFilter: IntNullableFilterType = schema.inputObject({
 });
 
 type IntFilterType = schema.InputObjectType<{
-  equals: schema.Arg<typeof schema.Int, undefined>;
-  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Int>>, undefined>;
-  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Int>>, undefined>;
-  lt: schema.Arg<typeof schema.Int, undefined>;
-  lte: schema.Arg<typeof schema.Int, undefined>;
-  gt: schema.Arg<typeof schema.Int, undefined>;
-  gte: schema.Arg<typeof schema.Int, undefined>;
-  not: schema.Arg<typeof IntFilter, undefined>;
+  equals: schema.Arg<typeof schema.Int>;
+  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Int>>>;
+  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Int>>>;
+  lt: schema.Arg<typeof schema.Int>;
+  lte: schema.Arg<typeof schema.Int>;
+  gt: schema.Arg<typeof schema.Int>;
+  gte: schema.Arg<typeof schema.Int>;
+  not: schema.Arg<typeof IntFilter>;
 }>;
 
 const IntFilter: IntFilterType = schema.inputObject({
@@ -233,17 +233,17 @@ const IntFilter: IntFilterType = schema.inputObject({
 
 type FloatNullableFilterType = schema.InputObjectType<{
   // can be null
-  equals: schema.Arg<typeof schema.Float, undefined>;
+  equals: schema.Arg<typeof schema.Float>;
   // can be null
-  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Float>>, undefined>;
+  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Float>>>;
   // can be null
-  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Float>>, undefined>;
-  lt: schema.Arg<typeof schema.Float, undefined>;
-  lte: schema.Arg<typeof schema.Float, undefined>;
-  gt: schema.Arg<typeof schema.Float, undefined>;
-  gte: schema.Arg<typeof schema.Float, undefined>;
+  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Float>>>;
+  lt: schema.Arg<typeof schema.Float>;
+  lte: schema.Arg<typeof schema.Float>;
+  gt: schema.Arg<typeof schema.Float>;
+  gte: schema.Arg<typeof schema.Float>;
   // can be null
-  not: schema.Arg<typeof FloatNullableFilter, undefined>;
+  not: schema.Arg<typeof FloatNullableFilter>;
 }>;
 
 const FloatNullableFilter: FloatNullableFilterType = schema.inputObject({
@@ -265,14 +265,14 @@ const FloatNullableFilter: FloatNullableFilterType = schema.inputObject({
 });
 
 type FloatFilterType = schema.InputObjectType<{
-  equals: schema.Arg<typeof schema.Float, undefined>;
-  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Float>>, undefined>;
-  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Float>>, undefined>;
-  lt: schema.Arg<typeof schema.Float, undefined>;
-  lte: schema.Arg<typeof schema.Float, undefined>;
-  gt: schema.Arg<typeof schema.Float, undefined>;
-  gte: schema.Arg<typeof schema.Float, undefined>;
-  not: schema.Arg<typeof FloatFilter, undefined>;
+  equals: schema.Arg<typeof schema.Float>;
+  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Float>>>;
+  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.Float>>>;
+  lt: schema.Arg<typeof schema.Float>;
+  lte: schema.Arg<typeof schema.Float>;
+  gt: schema.Arg<typeof schema.Float>;
+  gte: schema.Arg<typeof schema.Float>;
+  not: schema.Arg<typeof FloatFilter>;
 }>;
 
 const FloatFilter: FloatFilterType = schema.inputObject({
@@ -291,17 +291,17 @@ const FloatFilter: FloatFilterType = schema.inputObject({
 
 type DateTimeNullableFilterType = schema.InputObjectType<{
   // can be null
-  equals: schema.Arg<typeof schema.String, undefined>;
+  equals: schema.Arg<typeof schema.String>;
   // can be null
-  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
+  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
   // can be null
-  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  lt: schema.Arg<typeof schema.String, undefined>;
-  lte: schema.Arg<typeof schema.String, undefined>;
-  gt: schema.Arg<typeof schema.String, undefined>;
-  gte: schema.Arg<typeof schema.String, undefined>;
+  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  lt: schema.Arg<typeof schema.String>;
+  lte: schema.Arg<typeof schema.String>;
+  gt: schema.Arg<typeof schema.String>;
+  gte: schema.Arg<typeof schema.String>;
   // can be null
-  not: schema.Arg<typeof DateTimeNullableFilter, undefined>;
+  not: schema.Arg<typeof DateTimeNullableFilter>;
 }>;
 
 const DateTimeNullableFilter: DateTimeNullableFilterType = schema.inputObject({
@@ -323,14 +323,14 @@ const DateTimeNullableFilter: DateTimeNullableFilterType = schema.inputObject({
 });
 
 type DateTimeFilterType = schema.InputObjectType<{
-  equals: schema.Arg<typeof schema.String, undefined>;
-  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  lt: schema.Arg<typeof schema.String, undefined>;
-  lte: schema.Arg<typeof schema.String, undefined>;
-  gt: schema.Arg<typeof schema.String, undefined>;
-  gte: schema.Arg<typeof schema.String, undefined>;
-  not: schema.Arg<typeof DateTimeFilter, undefined>;
+  equals: schema.Arg<typeof schema.String>;
+  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  lt: schema.Arg<typeof schema.String>;
+  lte: schema.Arg<typeof schema.String>;
+  gt: schema.Arg<typeof schema.String>;
+  gte: schema.Arg<typeof schema.String>;
+  not: schema.Arg<typeof DateTimeFilter>;
 }>;
 
 const DateTimeFilter: DateTimeFilterType = schema.inputObject({
@@ -349,17 +349,17 @@ const DateTimeFilter: DateTimeFilterType = schema.inputObject({
 
 type DecimalNullableFilterType = schema.InputObjectType<{
   // can be null
-  equals: schema.Arg<typeof schema.String, undefined>;
+  equals: schema.Arg<typeof schema.String>;
   // can be null
-  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
+  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
   // can be null
-  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  lt: schema.Arg<typeof schema.String, undefined>;
-  lte: schema.Arg<typeof schema.String, undefined>;
-  gt: schema.Arg<typeof schema.String, undefined>;
-  gte: schema.Arg<typeof schema.String, undefined>;
+  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  lt: schema.Arg<typeof schema.String>;
+  lte: schema.Arg<typeof schema.String>;
+  gt: schema.Arg<typeof schema.String>;
+  gte: schema.Arg<typeof schema.String>;
   // can be null
-  not: schema.Arg<typeof DecimalNullableFilter, undefined>;
+  not: schema.Arg<typeof DecimalNullableFilter>;
 }>;
 
 const DecimalNullableFilter: DecimalNullableFilterType = schema.inputObject({
@@ -381,14 +381,14 @@ const DecimalNullableFilter: DecimalNullableFilterType = schema.inputObject({
 });
 
 type DecimalFilterType = schema.InputObjectType<{
-  equals: schema.Arg<typeof schema.String, undefined>;
-  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>, undefined>;
-  lt: schema.Arg<typeof schema.String, undefined>;
-  lte: schema.Arg<typeof schema.String, undefined>;
-  gt: schema.Arg<typeof schema.String, undefined>;
-  gte: schema.Arg<typeof schema.String, undefined>;
-  not: schema.Arg<typeof DecimalFilter, undefined>;
+  equals: schema.Arg<typeof schema.String>;
+  in: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  notIn: schema.Arg<schema.ListType<schema.NonNullType<typeof schema.String>>>;
+  lt: schema.Arg<typeof schema.String>;
+  lte: schema.Arg<typeof schema.String>;
+  gt: schema.Arg<typeof schema.String>;
+  gte: schema.Arg<typeof schema.String>;
+  not: schema.Arg<typeof DecimalFilter>;
 }>;
 
 const DecimalFilter: DecimalFilterType = schema.inputObject({
diff --git a/packages/types/src/json-field-type-polyfill-for-sqlite.ts b/packages/types/src/json-field-type-polyfill-for-sqlite.ts
index 5ea475b0fed..9ad7a9a307c 100644
--- a/packages/types/src/json-field-type-polyfill-for-sqlite.ts
+++ b/packages/types/src/json-field-type-polyfill-for-sqlite.ts
@@ -98,8 +98,8 @@ export function jsonFieldTypePolyfilledForSQLite<
     ScalarDBField<'Json', 'optional'>,
     CreateArg,
     UpdateArg,
-    schema.Arg<schema.NullableInputType, undefined>,
-    schema.Arg<schema.NullableInputType, undefined>
+    schema.Arg<schema.NullableInputType, false>,
+    schema.Arg<schema.NullableInputType, false>
   > & {
     input?: {
       uniqueWhere?: undefined;
diff --git a/packages/types/src/next-fields.ts b/packages/types/src/next-fields.ts
index 83284da4b04..645f36b37a8 100644
--- a/packages/types/src/next-fields.ts
+++ b/packages/types/src/next-fields.ts
@@ -39,17 +39,17 @@ export type NextFieldType<
     | schema.Arg<schema.InputType>
     | undefined,
   UpdateArg extends schema.Arg<schema.InputType> = schema.Arg<schema.InputType>,
-  UniqueWhereArg extends schema.Arg<schema.NullableInputType, undefined> = schema.Arg<
+  UniqueWhereArg extends schema.Arg<schema.NullableInputType, false> = schema.Arg<
     schema.NullableInputType,
-    undefined
+    false
   >,
-  OrderByArg extends schema.Arg<schema.NullableInputType, undefined> = schema.Arg<
+  OrderByArg extends schema.Arg<schema.NullableInputType, false> = schema.Arg<
     schema.NullableInputType,
-    undefined
+    false
   >,
-  FilterArg extends schema.Arg<schema.NullableInputType, undefined> = schema.Arg<
+  FilterArg extends schema.Arg<schema.NullableInputType, false> = schema.Arg<
     schema.NullableInputType,
-    undefined
+    false
   >
 > = {
   dbField: TDBField;
@@ -351,17 +351,17 @@ export type FieldTypeWithoutDBField<
     | schema.Arg<schema.InputType>
     | undefined,
   UpdateArg extends schema.Arg<schema.InputType> = schema.Arg<schema.InputType>,
-  UniqueWhereArg extends schema.Arg<schema.NullableInputType, undefined> = schema.Arg<
+  UniqueWhereArg extends schema.Arg<schema.NullableInputType, false> = schema.Arg<
     schema.NullableInputType,
-    undefined
+    false
   >,
-  OrderByArg extends schema.Arg<schema.NullableInputType, undefined> = schema.Arg<
+  OrderByArg extends schema.Arg<schema.NullableInputType, false> = schema.Arg<
     schema.NullableInputType,
-    undefined
+    false
   >,
-  FilterArg extends schema.Arg<schema.NullableInputType, undefined> = schema.Arg<
+  FilterArg extends schema.Arg<schema.NullableInputType, false> = schema.Arg<
     schema.NullableInputType,
-    undefined
+    false
   >
 > = {
   input?: {
@@ -393,9 +393,9 @@ export function fieldType<TDBField extends DBField>(dbField: TDBField) {
   return function <
     CreateArg extends schema.Arg<schema.InputType> | undefined,
     UpdateArg extends schema.Arg<schema.InputType>,
-    UniqueWhereArg extends schema.Arg<schema.NullableInputType, undefined>,
-    OrderByArg extends schema.Arg<schema.NullableInputType, undefined>,
-    FilterArg extends schema.Arg<schema.NullableInputType, undefined>
+    UniqueWhereArg extends schema.Arg<schema.NullableInputType, false>,
+    OrderByArg extends schema.Arg<schema.NullableInputType, false>,
+    FilterArg extends schema.Arg<schema.NullableInputType, false>
   >(
     stuff: FieldTypeWithoutDBField<
       TDBField,
@@ -453,13 +453,13 @@ export type TypesForList = {
 };
 
 export type FindManyArgs = {
-  where: schema.Arg<schema.NonNullType<TypesForList['where']>, {}>;
+  where: schema.Arg<schema.NonNullType<TypesForList['where']>, true>;
   orderBy: schema.Arg<
     schema.NonNullType<schema.ListType<schema.NonNullType<TypesForList['orderBy']>>>,
-    Record<string, any>[]
+    true
   >;
   take: schema.Arg<typeof schema.Int>;
-  skip: schema.Arg<schema.NonNullType<typeof schema.Int>, number>;
+  skip: schema.Arg<schema.NonNullType<typeof schema.Int>, true>;
 };
 
 export type FindManyArgsValue = schema.InferValueFromArgs<FindManyArgs>;
diff --git a/prisma-utils/src/index.ts b/prisma-utils/src/index.ts
index d27cf905cae..c4570a8c39f 100644
--- a/prisma-utils/src/index.ts
+++ b/prisma-utils/src/index.ts
@@ -280,7 +280,7 @@ function printInputTypeForGraphQLTS(
           field.isList
             ? `schema.ListType<schema.NonNullType<typeof ${field.type}>>`
             : `typeof ${field.type}`
-        }, undefined>`;
+        }>`;
       })
       .join(',\n')}
   }>
diff --git a/yarn.lock b/yarn.lock
index d1cafddddfe..759cf040fd6 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1535,10 +1535,10 @@
   dependencies:
     tslib "~2.3.0"
 
-"@graphql-ts/schema@0.1.2":
-  version "0.1.2"
-  resolved "https://registry.yarnpkg.com/@graphql-ts/schema/-/schema-0.1.2.tgz#71b04cc88ff61f5c19a81ac70f878b1e36f617da"
-  integrity sha512-ZP4Nj70B18q1Y7B4WHeJR5gMyoH8oX9umnpmT9gu6kUD9rmTZfqHE9cGHRisw+ZOlWBnx6rPrx0BmUROFQFORA==
+"@graphql-ts/schema@0.2.0":
+  version "0.2.0"
+  resolved "https://registry.yarnpkg.com/@graphql-ts/schema/-/schema-0.2.0.tgz#1fc11a985cd5b0534de6616abcf05b0b493b8252"
+  integrity sha512-4hLQW5RfJkSkqia3Tl/LRVjsIGziTN/fHsUEuSIg1quD0y3pPpQxisDAIt4nkevY53q+JuGSVG1isJz+v8Ym/g==
   dependencies:
     "@babel/runtime" "^7.9.2"