diff --git a/package.json b/package.json
index 46f72f30..2787bb1b 100644
--- a/package.json
+++ b/package.json
@@ -33,6 +33,11 @@
         "default": "./build/entrypoints/schema.js"
       }
     },
+    "./generator-helpers/standard-scalar-types": {
+      "import": {
+        "default": "./build/entrypoints/generator-helpers/standardScalarTypes.js"
+      }
+    },
     "./utilities-for-generated": {
       "import": {
         "default": "./build/entrypoints/utilities-for-generated.js"
diff --git a/src/entrypoints/generator-helpers/standardScalarTypes.ts b/src/entrypoints/generator-helpers/standardScalarTypes.ts
new file mode 100644
index 00000000..2107179b
--- /dev/null
+++ b/src/entrypoints/generator-helpers/standardScalarTypes.ts
@@ -0,0 +1 @@
+export * from '../../types/Schema/types/Scalar/standardScalarTypes.js'
diff --git a/src/entrypoints/utilities-for-generated.ts b/src/entrypoints/utilities-for-generated.ts
index 7c6bb650..09c9fb5e 100644
--- a/src/entrypoints/utilities-for-generated.ts
+++ b/src/entrypoints/utilities-for-generated.ts
@@ -1,5 +1,4 @@
 export { type Simplify } from 'type-fest'
-export { type Schema as SchemaIndexBase } from '../generator/generators/Schema.js'
 export * from '../layers/2_Select/__.js'
 export { type ClientContext } from '../layers/6_client/fluent.js'
 export type {
@@ -12,5 +11,6 @@ export type { Config } from '../layers/6_client/Settings/Config.js'
 export { type Exact, type ExactNonEmpty, type UnionExpanded } from '../lib/prelude.js'
 export { TypeFunction } from '../lib/type-function/__.js'
 export { type GlobalRegistry } from '../types/GlobalRegistry/GlobalRegistry.js'
-export { SchemaKit } from '../types/Schema/__.js'
+export { Schema } from '../types/Schema/__.js'
+export * from '../types/Schema/types/Scalar/standardScalarTypes.js'
 export { type SchemaDrivenDataMap } from '../types/SchemaDrivenDataMap/__.js'
diff --git a/src/extensions/CustomScalars/decode.ts b/src/extensions/CustomScalars/decode.ts
index 5b5d639e..3128f759 100644
--- a/src/extensions/CustomScalars/decode.ts
+++ b/src/extensions/CustomScalars/decode.ts
@@ -1,5 +1,5 @@
 import { Kind } from 'graphql'
-import { SchemaKit } from '../../entrypoints/schema.js'
+import { Schema } from '../../entrypoints/schema.js'
 import type { RegisteredScalars } from '../../layers/6_client/fluent.js'
 import type { Grafaid } from '../../lib/grafaid/__.js'
 import { SchemaDrivenDataMap } from '../../types/SchemaDrivenDataMap/__.js'
@@ -59,10 +59,10 @@ const decodeResultData_ = (input: {
     const sddmNode = sddmOutputField.nt
 
     if (SchemaDrivenDataMap.isScalar(sddmNode)) {
-      data[k] = SchemaKit.Scalar.applyCodec(sddmNode.codec.decode, v)
+      data[k] = Schema.Scalar.applyCodec(sddmNode.codec.decode, v)
     } else if (SchemaDrivenDataMap.isCustomScalarName(sddmNode)) {
-      const scalar = SchemaKit.Scalar.lookupCustomScalarOrFallbackToString(scalars, sddmNode)
-      data[k] = SchemaKit.Scalar.applyCodec(scalar.codec.decode, v)
+      const scalar = Schema.Scalar.lookupCustomScalarOrFallbackToString(scalars, sddmNode)
+      data[k] = Schema.Scalar.applyCodec(scalar.codec.decode, v)
     } else if (SchemaDrivenDataMap.isOutputObject(sddmNode)) {
       decodeResultData_({
         data: v,
diff --git a/src/extensions/CustomScalars/encode.ts b/src/extensions/CustomScalars/encode.ts
index a35cc3fa..4c8a9403 100644
--- a/src/extensions/CustomScalars/encode.ts
+++ b/src/extensions/CustomScalars/encode.ts
@@ -1,4 +1,4 @@
-import { SchemaKit } from '../../entrypoints/schema.js'
+import { Schema } from '../../entrypoints/schema.js'
 import type { RegisteredScalars } from '../../layers/6_client/fluent.js'
 import { Grafaid } from '../../lib/grafaid/__.js'
 import { SchemaDrivenDataMap } from '../../types/SchemaDrivenDataMap/__.js'
@@ -55,13 +55,13 @@ const encodeInputFieldLike = (
    */
 
   if (SchemaDrivenDataMap.isCustomScalarName(sddmNode)) {
-    const scalar = SchemaKit.Scalar.lookupCustomScalarOrFallbackToString(scalars, sddmNode)
-    args[argName] = SchemaKit.Scalar.applyCodec(scalar.codec.encode, argValue)
+    const scalar = Schema.Scalar.lookupCustomScalarOrFallbackToString(scalars, sddmNode)
+    args[argName] = Schema.Scalar.applyCodec(scalar.codec.encode, argValue)
     return
   }
 
   if (SchemaDrivenDataMap.isScalar(sddmNode)) {
-    args[argName] = SchemaKit.Scalar.applyCodec(sddmNode.codec.encode, argValue)
+    args[argName] = Schema.Scalar.applyCodec(sddmNode.codec.encode, argValue)
     return
   }
 
diff --git a/src/extensions/SchemaErrors/tests/fixture/graffle.config.ts b/src/extensions/SchemaErrors/tests/fixture/graffle.config.ts
index 7667f0a0..b8b1a83b 100644
--- a/src/extensions/SchemaErrors/tests/fixture/graffle.config.ts
+++ b/src/extensions/SchemaErrors/tests/fixture/graffle.config.ts
@@ -12,7 +12,7 @@ export default Generator
     libraryPaths: {
       client: `../../../../entrypoints/client.ts`,
       schema: `../../../../entrypoints/schema.ts`,
-      scalars: `../../../../types/Schema/types/Scalar/scalars.ts`,
+      scalars: `../../../../types/Schema/types/Scalar/standardScalarTypes.ts`,
       utilitiesForGenerated: `../../../../entrypoints/utilities-for-generated.ts`,
     },
   })
diff --git a/src/extensions/SchemaErrors/tests/fixture/graffle/modules/Scalar.ts b/src/extensions/SchemaErrors/tests/fixture/graffle/modules/Scalar.ts
index 693d8619..bc20fd6c 100644
--- a/src/extensions/SchemaErrors/tests/fixture/graffle/modules/Scalar.ts
+++ b/src/extensions/SchemaErrors/tests/fixture/graffle/modules/Scalar.ts
@@ -1,6 +1,6 @@
 import type * as $$Utilities from '../../../../../../entrypoints/utilities-for-generated.js'
 
-export * from '../../../../../../types/Schema/types/Scalar/scalars.js'
+export * from '../../../../../../types/Schema/types/Scalar/standardScalarTypes.js'
 
 //
 //
@@ -14,4 +14,4 @@ export * from '../../../../../../types/Schema/types/Scalar/scalars.js'
 //
 //
 
-export type Date = $$Utilities.SchemaKit.Scalar.ScalarCodecless<'Date'>
+export type Date = $$Utilities.Schema.Scalar.ScalarCodecless<'Date'>
diff --git a/src/extensions/SchemaErrors/tests/fixture/graffle/modules/Schema.ts b/src/extensions/SchemaErrors/tests/fixture/graffle/modules/Schema.ts
index bcb9dcec..11c71e39 100644
--- a/src/extensions/SchemaErrors/tests/fixture/graffle/modules/Schema.ts
+++ b/src/extensions/SchemaErrors/tests/fixture/graffle/modules/Schema.ts
@@ -1,4 +1,4 @@
-import type { SchemaKit as $ } from '../../../../../../entrypoints/utilities-for-generated.js'
+import type { Schema as $ } from '../../../../../../entrypoints/utilities-for-generated.js'
 import type * as $$Utilities from '../../../../../../entrypoints/utilities-for-generated.js'
 import type * as Data from './Data.js'
 import type * as MethodsRoot from './MethodsRoot.js'
@@ -445,9 +445,7 @@ export namespace Schema {
 //
 //
 //
-export interface Schema<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
-  extends $$Utilities.SchemaIndexBase
-{
+export interface Schema<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $$Utilities.Schema {
   name: Data.Name
   RootTypesPresent: ['Mutation', 'Query']
   RootUnion: Schema.Mutation | Schema.Query
diff --git a/src/extensions/SchemaErrors/tests/fixture/graffle/modules/SelectionSets.ts b/src/extensions/SchemaErrors/tests/fixture/graffle/modules/SelectionSets.ts
index fefeb0da..969f87a9 100644
--- a/src/extensions/SchemaErrors/tests/fixture/graffle/modules/SelectionSets.ts
+++ b/src/extensions/SchemaErrors/tests/fixture/graffle/modules/SelectionSets.ts
@@ -19,7 +19,7 @@ import type * as $Scalar from './Scalar.js'
 //
 
 // Prefix with $ because this is not a schema type. A user could have a schema type named "Document" that this would conflict with.
-export interface $Document<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface $Document<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   query?: Record<string, Query<$Scalars>>
   mutation?: Record<string, Mutation<$Scalars>>
 }
@@ -54,7 +54,7 @@ export interface $Document<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarM
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface Mutation<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface Mutation<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   /**
    * Select the `id` field on the `Mutation` object. Its type is `ID` (a `Scalar`).
    */
@@ -86,18 +86,18 @@ export interface Mutation<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMa
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Mutation$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Mutation$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Mutation<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace Mutation {
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -108,18 +108,18 @@ export namespace Mutation {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type idNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type idNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | idNonNull$SelectionSet<$Scalars>
 
-  export interface idNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface idNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -130,7 +130,7 @@ export namespace Mutation {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type idNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type idNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | idNonNull$SelectionSet<$Scalars>
   >
@@ -150,7 +150,7 @@ export namespace Mutation {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface Query<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface Query<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   /**
    * Select the `InputObjectNested` field on the `Query` object. Its type is `ID` (a `Scalar`).
    */
@@ -428,18 +428,18 @@ export interface Query<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap =
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Query$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Query$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Query<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace Query {
-  export type InputObjectNested<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type InputObjectNested<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | InputObjectNested$SelectionSet<$Scalars>
 
-  export interface InputObjectNested$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface InputObjectNested$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -448,7 +448,7 @@ export namespace Query {
     $?: InputObjectNested$Arguments<$Scalars>
   }
 
-  export interface InputObjectNested$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface InputObjectNested$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     input?: $NamedTypes.$InputObjectNested<$Scalars> | undefined | null
   }
 
@@ -459,7 +459,7 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type InputObjectNested$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type InputObjectNested$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       | $Select.Indicator.NoArgsIndicator
       | InputObjectNested$SelectionSet<$Scalars>
@@ -467,10 +467,10 @@ export namespace Query {
 
   // --------------------------------------------------------------------------------------------------
 
-  export type InputObjectNestedNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type InputObjectNestedNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     InputObjectNestedNonNull$SelectionSet<$Scalars>
 
-  export interface InputObjectNestedNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface InputObjectNestedNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -479,7 +479,7 @@ export namespace Query {
     $: InputObjectNestedNonNull$Arguments<$Scalars>
   }
 
-  export interface InputObjectNestedNonNull$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface InputObjectNestedNonNull$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     input: $NamedTypes.$InputObjectNestedNonNull<$Scalars>
   }
 
@@ -490,18 +490,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type InputObjectNestedNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type InputObjectNestedNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       InputObjectNestedNonNull$SelectionSet<$Scalars>
     >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type abcEnum<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type abcEnum<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | abcEnum$SelectionSet<$Scalars>
 
-  export interface abcEnum$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface abcEnum$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -512,18 +512,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type abcEnum$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type abcEnum$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | abcEnum$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type argInputObjectCircular<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type argInputObjectCircular<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | argInputObjectCircular$SelectionSet<$Scalars>
 
-  export interface argInputObjectCircular$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface argInputObjectCircular$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -532,7 +532,7 @@ export namespace Query {
     $?: argInputObjectCircular$Arguments<$Scalars>
   }
 
-  export interface argInputObjectCircular$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface argInputObjectCircular$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     input?: $NamedTypes.$InputObjectCircular<$Scalars> | undefined | null
   }
 
@@ -543,7 +543,7 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type argInputObjectCircular$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type argInputObjectCircular$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       | $Select.Indicator.NoArgsIndicator
       | argInputObjectCircular$SelectionSet<$Scalars>
@@ -551,11 +551,11 @@ export namespace Query {
 
   // --------------------------------------------------------------------------------------------------
 
-  export type date<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type date<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | date$SelectionSet<$Scalars>
 
-  export interface date$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface date$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -566,18 +566,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type date$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type date$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | date$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type dateArg<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type dateArg<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | dateArg$SelectionSet<$Scalars>
 
-  export interface dateArg$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface dateArg$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -586,10 +586,10 @@ export namespace Query {
     $?: dateArg$Arguments<$Scalars>
   }
 
-  export interface dateArg$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface dateArg$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     date?:
-      | $$Utilities.SchemaKit.Scalar.GetDecoded<
-        $$Utilities.SchemaKit.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
+      | $$Utilities.Schema.Scalar.GetDecoded<
+        $$Utilities.Schema.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
       >
       | undefined
       | null
@@ -602,18 +602,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type dateArg$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type dateArg$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | dateArg$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type dateArgInputObject<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type dateArgInputObject<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | dateArgInputObject$SelectionSet<$Scalars>
 
-  export interface dateArgInputObject$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface dateArgInputObject$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -622,7 +622,7 @@ export namespace Query {
     $?: dateArgInputObject$Arguments<$Scalars>
   }
 
-  export interface dateArgInputObject$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface dateArgInputObject$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     input?: $NamedTypes.$InputObject<$Scalars> | undefined | null
   }
 
@@ -633,7 +633,7 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type dateArgInputObject$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type dateArgInputObject$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       | $Select.Indicator.NoArgsIndicator
       | dateArgInputObject$SelectionSet<$Scalars>
@@ -641,11 +641,11 @@ export namespace Query {
 
   // --------------------------------------------------------------------------------------------------
 
-  export type dateArgList<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type dateArgList<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | dateArgList$SelectionSet<$Scalars>
 
-  export interface dateArgList$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface dateArgList$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -654,11 +654,11 @@ export namespace Query {
     $?: dateArgList$Arguments<$Scalars>
   }
 
-  export interface dateArgList$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface dateArgList$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     date?:
       | Array<
-        | $$Utilities.SchemaKit.Scalar.GetDecoded<
-          $$Utilities.SchemaKit.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
+        | $$Utilities.Schema.Scalar.GetDecoded<
+          $$Utilities.Schema.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
         >
         | undefined
         | null
@@ -674,17 +674,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type dateArgList$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type dateArgList$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | dateArgList$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type dateArgNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    dateArgNonNull$SelectionSet<$Scalars>
+  export type dateArgNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = dateArgNonNull$SelectionSet<
+    $Scalars
+  >
 
-  export interface dateArgNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface dateArgNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -693,9 +694,9 @@ export namespace Query {
     $: dateArgNonNull$Arguments<$Scalars>
   }
 
-  export interface dateArgNonNull$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
-    date: $$Utilities.SchemaKit.Scalar.GetDecoded<
-      $$Utilities.SchemaKit.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
+  export interface dateArgNonNull$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
+    date: $$Utilities.Schema.Scalar.GetDecoded<
+      $$Utilities.Schema.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
     >
   }
 
@@ -706,17 +707,16 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type dateArgNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    $$Utilities.Simplify<
-      dateArgNonNull$SelectionSet<$Scalars>
-    >
+  export type dateArgNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+    dateArgNonNull$SelectionSet<$Scalars>
+  >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type dateArgNonNullList<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type dateArgNonNullList<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     dateArgNonNullList$SelectionSet<$Scalars>
 
-  export interface dateArgNonNullList$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface dateArgNonNullList$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -725,10 +725,10 @@ export namespace Query {
     $: dateArgNonNullList$Arguments<$Scalars>
   }
 
-  export interface dateArgNonNullList$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface dateArgNonNullList$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     date: Array<
-      | $$Utilities.SchemaKit.Scalar.GetDecoded<
-        $$Utilities.SchemaKit.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
+      | $$Utilities.Schema.Scalar.GetDecoded<
+        $$Utilities.Schema.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
       >
       | undefined
       | null
@@ -742,17 +742,17 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type dateArgNonNullList$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type dateArgNonNullList$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       dateArgNonNullList$SelectionSet<$Scalars>
     >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type dateArgNonNullListNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type dateArgNonNullListNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     dateArgNonNullListNonNull$SelectionSet<$Scalars>
 
-  export interface dateArgNonNullListNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface dateArgNonNullListNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -761,10 +761,10 @@ export namespace Query {
     $: dateArgNonNullListNonNull$Arguments<$Scalars>
   }
 
-  export interface dateArgNonNullListNonNull$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface dateArgNonNullListNonNull$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     date: Array<
-      | $$Utilities.SchemaKit.Scalar.GetDecoded<
-        $$Utilities.SchemaKit.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
+      | $$Utilities.Schema.Scalar.GetDecoded<
+        $$Utilities.Schema.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
       >
       | undefined
       | null
@@ -778,17 +778,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type dateArgNonNullListNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type dateArgNonNullListNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       dateArgNonNullListNonNull$SelectionSet<$Scalars>
     >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type dateInterface1<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    dateInterface1$SelectionSet<$Scalars>
+  export type dateInterface1<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = dateInterface1$SelectionSet<
+    $Scalars
+  >
 
-  export interface dateInterface1$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface dateInterface1$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$DateInterface1<$Scalars>
   {}
 
@@ -799,18 +800,17 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type dateInterface1$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    $$Utilities.Simplify<
-      dateInterface1$SelectionSet<$Scalars>
-    >
+  export type dateInterface1$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+    dateInterface1$SelectionSet<$Scalars>
+  >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type dateList<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type dateList<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | dateList$SelectionSet<$Scalars>
 
-  export interface dateList$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface dateList$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -821,18 +821,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type dateList$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type dateList$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | dateList$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type dateListList<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type dateListList<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | dateListList$SelectionSet<$Scalars>
 
-  export interface dateListList$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface dateListList$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -843,19 +843,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type dateListList$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    $$Utilities.Simplify<
-      | $Select.Indicator.NoArgsIndicator
-      | dateListList$SelectionSet<$Scalars>
-    >
+  export type dateListList$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+    | $Select.Indicator.NoArgsIndicator
+    | dateListList$SelectionSet<$Scalars>
+  >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type dateListNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type dateListNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | dateListNonNull$SelectionSet<$Scalars>
 
-  export interface dateListNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface dateListNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -866,7 +865,7 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type dateListNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type dateListNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       | $Select.Indicator.NoArgsIndicator
       | dateListNonNull$SelectionSet<$Scalars>
@@ -874,11 +873,11 @@ export namespace Query {
 
   // --------------------------------------------------------------------------------------------------
 
-  export type dateNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type dateNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | dateNonNull$SelectionSet<$Scalars>
 
-  export interface dateNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface dateNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -889,18 +888,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type dateNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type dateNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | dateNonNull$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type dateObject1<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = dateObject1$SelectionSet<
+  export type dateObject1<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = dateObject1$SelectionSet<
     $Scalars
   >
 
-  export interface dateObject1$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface dateObject1$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$DateObject1<$Scalars>
   {}
 
@@ -911,15 +910,15 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type dateObject1$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type dateObject1$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     dateObject1$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type dateUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = dateUnion$SelectionSet<$Scalars>
+  export type dateUnion<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = dateUnion$SelectionSet<$Scalars>
 
-  export interface dateUnion$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface dateUnion$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$DateUnion<$Scalars>
   {}
 
@@ -930,17 +929,17 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type dateUnion$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type dateUnion$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     dateUnion$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type error<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type error<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | error$SelectionSet<$Scalars>
 
-  export interface error$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface error$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -949,7 +948,7 @@ export namespace Query {
     $?: error$Arguments<$Scalars>
   }
 
-  export interface error$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface error$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     case?: string | undefined | null
   }
 
@@ -960,18 +959,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type error$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type error$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | error$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -982,18 +981,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type idNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type idNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | idNonNull$SelectionSet<$Scalars>
 
-  export interface idNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface idNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1004,18 +1003,16 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type idNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type idNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | idNonNull$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type $interface<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $interface$SelectionSet<
-    $Scalars
-  >
+  export type $interface<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $interface$SelectionSet<$Scalars>
 
-  export interface $interface$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface $interface$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Interface<$Scalars>
   {}
 
@@ -1026,16 +1023,16 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type $interface$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type $interface$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     $interface$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type interfaceNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type interfaceNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     interfaceNonNull$SelectionSet<$Scalars>
 
-  export interface interfaceNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface interfaceNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Interface<$Scalars>
   {}
 
@@ -1046,17 +1043,17 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type interfaceNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type interfaceNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       interfaceNonNull$SelectionSet<$Scalars>
     >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type interfaceWithArgs<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type interfaceWithArgs<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     interfaceWithArgs$SelectionSet<$Scalars>
 
-  export interface interfaceWithArgs$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface interfaceWithArgs$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Interface<$Scalars>
   {
     /**
@@ -1065,7 +1062,7 @@ export namespace Query {
     $: interfaceWithArgs$Arguments<$Scalars>
   }
 
-  export interface interfaceWithArgs$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface interfaceWithArgs$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     id: string
   }
 
@@ -1076,18 +1073,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type interfaceWithArgs$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type interfaceWithArgs$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       interfaceWithArgs$SelectionSet<$Scalars>
     >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type listInt<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type listInt<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | listInt$SelectionSet<$Scalars>
 
-  export interface listInt$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface listInt$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1098,18 +1095,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type listInt$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type listInt$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | listInt$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type listIntNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type listIntNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | listIntNonNull$SelectionSet<$Scalars>
 
-  export interface listIntNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface listIntNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1120,19 +1117,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type listIntNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    $$Utilities.Simplify<
-      | $Select.Indicator.NoArgsIndicator
-      | listIntNonNull$SelectionSet<$Scalars>
-    >
+  export type listIntNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+    | $Select.Indicator.NoArgsIndicator
+    | listIntNonNull$SelectionSet<$Scalars>
+  >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type listListInt<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type listListInt<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | listListInt$SelectionSet<$Scalars>
 
-  export interface listListInt$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface listListInt$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1143,18 +1139,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type listListInt$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type listListInt$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | listListInt$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type listListIntNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type listListIntNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | listListIntNonNull$SelectionSet<$Scalars>
 
-  export interface listListIntNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface listListIntNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1165,7 +1161,7 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type listListIntNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type listListIntNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       | $Select.Indicator.NoArgsIndicator
       | listListIntNonNull$SelectionSet<$Scalars>
@@ -1173,10 +1169,11 @@ export namespace Query {
 
   // --------------------------------------------------------------------------------------------------
 
-  export type lowerCaseUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    lowerCaseUnion$SelectionSet<$Scalars>
+  export type lowerCaseUnion<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = lowerCaseUnion$SelectionSet<
+    $Scalars
+  >
 
-  export interface lowerCaseUnion$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface lowerCaseUnion$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$lowerCaseUnion<$Scalars>
   {}
 
@@ -1187,16 +1184,15 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type lowerCaseUnion$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    $$Utilities.Simplify<
-      lowerCaseUnion$SelectionSet<$Scalars>
-    >
+  export type lowerCaseUnion$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+    lowerCaseUnion$SelectionSet<$Scalars>
+  >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type $object<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $object$SelectionSet<$Scalars>
+  export type $object<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $object$SelectionSet<$Scalars>
 
-  export interface $object$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface $object$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Object1<$Scalars>
   {}
 
@@ -1207,17 +1203,15 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type $object$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type $object$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     $object$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type objectList<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = objectList$SelectionSet<
-    $Scalars
-  >
+  export type objectList<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = objectList$SelectionSet<$Scalars>
 
-  export interface objectList$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface objectList$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Object1<$Scalars>
   {}
 
@@ -1228,16 +1222,16 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type objectList$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type objectList$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     objectList$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type objectListNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type objectListNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     objectListNonNull$SelectionSet<$Scalars>
 
-  export interface objectListNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface objectListNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Object1<$Scalars>
   {}
 
@@ -1248,18 +1242,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type objectListNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type objectListNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       objectListNonNull$SelectionSet<$Scalars>
     >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type objectNested<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = objectNested$SelectionSet<
+  export type objectNested<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = objectNested$SelectionSet<
     $Scalars
   >
 
-  export interface objectNested$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface objectNested$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$ObjectNested<$Scalars>
   {}
 
@@ -1270,18 +1264,17 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type objectNested$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    $$Utilities.Simplify<
-      objectNested$SelectionSet<$Scalars>
-    >
+  export type objectNested$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+    objectNested$SelectionSet<$Scalars>
+  >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type objectNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = objectNonNull$SelectionSet<
+  export type objectNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = objectNonNull$SelectionSet<
     $Scalars
   >
 
-  export interface objectNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface objectNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Object1<$Scalars>
   {}
 
@@ -1292,17 +1285,17 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type objectNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    $$Utilities.Simplify<
-      objectNonNull$SelectionSet<$Scalars>
-    >
+  export type objectNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+    objectNonNull$SelectionSet<$Scalars>
+  >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type objectWithArgs<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    objectWithArgs$SelectionSet<$Scalars>
+  export type objectWithArgs<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = objectWithArgs$SelectionSet<
+    $Scalars
+  >
 
-  export interface objectWithArgs$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface objectWithArgs$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Object1<$Scalars>
   {
     /**
@@ -1311,7 +1304,7 @@ export namespace Query {
     $?: objectWithArgs$Arguments<$Scalars>
   }
 
-  export interface objectWithArgs$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface objectWithArgs$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     boolean?: boolean | undefined | null
     float?: number | undefined | null
     id?: string | undefined | null
@@ -1326,16 +1319,15 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type objectWithArgs$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    $$Utilities.Simplify<
-      objectWithArgs$SelectionSet<$Scalars>
-    >
+  export type objectWithArgs$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+    objectWithArgs$SelectionSet<$Scalars>
+  >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type result<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = result$SelectionSet<$Scalars>
+  export type result<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = result$SelectionSet<$Scalars>
 
-  export interface result$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface result$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Result<$Scalars>
   {
     /**
@@ -1344,7 +1336,7 @@ export namespace Query {
     $: result$Arguments<$Scalars>
   }
 
-  export interface result$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface result$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     $case: $NamedTypes.$Case
   }
 
@@ -1355,17 +1347,17 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type result$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type result$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     result$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type resultNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = resultNonNull$SelectionSet<
+  export type resultNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = resultNonNull$SelectionSet<
     $Scalars
   >
 
-  export interface resultNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface resultNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Result<$Scalars>
   {
     /**
@@ -1374,7 +1366,7 @@ export namespace Query {
     $?: resultNonNull$Arguments<$Scalars>
   }
 
-  export interface resultNonNull$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface resultNonNull$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     $case?: $NamedTypes.$Case | undefined | null
   }
 
@@ -1385,18 +1377,17 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type resultNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    $$Utilities.Simplify<
-      resultNonNull$SelectionSet<$Scalars>
-    >
+  export type resultNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+    resultNonNull$SelectionSet<$Scalars>
+  >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type $string<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type $string<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | $string$SelectionSet<$Scalars>
 
-  export interface $string$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface $string$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1407,18 +1398,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type $string$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type $string$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | $string$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type stringWithArgEnum<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type stringWithArgEnum<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | stringWithArgEnum$SelectionSet<$Scalars>
 
-  export interface stringWithArgEnum$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface stringWithArgEnum$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -1427,7 +1418,7 @@ export namespace Query {
     $?: stringWithArgEnum$Arguments<$Scalars>
   }
 
-  export interface stringWithArgEnum$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface stringWithArgEnum$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     $ABCEnum?: $NamedTypes.$ABCEnum | undefined | null
   }
 
@@ -1438,7 +1429,7 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type stringWithArgEnum$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type stringWithArgEnum$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       | $Select.Indicator.NoArgsIndicator
       | stringWithArgEnum$SelectionSet<$Scalars>
@@ -1446,11 +1437,11 @@ export namespace Query {
 
   // --------------------------------------------------------------------------------------------------
 
-  export type stringWithArgInputObject<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type stringWithArgInputObject<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | stringWithArgInputObject$SelectionSet<$Scalars>
 
-  export interface stringWithArgInputObject$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface stringWithArgInputObject$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -1459,7 +1450,7 @@ export namespace Query {
     $?: stringWithArgInputObject$Arguments<$Scalars>
   }
 
-  export interface stringWithArgInputObject$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface stringWithArgInputObject$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     input?: $NamedTypes.$InputObject<$Scalars> | undefined | null
   }
 
@@ -1470,7 +1461,7 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type stringWithArgInputObject$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type stringWithArgInputObject$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       | $Select.Indicator.NoArgsIndicator
       | stringWithArgInputObject$SelectionSet<$Scalars>
@@ -1478,11 +1469,11 @@ export namespace Query {
 
   // --------------------------------------------------------------------------------------------------
 
-  export type stringWithArgInputObjectRequired<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type stringWithArgInputObjectRequired<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     stringWithArgInputObjectRequired$SelectionSet<$Scalars>
 
   export interface stringWithArgInputObjectRequired$SelectionSet<
-    $Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {},
+    $Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {},
   > extends $Select.Bases.Base {
     /**
      * Arguments for `stringWithArgInputObjectRequired` field. All arguments are required so you must include this.
@@ -1491,7 +1482,7 @@ export namespace Query {
   }
 
   export interface stringWithArgInputObjectRequired$Arguments<
-    $Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {},
+    $Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {},
   > {
     input: $NamedTypes.$InputObject<$Scalars>
   }
@@ -1503,18 +1494,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type stringWithArgInputObjectRequired$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type stringWithArgInputObjectRequired$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       stringWithArgInputObjectRequired$SelectionSet<$Scalars>
     >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type stringWithArgs<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type stringWithArgs<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | stringWithArgs$SelectionSet<$Scalars>
 
-  export interface stringWithArgs$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface stringWithArgs$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -1523,7 +1514,7 @@ export namespace Query {
     $?: stringWithArgs$Arguments<$Scalars>
   }
 
-  export interface stringWithArgs$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface stringWithArgs$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     boolean?: boolean | undefined | null
     float?: number | undefined | null
     id?: string | undefined | null
@@ -1538,19 +1529,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type stringWithArgs$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    $$Utilities.Simplify<
-      | $Select.Indicator.NoArgsIndicator
-      | stringWithArgs$SelectionSet<$Scalars>
-    >
+  export type stringWithArgs$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+    | $Select.Indicator.NoArgsIndicator
+    | stringWithArgs$SelectionSet<$Scalars>
+  >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type stringWithListArg<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type stringWithListArg<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | stringWithListArg$SelectionSet<$Scalars>
 
-  export interface stringWithListArg$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface stringWithListArg$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -1559,7 +1549,7 @@ export namespace Query {
     $?: stringWithListArg$Arguments<$Scalars>
   }
 
-  export interface stringWithListArg$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface stringWithListArg$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     ints?: Array<number | undefined | null> | undefined | null
   }
 
@@ -1570,7 +1560,7 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type stringWithListArg$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type stringWithListArg$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       | $Select.Indicator.NoArgsIndicator
       | stringWithListArg$SelectionSet<$Scalars>
@@ -1578,10 +1568,10 @@ export namespace Query {
 
   // --------------------------------------------------------------------------------------------------
 
-  export type stringWithListArgRequired<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type stringWithListArgRequired<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     stringWithListArgRequired$SelectionSet<$Scalars>
 
-  export interface stringWithListArgRequired$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface stringWithListArgRequired$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -1590,7 +1580,7 @@ export namespace Query {
     $: stringWithListArgRequired$Arguments<$Scalars>
   }
 
-  export interface stringWithListArgRequired$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface stringWithListArgRequired$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     ints: Array<number | undefined | null>
   }
 
@@ -1601,17 +1591,17 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type stringWithListArgRequired$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type stringWithListArgRequired$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       stringWithListArgRequired$SelectionSet<$Scalars>
     >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type stringWithRequiredArg<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type stringWithRequiredArg<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     stringWithRequiredArg$SelectionSet<$Scalars>
 
-  export interface stringWithRequiredArg$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface stringWithRequiredArg$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -1620,7 +1610,7 @@ export namespace Query {
     $: stringWithRequiredArg$Arguments<$Scalars>
   }
 
-  export interface stringWithRequiredArg$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface stringWithRequiredArg$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     string: string
   }
 
@@ -1631,18 +1621,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type stringWithRequiredArg$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type stringWithRequiredArg$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       stringWithRequiredArg$SelectionSet<$Scalars>
     >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type unionFooBar<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = unionFooBar$SelectionSet<
+  export type unionFooBar<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = unionFooBar$SelectionSet<
     $Scalars
   >
 
-  export interface unionFooBar$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface unionFooBar$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$FooBarUnion<$Scalars>
   {}
 
@@ -1653,16 +1643,16 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type unionFooBar$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type unionFooBar$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     unionFooBar$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type unionFooBarNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type unionFooBarNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     unionFooBarNonNull$SelectionSet<$Scalars>
 
-  export interface unionFooBarNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface unionFooBarNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$FooBarUnion<$Scalars>
   {}
 
@@ -1673,17 +1663,17 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type unionFooBarNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type unionFooBarNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       unionFooBarNonNull$SelectionSet<$Scalars>
     >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type unionFooBarWithArgs<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type unionFooBarWithArgs<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     unionFooBarWithArgs$SelectionSet<$Scalars>
 
-  export interface unionFooBarWithArgs$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface unionFooBarWithArgs$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$FooBarUnion<$Scalars>
   {
     /**
@@ -1692,7 +1682,7 @@ export namespace Query {
     $?: unionFooBarWithArgs$Arguments<$Scalars>
   }
 
-  export interface unionFooBarWithArgs$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface unionFooBarWithArgs$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     id?: string | undefined | null
   }
 
@@ -1703,18 +1693,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type unionFooBarWithArgs$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type unionFooBarWithArgs$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       unionFooBarWithArgs$SelectionSet<$Scalars>
     >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type unionObject<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = unionObject$SelectionSet<
+  export type unionObject<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = unionObject$SelectionSet<
     $Scalars
   >
 
-  export interface unionObject$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface unionObject$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$ObjectUnion<$Scalars>
   {}
 
@@ -1725,16 +1715,16 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type unionObject$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type unionObject$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     unionObject$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type unionObjectNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type unionObjectNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     unionObjectNonNull$SelectionSet<$Scalars>
 
-  export interface unionObjectNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface unionObjectNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$ObjectUnion<$Scalars>
   {}
 
@@ -1745,7 +1735,7 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type unionObjectNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type unionObjectNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       unionObjectNonNull$SelectionSet<$Scalars>
     >
@@ -1795,35 +1785,35 @@ export type Case = 'ErrorOne' | 'ErrorTwo' | 'Object1'
 //
 //
 
-export interface InputObject<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface InputObject<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   date?:
-    | $$Utilities.SchemaKit.Scalar.GetDecoded<
-      $$Utilities.SchemaKit.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
+    | $$Utilities.Schema.Scalar.GetDecoded<
+      $$Utilities.Schema.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
     >
     | undefined
     | null
-  dateRequired: $$Utilities.SchemaKit.Scalar.GetDecoded<
-    $$Utilities.SchemaKit.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
+  dateRequired: $$Utilities.Schema.Scalar.GetDecoded<
+    $$Utilities.Schema.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
   >
   id?: string | undefined | null
   idRequired: string
 }
 
-export interface InputObjectCircular<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface InputObjectCircular<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   circular?: $NamedTypes.$InputObjectCircular<$Scalars> | undefined | null
   date?:
-    | $$Utilities.SchemaKit.Scalar.GetDecoded<
-      $$Utilities.SchemaKit.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
+    | $$Utilities.Schema.Scalar.GetDecoded<
+      $$Utilities.Schema.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
     >
     | undefined
     | null
 }
 
-export interface InputObjectNested<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface InputObjectNested<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   InputObject?: $NamedTypes.$InputObject<$Scalars> | undefined | null
 }
 
-export interface InputObjectNestedNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface InputObjectNestedNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   InputObject: $NamedTypes.$InputObject<$Scalars>
 }
 
@@ -1846,7 +1836,7 @@ export interface InputObjectNestedNonNull<$Scalars extends $$Utilities.SchemaKit
 // Interface Type: DateInterface1
 // --------------------------------------------------------------------------------------------------
 
-export interface DateInterface1<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface DateInterface1<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends $Select.Bases.ObjectLike
 {
   date1?: DateInterface1.date1<$Scalars>
@@ -1875,16 +1865,16 @@ export interface DateInterface1<$Scalars extends $$Utilities.SchemaKit.Scalar.Sc
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface DateInterface1$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface DateInterface1$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends DateInterface1<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 export namespace DateInterface1 {
-  export type date1<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type date1<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | date1$SelectionSet<$Scalars>
 
-  export interface date1$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface date1$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1895,7 +1885,7 @@ export namespace DateInterface1 {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type date1$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type date1$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | date1$SelectionSet<$Scalars>
   >
@@ -1904,7 +1894,7 @@ export namespace DateInterface1 {
 // Interface Type: Error
 // --------------------------------------------------------------------------------------------------
 
-export interface Error<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
+export interface Error<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
   message?: Error.message<$Scalars>
   ___on_ErrorOne?: ErrorOne<$Scalars>
   ___on_ErrorTwo?: ErrorTwo<$Scalars>
@@ -1932,16 +1922,16 @@ export interface Error<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap =
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Error$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Error$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Error<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 export namespace Error {
-  export type message<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type message<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | message$SelectionSet<$Scalars>
 
-  export interface message$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface message$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1952,7 +1942,7 @@ export namespace Error {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type message$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type message$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | message$SelectionSet<$Scalars>
   >
@@ -1961,9 +1951,7 @@ export namespace Error {
 // Interface Type: Interface
 // --------------------------------------------------------------------------------------------------
 
-export interface Interface<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
-  extends $Select.Bases.ObjectLike
-{
+export interface Interface<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
   id?: Interface.id<$Scalars>
   ___on_Object1ImplementingInterface?: Object1ImplementingInterface<$Scalars>
   ___on_Object2ImplementingInterface?: Object2ImplementingInterface<$Scalars>
@@ -1991,16 +1979,16 @@ export interface Interface<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarM
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Interface$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Interface$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Interface<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 export namespace Interface {
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2011,7 +1999,7 @@ export namespace Interface {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
@@ -2047,7 +2035,7 @@ export namespace Interface {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface Bar<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
+export interface Bar<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
   /**
    * Select the `int` field on the `Bar` object. Its type is `Int` (a `Scalar`).
    */
@@ -2075,18 +2063,18 @@ export interface Bar<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Bar$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Bar$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Bar<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace Bar {
-  export type int<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type int<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | int$SelectionSet<$Scalars>
 
-  export interface int$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface int$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2097,7 +2085,7 @@ export namespace Bar {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type int$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type int$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | int$SelectionSet<$Scalars>
   >
@@ -2117,7 +2105,7 @@ export namespace Bar {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface DateObject1<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface DateObject1<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends $Select.Bases.ObjectLike
 {
   /**
@@ -2147,18 +2135,18 @@ export interface DateObject1<$Scalars extends $$Utilities.SchemaKit.Scalar.Scala
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface DateObject1$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface DateObject1$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends DateObject1<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace DateObject1 {
-  export type date1<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type date1<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | date1$SelectionSet<$Scalars>
 
-  export interface date1$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface date1$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2169,7 +2157,7 @@ export namespace DateObject1 {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type date1$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type date1$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | date1$SelectionSet<$Scalars>
   >
@@ -2189,7 +2177,7 @@ export namespace DateObject1 {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface DateObject2<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface DateObject2<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends $Select.Bases.ObjectLike
 {
   /**
@@ -2219,18 +2207,18 @@ export interface DateObject2<$Scalars extends $$Utilities.SchemaKit.Scalar.Scala
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface DateObject2$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface DateObject2$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends DateObject2<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace DateObject2 {
-  export type date2<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type date2<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | date2$SelectionSet<$Scalars>
 
-  export interface date2$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface date2$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2241,7 +2229,7 @@ export namespace DateObject2 {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type date2$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type date2$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | date2$SelectionSet<$Scalars>
   >
@@ -2261,9 +2249,7 @@ export namespace DateObject2 {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface ErrorOne<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
-  extends $Select.Bases.ObjectLike
-{
+export interface ErrorOne<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
   /**
    * Select the `infoId` field on the `ErrorOne` object. Its type is `ID` (a `Scalar`).
    */
@@ -2295,18 +2281,18 @@ export interface ErrorOne<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMa
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface ErrorOne$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface ErrorOne$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends ErrorOne<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace ErrorOne {
-  export type infoId<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type infoId<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | infoId$SelectionSet<$Scalars>
 
-  export interface infoId$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface infoId$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2317,18 +2303,18 @@ export namespace ErrorOne {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type infoId$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type infoId$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | infoId$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type message<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type message<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | message$SelectionSet<$Scalars>
 
-  export interface message$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface message$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2339,7 +2325,7 @@ export namespace ErrorOne {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type message$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type message$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | message$SelectionSet<$Scalars>
   >
@@ -2359,9 +2345,7 @@ export namespace ErrorOne {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface ErrorTwo<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
-  extends $Select.Bases.ObjectLike
-{
+export interface ErrorTwo<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
   /**
    * Select the `infoInt` field on the `ErrorTwo` object. Its type is `Int` (a `Scalar`).
    */
@@ -2393,18 +2377,18 @@ export interface ErrorTwo<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMa
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface ErrorTwo$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface ErrorTwo$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends ErrorTwo<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace ErrorTwo {
-  export type infoInt<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type infoInt<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | infoInt$SelectionSet<$Scalars>
 
-  export interface infoInt$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface infoInt$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2415,18 +2399,18 @@ export namespace ErrorTwo {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type infoInt$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type infoInt$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | infoInt$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type message<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type message<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | message$SelectionSet<$Scalars>
 
-  export interface message$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface message$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2437,7 +2421,7 @@ export namespace ErrorTwo {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type message$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type message$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | message$SelectionSet<$Scalars>
   >
@@ -2460,7 +2444,7 @@ export namespace ErrorTwo {
 /**
  * Object documentation.
  */
-export interface Foo<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
+export interface Foo<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
   /**
    * Select the `id` field on the `Foo` object. Its type is `ID` (a `Scalar`).
    */
@@ -2488,18 +2472,18 @@ export interface Foo<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Foo$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Foo$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Foo<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace Foo {
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2510,7 +2494,7 @@ export namespace Foo {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
@@ -2530,9 +2514,7 @@ export namespace Foo {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface Object1<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
-  extends $Select.Bases.ObjectLike
-{
+export interface Object1<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
   /**
    * Select the `ABCEnum` field on the `Object1` object. Its type is Enum.
    */
@@ -2580,18 +2562,18 @@ export interface Object1<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Object1$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Object1$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Object1<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace Object1 {
-  export type ABCEnum<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type ABCEnum<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | ABCEnum$SelectionSet<$Scalars>
 
-  export interface ABCEnum$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface ABCEnum$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2602,18 +2584,18 @@ export namespace Object1 {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type ABCEnum$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type ABCEnum$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | ABCEnum$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type $boolean<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type $boolean<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | $boolean$SelectionSet<$Scalars>
 
-  export interface $boolean$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface $boolean$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2624,18 +2606,18 @@ export namespace Object1 {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type $boolean$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type $boolean$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | $boolean$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type float<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type float<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | float$SelectionSet<$Scalars>
 
-  export interface float$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface float$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2646,18 +2628,18 @@ export namespace Object1 {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type float$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type float$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | float$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2668,18 +2650,18 @@ export namespace Object1 {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type int<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type int<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | int$SelectionSet<$Scalars>
 
-  export interface int$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface int$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2690,18 +2672,18 @@ export namespace Object1 {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type int$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type int$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | int$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type $string<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type $string<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | $string$SelectionSet<$Scalars>
 
-  export interface $string$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface $string$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2712,7 +2694,7 @@ export namespace Object1 {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type $string$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type $string$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | $string$SelectionSet<$Scalars>
   >
@@ -2732,7 +2714,7 @@ export namespace Object1 {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface Object1ImplementingInterface<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Object1ImplementingInterface<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends $Select.Bases.ObjectLike
 {
   /**
@@ -2770,18 +2752,18 @@ export interface Object1ImplementingInterface<$Scalars extends $$Utilities.Schem
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Object1ImplementingInterface$FragmentInline<
-  $Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {},
-> extends Object1ImplementingInterface<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields {}
+export interface Object1ImplementingInterface$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
+  extends Object1ImplementingInterface<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
+{}
 
 // ----------------------------------------| Fields |
 
 export namespace Object1ImplementingInterface {
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2792,18 +2774,18 @@ export namespace Object1ImplementingInterface {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type int<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type int<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | int$SelectionSet<$Scalars>
 
-  export interface int$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface int$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2814,7 +2796,7 @@ export namespace Object1ImplementingInterface {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type int$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type int$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | int$SelectionSet<$Scalars>
   >
@@ -2834,7 +2816,7 @@ export namespace Object1ImplementingInterface {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface Object2ImplementingInterface<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Object2ImplementingInterface<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends $Select.Bases.ObjectLike
 {
   /**
@@ -2872,18 +2854,18 @@ export interface Object2ImplementingInterface<$Scalars extends $$Utilities.Schem
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Object2ImplementingInterface$FragmentInline<
-  $Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {},
-> extends Object2ImplementingInterface<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields {}
+export interface Object2ImplementingInterface$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
+  extends Object2ImplementingInterface<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
+{}
 
 // ----------------------------------------| Fields |
 
 export namespace Object2ImplementingInterface {
-  export type $boolean<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type $boolean<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | $boolean$SelectionSet<$Scalars>
 
-  export interface $boolean$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface $boolean$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2894,18 +2876,18 @@ export namespace Object2ImplementingInterface {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type $boolean$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type $boolean$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | $boolean$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2916,7 +2898,7 @@ export namespace Object2ImplementingInterface {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
@@ -2936,7 +2918,7 @@ export namespace Object2ImplementingInterface {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface ObjectNested<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface ObjectNested<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends $Select.Bases.ObjectLike
 {
   /**
@@ -2970,18 +2952,18 @@ export interface ObjectNested<$Scalars extends $$Utilities.SchemaKit.Scalar.Scal
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface ObjectNested$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface ObjectNested$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends ObjectNested<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace ObjectNested {
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2992,16 +2974,16 @@ export namespace ObjectNested {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type $object<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $object$SelectionSet<$Scalars>
+  export type $object<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $object$SelectionSet<$Scalars>
 
-  export interface $object$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface $object$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Object1<$Scalars>
   {}
 
@@ -3012,7 +2994,7 @@ export namespace ObjectNested {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type $object$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type $object$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     $object$SelectionSet<$Scalars>
   >
 }
@@ -3031,7 +3013,7 @@ export namespace ObjectNested {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface ObjectUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface ObjectUnion<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends $Select.Bases.ObjectLike
 {
   /**
@@ -3063,18 +3045,18 @@ export interface ObjectUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.Scala
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface ObjectUnion$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface ObjectUnion$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends ObjectUnion<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace ObjectUnion {
-  export type fooBarUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = fooBarUnion$SelectionSet<
+  export type fooBarUnion<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = fooBarUnion$SelectionSet<
     $Scalars
   >
 
-  export interface fooBarUnion$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface fooBarUnion$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$FooBarUnion<$Scalars>
   {}
 
@@ -3085,7 +3067,7 @@ export namespace ObjectUnion {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type fooBarUnion$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type fooBarUnion$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     fooBarUnion$SelectionSet<$Scalars>
   >
 }
@@ -3104,7 +3086,7 @@ export namespace ObjectUnion {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface lowerCaseObject<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface lowerCaseObject<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends $Select.Bases.ObjectLike
 {
   /**
@@ -3134,18 +3116,18 @@ export interface lowerCaseObject<$Scalars extends $$Utilities.SchemaKit.Scalar.S
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface lowerCaseObject$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface lowerCaseObject$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends lowerCaseObject<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace lowerCaseObject {
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -3156,7 +3138,7 @@ export namespace lowerCaseObject {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
@@ -3176,7 +3158,7 @@ export namespace lowerCaseObject {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface lowerCaseObject2<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface lowerCaseObject2<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends $Select.Bases.ObjectLike
 {
   /**
@@ -3206,18 +3188,18 @@ export interface lowerCaseObject2<$Scalars extends $$Utilities.SchemaKit.Scalar.
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface lowerCaseObject2$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface lowerCaseObject2$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends lowerCaseObject2<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace lowerCaseObject2 {
-  export type int<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type int<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | int$SelectionSet<$Scalars>
 
-  export interface int$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface int$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -3228,7 +3210,7 @@ export namespace lowerCaseObject2 {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type int$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type int$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | int$SelectionSet<$Scalars>
   >
@@ -3250,7 +3232,7 @@ export namespace lowerCaseObject2 {
 //
 //
 
-export interface DateUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface DateUnion<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   ___on_DateObject1?: DateObject1<$Scalars>
   ___on_DateObject2?: DateObject2<$Scalars>
 
@@ -3276,14 +3258,14 @@ export interface DateUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarM
     | $Select.Indicator.NoArgsIndicator$Expanded
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
-export interface DateUnion$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface DateUnion$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends DateUnion<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 /**
  * Union documentation.
  */
-export interface FooBarUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface FooBarUnion<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   ___on_Bar?: Bar<$Scalars>
   ___on_Foo?: Foo<$Scalars>
 
@@ -3309,11 +3291,11 @@ export interface FooBarUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.Scala
     | $Select.Indicator.NoArgsIndicator$Expanded
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
-export interface FooBarUnion$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface FooBarUnion$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends FooBarUnion<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
-export interface Result<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface Result<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   ___on_ErrorOne?: ErrorOne<$Scalars>
   ___on_ErrorTwo?: ErrorTwo<$Scalars>
   ___on_Object1?: Object1<$Scalars>
@@ -3340,11 +3322,11 @@ export interface Result<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap
     | $Select.Indicator.NoArgsIndicator$Expanded
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
-export interface Result$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Result$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Result<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
-export interface lowerCaseUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface lowerCaseUnion<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   ___on_lowerCaseObject?: lowerCaseObject<$Scalars>
   ___on_lowerCaseObject2?: lowerCaseObject2<$Scalars>
 
@@ -3370,7 +3352,7 @@ export interface lowerCaseUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.Sc
     | $Select.Indicator.NoArgsIndicator$Expanded
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
-export interface lowerCaseUnion$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface lowerCaseUnion$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends lowerCaseUnion<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
@@ -3382,41 +3364,39 @@ export interface lowerCaseUnion$FragmentInline<$Scalars extends $$Utilities.Sche
  *     would end up with an error of `export interface Foo extends Foo ...`
  */
 export namespace $NamedTypes {
-  export type $Mutation<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Mutation<$Scalars>
-  export type $Query<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Query<$Scalars>
+  export type $Mutation<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Mutation<$Scalars>
+  export type $Query<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Query<$Scalars>
   export type $ABCEnum = ABCEnum
   export type $Case = Case
-  export type $InputObject<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = InputObject<$Scalars>
-  export type $InputObjectCircular<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = InputObjectCircular<
+  export type $InputObject<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = InputObject<$Scalars>
+  export type $InputObjectCircular<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = InputObjectCircular<
     $Scalars
   >
-  export type $InputObjectNested<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = InputObjectNested<
+  export type $InputObjectNested<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = InputObjectNested<
     $Scalars
   >
-  export type $InputObjectNestedNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type $InputObjectNestedNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     InputObjectNestedNonNull<$Scalars>
-  export type $DateInterface1<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = DateInterface1<$Scalars>
-  export type $Error<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Error<$Scalars>
-  export type $Interface<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Interface<$Scalars>
-  export type $Bar<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Bar<$Scalars>
-  export type $DateObject1<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = DateObject1<$Scalars>
-  export type $DateObject2<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = DateObject2<$Scalars>
-  export type $ErrorOne<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = ErrorOne<$Scalars>
-  export type $ErrorTwo<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = ErrorTwo<$Scalars>
-  export type $Foo<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Foo<$Scalars>
-  export type $Object1<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Object1<$Scalars>
-  export type $Object1ImplementingInterface<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type $DateInterface1<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = DateInterface1<$Scalars>
+  export type $Error<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Error<$Scalars>
+  export type $Interface<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Interface<$Scalars>
+  export type $Bar<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Bar<$Scalars>
+  export type $DateObject1<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = DateObject1<$Scalars>
+  export type $DateObject2<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = DateObject2<$Scalars>
+  export type $ErrorOne<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = ErrorOne<$Scalars>
+  export type $ErrorTwo<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = ErrorTwo<$Scalars>
+  export type $Foo<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Foo<$Scalars>
+  export type $Object1<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Object1<$Scalars>
+  export type $Object1ImplementingInterface<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     Object1ImplementingInterface<$Scalars>
-  export type $Object2ImplementingInterface<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type $Object2ImplementingInterface<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     Object2ImplementingInterface<$Scalars>
-  export type $ObjectNested<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = ObjectNested<$Scalars>
-  export type $ObjectUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = ObjectUnion<$Scalars>
-  export type $lowerCaseObject<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = lowerCaseObject<$Scalars>
-  export type $lowerCaseObject2<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = lowerCaseObject2<
-    $Scalars
-  >
-  export type $DateUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = DateUnion<$Scalars>
-  export type $FooBarUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = FooBarUnion<$Scalars>
-  export type $Result<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Result<$Scalars>
-  export type $lowerCaseUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = lowerCaseUnion<$Scalars>
+  export type $ObjectNested<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = ObjectNested<$Scalars>
+  export type $ObjectUnion<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = ObjectUnion<$Scalars>
+  export type $lowerCaseObject<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = lowerCaseObject<$Scalars>
+  export type $lowerCaseObject2<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = lowerCaseObject2<$Scalars>
+  export type $DateUnion<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = DateUnion<$Scalars>
+  export type $FooBarUnion<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = FooBarUnion<$Scalars>
+  export type $Result<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Result<$Scalars>
+  export type $lowerCaseUnion<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = lowerCaseUnion<$Scalars>
 }
diff --git a/src/generator/config/defaults.ts b/src/generator/config/defaults.ts
index b119c15c..2f7c0a14 100644
--- a/src/generator/config/defaults.ts
+++ b/src/generator/config/defaults.ts
@@ -2,7 +2,7 @@ export const defaultName = `default`
 
 export const defaultLibraryPaths = {
   client: `graffle/client`,
-  scalars: `graffle/schema/scalars`,
+  scalars: `graffle/generator-helpers/standard-scalar-types`,
   schema: `graffle/schema`,
   utilitiesForGenerated: `graffle/utilities-for-generated`,
 }
diff --git a/src/generator/generators/Scalar.ts b/src/generator/generators/Scalar.ts
index 794312ca..43be923f 100644
--- a/src/generator/generators/Scalar.ts
+++ b/src/generator/generators/Scalar.ts
@@ -31,10 +31,10 @@ export const ModuleGeneratorScalar = createModuleGenerator(
         `)
         code(`type ${scalar.name}_ = typeof ${identifiers.CustomScalars}.${scalar.name}`)
         code(
-          `export type ${scalar.name}Decoded = ${identifiers.$$Utilities}.SchemaKit.Scalar.GetDecoded<${scalar.name}_>`,
+          `export type ${scalar.name}Decoded = ${identifiers.$$Utilities}.Schema.Scalar.GetDecoded<${scalar.name}_>`,
         )
         code(
-          `export type ${scalar.name}Encoded = ${identifiers.$$Utilities}.SchemaKit.Scalar.GetEncoded<${scalar.name}_>`,
+          `export type ${scalar.name}Encoded = ${identifiers.$$Utilities}.Schema.Scalar.GetEncoded<${scalar.name}_>`,
         )
         code()
       }
@@ -53,12 +53,12 @@ export const ModuleGeneratorScalar = createModuleGenerator(
       for (const scalar of config.schema.kindMap.GraphQLScalarTypeCustom) {
         code(typeTitle2(`custom scalar type`)(scalar))
         code()
-        code(`export type ${scalar.name} = ${identifiers.$$Utilities}.SchemaKit.Scalar.ScalarCodecless<'Date'>`)
+        code(`export type ${scalar.name} = ${identifiers.$$Utilities}.Schema.Scalar.ScalarCodecless<'Date'>`)
         // code(`import type { String as ${scalar.name} } from '${config.paths.imports.grafflePackage.scalars}'`)
         // code()
         // code(`export { String as ${scalar.name} } from '${config.paths.imports.grafflePackage.scalars}'`)
-        // code(`export type ${scalar.name}Decoded = SchemaKit.Scalar.GetDecoded<${scalar.name}>`)
-        // code(`export type ${scalar.name}Encoded = SchemaKit.Scalar.GetEncoded<${scalar.name}>`)
+        // code(`export type ${scalar.name}Decoded = Schema.Scalar.GetDecoded<${scalar.name}>`)
+        // code(`export type ${scalar.name}Encoded = Schema.Scalar.GetEncoded<${scalar.name}>`)
         // code()
       }
     }
diff --git a/src/generator/generators/Schema.ts b/src/generator/generators/Schema.ts
index 99034bc4..0514173b 100644
--- a/src/generator/generators/Schema.ts
+++ b/src/generator/generators/Schema.ts
@@ -1,8 +1,6 @@
 import { Code } from '../../lib/Code.js'
 import { Grafaid } from '../../lib/grafaid/__.js'
 import { entries, isObjectEmpty, values } from '../../lib/prelude.js'
-import type { GlobalRegistry } from '../../types/GlobalRegistry/GlobalRegistry.js'
-import type { SchemaKit } from '../../types/Schema/__.js'
 import type { Config } from '../config/config.js'
 import { identifiers } from '../helpers/identifiers.js'
 import { createModuleGenerator } from '../helpers/moduleGenerator.js'
@@ -12,41 +10,6 @@ import { ModuleGeneratorData } from './Data.js'
 import { ModuleGeneratorMethodsRoot } from './MethodsRoot.js'
 import { ModuleGeneratorScalar } from './Scalar.js'
 
-/**
- * A generic schema type. Any particular schema will be a subtype of this, with
- * additional specificity such as on objects where here `Record` is used.
- */
-export interface Schema<
-  $Extensions extends GlobalRegistry.TypeExtensions = GlobalRegistry.TypeExtensions,
-  $Scalars extends SchemaKit.Scalar.ScalarMap = SchemaKit.Scalar.ScalarMap,
-> {
-  name: GlobalRegistry.ClientNames
-  RootTypesPresent: ('Query' | 'Mutation' | 'Subscription')[]
-  RootUnion: SchemaKit.RootType
-  Root: {
-    Query: null | SchemaKit.ObjectQuery
-    Mutation: null | SchemaKit.ObjectMutation
-    Subscription: null | SchemaKit.ObjectSubscription
-  }
-  allTypes: Record<
-    string,
-    | SchemaKit.Enum
-    | SchemaKit.ObjectQuery
-    | SchemaKit.ObjectMutation
-    | SchemaKit.OutputObject
-    | SchemaKit.Union
-    | SchemaKit.Interface
-  >
-  objects: Record<string, SchemaKit.OutputObject>
-  unions: Record<string, SchemaKit.Union>
-  interfaces: Record<string, SchemaKit.Interface>
-  /**
-   * A map of scalar definitions. Useful for custom scalars.
-   */
-  scalars: $Scalars
-  extensions: $Extensions
-}
-
 export const ModuleGeneratorSchema = createModuleGenerator(
   `Schema`,
   ({ config, code }) => {
@@ -54,7 +17,7 @@ export const ModuleGeneratorSchema = createModuleGenerator(
     code(`
       import type * as Data from './${ModuleGeneratorData.name}.js'
       import type * as ${identifiers.MethodsRoot} from './${ModuleGeneratorMethodsRoot.name}.js'
-      import type { SchemaKit as $ } from '${config.paths.imports.grafflePackage.utilitiesForGenerated}'
+      import type { Schema as $ } from '${config.paths.imports.grafflePackage.utilitiesForGenerated}'
       import type * as ${identifiers.$$Utilities} from '${config.paths.imports.grafflePackage.utilitiesForGenerated}'
       import type * as $Scalar from './${ModuleGeneratorScalar.name}.js'
     `)
@@ -146,7 +109,7 @@ export const SchemaGenerator = createCodeGenerator(
     // ---
 
     code(
-      `export interface ${identifiers.Schema}<$Scalars extends ${identifiers.$$Utilities}.SchemaKit.Scalar.ScalarMap = {}> extends ${identifiers.$$Utilities}.SchemaIndexBase
+      `export interface ${identifiers.Schema}<$Scalars extends ${identifiers.$$Utilities}.Schema.Scalar.ScalarMap = {}> extends ${identifiers.$$Utilities}.Schema
         ${Code.termObject(schema)}
       `,
     )
diff --git a/src/generator/generators/SelectionSets.ts b/src/generator/generators/SelectionSets.ts
index d9f352d2..e77647f8 100644
--- a/src/generator/generators/SelectionSets.ts
+++ b/src/generator/generators/SelectionSets.ts
@@ -14,8 +14,8 @@ import { createCodeGenerator } from '../helpers/moduleGeneratorRunner.js'
 import { getDocumentation, renderDocumentation, renderName, title1, typeTitle2SelectionSet } from '../helpers/render.js'
 import { ModuleGeneratorScalar } from './Scalar.js'
 
-const $ScalarsTypeParameter = `$Scalars extends ${identifiers.$$Utilities}.SchemaKit.Scalar.ScalarMap = {}`
-// `$Scalars extends ${identifiers.$$Utilities}.SchemaKit.Scalar.ScalarMap`
+const $ScalarsTypeParameter = `$Scalars extends ${identifiers.$$Utilities}.Schema.Scalar.ScalarMap = {}`
+// `$Scalars extends ${identifiers.$$Utilities}.Schema.Scalar.ScalarMap`
 
 export const ModuleGeneratorSelectionSets = createModuleGenerator(
   `SelectionSets`,
@@ -339,7 +339,7 @@ const renderArgumentType = (type: Grafaid.Schema.InputTypes): string => {
   if (Grafaid.Schema.isScalarType(sansNullabilityType)) {
     if (Grafaid.Schema.isScalarTypeCustom(sansNullabilityType)) {
       const scalarTypeRendered =
-        `${identifiers.$$Utilities}.SchemaKit.Scalar.GetDecoded<${identifiers.$$Utilities}.SchemaKit.Scalar.LookupCustomScalarOrFallbackToString<'${sansNullabilityType.name}', $Scalars>>`
+        `${identifiers.$$Utilities}.Schema.Scalar.GetDecoded<${identifiers.$$Utilities}.Schema.Scalar.LookupCustomScalarOrFallbackToString<'${sansNullabilityType.name}', $Scalars>>`
       return `${scalarTypeRendered} ${nullableRendered}`
     }
     const scalarTypeRendered =
diff --git a/src/generator/helpers/identifiers.ts b/src/generator/helpers/identifiers.ts
index 76e88e29..86055164 100644
--- a/src/generator/helpers/identifiers.ts
+++ b/src/generator/helpers/identifiers.ts
@@ -1,6 +1,6 @@
 export const identifiers = {
   Schema: `Schema`,
-  $SchemaKit: `$SchemaKit`,
+  $Schema: `$Schema`,
   $$Utilities: `$$Utilities`,
   MethodsRoot: `MethodsRoot`,
   Scalar: `Scalar`,
diff --git a/src/layers/2_Select/Directive/$types.ts b/src/layers/2_Select/Directive/$types.ts
index eae7338a..4da014ea 100644
--- a/src/layers/2_Select/Directive/$types.ts
+++ b/src/layers/2_Select/Directive/$types.ts
@@ -1,9 +1,9 @@
-import type { SchemaKit } from '../../../types/Schema/__.js'
+import type { Schema } from '../../../types/Schema/__.js'
 import type { Include, Skip } from './_.js'
 
 export interface Definition {
   name: string
-  type: SchemaKit.Directives.Directive
+  type: Schema.Directives.Directive
   normalizeArguments: (args: any) => Record<string, any>
 }
 
diff --git a/src/layers/2_Select/Directive/include.ts b/src/layers/2_Select/Directive/include.ts
index 076033da..331b4bb9 100644
--- a/src/layers/2_Select/Directive/include.ts
+++ b/src/layers/2_Select/Directive/include.ts
@@ -1,10 +1,10 @@
 import { shallowMergeDefaults } from '../../../lib/prelude.js'
-import { SchemaKit } from '../../../types/Schema/__.js'
+import { Schema } from '../../../types/Schema/__.js'
 import type { Definition } from './$types.js'
 
 export const Include: Definition = {
   name: `include`,
-  type: SchemaKit.Directives.standardDirectivesByName.include,
+  type: Schema.Directives.standardDirectivesByName.include,
   normalizeArguments: (input: ArgsInput): Args => {
     return typeof input === `boolean`
       ? expandShortHand(input)
diff --git a/src/layers/2_Select/Directive/skip.ts b/src/layers/2_Select/Directive/skip.ts
index 04289e32..0664a79e 100644
--- a/src/layers/2_Select/Directive/skip.ts
+++ b/src/layers/2_Select/Directive/skip.ts
@@ -1,9 +1,9 @@
-import { SchemaKit } from '../../../types/Schema/__.js'
+import { Schema } from '../../../types/Schema/__.js'
 import type { Definition } from './$types.js'
 
 export const Skip: Definition = {
   name: `skip`,
-  type: SchemaKit.Directives.standardDirectivesByName.skip,
+  type: Schema.Directives.standardDirectivesByName.skip,
   normalizeArguments: (args: ArgsInput): Args => {
     return {
       if: typeof args === `boolean` ? args : args.if === undefined ? true : args.if,
diff --git a/src/layers/3_InferResult/Alias.ts b/src/layers/3_InferResult/Alias.ts
index 129f47b9..68a863fb 100644
--- a/src/layers/3_InferResult/Alias.ts
+++ b/src/layers/3_InferResult/Alias.ts
@@ -1,6 +1,5 @@
-import type { Schema } from '../../generator/generators/Schema.js'
 import type { mergeObjectArray, ValuesOrEmptyObject } from '../../lib/prelude.js'
-import type { SchemaKit } from '../../types/Schema/__.js'
+import type { Schema } from '../../types/Schema/__.js'
 import type { Select } from '../2_Select/__.js'
 import type { Field } from './Field.js'
 
@@ -8,7 +7,7 @@ import type { Field } from './Field.js'
 export type Alias<
 	$SelectionSet,
 	$Schema extends Schema,
-	$Node extends SchemaKit.OutputObject
+	$Node extends Schema.OutputObject
 > =
   ValuesOrEmptyObject<
     {
@@ -32,7 +31,7 @@ type InferSelectAlias<
   $SelectAlias extends Select.SelectAlias.SelectAlias,
   $FieldName extends string,
   $Schema extends Schema,
-  $Node extends SchemaKit.OutputObject,
+  $Node extends Schema.OutputObject,
 > =
   $SelectAlias extends Select.SelectAlias.SelectAliasOne      ? InferSelectAliasOne<$SelectAlias, $FieldName, $Schema, $Node> :
   $SelectAlias extends Select.SelectAlias.SelectAliasMultiple ? InferSelectAliasMultiple<$SelectAlias, $FieldName, $Schema, $Node> :
@@ -42,7 +41,7 @@ type InferSelectAliasMultiple<
   $SelectAliasMultiple extends Select.SelectAlias.SelectAliasMultiple,
   $FieldName extends string,
   $Schema extends Schema,
-  $Node extends SchemaKit.OutputObject,
+  $Node extends Schema.OutputObject,
 > = mergeObjectArray<
   {
     [_ in keyof $SelectAliasMultiple]: InferSelectAliasOne<$SelectAliasMultiple[_], $FieldName, $Schema, $Node>
@@ -53,7 +52,7 @@ type InferSelectAliasOne<
   $SelectAliasOne extends Select.SelectAlias.SelectAliasOne,
   $FieldName extends string,
   $Schema extends Schema,
-  $Node extends SchemaKit.OutputObject,
+  $Node extends Schema.OutputObject,
 > = {
   [_ in $SelectAliasOne[0]]: Field<$SelectAliasOne[1], $Node['fields'][$FieldName], $Schema>
 }
diff --git a/src/layers/3_InferResult/Field.ts b/src/layers/3_InferResult/Field.ts
index 63641487..e58de406 100644
--- a/src/layers/3_InferResult/Field.ts
+++ b/src/layers/3_InferResult/Field.ts
@@ -1,14 +1,13 @@
 import type { Simplify } from 'type-fest'
-import type { Schema } from '../../generator/generators/Schema.js'
 import type { TSErrorDescriptive } from '../../lib/ts-error.js'
-import type { SchemaKit } from '../../types/Schema/__.js'
+import type { Schema } from '../../types/Schema/__.js'
 import type { Select } from '../2_Select/__.js'
 import type { Interface } from './Interface.js'
 import type { Object } from './Object.js'
 import type { Union } from './Union.js'
 
 // dprint-ignore
-export type Field<$SelectionSet, $Field extends SchemaKit.SomeField, $Schema extends Schema> =
+export type Field<$SelectionSet, $Field extends Schema.SomeField, $Schema extends Schema> =
   Simplify<
     $SelectionSet extends Select.Directive.Include.FieldStates.Negative | Select.Directive.Skip.FieldStates.Positive ?
        null :
@@ -22,28 +21,28 @@ export type Field<$SelectionSet, $Field extends SchemaKit.SomeField, $Schema ext
 // dprint-ignore
 type FieldType<
   $SelectionSet,
-  $Type extends SchemaKit.OutputTypes,
+  $Type extends Schema.OutputTypes,
   $Schema extends Schema
 > = 
-  $Type extends SchemaKit.__typename<infer $Value>                                      ? $Value :
-  $Type extends SchemaKit.Nullable<infer $InnerType extends SchemaKit.OutputTypes>      ? null | FieldType<$SelectionSet, $InnerType, $Schema> :
-  $Type extends SchemaKit.List<infer $InnerType extends SchemaKit.OutputTypes>          ? Array<FieldType<$SelectionSet, $InnerType, $Schema>> :
-  $Type extends SchemaKit.Enum<infer _, infer $Members>                                 ? $Members[number] :
-  $Type extends SchemaKit.Scalar                                                        ? ReturnType<$Type['codec']['decode']> :
-  $Type extends SchemaKit.Scalar.ScalarCodecless                                        ? ReturnType<GetCodecForCodecless<$Type, $Schema>['codec']['decode']> :
-  $Type extends SchemaKit.OutputObject                                                      ? Object<$SelectionSet, $Schema, $Type> :
-  $Type extends SchemaKit.Interface                                                     ? Interface<$SelectionSet, $Schema, $Type> :
-  $Type extends SchemaKit.Union                                                         ? Union<$SelectionSet, $Schema, $Type> :
+  $Type extends Schema.__typename<infer $Value>                                      ? $Value :
+  $Type extends Schema.Nullable<infer $InnerType extends Schema.OutputTypes>      ? null | FieldType<$SelectionSet, $InnerType, $Schema> :
+  $Type extends Schema.List<infer $InnerType extends Schema.OutputTypes>          ? Array<FieldType<$SelectionSet, $InnerType, $Schema>> :
+  $Type extends Schema.Enum<infer _, infer $Members>                                 ? $Members[number] :
+  $Type extends Schema.Scalar                                                        ? ReturnType<$Type['codec']['decode']> :
+  $Type extends Schema.Scalar.ScalarCodecless                                        ? ReturnType<GetCodecForCodecless<$Type, $Schema>['codec']['decode']> :
+  $Type extends Schema.OutputObject                                                      ? Object<$SelectionSet, $Schema, $Type> :
+  $Type extends Schema.Interface                                                     ? Interface<$SelectionSet, $Schema, $Type> :
+  $Type extends Schema.Union                                                         ? Union<$SelectionSet, $Schema, $Type> :
                                                                                           TSErrorDescriptive<'FieldType', `Unknown type`, { $Type: $Type; $SelectionSet: $SelectionSet; $Schema:$Schema }>
 
 // dprint-ignore
 type GetCodecForCodecless<
-  $Type extends SchemaKit.Scalar.ScalarCodecless,
+  $Type extends Schema.Scalar.ScalarCodecless,
   $Schema extends Schema
 > =
   $Type['name'] extends keyof $Schema['scalars']
     ? $Schema['scalars'][$Type['name']]
-    : SchemaKit.Scalar.String
+    : Schema.Scalar.String
 
 // dprint-ignore
 type FieldDirectiveInclude<$SelectionSet> =
diff --git a/src/layers/3_InferResult/InlineFragment.ts b/src/layers/3_InferResult/InlineFragment.ts
index 4062431b..5b93db49 100644
--- a/src/layers/3_InferResult/InlineFragment.ts
+++ b/src/layers/3_InferResult/InlineFragment.ts
@@ -1,11 +1,10 @@
-import type { Schema } from '../../generator/generators/Schema.js'
 import { type GetKeyOr } from '../../lib/prelude.js'
-import type { SchemaKit } from '../../types/Schema/__.js'
+import type { Schema } from '../../types/Schema/__.js'
 import type { Select } from '../2_Select/__.js'
 import type { Object } from './Object.js'
 
 // dprint-ignore
-export type InlineFragmentTypeConditional<$SelectionSet, $Node extends SchemaKit.OutputObject, $Index extends Schema> =
+export type InlineFragmentTypeConditional<$SelectionSet, $Node extends Schema.OutputObject, $Schema extends Schema> =
   $Node extends any // force distribution
     ? Object<
         & GetKeyOr<
@@ -14,7 +13,7 @@ export type InlineFragmentTypeConditional<$SelectionSet, $Node extends SchemaKit
             {}
           >
         & Select.InlineFragment.OmitInlineFragmentsWithTypeConditions<$SelectionSet>,
-        $Index,
+        $Schema,
         $Node
       >
     : never
diff --git a/src/layers/3_InferResult/Interface.ts b/src/layers/3_InferResult/Interface.ts
index 185b71a8..4db39841 100644
--- a/src/layers/3_InferResult/Interface.ts
+++ b/src/layers/3_InferResult/Interface.ts
@@ -1,7 +1,6 @@
-import type { Schema } from '../../generator/generators/Schema.js'
-import type { SchemaKit } from '../../types/Schema/__.js'
+import type { Schema } from '../../types/Schema/__.js'
 import type { InlineFragmentTypeConditional } from './InlineFragment.js'
 
 // dprint-ignore
-export type Interface<$SelectionSet, $Index extends Schema, $Node extends SchemaKit.Interface> =
-  InlineFragmentTypeConditional<$SelectionSet, $Node['implementors'][number], $Index>
+export type Interface<$SelectionSet, $Schema extends Schema, $Node extends Schema.Interface> =
+  InlineFragmentTypeConditional<$SelectionSet, $Node['implementors'][number], $Schema>
diff --git a/src/layers/3_InferResult/Object.ts b/src/layers/3_InferResult/Object.ts
index 6df0cee2..928f19b8 100644
--- a/src/layers/3_InferResult/Object.ts
+++ b/src/layers/3_InferResult/Object.ts
@@ -1,15 +1,14 @@
 import type { Simplify } from 'type-fest'
-import type { Schema } from '../../generator/generators/Schema.js'
 import { type StringKeyof } from '../../lib/prelude.js'
 import type { TSErrorDescriptive } from '../../lib/ts-error.js'
-import type { SchemaKit } from '../../types/Schema/__.js'
+import type { Schema } from '../../types/Schema/__.js'
 import type { Select } from '../2_Select/__.js'
 import type { Alias } from './Alias.js'
 import type { Field } from './Field.js'
 import type { ScalarsWildcard } from './ScalarsWildcard.js'
 
 // dprint-ignore
-export type Object<$SelectionSet, $Schema extends Schema, $Node extends SchemaKit.OutputObject> =
+export type Object<$SelectionSet, $Schema extends Schema, $Node extends Schema.OutputObject> =
   Select.SelectScalarsWildcard.IsSelectScalarsWildcard<$SelectionSet> extends true
     // todo what about when scalars wildcard is combined with other fields like relations?
     ? ScalarsWildcard<$SelectionSet, $Schema,$Node>
@@ -20,7 +19,7 @@ export type Object<$SelectionSet, $Schema extends Schema, $Node extends SchemaKi
       >
 
 // dprint-ignore
-type SelectionNonSelectAlias<$SelectionSet , $Schema extends Schema, $SchemaNode extends SchemaKit.OutputObject> =
+type SelectionNonSelectAlias<$SelectionSet , $Schema extends Schema, $SchemaNode extends Schema.OutputObject> =
   {
     [$Key in PickSelectsPositiveIndicatorAndNotSelectAlias<$SelectionSet>]:
       $Key extends keyof $SchemaNode['fields']
@@ -30,7 +29,7 @@ type SelectionNonSelectAlias<$SelectionSet , $Schema extends Schema, $SchemaNode
 
 // dprint-ignore
 export namespace Errors {
-  export type UnknownFieldName<$FieldName extends string, $Object extends SchemaKit.RootType | SchemaKit.OutputObject> =
+  export type UnknownFieldName<$FieldName extends string, $Object extends Schema.RootType | Schema.OutputObject> =
     TSErrorDescriptive<'Object', `field "${$FieldName}" does not exist on object "${$Object['fields']['__typename']['type']['type']}"`>
 }
 
diff --git a/src/layers/3_InferResult/ScalarsWildcard.ts b/src/layers/3_InferResult/ScalarsWildcard.ts
index 6042e8b8..a6452f15 100644
--- a/src/layers/3_InferResult/ScalarsWildcard.ts
+++ b/src/layers/3_InferResult/ScalarsWildcard.ts
@@ -1,20 +1,19 @@
-import type { Schema } from '../../generator/generators/Schema.js'
-import type { SchemaKit } from '../../types/Schema/__.js'
+import type { Schema } from '../../types/Schema/__.js'
 import type { Field } from './Field.js'
 
 export type ScalarsWildcard<
   $SelectionSet,
-  $Index extends Schema,
-  $Node extends SchemaKit.OutputObject,
+  $Schema extends Schema,
+  $Node extends Schema.OutputObject,
 > = {
-  [$Key in keyof PickScalarFields<$Node>]: Field<$SelectionSet, $Node['fields'][$Key], $Index>
+  [$Key in keyof PickScalarFields<$Node>]: Field<$SelectionSet, $Node['fields'][$Key], $Schema>
 }
 
 // dprint-ignore
-type PickScalarFields<$Object extends SchemaKit.OutputObject> = {
+type PickScalarFields<$Object extends Schema.OutputObject> = {
   [
     $Key in keyof $Object['fields']
-    as SchemaKit.GetNamedType<$Object['fields'][$Key]['type']> extends SchemaKit.ScalarLikeTypes 
+    as Schema.GetNamedType<$Object['fields'][$Key]['type']> extends Schema.ScalarLikeTypes 
       ? $Key
       : never
   ]: $Object['fields'][$Key]
diff --git a/src/layers/3_InferResult/Union.ts b/src/layers/3_InferResult/Union.ts
index 6821084c..d463a537 100644
--- a/src/layers/3_InferResult/Union.ts
+++ b/src/layers/3_InferResult/Union.ts
@@ -1,7 +1,6 @@
-import type { Schema } from '../../generator/generators/Schema.js'
-import type { SchemaKit } from '../../types/Schema/__.js'
+import type { Schema } from '../../types/Schema/__.js'
 import type { InlineFragmentTypeConditional } from './InlineFragment.js'
 
 // dprint-ignore
-export type Union<$SelectionSet, $Index extends Schema, $Type extends SchemaKit.Union> =
-  InlineFragmentTypeConditional<$SelectionSet, $Type['members'][number], $Index>
+export type Union<$SelectionSet, $Schema extends Schema, $Type extends Schema.Union> =
+  InlineFragmentTypeConditional<$SelectionSet, $Type['members'][number], $Schema>
diff --git a/src/layers/3_InferResult/root.ts b/src/layers/3_InferResult/root.ts
index cbd71f31..16cc3af5 100644
--- a/src/layers/3_InferResult/root.ts
+++ b/src/layers/3_InferResult/root.ts
@@ -1,13 +1,12 @@
-import type { Schema } from '../../generator/generators/Schema.js'
 import type { Grafaid } from '../../lib/grafaid/__.js'
 import { type ExcludeNull } from '../../lib/prelude.js'
-import type { SchemaKit } from '../../types/Schema/__.js'
+import type { Schema } from '../../types/Schema/__.js'
 import type { Object } from './Object.js'
 
 export type RootViaObject<
   $SelectionSet,
   $Schema extends Schema,
-  $RootType extends SchemaKit.RootType,
+  $RootType extends Schema.RootType,
 > = Root<
   $SelectionSet,
   $Schema,
diff --git a/src/layers/3_SelectGraphQLMapper/context.ts b/src/layers/3_SelectGraphQLMapper/context.ts
index ba3aad6e..fd889f4c 100644
--- a/src/layers/3_SelectGraphQLMapper/context.ts
+++ b/src/layers/3_SelectGraphQLMapper/context.ts
@@ -1,13 +1,13 @@
 import type { Grafaid } from '../../lib/grafaid/__.js'
 import { Nodes } from '../../lib/grafaid/_Nodes.js'
-import type { SchemaKit } from '../../types/Schema/__.js'
+import type { Schema } from '../../types/Schema/__.js'
 import type { SchemaDrivenDataMap } from '../../types/SchemaDrivenDataMap/__.js'
 import { inferVariableType } from './inferVariableType.js'
 import type { Options } from './nodes/1_Document.js'
 
 export interface OperationContext {
   sddm?: SchemaDrivenDataMap
-  scalars: SchemaKit.Scalar.ScalarMap
+  scalars: Schema.Scalar.ScalarMap
   variables: {
     /**
      * Should variables be used for arguments?
diff --git a/src/layers/3_SelectGraphQLMapper/nodes/1_Document.ts b/src/layers/3_SelectGraphQLMapper/nodes/1_Document.ts
index b57bebf3..8085ee61 100644
--- a/src/layers/3_SelectGraphQLMapper/nodes/1_Document.ts
+++ b/src/layers/3_SelectGraphQLMapper/nodes/1_Document.ts
@@ -1,4 +1,4 @@
-import type { SchemaDrivenDataMap, SchemaKit } from '../../../entrypoints/utilities-for-generated.js'
+import type { Schema, SchemaDrivenDataMap } from '../../../entrypoints/utilities-for-generated.js'
 import type { Grafaid } from '../../../lib/grafaid/__.js'
 import { Nodes } from '../../../lib/grafaid/_Nodes.js'
 import type { Select } from '../../2_Select/__.js'
@@ -34,7 +34,7 @@ export const toGraphQLDocument = (
 
 export interface Options {
   sddm?: SchemaDrivenDataMap | null
-  scalars?: SchemaKit.Scalar.ScalarMap
+  scalars?: Schema.Scalar.ScalarMap
   operationVariables?: boolean
 }
 
diff --git a/src/layers/3_SelectGraphQLMapper/nodes/Value.ts b/src/layers/3_SelectGraphQLMapper/nodes/Value.ts
index 70d661f4..51bdf280 100644
--- a/src/layers/3_SelectGraphQLMapper/nodes/Value.ts
+++ b/src/layers/3_SelectGraphQLMapper/nodes/Value.ts
@@ -1,6 +1,6 @@
 import type { Grafaid } from '../../../lib/grafaid/__.js'
 import { Nodes } from '../../../lib/grafaid/_Nodes.js'
-import { SchemaKit } from '../../../types/Schema/__.js'
+import { Schema } from '../../../types/Schema/__.js'
 import { SchemaDrivenDataMap } from '../../../types/SchemaDrivenDataMap/__.js'
 import type { OperationContext } from '../context.js'
 import { type GraphQLPostOperationMapper } from '../mapper.js'
@@ -13,7 +13,7 @@ export const toGraphQLValue: ValueMapper = (context, sddm, value) => {
   if (SchemaDrivenDataMap.isScalarLike(sddm?.nt)) {
     const scalar = SchemaDrivenDataMap.isScalar(sddm.nt)
       ? sddm.nt
-      : SchemaKit.Scalar.lookupCustomScalarOrFallbackToString(context.scalars, sddm.nt)
+      : Schema.Scalar.lookupCustomScalarOrFallbackToString(context.scalars, sddm.nt)
     return applyScalar(context, scalar, value)
   }
 
@@ -82,7 +82,7 @@ interface AdditionalContext {
 
 const applyScalar = (
   context: OperationContext & AdditionalContext,
-  scalar: SchemaKit.Scalar,
+  scalar: Schema.Scalar,
   value: unknown,
 ): Grafaid.Document.ValueNode => {
   if (value === null) return Nodes.NullValue()
diff --git a/src/layers/3_SelectGraphQLMapper/toGraphQL.test.ts b/src/layers/3_SelectGraphQLMapper/toGraphQL.test.ts
index 0e40d1cc..6c95fbf4 100644
--- a/src/layers/3_SelectGraphQLMapper/toGraphQL.test.ts
+++ b/src/layers/3_SelectGraphQLMapper/toGraphQL.test.ts
@@ -4,7 +4,7 @@ import { db } from '../../../tests/_/schemas/db.js'
 import { schemaDrivenDataMap } from '../../../tests/_/schemas/kitchen-sink/graffle/modules/SchemaDrivenDataMap.js'
 import type * as SelectionSets from '../../../tests/_/schemas/kitchen-sink/graffle/modules/SelectionSets.js'
 import { Grafaid } from '../../lib/grafaid/__.js'
-import type { SchemaKit } from '../../types/Schema/__.js'
+import type { Schema } from '../../types/Schema/__.js'
 import { Select } from '../2_Select/__.js'
 import { toGraphQLDocument } from './nodes/1_Document.js'
 
@@ -22,7 +22,7 @@ type CasesDescriptiveQueryWithCustomScalars = [
 ]
 const testEachQueryWithDescriptionWithCustomScalars = test.for.bind(test)<CasesDescriptiveQueryWithCustomScalars>
 
-const tester = <$Scalars extends SchemaKit.Scalar.ScalarMap>(
+const tester = <$Scalars extends Schema.Scalar.ScalarMap>(
   input: { variables: boolean; scalars: $Scalars },
 ) => {
   // dprint-ignore
diff --git a/src/layers/6_client/fluent.ts b/src/layers/6_client/fluent.ts
index a0b02770..753cc774 100644
--- a/src/layers/6_client/fluent.ts
+++ b/src/layers/6_client/fluent.ts
@@ -1,6 +1,6 @@
 import type { Anyware } from '../../lib/anyware/__.js'
 import type { Fluent } from '../../lib/fluent/__.js'
-import type { SchemaKit } from '../../types/Schema/__.js'
+import type { Schema } from '../../types/Schema/__.js'
 import type { RequestCore } from '../5_request/__.js'
 import type { Extension } from './extension/extension.js'
 import type { Config } from './Settings/Config.js'
@@ -55,7 +55,7 @@ export interface ClientContext {
   scalars: RegisteredScalars
 }
 
-export type RegisteredScalars = Record<string, SchemaKit.Scalar>
+export type RegisteredScalars = Record<string, Schema.Scalar>
 
 export const createState = (stateWithoutConfig: StateWithoutConfig): ClientContext => {
   let config: Config | null
diff --git a/src/layers/6_client/properties/scalar.ts b/src/layers/6_client/properties/scalar.ts
index 8a302aa1..8855c21a 100644
--- a/src/layers/6_client/properties/scalar.ts
+++ b/src/layers/6_client/properties/scalar.ts
@@ -1,6 +1,6 @@
 import type { ConfigManager } from '../../../lib/config-manager/__.js'
 import type { Fluent } from '../../../lib/fluent/__.js'
-import type { SchemaKit } from '../../../types/Schema/__.js'
+import type { Schema } from '../../../types/Schema/__.js'
 import { type ClientContext, defineProperties, type FnParametersProperty } from '../fluent.js'
 
 export interface ScalarFn extends Fluent.FnProperty<`scalar`> {
@@ -13,7 +13,7 @@ export interface Scalar<$Args extends FnParametersProperty> {
    * TODO Docs.
    */
   // @ts-expect-error todo
-  <$Scalar extends SchemaKit.Scalar.Scalar>(scalar: $Scalar): Fluent.IncrementWithStateSet<ClientContext, $Args, {
+  <$Scalar extends Schema.Scalar.Scalar>(scalar: $Scalar): Fluent.IncrementWithStateSet<ClientContext, $Args, {
     context: ConfigManager.SetAtPath<
       $Args['state']['context'],
       ['scalars', $Scalar['name']],
@@ -25,7 +25,7 @@ export interface Scalar<$Args extends FnParametersProperty> {
 
 export const scalarProperties = defineProperties((builder, state) => {
   return {
-    scalar: (scalar: SchemaKit.Scalar) => {
+    scalar: (scalar: Schema.Scalar) => {
       return builder({
         ...state,
         scalars: {
diff --git a/src/layers/6_client/requestMethods/document.ts b/src/layers/6_client/requestMethods/document.ts
index 25e174ea..8c2c3fd9 100644
--- a/src/layers/6_client/requestMethods/document.ts
+++ b/src/layers/6_client/requestMethods/document.ts
@@ -1,5 +1,5 @@
 import type { UnionToTuple } from 'type-fest'
-import type { Schema } from '../../../generator/generators/Schema.js'
+import type { Schema } from '../../../entrypoints/schema.js'
 import type { IsTupleMultiple } from '../../../lib/prelude.js'
 import type { Select } from '../../2_Select/__.js'
 import type { InferResult } from '../../3_InferResult/__.js'
diff --git a/src/types/GlobalRegistry/types.ts b/src/types/GlobalRegistry/types.ts
index 4a347e4f..e2831489 100644
--- a/src/types/GlobalRegistry/types.ts
+++ b/src/types/GlobalRegistry/types.ts
@@ -1,6 +1,5 @@
 import type { IsNever } from 'type-fest'
-import type { TypeFunction } from '../../entrypoints/utilities-for-generated.js'
-import type { Schema } from '../../generator/generators/Schema.js'
+import type { Schema, TypeFunction } from '../../entrypoints/utilities-for-generated.js'
 import type { ConfigManager } from '../../lib/config-manager/__.js'
 import type { Values } from '../../lib/prelude.js'
 import type { TSErrorDescriptive } from '../../lib/ts-error.js'
diff --git a/src/types/Schema/__.ts b/src/types/Schema/__.ts
index 4d0ae689..c5da239d 100644
--- a/src/types/Schema/__.ts
+++ b/src/types/Schema/__.ts
@@ -1 +1,44 @@
-export * as SchemaKit from './_.js'
+export * as Schema from './_.js'
+
+import type { GlobalRegistry } from '../GlobalRegistry/GlobalRegistry.js'
+import type { Enum } from './types/Enum.js'
+import type { Interface } from './types/Interface.js'
+import type { OutputObject } from './types/OutputObject.js'
+import type { Scalar } from './types/Scalar/Scalar.js'
+import type { Union } from './types/Union.js'
+import type { ObjectMutation, ObjectQuery, ObjectSubscription, RootType } from './typeTypes.js'
+
+/**
+ * A generic schema type. Any particular schema will be a subtype of this, with
+ * additional specificity such as on objects where here `Record` is used.
+ */
+export interface Schema<
+  $Extensions extends GlobalRegistry.TypeExtensions = GlobalRegistry.TypeExtensions,
+  $Scalars extends Scalar.ScalarMap = Scalar.ScalarMap,
+> {
+  name: GlobalRegistry.ClientNames
+  RootTypesPresent: ('Query' | 'Mutation' | 'Subscription')[]
+  RootUnion: RootType
+  Root: {
+    Query: null | ObjectQuery
+    Mutation: null | ObjectMutation
+    Subscription: null | ObjectSubscription
+  }
+  allTypes: Record<
+    string,
+    | Enum
+    | ObjectQuery
+    | ObjectMutation
+    | OutputObject
+    | Union
+    | Interface
+  >
+  objects: Record<string, OutputObject>
+  unions: Record<string, Union>
+  interfaces: Record<string, Interface>
+  /**
+   * A map of scalar definitions. Useful for custom scalars.
+   */
+  scalars: $Scalars
+  extensions: $Extensions
+}
diff --git a/src/types/Schema/types/Scalar/_.ts b/src/types/Schema/types/Scalar/_.ts
index ec5d2aea..5d5f789a 100644
--- a/src/types/Schema/types/Scalar/_.ts
+++ b/src/types/Schema/types/Scalar/_.ts
@@ -2,4 +2,4 @@ export * from './create.js'
 export * from './helpers.js'
 export * from './JavaScriptScalarCodecs.js'
 export * from './ScalarCodecless.js'
-export * from './scalars.js'
+export * from './standardScalarTypes.js'
diff --git a/src/types/Schema/types/Scalar/helpers.ts b/src/types/Schema/types/Scalar/helpers.ts
index cf4db218..91378dda 100644
--- a/src/types/Schema/types/Scalar/helpers.ts
+++ b/src/types/Schema/types/Scalar/helpers.ts
@@ -1,6 +1,6 @@
 import type { Mapper } from './codec.js'
 import type { Scalar } from './Scalar.js'
-import { String } from './scalars.js'
+import { String } from './standardScalarTypes.js'
 
 export type GetEncoded<$Scalar> = $Scalar extends Scalar<infer _, infer _, infer $Encoded> ? $Encoded : never
 
diff --git a/src/types/Schema/types/Scalar/scalars.ts b/src/types/Schema/types/Scalar/standardScalarTypes.ts
similarity index 100%
rename from src/types/Schema/types/Scalar/scalars.ts
rename to src/types/Schema/types/Scalar/standardScalarTypes.ts
diff --git a/src/types/SchemaDrivenDataMap/SchemaDrivenDataMap.ts b/src/types/SchemaDrivenDataMap/SchemaDrivenDataMap.ts
index abcacff9..390c2de2 100644
--- a/src/types/SchemaDrivenDataMap/SchemaDrivenDataMap.ts
+++ b/src/types/SchemaDrivenDataMap/SchemaDrivenDataMap.ts
@@ -1,6 +1,6 @@
 import type { Grafaid } from '../../lib/grafaid/__.js'
 import { isString } from '../../lib/prelude.js'
-import { SchemaKit } from '../Schema/__.js'
+import { Schema } from '../Schema/__.js'
 
 declare global {
   namespace GraffleGlobal {
@@ -98,7 +98,7 @@ export type Enum = GraffleGlobal.SchemaDrivenDataMap.Enum
 
 export type ArgumentsOrInputObjectFields = GraffleGlobal.SchemaDrivenDataMap.ArgumentsOrInputObjectFields
 
-export type Scalar = SchemaKit.Scalar
+export type Scalar = Schema.Scalar
 
 export type CustomScalarName = string
 
@@ -136,10 +136,10 @@ export const isEnum = (
 
 export const isCustomScalarName = (value: unknown): value is CustomScalarName => isString(value)
 
-export const isScalar = SchemaKit.Scalar.isScalar
+export const isScalar = Schema.Scalar.isScalar
 
 export const isScalarLike = (value: unknown): value is ScalarLike =>
-  SchemaKit.Scalar.isScalar(value) || isCustomScalarName(value)
+  Schema.Scalar.isScalar(value) || isCustomScalarName(value)
 
 export const isOutputObject = (
   node?: Node,
diff --git a/tests/_/schemas/generate.ts b/tests/_/schemas/generate.ts
index 0980d18d..50dddaac 100644
--- a/tests/_/schemas/generate.ts
+++ b/tests/_/schemas/generate.ts
@@ -25,7 +25,7 @@ const generate = async (
     libraryPaths: {
       client: `../../../src/entrypoints/client.ts`,
       schema: `../../../src/entrypoints/schema.ts`,
-      scalars: `../../../src/types/Schema/types/Scalar/scalars.ts`,
+      scalars: `../../../src/types/Schema/types/Scalar/standardScalarTypes.ts`,
       utilitiesForGenerated: `../../../src/entrypoints/utilities-for-generated.ts`,
     },
     ...input.input,
diff --git a/tests/_/schemas/kitchen-sink/graffle/modules/Scalar.ts b/tests/_/schemas/kitchen-sink/graffle/modules/Scalar.ts
index cfdb373d..22222541 100644
--- a/tests/_/schemas/kitchen-sink/graffle/modules/Scalar.ts
+++ b/tests/_/schemas/kitchen-sink/graffle/modules/Scalar.ts
@@ -1,6 +1,6 @@
 import type * as $$Utilities from '../../../../../../src/entrypoints/utilities-for-generated.js'
 
-export * from '../../../../../../src/types/Schema/types/Scalar/scalars.js'
+export * from '../../../../../../src/types/Schema/types/Scalar/standardScalarTypes.js'
 
 //
 //
@@ -14,4 +14,4 @@ export * from '../../../../../../src/types/Schema/types/Scalar/scalars.js'
 //
 //
 
-export type Date = $$Utilities.SchemaKit.Scalar.ScalarCodecless<'Date'>
+export type Date = $$Utilities.Schema.Scalar.ScalarCodecless<'Date'>
diff --git a/tests/_/schemas/kitchen-sink/graffle/modules/Schema.ts b/tests/_/schemas/kitchen-sink/graffle/modules/Schema.ts
index 560635b8..cfb0e4f2 100644
--- a/tests/_/schemas/kitchen-sink/graffle/modules/Schema.ts
+++ b/tests/_/schemas/kitchen-sink/graffle/modules/Schema.ts
@@ -1,4 +1,4 @@
-import type { SchemaKit as $ } from '../../../../../../src/entrypoints/utilities-for-generated.js'
+import type { Schema as $ } from '../../../../../../src/entrypoints/utilities-for-generated.js'
 import type * as $$Utilities from '../../../../../../src/entrypoints/utilities-for-generated.js'
 import type * as Data from './Data.js'
 import type * as MethodsRoot from './MethodsRoot.js'
@@ -445,9 +445,7 @@ export namespace Schema {
 //
 //
 //
-export interface Schema<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
-  extends $$Utilities.SchemaIndexBase
-{
+export interface Schema<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $$Utilities.Schema {
   name: Data.Name
   RootTypesPresent: ['Mutation', 'Query']
   RootUnion: Schema.Mutation | Schema.Query
diff --git a/tests/_/schemas/kitchen-sink/graffle/modules/SelectionSets.ts b/tests/_/schemas/kitchen-sink/graffle/modules/SelectionSets.ts
index 722a46bd..c670f146 100644
--- a/tests/_/schemas/kitchen-sink/graffle/modules/SelectionSets.ts
+++ b/tests/_/schemas/kitchen-sink/graffle/modules/SelectionSets.ts
@@ -19,7 +19,7 @@ import type * as $Scalar from './Scalar.js'
 //
 
 // Prefix with $ because this is not a schema type. A user could have a schema type named "Document" that this would conflict with.
-export interface $Document<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface $Document<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   query?: Record<string, Query<$Scalars>>
   mutation?: Record<string, Mutation<$Scalars>>
 }
@@ -54,7 +54,7 @@ export interface $Document<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarM
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface Mutation<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface Mutation<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   /**
    * Select the `id` field on the `Mutation` object. Its type is `ID` (a `Scalar`).
    */
@@ -86,18 +86,18 @@ export interface Mutation<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMa
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Mutation$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Mutation$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Mutation<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace Mutation {
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -108,18 +108,18 @@ export namespace Mutation {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type idNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type idNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | idNonNull$SelectionSet<$Scalars>
 
-  export interface idNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface idNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -130,7 +130,7 @@ export namespace Mutation {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type idNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type idNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | idNonNull$SelectionSet<$Scalars>
   >
@@ -150,7 +150,7 @@ export namespace Mutation {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface Query<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface Query<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   /**
    * Select the `InputObjectNested` field on the `Query` object. Its type is `ID` (a `Scalar`).
    */
@@ -428,18 +428,18 @@ export interface Query<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap =
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Query$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Query$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Query<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace Query {
-  export type InputObjectNested<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type InputObjectNested<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | InputObjectNested$SelectionSet<$Scalars>
 
-  export interface InputObjectNested$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface InputObjectNested$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -448,7 +448,7 @@ export namespace Query {
     $?: InputObjectNested$Arguments<$Scalars>
   }
 
-  export interface InputObjectNested$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface InputObjectNested$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     input?: $NamedTypes.$InputObjectNested<$Scalars> | undefined | null
   }
 
@@ -459,7 +459,7 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type InputObjectNested$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type InputObjectNested$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       | $Select.Indicator.NoArgsIndicator
       | InputObjectNested$SelectionSet<$Scalars>
@@ -467,10 +467,10 @@ export namespace Query {
 
   // --------------------------------------------------------------------------------------------------
 
-  export type InputObjectNestedNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type InputObjectNestedNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     InputObjectNestedNonNull$SelectionSet<$Scalars>
 
-  export interface InputObjectNestedNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface InputObjectNestedNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -479,7 +479,7 @@ export namespace Query {
     $: InputObjectNestedNonNull$Arguments<$Scalars>
   }
 
-  export interface InputObjectNestedNonNull$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface InputObjectNestedNonNull$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     input: $NamedTypes.$InputObjectNestedNonNull<$Scalars>
   }
 
@@ -490,18 +490,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type InputObjectNestedNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type InputObjectNestedNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       InputObjectNestedNonNull$SelectionSet<$Scalars>
     >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type abcEnum<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type abcEnum<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | abcEnum$SelectionSet<$Scalars>
 
-  export interface abcEnum$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface abcEnum$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -512,18 +512,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type abcEnum$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type abcEnum$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | abcEnum$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type argInputObjectCircular<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type argInputObjectCircular<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | argInputObjectCircular$SelectionSet<$Scalars>
 
-  export interface argInputObjectCircular$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface argInputObjectCircular$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -532,7 +532,7 @@ export namespace Query {
     $?: argInputObjectCircular$Arguments<$Scalars>
   }
 
-  export interface argInputObjectCircular$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface argInputObjectCircular$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     input?: $NamedTypes.$InputObjectCircular<$Scalars> | undefined | null
   }
 
@@ -543,7 +543,7 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type argInputObjectCircular$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type argInputObjectCircular$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       | $Select.Indicator.NoArgsIndicator
       | argInputObjectCircular$SelectionSet<$Scalars>
@@ -551,11 +551,11 @@ export namespace Query {
 
   // --------------------------------------------------------------------------------------------------
 
-  export type date<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type date<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | date$SelectionSet<$Scalars>
 
-  export interface date$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface date$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -566,18 +566,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type date$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type date$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | date$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type dateArg<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type dateArg<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | dateArg$SelectionSet<$Scalars>
 
-  export interface dateArg$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface dateArg$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -586,10 +586,10 @@ export namespace Query {
     $?: dateArg$Arguments<$Scalars>
   }
 
-  export interface dateArg$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface dateArg$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     date?:
-      | $$Utilities.SchemaKit.Scalar.GetDecoded<
-        $$Utilities.SchemaKit.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
+      | $$Utilities.Schema.Scalar.GetDecoded<
+        $$Utilities.Schema.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
       >
       | undefined
       | null
@@ -602,18 +602,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type dateArg$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type dateArg$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | dateArg$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type dateArgInputObject<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type dateArgInputObject<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | dateArgInputObject$SelectionSet<$Scalars>
 
-  export interface dateArgInputObject$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface dateArgInputObject$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -622,7 +622,7 @@ export namespace Query {
     $?: dateArgInputObject$Arguments<$Scalars>
   }
 
-  export interface dateArgInputObject$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface dateArgInputObject$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     input?: $NamedTypes.$InputObject<$Scalars> | undefined | null
   }
 
@@ -633,7 +633,7 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type dateArgInputObject$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type dateArgInputObject$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       | $Select.Indicator.NoArgsIndicator
       | dateArgInputObject$SelectionSet<$Scalars>
@@ -641,11 +641,11 @@ export namespace Query {
 
   // --------------------------------------------------------------------------------------------------
 
-  export type dateArgList<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type dateArgList<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | dateArgList$SelectionSet<$Scalars>
 
-  export interface dateArgList$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface dateArgList$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -654,11 +654,11 @@ export namespace Query {
     $?: dateArgList$Arguments<$Scalars>
   }
 
-  export interface dateArgList$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface dateArgList$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     date?:
       | Array<
-        | $$Utilities.SchemaKit.Scalar.GetDecoded<
-          $$Utilities.SchemaKit.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
+        | $$Utilities.Schema.Scalar.GetDecoded<
+          $$Utilities.Schema.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
         >
         | undefined
         | null
@@ -674,17 +674,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type dateArgList$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type dateArgList$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | dateArgList$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type dateArgNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    dateArgNonNull$SelectionSet<$Scalars>
+  export type dateArgNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = dateArgNonNull$SelectionSet<
+    $Scalars
+  >
 
-  export interface dateArgNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface dateArgNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -693,9 +694,9 @@ export namespace Query {
     $: dateArgNonNull$Arguments<$Scalars>
   }
 
-  export interface dateArgNonNull$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
-    date: $$Utilities.SchemaKit.Scalar.GetDecoded<
-      $$Utilities.SchemaKit.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
+  export interface dateArgNonNull$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
+    date: $$Utilities.Schema.Scalar.GetDecoded<
+      $$Utilities.Schema.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
     >
   }
 
@@ -706,17 +707,16 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type dateArgNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    $$Utilities.Simplify<
-      dateArgNonNull$SelectionSet<$Scalars>
-    >
+  export type dateArgNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+    dateArgNonNull$SelectionSet<$Scalars>
+  >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type dateArgNonNullList<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type dateArgNonNullList<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     dateArgNonNullList$SelectionSet<$Scalars>
 
-  export interface dateArgNonNullList$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface dateArgNonNullList$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -725,10 +725,10 @@ export namespace Query {
     $: dateArgNonNullList$Arguments<$Scalars>
   }
 
-  export interface dateArgNonNullList$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface dateArgNonNullList$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     date: Array<
-      | $$Utilities.SchemaKit.Scalar.GetDecoded<
-        $$Utilities.SchemaKit.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
+      | $$Utilities.Schema.Scalar.GetDecoded<
+        $$Utilities.Schema.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
       >
       | undefined
       | null
@@ -742,17 +742,17 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type dateArgNonNullList$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type dateArgNonNullList$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       dateArgNonNullList$SelectionSet<$Scalars>
     >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type dateArgNonNullListNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type dateArgNonNullListNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     dateArgNonNullListNonNull$SelectionSet<$Scalars>
 
-  export interface dateArgNonNullListNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface dateArgNonNullListNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -761,10 +761,10 @@ export namespace Query {
     $: dateArgNonNullListNonNull$Arguments<$Scalars>
   }
 
-  export interface dateArgNonNullListNonNull$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface dateArgNonNullListNonNull$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     date: Array<
-      | $$Utilities.SchemaKit.Scalar.GetDecoded<
-        $$Utilities.SchemaKit.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
+      | $$Utilities.Schema.Scalar.GetDecoded<
+        $$Utilities.Schema.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
       >
       | undefined
       | null
@@ -778,17 +778,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type dateArgNonNullListNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type dateArgNonNullListNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       dateArgNonNullListNonNull$SelectionSet<$Scalars>
     >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type dateInterface1<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    dateInterface1$SelectionSet<$Scalars>
+  export type dateInterface1<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = dateInterface1$SelectionSet<
+    $Scalars
+  >
 
-  export interface dateInterface1$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface dateInterface1$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$DateInterface1<$Scalars>
   {}
 
@@ -799,18 +800,17 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type dateInterface1$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    $$Utilities.Simplify<
-      dateInterface1$SelectionSet<$Scalars>
-    >
+  export type dateInterface1$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+    dateInterface1$SelectionSet<$Scalars>
+  >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type dateList<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type dateList<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | dateList$SelectionSet<$Scalars>
 
-  export interface dateList$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface dateList$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -821,18 +821,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type dateList$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type dateList$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | dateList$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type dateListList<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type dateListList<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | dateListList$SelectionSet<$Scalars>
 
-  export interface dateListList$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface dateListList$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -843,19 +843,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type dateListList$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    $$Utilities.Simplify<
-      | $Select.Indicator.NoArgsIndicator
-      | dateListList$SelectionSet<$Scalars>
-    >
+  export type dateListList$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+    | $Select.Indicator.NoArgsIndicator
+    | dateListList$SelectionSet<$Scalars>
+  >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type dateListNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type dateListNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | dateListNonNull$SelectionSet<$Scalars>
 
-  export interface dateListNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface dateListNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -866,7 +865,7 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type dateListNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type dateListNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       | $Select.Indicator.NoArgsIndicator
       | dateListNonNull$SelectionSet<$Scalars>
@@ -874,11 +873,11 @@ export namespace Query {
 
   // --------------------------------------------------------------------------------------------------
 
-  export type dateNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type dateNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | dateNonNull$SelectionSet<$Scalars>
 
-  export interface dateNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface dateNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -889,18 +888,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type dateNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type dateNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | dateNonNull$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type dateObject1<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = dateObject1$SelectionSet<
+  export type dateObject1<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = dateObject1$SelectionSet<
     $Scalars
   >
 
-  export interface dateObject1$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface dateObject1$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$DateObject1<$Scalars>
   {}
 
@@ -911,15 +910,15 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type dateObject1$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type dateObject1$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     dateObject1$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type dateUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = dateUnion$SelectionSet<$Scalars>
+  export type dateUnion<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = dateUnion$SelectionSet<$Scalars>
 
-  export interface dateUnion$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface dateUnion$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$DateUnion<$Scalars>
   {}
 
@@ -930,17 +929,17 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type dateUnion$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type dateUnion$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     dateUnion$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type error<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type error<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | error$SelectionSet<$Scalars>
 
-  export interface error$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface error$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -949,7 +948,7 @@ export namespace Query {
     $?: error$Arguments<$Scalars>
   }
 
-  export interface error$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface error$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     case?: string | undefined | null
   }
 
@@ -960,18 +959,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type error$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type error$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | error$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -982,18 +981,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type idNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type idNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | idNonNull$SelectionSet<$Scalars>
 
-  export interface idNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface idNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1004,18 +1003,16 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type idNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type idNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | idNonNull$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type $interface<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $interface$SelectionSet<
-    $Scalars
-  >
+  export type $interface<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $interface$SelectionSet<$Scalars>
 
-  export interface $interface$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface $interface$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Interface<$Scalars>
   {}
 
@@ -1026,16 +1023,16 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type $interface$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type $interface$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     $interface$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type interfaceNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type interfaceNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     interfaceNonNull$SelectionSet<$Scalars>
 
-  export interface interfaceNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface interfaceNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Interface<$Scalars>
   {}
 
@@ -1046,17 +1043,17 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type interfaceNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type interfaceNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       interfaceNonNull$SelectionSet<$Scalars>
     >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type interfaceWithArgs<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type interfaceWithArgs<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     interfaceWithArgs$SelectionSet<$Scalars>
 
-  export interface interfaceWithArgs$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface interfaceWithArgs$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Interface<$Scalars>
   {
     /**
@@ -1065,7 +1062,7 @@ export namespace Query {
     $: interfaceWithArgs$Arguments<$Scalars>
   }
 
-  export interface interfaceWithArgs$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface interfaceWithArgs$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     id: string
   }
 
@@ -1076,18 +1073,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type interfaceWithArgs$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type interfaceWithArgs$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       interfaceWithArgs$SelectionSet<$Scalars>
     >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type listInt<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type listInt<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | listInt$SelectionSet<$Scalars>
 
-  export interface listInt$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface listInt$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1098,18 +1095,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type listInt$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type listInt$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | listInt$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type listIntNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type listIntNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | listIntNonNull$SelectionSet<$Scalars>
 
-  export interface listIntNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface listIntNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1120,19 +1117,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type listIntNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    $$Utilities.Simplify<
-      | $Select.Indicator.NoArgsIndicator
-      | listIntNonNull$SelectionSet<$Scalars>
-    >
+  export type listIntNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+    | $Select.Indicator.NoArgsIndicator
+    | listIntNonNull$SelectionSet<$Scalars>
+  >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type listListInt<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type listListInt<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | listListInt$SelectionSet<$Scalars>
 
-  export interface listListInt$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface listListInt$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1143,18 +1139,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type listListInt$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type listListInt$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | listListInt$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type listListIntNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type listListIntNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | listListIntNonNull$SelectionSet<$Scalars>
 
-  export interface listListIntNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface listListIntNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1165,7 +1161,7 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type listListIntNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type listListIntNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       | $Select.Indicator.NoArgsIndicator
       | listListIntNonNull$SelectionSet<$Scalars>
@@ -1173,10 +1169,11 @@ export namespace Query {
 
   // --------------------------------------------------------------------------------------------------
 
-  export type lowerCaseUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    lowerCaseUnion$SelectionSet<$Scalars>
+  export type lowerCaseUnion<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = lowerCaseUnion$SelectionSet<
+    $Scalars
+  >
 
-  export interface lowerCaseUnion$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface lowerCaseUnion$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$lowerCaseUnion<$Scalars>
   {}
 
@@ -1187,16 +1184,15 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type lowerCaseUnion$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    $$Utilities.Simplify<
-      lowerCaseUnion$SelectionSet<$Scalars>
-    >
+  export type lowerCaseUnion$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+    lowerCaseUnion$SelectionSet<$Scalars>
+  >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type $object<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $object$SelectionSet<$Scalars>
+  export type $object<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $object$SelectionSet<$Scalars>
 
-  export interface $object$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface $object$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Object1<$Scalars>
   {}
 
@@ -1207,17 +1203,15 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type $object$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type $object$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     $object$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type objectList<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = objectList$SelectionSet<
-    $Scalars
-  >
+  export type objectList<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = objectList$SelectionSet<$Scalars>
 
-  export interface objectList$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface objectList$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Object1<$Scalars>
   {}
 
@@ -1228,16 +1222,16 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type objectList$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type objectList$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     objectList$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type objectListNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type objectListNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     objectListNonNull$SelectionSet<$Scalars>
 
-  export interface objectListNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface objectListNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Object1<$Scalars>
   {}
 
@@ -1248,18 +1242,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type objectListNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type objectListNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       objectListNonNull$SelectionSet<$Scalars>
     >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type objectNested<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = objectNested$SelectionSet<
+  export type objectNested<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = objectNested$SelectionSet<
     $Scalars
   >
 
-  export interface objectNested$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface objectNested$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$ObjectNested<$Scalars>
   {}
 
@@ -1270,18 +1264,17 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type objectNested$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    $$Utilities.Simplify<
-      objectNested$SelectionSet<$Scalars>
-    >
+  export type objectNested$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+    objectNested$SelectionSet<$Scalars>
+  >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type objectNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = objectNonNull$SelectionSet<
+  export type objectNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = objectNonNull$SelectionSet<
     $Scalars
   >
 
-  export interface objectNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface objectNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Object1<$Scalars>
   {}
 
@@ -1292,17 +1285,17 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type objectNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    $$Utilities.Simplify<
-      objectNonNull$SelectionSet<$Scalars>
-    >
+  export type objectNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+    objectNonNull$SelectionSet<$Scalars>
+  >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type objectWithArgs<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    objectWithArgs$SelectionSet<$Scalars>
+  export type objectWithArgs<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = objectWithArgs$SelectionSet<
+    $Scalars
+  >
 
-  export interface objectWithArgs$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface objectWithArgs$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Object1<$Scalars>
   {
     /**
@@ -1311,7 +1304,7 @@ export namespace Query {
     $?: objectWithArgs$Arguments<$Scalars>
   }
 
-  export interface objectWithArgs$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface objectWithArgs$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     boolean?: boolean | undefined | null
     float?: number | undefined | null
     id?: string | undefined | null
@@ -1326,16 +1319,15 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type objectWithArgs$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    $$Utilities.Simplify<
-      objectWithArgs$SelectionSet<$Scalars>
-    >
+  export type objectWithArgs$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+    objectWithArgs$SelectionSet<$Scalars>
+  >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type result<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = result$SelectionSet<$Scalars>
+  export type result<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = result$SelectionSet<$Scalars>
 
-  export interface result$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface result$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Result<$Scalars>
   {
     /**
@@ -1344,7 +1336,7 @@ export namespace Query {
     $: result$Arguments<$Scalars>
   }
 
-  export interface result$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface result$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     $case: $NamedTypes.$Case
   }
 
@@ -1355,17 +1347,17 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type result$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type result$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     result$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type resultNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = resultNonNull$SelectionSet<
+  export type resultNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = resultNonNull$SelectionSet<
     $Scalars
   >
 
-  export interface resultNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface resultNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Result<$Scalars>
   {
     /**
@@ -1374,7 +1366,7 @@ export namespace Query {
     $?: resultNonNull$Arguments<$Scalars>
   }
 
-  export interface resultNonNull$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface resultNonNull$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     $case?: $NamedTypes.$Case | undefined | null
   }
 
@@ -1385,18 +1377,17 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type resultNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    $$Utilities.Simplify<
-      resultNonNull$SelectionSet<$Scalars>
-    >
+  export type resultNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+    resultNonNull$SelectionSet<$Scalars>
+  >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type $string<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type $string<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | $string$SelectionSet<$Scalars>
 
-  export interface $string$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface $string$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1407,18 +1398,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type $string$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type $string$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | $string$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type stringWithArgEnum<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type stringWithArgEnum<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | stringWithArgEnum$SelectionSet<$Scalars>
 
-  export interface stringWithArgEnum$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface stringWithArgEnum$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -1427,7 +1418,7 @@ export namespace Query {
     $?: stringWithArgEnum$Arguments<$Scalars>
   }
 
-  export interface stringWithArgEnum$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface stringWithArgEnum$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     $ABCEnum?: $NamedTypes.$ABCEnum | undefined | null
   }
 
@@ -1438,7 +1429,7 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type stringWithArgEnum$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type stringWithArgEnum$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       | $Select.Indicator.NoArgsIndicator
       | stringWithArgEnum$SelectionSet<$Scalars>
@@ -1446,11 +1437,11 @@ export namespace Query {
 
   // --------------------------------------------------------------------------------------------------
 
-  export type stringWithArgInputObject<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type stringWithArgInputObject<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | stringWithArgInputObject$SelectionSet<$Scalars>
 
-  export interface stringWithArgInputObject$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface stringWithArgInputObject$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -1459,7 +1450,7 @@ export namespace Query {
     $?: stringWithArgInputObject$Arguments<$Scalars>
   }
 
-  export interface stringWithArgInputObject$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface stringWithArgInputObject$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     input?: $NamedTypes.$InputObject<$Scalars> | undefined | null
   }
 
@@ -1470,7 +1461,7 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type stringWithArgInputObject$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type stringWithArgInputObject$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       | $Select.Indicator.NoArgsIndicator
       | stringWithArgInputObject$SelectionSet<$Scalars>
@@ -1478,11 +1469,11 @@ export namespace Query {
 
   // --------------------------------------------------------------------------------------------------
 
-  export type stringWithArgInputObjectRequired<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type stringWithArgInputObjectRequired<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     stringWithArgInputObjectRequired$SelectionSet<$Scalars>
 
   export interface stringWithArgInputObjectRequired$SelectionSet<
-    $Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {},
+    $Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {},
   > extends $Select.Bases.Base {
     /**
      * Arguments for `stringWithArgInputObjectRequired` field. All arguments are required so you must include this.
@@ -1491,7 +1482,7 @@ export namespace Query {
   }
 
   export interface stringWithArgInputObjectRequired$Arguments<
-    $Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {},
+    $Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {},
   > {
     input: $NamedTypes.$InputObject<$Scalars>
   }
@@ -1503,18 +1494,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type stringWithArgInputObjectRequired$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type stringWithArgInputObjectRequired$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       stringWithArgInputObjectRequired$SelectionSet<$Scalars>
     >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type stringWithArgs<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type stringWithArgs<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | stringWithArgs$SelectionSet<$Scalars>
 
-  export interface stringWithArgs$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface stringWithArgs$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -1523,7 +1514,7 @@ export namespace Query {
     $?: stringWithArgs$Arguments<$Scalars>
   }
 
-  export interface stringWithArgs$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface stringWithArgs$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     boolean?: boolean | undefined | null
     float?: number | undefined | null
     id?: string | undefined | null
@@ -1538,19 +1529,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type stringWithArgs$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    $$Utilities.Simplify<
-      | $Select.Indicator.NoArgsIndicator
-      | stringWithArgs$SelectionSet<$Scalars>
-    >
+  export type stringWithArgs$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+    | $Select.Indicator.NoArgsIndicator
+    | stringWithArgs$SelectionSet<$Scalars>
+  >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type stringWithListArg<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type stringWithListArg<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | stringWithListArg$SelectionSet<$Scalars>
 
-  export interface stringWithListArg$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface stringWithListArg$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -1559,7 +1549,7 @@ export namespace Query {
     $?: stringWithListArg$Arguments<$Scalars>
   }
 
-  export interface stringWithListArg$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface stringWithListArg$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     ints?: Array<number | undefined | null> | undefined | null
   }
 
@@ -1570,7 +1560,7 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type stringWithListArg$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type stringWithListArg$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       | $Select.Indicator.NoArgsIndicator
       | stringWithListArg$SelectionSet<$Scalars>
@@ -1578,10 +1568,10 @@ export namespace Query {
 
   // --------------------------------------------------------------------------------------------------
 
-  export type stringWithListArgRequired<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type stringWithListArgRequired<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     stringWithListArgRequired$SelectionSet<$Scalars>
 
-  export interface stringWithListArgRequired$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface stringWithListArgRequired$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -1590,7 +1580,7 @@ export namespace Query {
     $: stringWithListArgRequired$Arguments<$Scalars>
   }
 
-  export interface stringWithListArgRequired$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface stringWithListArgRequired$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     ints: Array<number | undefined | null>
   }
 
@@ -1601,17 +1591,17 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type stringWithListArgRequired$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type stringWithListArgRequired$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       stringWithListArgRequired$SelectionSet<$Scalars>
     >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type stringWithRequiredArg<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type stringWithRequiredArg<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     stringWithRequiredArg$SelectionSet<$Scalars>
 
-  export interface stringWithRequiredArg$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface stringWithRequiredArg$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -1620,7 +1610,7 @@ export namespace Query {
     $: stringWithRequiredArg$Arguments<$Scalars>
   }
 
-  export interface stringWithRequiredArg$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface stringWithRequiredArg$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     string: string
   }
 
@@ -1631,18 +1621,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type stringWithRequiredArg$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type stringWithRequiredArg$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       stringWithRequiredArg$SelectionSet<$Scalars>
     >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type unionFooBar<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = unionFooBar$SelectionSet<
+  export type unionFooBar<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = unionFooBar$SelectionSet<
     $Scalars
   >
 
-  export interface unionFooBar$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface unionFooBar$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$FooBarUnion<$Scalars>
   {}
 
@@ -1653,16 +1643,16 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type unionFooBar$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type unionFooBar$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     unionFooBar$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type unionFooBarNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type unionFooBarNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     unionFooBarNonNull$SelectionSet<$Scalars>
 
-  export interface unionFooBarNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface unionFooBarNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$FooBarUnion<$Scalars>
   {}
 
@@ -1673,17 +1663,17 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type unionFooBarNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type unionFooBarNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       unionFooBarNonNull$SelectionSet<$Scalars>
     >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type unionFooBarWithArgs<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type unionFooBarWithArgs<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     unionFooBarWithArgs$SelectionSet<$Scalars>
 
-  export interface unionFooBarWithArgs$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface unionFooBarWithArgs$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$FooBarUnion<$Scalars>
   {
     /**
@@ -1692,7 +1682,7 @@ export namespace Query {
     $?: unionFooBarWithArgs$Arguments<$Scalars>
   }
 
-  export interface unionFooBarWithArgs$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface unionFooBarWithArgs$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     id?: string | undefined | null
   }
 
@@ -1703,18 +1693,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type unionFooBarWithArgs$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type unionFooBarWithArgs$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       unionFooBarWithArgs$SelectionSet<$Scalars>
     >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type unionObject<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = unionObject$SelectionSet<
+  export type unionObject<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = unionObject$SelectionSet<
     $Scalars
   >
 
-  export interface unionObject$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface unionObject$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$ObjectUnion<$Scalars>
   {}
 
@@ -1725,16 +1715,16 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type unionObject$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type unionObject$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     unionObject$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type unionObjectNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type unionObjectNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     unionObjectNonNull$SelectionSet<$Scalars>
 
-  export interface unionObjectNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface unionObjectNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$ObjectUnion<$Scalars>
   {}
 
@@ -1745,7 +1735,7 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type unionObjectNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type unionObjectNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     $$Utilities.Simplify<
       unionObjectNonNull$SelectionSet<$Scalars>
     >
@@ -1795,35 +1785,35 @@ export type Case = 'ErrorOne' | 'ErrorTwo' | 'Object1'
 //
 //
 
-export interface InputObject<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface InputObject<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   date?:
-    | $$Utilities.SchemaKit.Scalar.GetDecoded<
-      $$Utilities.SchemaKit.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
+    | $$Utilities.Schema.Scalar.GetDecoded<
+      $$Utilities.Schema.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
     >
     | undefined
     | null
-  dateRequired: $$Utilities.SchemaKit.Scalar.GetDecoded<
-    $$Utilities.SchemaKit.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
+  dateRequired: $$Utilities.Schema.Scalar.GetDecoded<
+    $$Utilities.Schema.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
   >
   id?: string | undefined | null
   idRequired: string
 }
 
-export interface InputObjectCircular<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface InputObjectCircular<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   circular?: $NamedTypes.$InputObjectCircular<$Scalars> | undefined | null
   date?:
-    | $$Utilities.SchemaKit.Scalar.GetDecoded<
-      $$Utilities.SchemaKit.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
+    | $$Utilities.Schema.Scalar.GetDecoded<
+      $$Utilities.Schema.Scalar.LookupCustomScalarOrFallbackToString<'Date', $Scalars>
     >
     | undefined
     | null
 }
 
-export interface InputObjectNested<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface InputObjectNested<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   InputObject?: $NamedTypes.$InputObject<$Scalars> | undefined | null
 }
 
-export interface InputObjectNestedNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface InputObjectNestedNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   InputObject: $NamedTypes.$InputObject<$Scalars>
 }
 
@@ -1846,7 +1836,7 @@ export interface InputObjectNestedNonNull<$Scalars extends $$Utilities.SchemaKit
 // Interface Type: DateInterface1
 // --------------------------------------------------------------------------------------------------
 
-export interface DateInterface1<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface DateInterface1<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends $Select.Bases.ObjectLike
 {
   date1?: DateInterface1.date1<$Scalars>
@@ -1875,16 +1865,16 @@ export interface DateInterface1<$Scalars extends $$Utilities.SchemaKit.Scalar.Sc
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface DateInterface1$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface DateInterface1$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends DateInterface1<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 export namespace DateInterface1 {
-  export type date1<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type date1<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | date1$SelectionSet<$Scalars>
 
-  export interface date1$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface date1$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1895,7 +1885,7 @@ export namespace DateInterface1 {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type date1$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type date1$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | date1$SelectionSet<$Scalars>
   >
@@ -1904,7 +1894,7 @@ export namespace DateInterface1 {
 // Interface Type: Error
 // --------------------------------------------------------------------------------------------------
 
-export interface Error<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
+export interface Error<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
   message?: Error.message<$Scalars>
   ___on_ErrorOne?: ErrorOne<$Scalars>
   ___on_ErrorTwo?: ErrorTwo<$Scalars>
@@ -1932,16 +1922,16 @@ export interface Error<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap =
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Error$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Error$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Error<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 export namespace Error {
-  export type message<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type message<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | message$SelectionSet<$Scalars>
 
-  export interface message$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface message$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1952,7 +1942,7 @@ export namespace Error {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type message$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type message$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | message$SelectionSet<$Scalars>
   >
@@ -1961,9 +1951,7 @@ export namespace Error {
 // Interface Type: Interface
 // --------------------------------------------------------------------------------------------------
 
-export interface Interface<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
-  extends $Select.Bases.ObjectLike
-{
+export interface Interface<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
   id?: Interface.id<$Scalars>
   ___on_Object1ImplementingInterface?: Object1ImplementingInterface<$Scalars>
   ___on_Object2ImplementingInterface?: Object2ImplementingInterface<$Scalars>
@@ -1991,16 +1979,16 @@ export interface Interface<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarM
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Interface$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Interface$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Interface<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 export namespace Interface {
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2011,7 +1999,7 @@ export namespace Interface {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
@@ -2047,7 +2035,7 @@ export namespace Interface {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface Bar<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
+export interface Bar<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
   /**
    * Select the `int` field on the `Bar` object. Its type is `Int` (a `Scalar`).
    */
@@ -2075,18 +2063,18 @@ export interface Bar<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Bar$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Bar$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Bar<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace Bar {
-  export type int<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type int<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | int$SelectionSet<$Scalars>
 
-  export interface int$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface int$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2097,7 +2085,7 @@ export namespace Bar {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type int$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type int$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | int$SelectionSet<$Scalars>
   >
@@ -2117,7 +2105,7 @@ export namespace Bar {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface DateObject1<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface DateObject1<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends $Select.Bases.ObjectLike
 {
   /**
@@ -2147,18 +2135,18 @@ export interface DateObject1<$Scalars extends $$Utilities.SchemaKit.Scalar.Scala
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface DateObject1$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface DateObject1$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends DateObject1<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace DateObject1 {
-  export type date1<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type date1<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | date1$SelectionSet<$Scalars>
 
-  export interface date1$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface date1$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2169,7 +2157,7 @@ export namespace DateObject1 {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type date1$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type date1$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | date1$SelectionSet<$Scalars>
   >
@@ -2189,7 +2177,7 @@ export namespace DateObject1 {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface DateObject2<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface DateObject2<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends $Select.Bases.ObjectLike
 {
   /**
@@ -2219,18 +2207,18 @@ export interface DateObject2<$Scalars extends $$Utilities.SchemaKit.Scalar.Scala
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface DateObject2$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface DateObject2$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends DateObject2<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace DateObject2 {
-  export type date2<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type date2<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | date2$SelectionSet<$Scalars>
 
-  export interface date2$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface date2$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2241,7 +2229,7 @@ export namespace DateObject2 {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type date2$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type date2$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | date2$SelectionSet<$Scalars>
   >
@@ -2261,9 +2249,7 @@ export namespace DateObject2 {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface ErrorOne<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
-  extends $Select.Bases.ObjectLike
-{
+export interface ErrorOne<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
   /**
    * Select the `infoId` field on the `ErrorOne` object. Its type is `ID` (a `Scalar`).
    */
@@ -2295,18 +2281,18 @@ export interface ErrorOne<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMa
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface ErrorOne$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface ErrorOne$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends ErrorOne<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace ErrorOne {
-  export type infoId<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type infoId<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | infoId$SelectionSet<$Scalars>
 
-  export interface infoId$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface infoId$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2317,18 +2303,18 @@ export namespace ErrorOne {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type infoId$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type infoId$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | infoId$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type message<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type message<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | message$SelectionSet<$Scalars>
 
-  export interface message$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface message$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2339,7 +2325,7 @@ export namespace ErrorOne {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type message$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type message$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | message$SelectionSet<$Scalars>
   >
@@ -2359,9 +2345,7 @@ export namespace ErrorOne {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface ErrorTwo<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
-  extends $Select.Bases.ObjectLike
-{
+export interface ErrorTwo<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
   /**
    * Select the `infoInt` field on the `ErrorTwo` object. Its type is `Int` (a `Scalar`).
    */
@@ -2393,18 +2377,18 @@ export interface ErrorTwo<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMa
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface ErrorTwo$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface ErrorTwo$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends ErrorTwo<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace ErrorTwo {
-  export type infoInt<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type infoInt<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | infoInt$SelectionSet<$Scalars>
 
-  export interface infoInt$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface infoInt$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2415,18 +2399,18 @@ export namespace ErrorTwo {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type infoInt$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type infoInt$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | infoInt$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type message<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type message<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | message$SelectionSet<$Scalars>
 
-  export interface message$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface message$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2437,7 +2421,7 @@ export namespace ErrorTwo {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type message$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type message$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | message$SelectionSet<$Scalars>
   >
@@ -2460,7 +2444,7 @@ export namespace ErrorTwo {
 /**
  * Object documentation.
  */
-export interface Foo<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
+export interface Foo<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
   /**
    * Select the `id` field on the `Foo` object. Its type is `ID` (a `Scalar`).
    */
@@ -2488,18 +2472,18 @@ export interface Foo<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Foo$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Foo$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Foo<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace Foo {
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2510,7 +2494,7 @@ export namespace Foo {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
@@ -2530,9 +2514,7 @@ export namespace Foo {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface Object1<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
-  extends $Select.Bases.ObjectLike
-{
+export interface Object1<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
   /**
    * Select the `ABCEnum` field on the `Object1` object. Its type is Enum.
    */
@@ -2580,18 +2562,18 @@ export interface Object1<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Object1$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Object1$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Object1<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace Object1 {
-  export type ABCEnum<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type ABCEnum<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | ABCEnum$SelectionSet<$Scalars>
 
-  export interface ABCEnum$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface ABCEnum$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2602,18 +2584,18 @@ export namespace Object1 {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type ABCEnum$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type ABCEnum$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | ABCEnum$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type $boolean<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type $boolean<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | $boolean$SelectionSet<$Scalars>
 
-  export interface $boolean$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface $boolean$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2624,18 +2606,18 @@ export namespace Object1 {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type $boolean$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type $boolean$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | $boolean$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type float<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type float<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | float$SelectionSet<$Scalars>
 
-  export interface float$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface float$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2646,18 +2628,18 @@ export namespace Object1 {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type float$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type float$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | float$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2668,18 +2650,18 @@ export namespace Object1 {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type int<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type int<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | int$SelectionSet<$Scalars>
 
-  export interface int$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface int$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2690,18 +2672,18 @@ export namespace Object1 {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type int$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type int$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | int$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type $string<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type $string<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | $string$SelectionSet<$Scalars>
 
-  export interface $string$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface $string$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2712,7 +2694,7 @@ export namespace Object1 {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type $string$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type $string$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | $string$SelectionSet<$Scalars>
   >
@@ -2732,7 +2714,7 @@ export namespace Object1 {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface Object1ImplementingInterface<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Object1ImplementingInterface<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends $Select.Bases.ObjectLike
 {
   /**
@@ -2770,18 +2752,18 @@ export interface Object1ImplementingInterface<$Scalars extends $$Utilities.Schem
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Object1ImplementingInterface$FragmentInline<
-  $Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {},
-> extends Object1ImplementingInterface<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields {}
+export interface Object1ImplementingInterface$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
+  extends Object1ImplementingInterface<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
+{}
 
 // ----------------------------------------| Fields |
 
 export namespace Object1ImplementingInterface {
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2792,18 +2774,18 @@ export namespace Object1ImplementingInterface {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type int<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type int<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | int$SelectionSet<$Scalars>
 
-  export interface int$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface int$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2814,7 +2796,7 @@ export namespace Object1ImplementingInterface {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type int$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type int$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | int$SelectionSet<$Scalars>
   >
@@ -2834,7 +2816,7 @@ export namespace Object1ImplementingInterface {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface Object2ImplementingInterface<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Object2ImplementingInterface<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends $Select.Bases.ObjectLike
 {
   /**
@@ -2872,18 +2854,18 @@ export interface Object2ImplementingInterface<$Scalars extends $$Utilities.Schem
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Object2ImplementingInterface$FragmentInline<
-  $Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {},
-> extends Object2ImplementingInterface<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields {}
+export interface Object2ImplementingInterface$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
+  extends Object2ImplementingInterface<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
+{}
 
 // ----------------------------------------| Fields |
 
 export namespace Object2ImplementingInterface {
-  export type $boolean<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type $boolean<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | $boolean$SelectionSet<$Scalars>
 
-  export interface $boolean$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface $boolean$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2894,18 +2876,18 @@ export namespace Object2ImplementingInterface {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type $boolean$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type $boolean$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | $boolean$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2916,7 +2898,7 @@ export namespace Object2ImplementingInterface {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
@@ -2936,7 +2918,7 @@ export namespace Object2ImplementingInterface {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface ObjectNested<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface ObjectNested<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends $Select.Bases.ObjectLike
 {
   /**
@@ -2970,18 +2952,18 @@ export interface ObjectNested<$Scalars extends $$Utilities.SchemaKit.Scalar.Scal
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface ObjectNested$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface ObjectNested$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends ObjectNested<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace ObjectNested {
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -2992,16 +2974,16 @@ export namespace ObjectNested {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type $object<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $object$SelectionSet<$Scalars>
+  export type $object<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $object$SelectionSet<$Scalars>
 
-  export interface $object$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface $object$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Object1<$Scalars>
   {}
 
@@ -3012,7 +2994,7 @@ export namespace ObjectNested {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type $object$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type $object$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     $object$SelectionSet<$Scalars>
   >
 }
@@ -3031,7 +3013,7 @@ export namespace ObjectNested {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface ObjectUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface ObjectUnion<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends $Select.Bases.ObjectLike
 {
   /**
@@ -3063,18 +3045,18 @@ export interface ObjectUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.Scala
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface ObjectUnion$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface ObjectUnion$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends ObjectUnion<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace ObjectUnion {
-  export type fooBarUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = fooBarUnion$SelectionSet<
+  export type fooBarUnion<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = fooBarUnion$SelectionSet<
     $Scalars
   >
 
-  export interface fooBarUnion$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface fooBarUnion$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$FooBarUnion<$Scalars>
   {}
 
@@ -3085,7 +3067,7 @@ export namespace ObjectUnion {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type fooBarUnion$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type fooBarUnion$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     fooBarUnion$SelectionSet<$Scalars>
   >
 }
@@ -3104,7 +3086,7 @@ export namespace ObjectUnion {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface lowerCaseObject<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface lowerCaseObject<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends $Select.Bases.ObjectLike
 {
   /**
@@ -3134,18 +3116,18 @@ export interface lowerCaseObject<$Scalars extends $$Utilities.SchemaKit.Scalar.S
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface lowerCaseObject$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface lowerCaseObject$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends lowerCaseObject<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace lowerCaseObject {
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -3156,7 +3138,7 @@ export namespace lowerCaseObject {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
@@ -3176,7 +3158,7 @@ export namespace lowerCaseObject {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface lowerCaseObject2<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface lowerCaseObject2<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends $Select.Bases.ObjectLike
 {
   /**
@@ -3206,18 +3188,18 @@ export interface lowerCaseObject2<$Scalars extends $$Utilities.SchemaKit.Scalar.
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface lowerCaseObject2$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface lowerCaseObject2$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends lowerCaseObject2<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace lowerCaseObject2 {
-  export type int<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type int<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | int$SelectionSet<$Scalars>
 
-  export interface int$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface int$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -3228,7 +3210,7 @@ export namespace lowerCaseObject2 {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type int$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type int$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | int$SelectionSet<$Scalars>
   >
@@ -3250,7 +3232,7 @@ export namespace lowerCaseObject2 {
 //
 //
 
-export interface DateUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface DateUnion<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   ___on_DateObject1?: DateObject1<$Scalars>
   ___on_DateObject2?: DateObject2<$Scalars>
 
@@ -3276,14 +3258,14 @@ export interface DateUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarM
     | $Select.Indicator.NoArgsIndicator$Expanded
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
-export interface DateUnion$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface DateUnion$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends DateUnion<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 /**
  * Union documentation.
  */
-export interface FooBarUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface FooBarUnion<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   ___on_Bar?: Bar<$Scalars>
   ___on_Foo?: Foo<$Scalars>
 
@@ -3309,11 +3291,11 @@ export interface FooBarUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.Scala
     | $Select.Indicator.NoArgsIndicator$Expanded
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
-export interface FooBarUnion$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface FooBarUnion$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends FooBarUnion<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
-export interface Result<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface Result<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   ___on_ErrorOne?: ErrorOne<$Scalars>
   ___on_ErrorTwo?: ErrorTwo<$Scalars>
   ___on_Object1?: Object1<$Scalars>
@@ -3340,11 +3322,11 @@ export interface Result<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap
     | $Select.Indicator.NoArgsIndicator$Expanded
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
-export interface Result$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Result$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Result<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
-export interface lowerCaseUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface lowerCaseUnion<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   ___on_lowerCaseObject?: lowerCaseObject<$Scalars>
   ___on_lowerCaseObject2?: lowerCaseObject2<$Scalars>
 
@@ -3370,7 +3352,7 @@ export interface lowerCaseUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.Sc
     | $Select.Indicator.NoArgsIndicator$Expanded
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
-export interface lowerCaseUnion$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface lowerCaseUnion$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends lowerCaseUnion<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
@@ -3382,41 +3364,39 @@ export interface lowerCaseUnion$FragmentInline<$Scalars extends $$Utilities.Sche
  *     would end up with an error of `export interface Foo extends Foo ...`
  */
 export namespace $NamedTypes {
-  export type $Mutation<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Mutation<$Scalars>
-  export type $Query<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Query<$Scalars>
+  export type $Mutation<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Mutation<$Scalars>
+  export type $Query<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Query<$Scalars>
   export type $ABCEnum = ABCEnum
   export type $Case = Case
-  export type $InputObject<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = InputObject<$Scalars>
-  export type $InputObjectCircular<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = InputObjectCircular<
+  export type $InputObject<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = InputObject<$Scalars>
+  export type $InputObjectCircular<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = InputObjectCircular<
     $Scalars
   >
-  export type $InputObjectNested<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = InputObjectNested<
+  export type $InputObjectNested<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = InputObjectNested<
     $Scalars
   >
-  export type $InputObjectNestedNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type $InputObjectNestedNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     InputObjectNestedNonNull<$Scalars>
-  export type $DateInterface1<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = DateInterface1<$Scalars>
-  export type $Error<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Error<$Scalars>
-  export type $Interface<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Interface<$Scalars>
-  export type $Bar<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Bar<$Scalars>
-  export type $DateObject1<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = DateObject1<$Scalars>
-  export type $DateObject2<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = DateObject2<$Scalars>
-  export type $ErrorOne<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = ErrorOne<$Scalars>
-  export type $ErrorTwo<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = ErrorTwo<$Scalars>
-  export type $Foo<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Foo<$Scalars>
-  export type $Object1<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Object1<$Scalars>
-  export type $Object1ImplementingInterface<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type $DateInterface1<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = DateInterface1<$Scalars>
+  export type $Error<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Error<$Scalars>
+  export type $Interface<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Interface<$Scalars>
+  export type $Bar<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Bar<$Scalars>
+  export type $DateObject1<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = DateObject1<$Scalars>
+  export type $DateObject2<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = DateObject2<$Scalars>
+  export type $ErrorOne<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = ErrorOne<$Scalars>
+  export type $ErrorTwo<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = ErrorTwo<$Scalars>
+  export type $Foo<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Foo<$Scalars>
+  export type $Object1<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Object1<$Scalars>
+  export type $Object1ImplementingInterface<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     Object1ImplementingInterface<$Scalars>
-  export type $Object2ImplementingInterface<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type $Object2ImplementingInterface<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     Object2ImplementingInterface<$Scalars>
-  export type $ObjectNested<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = ObjectNested<$Scalars>
-  export type $ObjectUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = ObjectUnion<$Scalars>
-  export type $lowerCaseObject<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = lowerCaseObject<$Scalars>
-  export type $lowerCaseObject2<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = lowerCaseObject2<
-    $Scalars
-  >
-  export type $DateUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = DateUnion<$Scalars>
-  export type $FooBarUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = FooBarUnion<$Scalars>
-  export type $Result<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Result<$Scalars>
-  export type $lowerCaseUnion<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = lowerCaseUnion<$Scalars>
+  export type $ObjectNested<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = ObjectNested<$Scalars>
+  export type $ObjectUnion<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = ObjectUnion<$Scalars>
+  export type $lowerCaseObject<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = lowerCaseObject<$Scalars>
+  export type $lowerCaseObject2<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = lowerCaseObject2<$Scalars>
+  export type $DateUnion<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = DateUnion<$Scalars>
+  export type $FooBarUnion<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = FooBarUnion<$Scalars>
+  export type $Result<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Result<$Scalars>
+  export type $lowerCaseUnion<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = lowerCaseUnion<$Scalars>
 }
diff --git a/tests/_/schemas/mutation-only/graffle/modules/Scalar.ts b/tests/_/schemas/mutation-only/graffle/modules/Scalar.ts
index 0c865880..16a4866b 100644
--- a/tests/_/schemas/mutation-only/graffle/modules/Scalar.ts
+++ b/tests/_/schemas/mutation-only/graffle/modules/Scalar.ts
@@ -1,3 +1,3 @@
 import type * as $$Utilities from '../../../../../../src/entrypoints/utilities-for-generated.js'
 
-export * from '../../../../../../src/types/Schema/types/Scalar/scalars.js'
+export * from '../../../../../../src/types/Schema/types/Scalar/standardScalarTypes.js'
diff --git a/tests/_/schemas/mutation-only/graffle/modules/Schema.ts b/tests/_/schemas/mutation-only/graffle/modules/Schema.ts
index d7ae86f9..018f90b1 100644
--- a/tests/_/schemas/mutation-only/graffle/modules/Schema.ts
+++ b/tests/_/schemas/mutation-only/graffle/modules/Schema.ts
@@ -1,4 +1,4 @@
-import type { SchemaKit as $ } from '../../../../../../src/entrypoints/utilities-for-generated.js'
+import type { Schema as $ } from '../../../../../../src/entrypoints/utilities-for-generated.js'
 import type * as $$Utilities from '../../../../../../src/entrypoints/utilities-for-generated.js'
 import type * as Data from './Data.js'
 import type * as MethodsRoot from './MethodsRoot.js'
@@ -131,9 +131,7 @@ export namespace Schema {
 //
 //
 //
-export interface Schema<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
-  extends $$Utilities.SchemaIndexBase
-{
+export interface Schema<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $$Utilities.Schema {
   name: Data.Name
   RootTypesPresent: ['Mutation']
   RootUnion: Schema.Mutation
diff --git a/tests/_/schemas/mutation-only/graffle/modules/SelectionSets.ts b/tests/_/schemas/mutation-only/graffle/modules/SelectionSets.ts
index e9ce611d..8c0f2f13 100644
--- a/tests/_/schemas/mutation-only/graffle/modules/SelectionSets.ts
+++ b/tests/_/schemas/mutation-only/graffle/modules/SelectionSets.ts
@@ -18,7 +18,7 @@ import type * as $$Utilities from '../../../../../../src/entrypoints/utilities-f
 //
 
 // Prefix with $ because this is not a schema type. A user could have a schema type named "Document" that this would conflict with.
-export interface $Document<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface $Document<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   mutation?: Record<string, Mutation<$Scalars>>
 }
 
@@ -52,7 +52,7 @@ export interface $Document<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarM
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface Mutation<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface Mutation<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   /**
    * Select the `id` field on the `Mutation` object. Its type is `ID` (a `Scalar`).
    */
@@ -84,18 +84,18 @@ export interface Mutation<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMa
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Mutation$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Mutation$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Mutation<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace Mutation {
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -106,18 +106,18 @@ export namespace Mutation {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type idNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type idNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | idNonNull$SelectionSet<$Scalars>
 
-  export interface idNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface idNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -128,7 +128,7 @@ export namespace Mutation {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type idNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type idNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | idNonNull$SelectionSet<$Scalars>
   >
@@ -142,5 +142,5 @@ export namespace Mutation {
  *     would end up with an error of `export interface Foo extends Foo ...`
  */
 export namespace $NamedTypes {
-  export type $Mutation<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Mutation<$Scalars>
+  export type $Mutation<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Mutation<$Scalars>
 }
diff --git a/tests/_/schemas/pokemon/graffle/modules/Scalar.ts b/tests/_/schemas/pokemon/graffle/modules/Scalar.ts
index 0c865880..16a4866b 100644
--- a/tests/_/schemas/pokemon/graffle/modules/Scalar.ts
+++ b/tests/_/schemas/pokemon/graffle/modules/Scalar.ts
@@ -1,3 +1,3 @@
 import type * as $$Utilities from '../../../../../../src/entrypoints/utilities-for-generated.js'
 
-export * from '../../../../../../src/types/Schema/types/Scalar/scalars.js'
+export * from '../../../../../../src/types/Schema/types/Scalar/standardScalarTypes.js'
diff --git a/tests/_/schemas/pokemon/graffle/modules/Schema.ts b/tests/_/schemas/pokemon/graffle/modules/Schema.ts
index bc53d7c5..4d96dc14 100644
--- a/tests/_/schemas/pokemon/graffle/modules/Schema.ts
+++ b/tests/_/schemas/pokemon/graffle/modules/Schema.ts
@@ -1,4 +1,4 @@
-import type { SchemaKit as $ } from '../../../../../../src/entrypoints/utilities-for-generated.js'
+import type { Schema as $ } from '../../../../../../src/entrypoints/utilities-for-generated.js'
 import type * as $$Utilities from '../../../../../../src/entrypoints/utilities-for-generated.js'
 import type * as Data from './Data.js'
 import type * as MethodsRoot from './MethodsRoot.js'
@@ -262,9 +262,7 @@ export namespace Schema {
 //
 //
 //
-export interface Schema<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
-  extends $$Utilities.SchemaIndexBase
-{
+export interface Schema<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $$Utilities.Schema {
   name: Data.Name
   RootTypesPresent: ['Mutation', 'Query']
   RootUnion: Schema.Mutation | Schema.Query
diff --git a/tests/_/schemas/pokemon/graffle/modules/SelectionSets.ts b/tests/_/schemas/pokemon/graffle/modules/SelectionSets.ts
index b0a47d03..8a808daf 100644
--- a/tests/_/schemas/pokemon/graffle/modules/SelectionSets.ts
+++ b/tests/_/schemas/pokemon/graffle/modules/SelectionSets.ts
@@ -18,7 +18,7 @@ import type * as $$Utilities from '../../../../../../src/entrypoints/utilities-f
 //
 
 // Prefix with $ because this is not a schema type. A user could have a schema type named "Document" that this would conflict with.
-export interface $Document<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface $Document<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   query?: Record<string, Query<$Scalars>>
   mutation?: Record<string, Mutation<$Scalars>>
 }
@@ -53,7 +53,7 @@ export interface $Document<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarM
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface Mutation<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface Mutation<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   /**
    * Select the `addPokemon` field on the `Mutation` object. Its type is Object.
    */
@@ -81,18 +81,16 @@ export interface Mutation<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMa
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Mutation$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Mutation$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Mutation<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace Mutation {
-  export type addPokemon<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = addPokemon$SelectionSet<
-    $Scalars
-  >
+  export type addPokemon<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = addPokemon$SelectionSet<$Scalars>
 
-  export interface addPokemon$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface addPokemon$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Pokemon<$Scalars>
   {
     /**
@@ -101,7 +99,7 @@ export namespace Mutation {
     $: addPokemon$Arguments<$Scalars>
   }
 
-  export interface addPokemon$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface addPokemon$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     attack?: number | undefined | null
     defense?: number | undefined | null
     hp?: number | undefined | null
@@ -116,7 +114,7 @@ export namespace Mutation {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type addPokemon$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type addPokemon$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     addPokemon$SelectionSet<$Scalars>
   >
 }
@@ -135,7 +133,7 @@ export namespace Mutation {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface Query<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface Query<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   /**
    * Select the `battles` field on the `Query` object. Its type is Union.
    */
@@ -187,16 +185,16 @@ export interface Query<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap =
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Query$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Query$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Query<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace Query {
-  export type battles<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = battles$SelectionSet<$Scalars>
+  export type battles<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = battles$SelectionSet<$Scalars>
 
-  export interface battles$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface battles$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Battle<$Scalars>
   {}
 
@@ -207,15 +205,15 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type battles$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type battles$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     battles$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type beings<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = beings$SelectionSet<$Scalars>
+  export type beings<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = beings$SelectionSet<$Scalars>
 
-  export interface beings$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface beings$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Being<$Scalars>
   {}
 
@@ -226,15 +224,15 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type beings$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type beings$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     beings$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type pokemon<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = pokemon$SelectionSet<$Scalars>
+  export type pokemon<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = pokemon$SelectionSet<$Scalars>
 
-  export interface pokemon$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface pokemon$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Pokemon<$Scalars>
   {}
 
@@ -245,17 +243,17 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type pokemon$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type pokemon$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     pokemon$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type pokemonByName<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = pokemonByName$SelectionSet<
+  export type pokemonByName<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = pokemonByName$SelectionSet<
     $Scalars
   >
 
-  export interface pokemonByName$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface pokemonByName$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Pokemon<$Scalars>
   {
     /**
@@ -264,7 +262,7 @@ export namespace Query {
     $: pokemonByName$Arguments<$Scalars>
   }
 
-  export interface pokemonByName$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface pokemonByName$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     name: string
   }
 
@@ -275,16 +273,15 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type pokemonByName$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    $$Utilities.Simplify<
-      pokemonByName$SelectionSet<$Scalars>
-    >
+  export type pokemonByName$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+    pokemonByName$SelectionSet<$Scalars>
+  >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type pokemons<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = pokemons$SelectionSet<$Scalars>
+  export type pokemons<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = pokemons$SelectionSet<$Scalars>
 
-  export interface pokemons$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface pokemons$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Pokemon<$Scalars>
   {
     /**
@@ -293,7 +290,7 @@ export namespace Query {
     $?: pokemons$Arguments<$Scalars>
   }
 
-  export interface pokemons$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface pokemons$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     filter?: $NamedTypes.$PokemonFilter<$Scalars> | undefined | null
   }
 
@@ -304,17 +301,17 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type pokemons$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type pokemons$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     pokemons$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type trainerByName<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = trainerByName$SelectionSet<
+  export type trainerByName<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = trainerByName$SelectionSet<
     $Scalars
   >
 
-  export interface trainerByName$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface trainerByName$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Trainer<$Scalars>
   {
     /**
@@ -323,7 +320,7 @@ export namespace Query {
     $: trainerByName$Arguments<$Scalars>
   }
 
-  export interface trainerByName$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface trainerByName$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     name: string
   }
 
@@ -334,16 +331,15 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type trainerByName$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    $$Utilities.Simplify<
-      trainerByName$SelectionSet<$Scalars>
-    >
+  export type trainerByName$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+    trainerByName$SelectionSet<$Scalars>
+  >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type trainers<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = trainers$SelectionSet<$Scalars>
+  export type trainers<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = trainers$SelectionSet<$Scalars>
 
-  export interface trainers$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface trainers$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Trainer<$Scalars>
   {}
 
@@ -354,7 +350,7 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type trainers$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type trainers$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     trainers$SelectionSet<$Scalars>
   >
 }
@@ -410,17 +406,17 @@ export type TrainerClass =
 //
 //
 
-export interface DateFilter<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface DateFilter<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   gte?: number | undefined | null
   lte?: number | undefined | null
 }
 
-export interface PokemonFilter<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface PokemonFilter<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   birthday?: $NamedTypes.$DateFilter<$Scalars> | undefined | null
   name?: $NamedTypes.$StringFilter<$Scalars> | undefined | null
 }
 
-export interface StringFilter<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface StringFilter<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   contains?: string | undefined | null
   in?: Array<string | undefined | null> | undefined | null
 }
@@ -444,7 +440,7 @@ export interface StringFilter<$Scalars extends $$Utilities.SchemaKit.Scalar.Scal
 // Interface Type: Being
 // --------------------------------------------------------------------------------------------------
 
-export interface Being<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
+export interface Being<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
   id?: Being.id<$Scalars>
   name?: Being.name<$Scalars>
   ___on_Patron?: Patron<$Scalars>
@@ -474,16 +470,16 @@ export interface Being<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap =
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Being$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Being$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Being<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 export namespace Being {
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -494,16 +490,16 @@ export namespace Being {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
 
-  export type name<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type name<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | name$SelectionSet<$Scalars>
 
-  export interface name$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface name$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -514,7 +510,7 @@ export namespace Being {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type name$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type name$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | name$SelectionSet<$Scalars>
   >
@@ -550,7 +546,7 @@ export namespace Being {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface BattleRoyale<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface BattleRoyale<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends $Select.Bases.ObjectLike
 {
   /**
@@ -594,18 +590,16 @@ export interface BattleRoyale<$Scalars extends $$Utilities.SchemaKit.Scalar.Scal
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface BattleRoyale$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface BattleRoyale$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends BattleRoyale<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace BattleRoyale {
-  export type combatants<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = combatants$SelectionSet<
-    $Scalars
-  >
+  export type combatants<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = combatants$SelectionSet<$Scalars>
 
-  export interface combatants$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface combatants$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$CombatantMultiPokemon<$Scalars>
   {}
 
@@ -616,17 +610,17 @@ export namespace BattleRoyale {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type combatants$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type combatants$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     combatants$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type date<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type date<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | date$SelectionSet<$Scalars>
 
-  export interface date$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface date$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -637,18 +631,18 @@ export namespace BattleRoyale {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type date$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type date$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | date$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -659,16 +653,16 @@ export namespace BattleRoyale {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type winner<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = winner$SelectionSet<$Scalars>
+  export type winner<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = winner$SelectionSet<$Scalars>
 
-  export interface winner$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface winner$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Trainer<$Scalars>
   {}
 
@@ -679,7 +673,7 @@ export namespace BattleRoyale {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type winner$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type winner$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     winner$SelectionSet<$Scalars>
   >
 }
@@ -698,7 +692,7 @@ export namespace BattleRoyale {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface BattleTrainer<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface BattleTrainer<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends $Select.Bases.ObjectLike
 {
   /**
@@ -748,18 +742,16 @@ export interface BattleTrainer<$Scalars extends $$Utilities.SchemaKit.Scalar.Sca
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface BattleTrainer$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface BattleTrainer$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends BattleTrainer<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace BattleTrainer {
-  export type combatant1<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = combatant1$SelectionSet<
-    $Scalars
-  >
+  export type combatant1<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = combatant1$SelectionSet<$Scalars>
 
-  export interface combatant1$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface combatant1$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$CombatantSinglePokemon<$Scalars>
   {}
 
@@ -770,17 +762,15 @@ export namespace BattleTrainer {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type combatant1$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type combatant1$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     combatant1$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type combatant2<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = combatant2$SelectionSet<
-    $Scalars
-  >
+  export type combatant2<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = combatant2$SelectionSet<$Scalars>
 
-  export interface combatant2$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface combatant2$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$CombatantSinglePokemon<$Scalars>
   {}
 
@@ -791,17 +781,17 @@ export namespace BattleTrainer {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type combatant2$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type combatant2$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     combatant2$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type date<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type date<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | date$SelectionSet<$Scalars>
 
-  export interface date$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface date$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -812,18 +802,18 @@ export namespace BattleTrainer {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type date$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type date$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | date$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -834,16 +824,16 @@ export namespace BattleTrainer {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type winner<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = winner$SelectionSet<$Scalars>
+  export type winner<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = winner$SelectionSet<$Scalars>
 
-  export interface winner$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface winner$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Trainer<$Scalars>
   {}
 
@@ -854,7 +844,7 @@ export namespace BattleTrainer {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type winner$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type winner$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     winner$SelectionSet<$Scalars>
   >
 }
@@ -873,7 +863,7 @@ export namespace BattleTrainer {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface BattleWild<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface BattleWild<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends $Select.Bases.ObjectLike
 {
   /**
@@ -925,18 +915,18 @@ export interface BattleWild<$Scalars extends $$Utilities.SchemaKit.Scalar.Scalar
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface BattleWild$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface BattleWild$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends BattleWild<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace BattleWild {
-  export type date<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type date<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | date$SelectionSet<$Scalars>
 
-  export interface date$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface date$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -947,18 +937,18 @@ export namespace BattleWild {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type date$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type date$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | date$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -969,16 +959,16 @@ export namespace BattleWild {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type pokemon<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = pokemon$SelectionSet<$Scalars>
+  export type pokemon<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = pokemon$SelectionSet<$Scalars>
 
-  export interface pokemon$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface pokemon$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Pokemon<$Scalars>
   {}
 
@@ -989,17 +979,17 @@ export namespace BattleWild {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type pokemon$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type pokemon$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     pokemon$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type result<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type result<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | result$SelectionSet<$Scalars>
 
-  export interface result$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface result$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1010,16 +1000,16 @@ export namespace BattleWild {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type result$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type result$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | result$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type trainer<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = trainer$SelectionSet<$Scalars>
+  export type trainer<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = trainer$SelectionSet<$Scalars>
 
-  export interface trainer$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface trainer$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Trainer<$Scalars>
   {}
 
@@ -1030,17 +1020,17 @@ export namespace BattleWild {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type trainer$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type trainer$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     trainer$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type wildPokemons<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = wildPokemons$SelectionSet<
+  export type wildPokemons<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = wildPokemons$SelectionSet<
     $Scalars
   >
 
-  export interface wildPokemons$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface wildPokemons$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Pokemon<$Scalars>
   {}
 
@@ -1051,10 +1041,9 @@ export namespace BattleWild {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type wildPokemons$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    $$Utilities.Simplify<
-      wildPokemons$SelectionSet<$Scalars>
-    >
+  export type wildPokemons$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+    wildPokemons$SelectionSet<$Scalars>
+  >
 }
 
 //
@@ -1071,7 +1060,7 @@ export namespace BattleWild {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface CombatantMultiPokemon<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface CombatantMultiPokemon<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends $Select.Bases.ObjectLike
 {
   /**
@@ -1109,16 +1098,16 @@ export interface CombatantMultiPokemon<$Scalars extends $$Utilities.SchemaKit.Sc
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface CombatantMultiPokemon$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface CombatantMultiPokemon$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends CombatantMultiPokemon<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace CombatantMultiPokemon {
-  export type pokemons<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = pokemons$SelectionSet<$Scalars>
+  export type pokemons<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = pokemons$SelectionSet<$Scalars>
 
-  export interface pokemons$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface pokemons$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Pokemon<$Scalars>
   {}
 
@@ -1129,15 +1118,15 @@ export namespace CombatantMultiPokemon {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type pokemons$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type pokemons$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     pokemons$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type trainer<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = trainer$SelectionSet<$Scalars>
+  export type trainer<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = trainer$SelectionSet<$Scalars>
 
-  export interface trainer$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface trainer$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Trainer<$Scalars>
   {}
 
@@ -1148,7 +1137,7 @@ export namespace CombatantMultiPokemon {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type trainer$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type trainer$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     trainer$SelectionSet<$Scalars>
   >
 }
@@ -1167,7 +1156,7 @@ export namespace CombatantMultiPokemon {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface CombatantSinglePokemon<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface CombatantSinglePokemon<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends $Select.Bases.ObjectLike
 {
   /**
@@ -1205,16 +1194,16 @@ export interface CombatantSinglePokemon<$Scalars extends $$Utilities.SchemaKit.S
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface CombatantSinglePokemon$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface CombatantSinglePokemon$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends CombatantSinglePokemon<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace CombatantSinglePokemon {
-  export type pokemon<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = pokemon$SelectionSet<$Scalars>
+  export type pokemon<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = pokemon$SelectionSet<$Scalars>
 
-  export interface pokemon$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface pokemon$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Pokemon<$Scalars>
   {}
 
@@ -1225,15 +1214,15 @@ export namespace CombatantSinglePokemon {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type pokemon$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type pokemon$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     pokemon$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type trainer<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = trainer$SelectionSet<$Scalars>
+  export type trainer<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = trainer$SelectionSet<$Scalars>
 
-  export interface trainer$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface trainer$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Trainer<$Scalars>
   {}
 
@@ -1244,7 +1233,7 @@ export namespace CombatantSinglePokemon {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type trainer$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type trainer$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     trainer$SelectionSet<$Scalars>
   >
 }
@@ -1263,7 +1252,7 @@ export namespace CombatantSinglePokemon {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface Patron<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
+export interface Patron<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
   /**
    * Select the `id` field on the `Patron` object. Its type is `ID` (a `Scalar`).
    */
@@ -1299,18 +1288,18 @@ export interface Patron<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Patron$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Patron$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Patron<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace Patron {
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1321,18 +1310,18 @@ export namespace Patron {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type money<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type money<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | money$SelectionSet<$Scalars>
 
-  export interface money$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface money$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1343,18 +1332,18 @@ export namespace Patron {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type money$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type money$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | money$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type name<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type name<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | name$SelectionSet<$Scalars>
 
-  export interface name$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface name$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1365,7 +1354,7 @@ export namespace Patron {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type name$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type name$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | name$SelectionSet<$Scalars>
   >
@@ -1385,9 +1374,7 @@ export namespace Patron {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface Pokemon<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
-  extends $Select.Bases.ObjectLike
-{
+export interface Pokemon<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
   /**
    * Select the `attack` field on the `Pokemon` object. Its type is `Int` (a `Scalar`).
    */
@@ -1443,18 +1430,18 @@ export interface Pokemon<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Pokemon$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Pokemon$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Pokemon<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace Pokemon {
-  export type attack<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type attack<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | attack$SelectionSet<$Scalars>
 
-  export interface attack$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface attack$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1465,18 +1452,18 @@ export namespace Pokemon {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type attack$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type attack$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | attack$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type birthday<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type birthday<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | birthday$SelectionSet<$Scalars>
 
-  export interface birthday$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface birthday$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1487,18 +1474,18 @@ export namespace Pokemon {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type birthday$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type birthday$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | birthday$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type defense<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type defense<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | defense$SelectionSet<$Scalars>
 
-  export interface defense$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface defense$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1509,18 +1496,18 @@ export namespace Pokemon {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type defense$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type defense$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | defense$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type hp<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type hp<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | hp$SelectionSet<$Scalars>
 
-  export interface hp$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface hp$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1531,18 +1518,18 @@ export namespace Pokemon {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type hp$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type hp$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | hp$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1553,18 +1540,18 @@ export namespace Pokemon {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type name<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type name<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | name$SelectionSet<$Scalars>
 
-  export interface name$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface name$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1575,16 +1562,16 @@ export namespace Pokemon {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type name$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type name$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | name$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type trainer<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = trainer$SelectionSet<$Scalars>
+  export type trainer<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = trainer$SelectionSet<$Scalars>
 
-  export interface trainer$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface trainer$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Trainer<$Scalars>
   {}
 
@@ -1595,17 +1582,17 @@ export namespace Pokemon {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type trainer$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type trainer$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     trainer$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type type<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type type<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | type$SelectionSet<$Scalars>
 
-  export interface type$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface type$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1616,7 +1603,7 @@ export namespace Pokemon {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type type$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type type$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | type$SelectionSet<$Scalars>
   >
@@ -1636,9 +1623,7 @@ export namespace Pokemon {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface Trainer<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
-  extends $Select.Bases.ObjectLike
-{
+export interface Trainer<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
   /**
    * Select the `class` field on the `Trainer` object. Its type is Enum.
    */
@@ -1682,18 +1667,18 @@ export interface Trainer<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Trainer$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Trainer$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Trainer<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace Trainer {
-  export type $class<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type $class<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | $class$SelectionSet<$Scalars>
 
-  export interface $class$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface $class$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1704,16 +1689,16 @@ export namespace Trainer {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type $class$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type $class$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | $class$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type fans<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = fans$SelectionSet<$Scalars>
+  export type fans<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = fans$SelectionSet<$Scalars>
 
-  export interface fans$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface fans$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Patron<$Scalars>
   {}
 
@@ -1724,17 +1709,17 @@ export namespace Trainer {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type fans$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type fans$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     fans$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1745,18 +1730,18 @@ export namespace Trainer {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type name<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type name<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | name$SelectionSet<$Scalars>
 
-  export interface name$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface name$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1767,16 +1752,16 @@ export namespace Trainer {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type name$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type name$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | name$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type pokemon<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = pokemon$SelectionSet<$Scalars>
+  export type pokemon<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = pokemon$SelectionSet<$Scalars>
 
-  export interface pokemon$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface pokemon$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Pokemon<$Scalars>
   {}
 
@@ -1787,7 +1772,7 @@ export namespace Trainer {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type pokemon$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type pokemon$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     pokemon$SelectionSet<$Scalars>
   >
 }
@@ -1808,7 +1793,7 @@ export namespace Trainer {
 //
 //
 
-export interface Battle<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface Battle<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   ___on_BattleRoyale?: BattleRoyale<$Scalars>
   ___on_BattleTrainer?: BattleTrainer<$Scalars>
   ___on_BattleWild?: BattleWild<$Scalars>
@@ -1835,7 +1820,7 @@ export interface Battle<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap
     | $Select.Indicator.NoArgsIndicator$Expanded
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
-export interface Battle$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Battle$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Battle<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
@@ -1847,24 +1832,25 @@ export interface Battle$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Sc
  *     would end up with an error of `export interface Foo extends Foo ...`
  */
 export namespace $NamedTypes {
-  export type $Mutation<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Mutation<$Scalars>
-  export type $Query<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Query<$Scalars>
+  export type $Mutation<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Mutation<$Scalars>
+  export type $Query<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Query<$Scalars>
   export type $BattleWildResult = BattleWildResult
   export type $PokemonType = PokemonType
   export type $TrainerClass = TrainerClass
-  export type $DateFilter<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = DateFilter<$Scalars>
-  export type $PokemonFilter<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = PokemonFilter<$Scalars>
-  export type $StringFilter<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = StringFilter<$Scalars>
-  export type $Being<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Being<$Scalars>
-  export type $BattleRoyale<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = BattleRoyale<$Scalars>
-  export type $BattleTrainer<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = BattleTrainer<$Scalars>
-  export type $BattleWild<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = BattleWild<$Scalars>
-  export type $CombatantMultiPokemon<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    CombatantMultiPokemon<$Scalars>
-  export type $CombatantSinglePokemon<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type $DateFilter<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = DateFilter<$Scalars>
+  export type $PokemonFilter<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = PokemonFilter<$Scalars>
+  export type $StringFilter<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = StringFilter<$Scalars>
+  export type $Being<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Being<$Scalars>
+  export type $BattleRoyale<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = BattleRoyale<$Scalars>
+  export type $BattleTrainer<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = BattleTrainer<$Scalars>
+  export type $BattleWild<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = BattleWild<$Scalars>
+  export type $CombatantMultiPokemon<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = CombatantMultiPokemon<
+    $Scalars
+  >
+  export type $CombatantSinglePokemon<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     CombatantSinglePokemon<$Scalars>
-  export type $Patron<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Patron<$Scalars>
-  export type $Pokemon<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Pokemon<$Scalars>
-  export type $Trainer<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Trainer<$Scalars>
-  export type $Battle<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Battle<$Scalars>
+  export type $Patron<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Patron<$Scalars>
+  export type $Pokemon<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Pokemon<$Scalars>
+  export type $Trainer<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Trainer<$Scalars>
+  export type $Battle<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Battle<$Scalars>
 }
diff --git a/tests/_/schemas/query-only/graffle/modules/Scalar.ts b/tests/_/schemas/query-only/graffle/modules/Scalar.ts
index 0c865880..16a4866b 100644
--- a/tests/_/schemas/query-only/graffle/modules/Scalar.ts
+++ b/tests/_/schemas/query-only/graffle/modules/Scalar.ts
@@ -1,3 +1,3 @@
 import type * as $$Utilities from '../../../../../../src/entrypoints/utilities-for-generated.js'
 
-export * from '../../../../../../src/types/Schema/types/Scalar/scalars.js'
+export * from '../../../../../../src/types/Schema/types/Scalar/standardScalarTypes.js'
diff --git a/tests/_/schemas/query-only/graffle/modules/Schema.ts b/tests/_/schemas/query-only/graffle/modules/Schema.ts
index c3f7ab94..181727f1 100644
--- a/tests/_/schemas/query-only/graffle/modules/Schema.ts
+++ b/tests/_/schemas/query-only/graffle/modules/Schema.ts
@@ -1,4 +1,4 @@
-import type { SchemaKit as $ } from '../../../../../../src/entrypoints/utilities-for-generated.js'
+import type { Schema as $ } from '../../../../../../src/entrypoints/utilities-for-generated.js'
 import type * as $$Utilities from '../../../../../../src/entrypoints/utilities-for-generated.js'
 import type * as Data from './Data.js'
 import type * as MethodsRoot from './MethodsRoot.js'
@@ -131,9 +131,7 @@ export namespace Schema {
 //
 //
 //
-export interface Schema<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
-  extends $$Utilities.SchemaIndexBase
-{
+export interface Schema<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $$Utilities.Schema {
   name: Data.Name
   RootTypesPresent: ['Query']
   RootUnion: Schema.Query
diff --git a/tests/_/schemas/query-only/graffle/modules/SelectionSets.ts b/tests/_/schemas/query-only/graffle/modules/SelectionSets.ts
index 856b0b75..b72d9457 100644
--- a/tests/_/schemas/query-only/graffle/modules/SelectionSets.ts
+++ b/tests/_/schemas/query-only/graffle/modules/SelectionSets.ts
@@ -18,7 +18,7 @@ import type * as $$Utilities from '../../../../../../src/entrypoints/utilities-f
 //
 
 // Prefix with $ because this is not a schema type. A user could have a schema type named "Document" that this would conflict with.
-export interface $Document<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface $Document<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   query?: Record<string, Query<$Scalars>>
 }
 
@@ -52,7 +52,7 @@ export interface $Document<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarM
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface Query<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface Query<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   /**
    * Select the `id` field on the `Query` object. Its type is `ID` (a `Scalar`).
    */
@@ -84,18 +84,18 @@ export interface Query<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap =
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Query$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Query$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Query<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace Query {
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -106,18 +106,18 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type idNonNull<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type idNonNull<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | idNonNull$SelectionSet<$Scalars>
 
-  export interface idNonNull$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface idNonNull$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -128,7 +128,7 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type idNonNull$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type idNonNull$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | idNonNull$SelectionSet<$Scalars>
   >
@@ -142,5 +142,5 @@ export namespace Query {
  *     would end up with an error of `export interface Foo extends Foo ...`
  */
 export namespace $NamedTypes {
-  export type $Query<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Query<$Scalars>
+  export type $Query<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Query<$Scalars>
 }
diff --git a/website/graffle/modules/Scalar.ts b/website/graffle/modules/Scalar.ts
index ef72f421..98c8e166 100644
--- a/website/graffle/modules/Scalar.ts
+++ b/website/graffle/modules/Scalar.ts
@@ -1,3 +1,3 @@
 import type * as $$Utilities from 'graffle/utilities-for-generated'
 
-export * from 'graffle/schema/scalars'
+export * from 'graffle/generator-helpers/standard-scalar-types'
diff --git a/website/graffle/modules/Schema.ts b/website/graffle/modules/Schema.ts
index 59a1eac6..d543a9b0 100644
--- a/website/graffle/modules/Schema.ts
+++ b/website/graffle/modules/Schema.ts
@@ -1,4 +1,4 @@
-import type { SchemaKit as $ } from 'graffle/utilities-for-generated'
+import type { Schema as $ } from 'graffle/utilities-for-generated'
 import type * as $$Utilities from 'graffle/utilities-for-generated'
 import type * as Data from './Data.js'
 import type * as MethodsRoot from './MethodsRoot.js'
@@ -239,9 +239,7 @@ export namespace Schema {
 //
 //
 //
-export interface Schema<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
-  extends $$Utilities.SchemaIndexBase
-{
+export interface Schema<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $$Utilities.Schema {
   name: Data.Name
   RootTypesPresent: ['Query']
   RootUnion: Schema.Query
diff --git a/website/graffle/modules/SelectionSets.ts b/website/graffle/modules/SelectionSets.ts
index fcd69927..af553c68 100644
--- a/website/graffle/modules/SelectionSets.ts
+++ b/website/graffle/modules/SelectionSets.ts
@@ -18,7 +18,7 @@ import type * as $$Utilities from 'graffle/utilities-for-generated'
 //
 
 // Prefix with $ because this is not a schema type. A user could have a schema type named "Document" that this would conflict with.
-export interface $Document<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface $Document<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   query?: Record<string, Query<$Scalars>>
 }
 
@@ -52,7 +52,7 @@ export interface $Document<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarM
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface Query<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface Query<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   /**
    * Select the `continent` field on the `Query` object. Its type is Object.
    */
@@ -100,16 +100,16 @@ export interface Query<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap =
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Query$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Query$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Query<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace Query {
-  export type continent<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = continent$SelectionSet<$Scalars>
+  export type continent<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = continent$SelectionSet<$Scalars>
 
-  export interface continent$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface continent$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Continent<$Scalars>
   {
     /**
@@ -118,7 +118,7 @@ export namespace Query {
     $: continent$Arguments<$Scalars>
   }
 
-  export interface continent$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface continent$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     code: string
   }
 
@@ -129,17 +129,15 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type continent$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type continent$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     continent$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type continents<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = continents$SelectionSet<
-    $Scalars
-  >
+  export type continents<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = continents$SelectionSet<$Scalars>
 
-  export interface continents$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface continents$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Continent<$Scalars>
   {
     /**
@@ -148,7 +146,7 @@ export namespace Query {
     $?: continents$Arguments<$Scalars>
   }
 
-  export interface continents$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface continents$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     filter?: $NamedTypes.$ContinentFilterInput<$Scalars> | undefined | null
   }
 
@@ -159,15 +157,15 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type continents$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type continents$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     continents$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type countries<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = countries$SelectionSet<$Scalars>
+  export type countries<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = countries$SelectionSet<$Scalars>
 
-  export interface countries$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface countries$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Country<$Scalars>
   {
     /**
@@ -176,7 +174,7 @@ export namespace Query {
     $?: countries$Arguments<$Scalars>
   }
 
-  export interface countries$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface countries$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     filter?: $NamedTypes.$CountryFilterInput<$Scalars> | undefined | null
   }
 
@@ -187,15 +185,15 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type countries$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type countries$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     countries$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type country<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = country$SelectionSet<$Scalars>
+  export type country<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = country$SelectionSet<$Scalars>
 
-  export interface country$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface country$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Country<$Scalars>
   {
     /**
@@ -204,7 +202,7 @@ export namespace Query {
     $: country$Arguments<$Scalars>
   }
 
-  export interface country$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface country$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     code: string
   }
 
@@ -215,15 +213,15 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type country$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type country$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     country$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type language<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = language$SelectionSet<$Scalars>
+  export type language<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = language$SelectionSet<$Scalars>
 
-  export interface language$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface language$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Language<$Scalars>
   {
     /**
@@ -232,7 +230,7 @@ export namespace Query {
     $: language$Arguments<$Scalars>
   }
 
-  export interface language$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface language$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     code: string
   }
 
@@ -243,15 +241,15 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type language$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type language$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     language$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type languages<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = languages$SelectionSet<$Scalars>
+  export type languages<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = languages$SelectionSet<$Scalars>
 
-  export interface languages$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface languages$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Language<$Scalars>
   {
     /**
@@ -260,7 +258,7 @@ export namespace Query {
     $?: languages$Arguments<$Scalars>
   }
 
-  export interface languages$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface languages$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     filter?: $NamedTypes.$LanguageFilterInput<$Scalars> | undefined | null
   }
 
@@ -271,7 +269,7 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type languages$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type languages$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     languages$SelectionSet<$Scalars>
   >
 }
@@ -292,22 +290,22 @@ export namespace Query {
 //
 //
 
-export interface ContinentFilterInput<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface ContinentFilterInput<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   code?: $NamedTypes.$StringQueryOperatorInput<$Scalars> | undefined | null
 }
 
-export interface CountryFilterInput<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface CountryFilterInput<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   code?: $NamedTypes.$StringQueryOperatorInput<$Scalars> | undefined | null
   continent?: $NamedTypes.$StringQueryOperatorInput<$Scalars> | undefined | null
   currency?: $NamedTypes.$StringQueryOperatorInput<$Scalars> | undefined | null
   name?: $NamedTypes.$StringQueryOperatorInput<$Scalars> | undefined | null
 }
 
-export interface LanguageFilterInput<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface LanguageFilterInput<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   code?: $NamedTypes.$StringQueryOperatorInput<$Scalars> | undefined | null
 }
 
-export interface StringQueryOperatorInput<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface StringQueryOperatorInput<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   eq?: string | undefined | null
   in?: Array<string | undefined | null> | undefined | null
   ne?: string | undefined | null
@@ -345,9 +343,7 @@ export interface StringQueryOperatorInput<$Scalars extends $$Utilities.SchemaKit
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface Continent<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
-  extends $Select.Bases.ObjectLike
-{
+export interface Continent<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
   /**
    * Select the `code` field on the `Continent` object. Its type is `ID` (a `Scalar`).
    */
@@ -383,18 +379,18 @@ export interface Continent<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarM
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Continent$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Continent$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Continent<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace Continent {
-  export type code<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type code<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | code$SelectionSet<$Scalars>
 
-  export interface code$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface code$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -405,16 +401,16 @@ export namespace Continent {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type code$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type code$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | code$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type countries<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = countries$SelectionSet<$Scalars>
+  export type countries<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = countries$SelectionSet<$Scalars>
 
-  export interface countries$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface countries$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Country<$Scalars>
   {}
 
@@ -425,17 +421,17 @@ export namespace Continent {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type countries$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type countries$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     countries$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type name<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type name<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | name$SelectionSet<$Scalars>
 
-  export interface name$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface name$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -446,7 +442,7 @@ export namespace Continent {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type name$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type name$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | name$SelectionSet<$Scalars>
   >
@@ -466,9 +462,7 @@ export namespace Continent {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface Country<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
-  extends $Select.Bases.ObjectLike
-{
+export interface Country<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
   /**
    * Select the `awsRegion` field on the `Country` object. Its type is `String` (a `Scalar`).
    */
@@ -554,18 +548,18 @@ export interface Country<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Country$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Country$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Country<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace Country {
-  export type awsRegion<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type awsRegion<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | awsRegion$SelectionSet<$Scalars>
 
-  export interface awsRegion$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface awsRegion$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -576,18 +570,18 @@ export namespace Country {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type awsRegion$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type awsRegion$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | awsRegion$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type capital<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type capital<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | capital$SelectionSet<$Scalars>
 
-  export interface capital$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface capital$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -598,18 +592,18 @@ export namespace Country {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type capital$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type capital$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | capital$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type code<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type code<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | code$SelectionSet<$Scalars>
 
-  export interface code$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface code$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -620,16 +614,16 @@ export namespace Country {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type code$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type code$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | code$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type continent<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = continent$SelectionSet<$Scalars>
+  export type continent<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = continent$SelectionSet<$Scalars>
 
-  export interface continent$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface continent$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Continent<$Scalars>
   {}
 
@@ -640,17 +634,17 @@ export namespace Country {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type continent$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type continent$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     continent$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type currencies<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type currencies<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | currencies$SelectionSet<$Scalars>
 
-  export interface currencies$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface currencies$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -661,18 +655,18 @@ export namespace Country {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type currencies$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type currencies$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | currencies$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type currency<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type currency<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | currency$SelectionSet<$Scalars>
 
-  export interface currency$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface currency$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -683,18 +677,18 @@ export namespace Country {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type currency$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type currency$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | currency$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type emoji<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type emoji<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | emoji$SelectionSet<$Scalars>
 
-  export interface emoji$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface emoji$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -705,18 +699,18 @@ export namespace Country {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type emoji$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type emoji$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | emoji$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type emojiU<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type emojiU<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | emojiU$SelectionSet<$Scalars>
 
-  export interface emojiU$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface emojiU$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -727,16 +721,16 @@ export namespace Country {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type emojiU$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type emojiU$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | emojiU$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type languages<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = languages$SelectionSet<$Scalars>
+  export type languages<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = languages$SelectionSet<$Scalars>
 
-  export interface languages$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface languages$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Language<$Scalars>
   {}
 
@@ -747,17 +741,17 @@ export namespace Country {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type languages$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type languages$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     languages$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type name<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type name<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | name$SelectionSet<$Scalars>
 
-  export interface name$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface name$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {
     /**
@@ -766,7 +760,7 @@ export namespace Country {
     $?: name$Arguments<$Scalars>
   }
 
-  export interface name$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface name$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     lang?: string | undefined | null
   }
 
@@ -777,18 +771,18 @@ export namespace Country {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type name$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type name$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | name$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type native<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type native<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | native$SelectionSet<$Scalars>
 
-  export interface native$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface native$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -799,18 +793,18 @@ export namespace Country {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type native$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type native$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | native$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type phone<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type phone<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | phone$SelectionSet<$Scalars>
 
-  export interface phone$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface phone$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -821,18 +815,18 @@ export namespace Country {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type phone$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type phone$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | phone$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type phones<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type phones<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | phones$SelectionSet<$Scalars>
 
-  export interface phones$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface phones$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -843,16 +837,16 @@ export namespace Country {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type phones$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type phones$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | phones$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type states<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = states$SelectionSet<$Scalars>
+  export type states<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = states$SelectionSet<$Scalars>
 
-  export interface states$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface states$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$State<$Scalars>
   {}
 
@@ -863,17 +857,17 @@ export namespace Country {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type states$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type states$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     states$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type subdivisions<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = subdivisions$SelectionSet<
+  export type subdivisions<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = subdivisions$SelectionSet<
     $Scalars
   >
 
-  export interface subdivisions$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface subdivisions$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Subdivision<$Scalars>
   {}
 
@@ -884,10 +878,9 @@ export namespace Country {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type subdivisions$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    $$Utilities.Simplify<
-      subdivisions$SelectionSet<$Scalars>
-    >
+  export type subdivisions$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+    subdivisions$SelectionSet<$Scalars>
+  >
 }
 
 //
@@ -904,9 +897,7 @@ export namespace Country {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface Language<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
-  extends $Select.Bases.ObjectLike
-{
+export interface Language<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
   /**
    * Select the `code` field on the `Language` object. Its type is `ID` (a `Scalar`).
    */
@@ -946,18 +937,18 @@ export interface Language<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMa
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Language$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Language$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Language<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace Language {
-  export type code<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type code<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | code$SelectionSet<$Scalars>
 
-  export interface code$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface code$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -968,18 +959,18 @@ export namespace Language {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type code$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type code$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | code$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type name<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type name<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | name$SelectionSet<$Scalars>
 
-  export interface name$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface name$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -990,18 +981,18 @@ export namespace Language {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type name$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type name$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | name$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type native<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type native<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | native$SelectionSet<$Scalars>
 
-  export interface native$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface native$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1012,18 +1003,18 @@ export namespace Language {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type native$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type native$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | native$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type rtl<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type rtl<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | rtl$SelectionSet<$Scalars>
 
-  export interface rtl$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface rtl$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1034,7 +1025,7 @@ export namespace Language {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type rtl$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type rtl$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | rtl$SelectionSet<$Scalars>
   >
@@ -1054,7 +1045,7 @@ export namespace Language {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface State<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
+export interface State<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
   /**
    * Select the `code` field on the `State` object. Its type is `String` (a `Scalar`).
    */
@@ -1090,18 +1081,18 @@ export interface State<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap =
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface State$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface State$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends State<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace State {
-  export type code<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type code<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | code$SelectionSet<$Scalars>
 
-  export interface code$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface code$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1112,16 +1103,16 @@ export namespace State {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type code$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type code$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | code$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type country<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = country$SelectionSet<$Scalars>
+  export type country<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = country$SelectionSet<$Scalars>
 
-  export interface country$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface country$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Country<$Scalars>
   {}
 
@@ -1132,17 +1123,17 @@ export namespace State {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type country$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type country$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     country$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type name<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type name<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | name$SelectionSet<$Scalars>
 
-  export interface name$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface name$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1153,7 +1144,7 @@ export namespace State {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type name$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type name$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | name$SelectionSet<$Scalars>
   >
@@ -1173,7 +1164,7 @@ export namespace State {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface Subdivision<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Subdivision<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends $Select.Bases.ObjectLike
 {
   /**
@@ -1211,18 +1202,18 @@ export interface Subdivision<$Scalars extends $$Utilities.SchemaKit.Scalar.Scala
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Subdivision$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Subdivision$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Subdivision<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace Subdivision {
-  export type code<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type code<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | code$SelectionSet<$Scalars>
 
-  export interface code$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface code$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1233,18 +1224,18 @@ export namespace Subdivision {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type code$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type code$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | code$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type emoji<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type emoji<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | emoji$SelectionSet<$Scalars>
 
-  export interface emoji$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface emoji$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1255,18 +1246,18 @@ export namespace Subdivision {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type emoji$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type emoji$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | emoji$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type name<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type name<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | name$SelectionSet<$Scalars>
 
-  export interface name$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface name$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1277,7 +1268,7 @@ export namespace Subdivision {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type name$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type name$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | name$SelectionSet<$Scalars>
   >
@@ -1291,20 +1282,21 @@ export namespace Subdivision {
  *     would end up with an error of `export interface Foo extends Foo ...`
  */
 export namespace $NamedTypes {
-  export type $Query<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Query<$Scalars>
-  export type $ContinentFilterInput<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    ContinentFilterInput<$Scalars>
-  export type $CountryFilterInput<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = CountryFilterInput<
+  export type $Query<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Query<$Scalars>
+  export type $ContinentFilterInput<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = ContinentFilterInput<
+    $Scalars
+  >
+  export type $CountryFilterInput<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = CountryFilterInput<
     $Scalars
   >
-  export type $LanguageFilterInput<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = LanguageFilterInput<
+  export type $LanguageFilterInput<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = LanguageFilterInput<
     $Scalars
   >
-  export type $StringQueryOperatorInput<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type $StringQueryOperatorInput<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     StringQueryOperatorInput<$Scalars>
-  export type $Continent<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Continent<$Scalars>
-  export type $Country<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Country<$Scalars>
-  export type $Language<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Language<$Scalars>
-  export type $State<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = State<$Scalars>
-  export type $Subdivision<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Subdivision<$Scalars>
+  export type $Continent<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Continent<$Scalars>
+  export type $Country<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Country<$Scalars>
+  export type $Language<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Language<$Scalars>
+  export type $State<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = State<$Scalars>
+  export type $Subdivision<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Subdivision<$Scalars>
 }
diff --git a/website/pokemon/modules/Scalar.ts b/website/pokemon/modules/Scalar.ts
index ef72f421..98c8e166 100644
--- a/website/pokemon/modules/Scalar.ts
+++ b/website/pokemon/modules/Scalar.ts
@@ -1,3 +1,3 @@
 import type * as $$Utilities from 'graffle/utilities-for-generated'
 
-export * from 'graffle/schema/scalars'
+export * from 'graffle/generator-helpers/standard-scalar-types'
diff --git a/website/pokemon/modules/Schema.ts b/website/pokemon/modules/Schema.ts
index 9a2a1995..cb950cfa 100644
--- a/website/pokemon/modules/Schema.ts
+++ b/website/pokemon/modules/Schema.ts
@@ -1,4 +1,4 @@
-import type { SchemaKit as $ } from 'graffle/utilities-for-generated'
+import type { Schema as $ } from 'graffle/utilities-for-generated'
 import type * as $$Utilities from 'graffle/utilities-for-generated'
 import type * as Data from './Data.js'
 import type * as MethodsRoot from './MethodsRoot.js'
@@ -262,9 +262,7 @@ export namespace Schema {
 //
 //
 //
-export interface Schema<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
-  extends $$Utilities.SchemaIndexBase
-{
+export interface Schema<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $$Utilities.Schema {
   name: Data.Name
   RootTypesPresent: ['Mutation', 'Query']
   RootUnion: Schema.Mutation | Schema.Query
diff --git a/website/pokemon/modules/SelectionSets.ts b/website/pokemon/modules/SelectionSets.ts
index 06f5b0e6..f6c1b457 100644
--- a/website/pokemon/modules/SelectionSets.ts
+++ b/website/pokemon/modules/SelectionSets.ts
@@ -18,7 +18,7 @@ import type * as $$Utilities from 'graffle/utilities-for-generated'
 //
 
 // Prefix with $ because this is not a schema type. A user could have a schema type named "Document" that this would conflict with.
-export interface $Document<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface $Document<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   query?: Record<string, Query<$Scalars>>
   mutation?: Record<string, Mutation<$Scalars>>
 }
@@ -53,7 +53,7 @@ export interface $Document<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarM
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface Mutation<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface Mutation<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   /**
    * Select the `addPokemon` field on the `Mutation` object. Its type is Object.
    */
@@ -81,18 +81,16 @@ export interface Mutation<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMa
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Mutation$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Mutation$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Mutation<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace Mutation {
-  export type addPokemon<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = addPokemon$SelectionSet<
-    $Scalars
-  >
+  export type addPokemon<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = addPokemon$SelectionSet<$Scalars>
 
-  export interface addPokemon$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface addPokemon$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Pokemon<$Scalars>
   {
     /**
@@ -101,7 +99,7 @@ export namespace Mutation {
     $: addPokemon$Arguments<$Scalars>
   }
 
-  export interface addPokemon$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface addPokemon$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     attack?: number | undefined | null
     defense?: number | undefined | null
     hp?: number | undefined | null
@@ -116,7 +114,7 @@ export namespace Mutation {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type addPokemon$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type addPokemon$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     addPokemon$SelectionSet<$Scalars>
   >
 }
@@ -135,7 +133,7 @@ export namespace Mutation {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface Query<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface Query<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   /**
    * Select the `battles` field on the `Query` object. Its type is Union.
    */
@@ -187,16 +185,16 @@ export interface Query<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap =
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Query$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Query$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Query<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace Query {
-  export type battles<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = battles$SelectionSet<$Scalars>
+  export type battles<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = battles$SelectionSet<$Scalars>
 
-  export interface battles$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface battles$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Battle<$Scalars>
   {}
 
@@ -207,15 +205,15 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type battles$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type battles$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     battles$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type beings<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = beings$SelectionSet<$Scalars>
+  export type beings<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = beings$SelectionSet<$Scalars>
 
-  export interface beings$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface beings$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Being<$Scalars>
   {}
 
@@ -226,15 +224,15 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type beings$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type beings$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     beings$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type pokemon<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = pokemon$SelectionSet<$Scalars>
+  export type pokemon<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = pokemon$SelectionSet<$Scalars>
 
-  export interface pokemon$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface pokemon$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Pokemon<$Scalars>
   {}
 
@@ -245,17 +243,17 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type pokemon$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type pokemon$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     pokemon$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type pokemonByName<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = pokemonByName$SelectionSet<
+  export type pokemonByName<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = pokemonByName$SelectionSet<
     $Scalars
   >
 
-  export interface pokemonByName$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface pokemonByName$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Pokemon<$Scalars>
   {
     /**
@@ -264,7 +262,7 @@ export namespace Query {
     $: pokemonByName$Arguments<$Scalars>
   }
 
-  export interface pokemonByName$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface pokemonByName$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     name: string
   }
 
@@ -275,16 +273,15 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type pokemonByName$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    $$Utilities.Simplify<
-      pokemonByName$SelectionSet<$Scalars>
-    >
+  export type pokemonByName$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+    pokemonByName$SelectionSet<$Scalars>
+  >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type pokemons<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = pokemons$SelectionSet<$Scalars>
+  export type pokemons<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = pokemons$SelectionSet<$Scalars>
 
-  export interface pokemons$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface pokemons$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Pokemon<$Scalars>
   {
     /**
@@ -293,7 +290,7 @@ export namespace Query {
     $?: pokemons$Arguments<$Scalars>
   }
 
-  export interface pokemons$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface pokemons$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     filter?: $NamedTypes.$PokemonFilter<$Scalars> | undefined | null
   }
 
@@ -304,17 +301,17 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type pokemons$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type pokemons$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     pokemons$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type trainerByName<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = trainerByName$SelectionSet<
+  export type trainerByName<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = trainerByName$SelectionSet<
     $Scalars
   >
 
-  export interface trainerByName$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface trainerByName$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Trainer<$Scalars>
   {
     /**
@@ -323,7 +320,7 @@ export namespace Query {
     $: trainerByName$Arguments<$Scalars>
   }
 
-  export interface trainerByName$Arguments<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+  export interface trainerByName$Arguments<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
     name: string
   }
 
@@ -334,16 +331,15 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type trainerByName$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    $$Utilities.Simplify<
-      trainerByName$SelectionSet<$Scalars>
-    >
+  export type trainerByName$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+    trainerByName$SelectionSet<$Scalars>
+  >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type trainers<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = trainers$SelectionSet<$Scalars>
+  export type trainers<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = trainers$SelectionSet<$Scalars>
 
-  export interface trainers$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface trainers$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Trainer<$Scalars>
   {}
 
@@ -354,7 +350,7 @@ export namespace Query {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type trainers$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type trainers$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     trainers$SelectionSet<$Scalars>
   >
 }
@@ -410,17 +406,17 @@ export type TrainerClass =
 //
 //
 
-export interface DateFilter<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface DateFilter<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   gte?: number | undefined | null
   lte?: number | undefined | null
 }
 
-export interface PokemonFilter<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface PokemonFilter<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   birthday?: $NamedTypes.$DateFilter<$Scalars> | undefined | null
   name?: $NamedTypes.$StringFilter<$Scalars> | undefined | null
 }
 
-export interface StringFilter<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface StringFilter<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   contains?: string | undefined | null
   in?: Array<string | undefined | null> | undefined | null
 }
@@ -444,7 +440,7 @@ export interface StringFilter<$Scalars extends $$Utilities.SchemaKit.Scalar.Scal
 // Interface Type: Being
 // --------------------------------------------------------------------------------------------------
 
-export interface Being<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
+export interface Being<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
   id?: Being.id<$Scalars>
   name?: Being.name<$Scalars>
   ___on_Patron?: Patron<$Scalars>
@@ -474,16 +470,16 @@ export interface Being<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap =
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Being$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Being$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Being<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 export namespace Being {
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -494,16 +490,16 @@ export namespace Being {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
 
-  export type name<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type name<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | name$SelectionSet<$Scalars>
 
-  export interface name$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface name$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -514,7 +510,7 @@ export namespace Being {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type name$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type name$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | name$SelectionSet<$Scalars>
   >
@@ -550,7 +546,7 @@ export namespace Being {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface BattleRoyale<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface BattleRoyale<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends $Select.Bases.ObjectLike
 {
   /**
@@ -594,18 +590,16 @@ export interface BattleRoyale<$Scalars extends $$Utilities.SchemaKit.Scalar.Scal
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface BattleRoyale$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface BattleRoyale$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends BattleRoyale<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace BattleRoyale {
-  export type combatants<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = combatants$SelectionSet<
-    $Scalars
-  >
+  export type combatants<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = combatants$SelectionSet<$Scalars>
 
-  export interface combatants$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface combatants$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$CombatantMultiPokemon<$Scalars>
   {}
 
@@ -616,17 +610,17 @@ export namespace BattleRoyale {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type combatants$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type combatants$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     combatants$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type date<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type date<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | date$SelectionSet<$Scalars>
 
-  export interface date$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface date$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -637,18 +631,18 @@ export namespace BattleRoyale {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type date$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type date$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | date$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -659,16 +653,16 @@ export namespace BattleRoyale {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type winner<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = winner$SelectionSet<$Scalars>
+  export type winner<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = winner$SelectionSet<$Scalars>
 
-  export interface winner$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface winner$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Trainer<$Scalars>
   {}
 
@@ -679,7 +673,7 @@ export namespace BattleRoyale {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type winner$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type winner$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     winner$SelectionSet<$Scalars>
   >
 }
@@ -698,7 +692,7 @@ export namespace BattleRoyale {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface BattleTrainer<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface BattleTrainer<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends $Select.Bases.ObjectLike
 {
   /**
@@ -748,18 +742,16 @@ export interface BattleTrainer<$Scalars extends $$Utilities.SchemaKit.Scalar.Sca
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface BattleTrainer$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface BattleTrainer$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends BattleTrainer<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace BattleTrainer {
-  export type combatant1<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = combatant1$SelectionSet<
-    $Scalars
-  >
+  export type combatant1<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = combatant1$SelectionSet<$Scalars>
 
-  export interface combatant1$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface combatant1$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$CombatantSinglePokemon<$Scalars>
   {}
 
@@ -770,17 +762,15 @@ export namespace BattleTrainer {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type combatant1$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type combatant1$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     combatant1$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type combatant2<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = combatant2$SelectionSet<
-    $Scalars
-  >
+  export type combatant2<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = combatant2$SelectionSet<$Scalars>
 
-  export interface combatant2$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface combatant2$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$CombatantSinglePokemon<$Scalars>
   {}
 
@@ -791,17 +781,17 @@ export namespace BattleTrainer {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type combatant2$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type combatant2$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     combatant2$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type date<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type date<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | date$SelectionSet<$Scalars>
 
-  export interface date$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface date$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -812,18 +802,18 @@ export namespace BattleTrainer {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type date$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type date$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | date$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -834,16 +824,16 @@ export namespace BattleTrainer {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type winner<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = winner$SelectionSet<$Scalars>
+  export type winner<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = winner$SelectionSet<$Scalars>
 
-  export interface winner$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface winner$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Trainer<$Scalars>
   {}
 
@@ -854,7 +844,7 @@ export namespace BattleTrainer {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type winner$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type winner$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     winner$SelectionSet<$Scalars>
   >
 }
@@ -873,7 +863,7 @@ export namespace BattleTrainer {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface BattleWild<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface BattleWild<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends $Select.Bases.ObjectLike
 {
   /**
@@ -925,18 +915,18 @@ export interface BattleWild<$Scalars extends $$Utilities.SchemaKit.Scalar.Scalar
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface BattleWild$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface BattleWild$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends BattleWild<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace BattleWild {
-  export type date<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type date<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | date$SelectionSet<$Scalars>
 
-  export interface date$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface date$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -947,18 +937,18 @@ export namespace BattleWild {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type date$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type date$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | date$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -969,16 +959,16 @@ export namespace BattleWild {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type pokemon<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = pokemon$SelectionSet<$Scalars>
+  export type pokemon<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = pokemon$SelectionSet<$Scalars>
 
-  export interface pokemon$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface pokemon$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Pokemon<$Scalars>
   {}
 
@@ -989,17 +979,17 @@ export namespace BattleWild {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type pokemon$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type pokemon$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     pokemon$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type result<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type result<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | result$SelectionSet<$Scalars>
 
-  export interface result$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface result$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1010,16 +1000,16 @@ export namespace BattleWild {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type result$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type result$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | result$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type trainer<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = trainer$SelectionSet<$Scalars>
+  export type trainer<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = trainer$SelectionSet<$Scalars>
 
-  export interface trainer$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface trainer$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Trainer<$Scalars>
   {}
 
@@ -1030,17 +1020,17 @@ export namespace BattleWild {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type trainer$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type trainer$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     trainer$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type wildPokemons<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = wildPokemons$SelectionSet<
+  export type wildPokemons<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = wildPokemons$SelectionSet<
     $Scalars
   >
 
-  export interface wildPokemons$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface wildPokemons$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Pokemon<$Scalars>
   {}
 
@@ -1051,10 +1041,9 @@ export namespace BattleWild {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type wildPokemons$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    $$Utilities.Simplify<
-      wildPokemons$SelectionSet<$Scalars>
-    >
+  export type wildPokemons$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+    wildPokemons$SelectionSet<$Scalars>
+  >
 }
 
 //
@@ -1071,7 +1060,7 @@ export namespace BattleWild {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface CombatantMultiPokemon<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface CombatantMultiPokemon<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends $Select.Bases.ObjectLike
 {
   /**
@@ -1109,16 +1098,16 @@ export interface CombatantMultiPokemon<$Scalars extends $$Utilities.SchemaKit.Sc
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface CombatantMultiPokemon$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface CombatantMultiPokemon$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends CombatantMultiPokemon<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace CombatantMultiPokemon {
-  export type pokemons<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = pokemons$SelectionSet<$Scalars>
+  export type pokemons<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = pokemons$SelectionSet<$Scalars>
 
-  export interface pokemons$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface pokemons$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Pokemon<$Scalars>
   {}
 
@@ -1129,15 +1118,15 @@ export namespace CombatantMultiPokemon {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type pokemons$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type pokemons$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     pokemons$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type trainer<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = trainer$SelectionSet<$Scalars>
+  export type trainer<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = trainer$SelectionSet<$Scalars>
 
-  export interface trainer$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface trainer$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Trainer<$Scalars>
   {}
 
@@ -1148,7 +1137,7 @@ export namespace CombatantMultiPokemon {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type trainer$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type trainer$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     trainer$SelectionSet<$Scalars>
   >
 }
@@ -1167,7 +1156,7 @@ export namespace CombatantMultiPokemon {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface CombatantSinglePokemon<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface CombatantSinglePokemon<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends $Select.Bases.ObjectLike
 {
   /**
@@ -1205,16 +1194,16 @@ export interface CombatantSinglePokemon<$Scalars extends $$Utilities.SchemaKit.S
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface CombatantSinglePokemon$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface CombatantSinglePokemon$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends CombatantSinglePokemon<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace CombatantSinglePokemon {
-  export type pokemon<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = pokemon$SelectionSet<$Scalars>
+  export type pokemon<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = pokemon$SelectionSet<$Scalars>
 
-  export interface pokemon$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface pokemon$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Pokemon<$Scalars>
   {}
 
@@ -1225,15 +1214,15 @@ export namespace CombatantSinglePokemon {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type pokemon$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type pokemon$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     pokemon$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type trainer<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = trainer$SelectionSet<$Scalars>
+  export type trainer<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = trainer$SelectionSet<$Scalars>
 
-  export interface trainer$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface trainer$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Trainer<$Scalars>
   {}
 
@@ -1244,7 +1233,7 @@ export namespace CombatantSinglePokemon {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type trainer$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type trainer$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     trainer$SelectionSet<$Scalars>
   >
 }
@@ -1263,7 +1252,7 @@ export namespace CombatantSinglePokemon {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface Patron<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
+export interface Patron<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
   /**
    * Select the `id` field on the `Patron` object. Its type is `ID` (a `Scalar`).
    */
@@ -1299,18 +1288,18 @@ export interface Patron<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Patron$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Patron$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Patron<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace Patron {
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1321,18 +1310,18 @@ export namespace Patron {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type money<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type money<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | money$SelectionSet<$Scalars>
 
-  export interface money$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface money$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1343,18 +1332,18 @@ export namespace Patron {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type money$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type money$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | money$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type name<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type name<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | name$SelectionSet<$Scalars>
 
-  export interface name$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface name$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1365,7 +1354,7 @@ export namespace Patron {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type name$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type name$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | name$SelectionSet<$Scalars>
   >
@@ -1385,9 +1374,7 @@ export namespace Patron {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface Pokemon<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
-  extends $Select.Bases.ObjectLike
-{
+export interface Pokemon<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
   /**
    * Select the `attack` field on the `Pokemon` object. Its type is `Int` (a `Scalar`).
    */
@@ -1443,18 +1430,18 @@ export interface Pokemon<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Pokemon$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Pokemon$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Pokemon<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace Pokemon {
-  export type attack<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type attack<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | attack$SelectionSet<$Scalars>
 
-  export interface attack$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface attack$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1465,18 +1452,18 @@ export namespace Pokemon {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type attack$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type attack$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | attack$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type birthday<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type birthday<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | birthday$SelectionSet<$Scalars>
 
-  export interface birthday$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface birthday$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1487,18 +1474,18 @@ export namespace Pokemon {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type birthday$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type birthday$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | birthday$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type defense<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type defense<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | defense$SelectionSet<$Scalars>
 
-  export interface defense$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface defense$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1509,18 +1496,18 @@ export namespace Pokemon {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type defense$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type defense$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | defense$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type hp<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type hp<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | hp$SelectionSet<$Scalars>
 
-  export interface hp$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface hp$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1531,18 +1518,18 @@ export namespace Pokemon {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type hp$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type hp$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | hp$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1553,18 +1540,18 @@ export namespace Pokemon {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type name<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type name<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | name$SelectionSet<$Scalars>
 
-  export interface name$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface name$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1575,16 +1562,16 @@ export namespace Pokemon {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type name$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type name$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | name$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type trainer<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = trainer$SelectionSet<$Scalars>
+  export type trainer<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = trainer$SelectionSet<$Scalars>
 
-  export interface trainer$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface trainer$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Trainer<$Scalars>
   {}
 
@@ -1595,17 +1582,17 @@ export namespace Pokemon {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type trainer$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type trainer$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     trainer$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type type<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type type<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | type$SelectionSet<$Scalars>
 
-  export interface type$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface type$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1616,7 +1603,7 @@ export namespace Pokemon {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type type$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type type$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | type$SelectionSet<$Scalars>
   >
@@ -1636,9 +1623,7 @@ export namespace Pokemon {
 
 // ----------------------------------------| Entrypoint Interface |
 
-export interface Trainer<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
-  extends $Select.Bases.ObjectLike
-{
+export interface Trainer<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> extends $Select.Bases.ObjectLike {
   /**
    * Select the `class` field on the `Trainer` object. Its type is Enum.
    */
@@ -1682,18 +1667,18 @@ export interface Trainer<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
 
-export interface Trainer$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Trainer$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Trainer<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
 // ----------------------------------------| Fields |
 
 export namespace Trainer {
-  export type $class<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type $class<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | $class$SelectionSet<$Scalars>
 
-  export interface $class$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface $class$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1704,16 +1689,16 @@ export namespace Trainer {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type $class$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type $class$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | $class$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type fans<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = fans$SelectionSet<$Scalars>
+  export type fans<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = fans$SelectionSet<$Scalars>
 
-  export interface fans$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface fans$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Patron<$Scalars>
   {}
 
@@ -1724,17 +1709,17 @@ export namespace Trainer {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type fans$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type fans$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     fans$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type id<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type id<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
 
-  export interface id$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface id$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1745,18 +1730,18 @@ export namespace Trainer {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type id$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type id$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | id$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type name<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type name<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     | $Select.Indicator.NoArgsIndicator
     | name$SelectionSet<$Scalars>
 
-  export interface name$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface name$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base
   {}
 
@@ -1767,16 +1752,16 @@ export namespace Trainer {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type name$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type name$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     | $Select.Indicator.NoArgsIndicator
     | name$SelectionSet<$Scalars>
   >
 
   // --------------------------------------------------------------------------------------------------
 
-  export type pokemon<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = pokemon$SelectionSet<$Scalars>
+  export type pokemon<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = pokemon$SelectionSet<$Scalars>
 
-  export interface pokemon$SelectionSet<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+  export interface pokemon$SelectionSet<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
     extends $Select.Bases.Base, $NamedTypes.$Pokemon<$Scalars>
   {}
 
@@ -1787,7 +1772,7 @@ export namespace Trainer {
    * that IDEs will display its contents (a union type) directly, rather than the name of this type.
    * In some cases, this is a preferable DX, making the types easier to read for users.
    */
-  export type pokemon$Expanded<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
+  export type pokemon$Expanded<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = $$Utilities.Simplify<
     pokemon$SelectionSet<$Scalars>
   >
 }
@@ -1808,7 +1793,7 @@ export namespace Trainer {
 //
 //
 
-export interface Battle<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> {
+export interface Battle<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> {
   ___on_BattleRoyale?: BattleRoyale<$Scalars>
   ___on_BattleTrainer?: BattleTrainer<$Scalars>
   ___on_BattleWild?: BattleWild<$Scalars>
@@ -1835,7 +1820,7 @@ export interface Battle<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap
     | $Select.Indicator.NoArgsIndicator$Expanded
     | $Select.SelectAlias.SelectAlias<$Select.Indicator.NoArgsIndicator>
 }
-export interface Battle$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}>
+export interface Battle$FragmentInline<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}>
   extends Battle<$Scalars>, $Select.Directive.$Groups.InlineFragment.Fields
 {}
 
@@ -1847,24 +1832,25 @@ export interface Battle$FragmentInline<$Scalars extends $$Utilities.SchemaKit.Sc
  *     would end up with an error of `export interface Foo extends Foo ...`
  */
 export namespace $NamedTypes {
-  export type $Mutation<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Mutation<$Scalars>
-  export type $Query<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Query<$Scalars>
+  export type $Mutation<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Mutation<$Scalars>
+  export type $Query<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Query<$Scalars>
   export type $BattleWildResult = BattleWildResult
   export type $PokemonType = PokemonType
   export type $TrainerClass = TrainerClass
-  export type $DateFilter<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = DateFilter<$Scalars>
-  export type $PokemonFilter<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = PokemonFilter<$Scalars>
-  export type $StringFilter<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = StringFilter<$Scalars>
-  export type $Being<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Being<$Scalars>
-  export type $BattleRoyale<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = BattleRoyale<$Scalars>
-  export type $BattleTrainer<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = BattleTrainer<$Scalars>
-  export type $BattleWild<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = BattleWild<$Scalars>
-  export type $CombatantMultiPokemon<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
-    CombatantMultiPokemon<$Scalars>
-  export type $CombatantSinglePokemon<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> =
+  export type $DateFilter<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = DateFilter<$Scalars>
+  export type $PokemonFilter<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = PokemonFilter<$Scalars>
+  export type $StringFilter<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = StringFilter<$Scalars>
+  export type $Being<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Being<$Scalars>
+  export type $BattleRoyale<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = BattleRoyale<$Scalars>
+  export type $BattleTrainer<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = BattleTrainer<$Scalars>
+  export type $BattleWild<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = BattleWild<$Scalars>
+  export type $CombatantMultiPokemon<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = CombatantMultiPokemon<
+    $Scalars
+  >
+  export type $CombatantSinglePokemon<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> =
     CombatantSinglePokemon<$Scalars>
-  export type $Patron<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Patron<$Scalars>
-  export type $Pokemon<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Pokemon<$Scalars>
-  export type $Trainer<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Trainer<$Scalars>
-  export type $Battle<$Scalars extends $$Utilities.SchemaKit.Scalar.ScalarMap = {}> = Battle<$Scalars>
+  export type $Patron<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Patron<$Scalars>
+  export type $Pokemon<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Pokemon<$Scalars>
+  export type $Trainer<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Trainer<$Scalars>
+  export type $Battle<$Scalars extends $$Utilities.Schema.Scalar.ScalarMap = {}> = Battle<$Scalars>
 }