@gqlkit-ts/cli 0.2.0 → 0.4.0

package/src/auto-type-generator/auto-type-generator.ts

@@ -7,12 +7,15 @@ import type {
   DirectiveArgumentValue,
   DirectiveInfo,
 } from "../shared/directive-detector.js";
+import {
+  detectEnumPrefix,
+  stripEnumPrefix,
+} from "../shared/enum-prefix-detector.js";
+import { getSourceLocationOrDefault } from "../shared/source-location.js";
+import { toScreamingSnakeCase } from "../shared/string-utils.js";
 import type { DeprecationInfo } from "../shared/tsdoc-parser.js";
 import { convertTsTypeToGraphQLType } from "../shared/type-converter.js";
-import {
-  isEligibleAsInputObjectField,
-  isEligibleAsObjectField,
-} from "../type-extractor/converter/field-eligibility.js";
+import { isEligibleField } from "../type-extractor/converter/field-eligibility.js";
 import {
   createReferenceType,
   type Diagnostic,
@@ -24,15 +27,38 @@ import {
   type SourceLocation,
 } from "../type-extractor/types/index.js";
 import {
+  collectInlineEnumsFromPayloads,
   collectInlineEnumsFromResolvers,
   collectInlineEnumsFromTypes,
   type InlineEnumWithContext,
 } from "./inline-enum-collector.js";
+import {
+  collectInlineUnionsFromPayloads,
+  collectInlineUnionsFromResolvers,
+  collectInlineUnionsFromTypes,
+  type InlineUnionWithContext,
+} from "./inline-union-collector.js";
+import type { InlineUnionMemberInfo } from "./inline-union-types.js";
+import {
+  type ValidatedTypenameInfo,
+  validateOneOfMembers,
+  validateUnionMembers,
+  validateUnionMemberTypenames,
+} from "./inline-union-validator.js";
 import {
   type AutoTypeNameContext,
   buildFieldContext,
   generateAutoTypeName,
+  isInputTypeName,
 } from "./naming-convention.js";
+import type { ResolveTypeFieldPattern } from "./resolve-type-generator.js";
+import { forEachResolverField } from "./resolver-field-iterator.js";
+import {
+  createFieldNameSet,
+  findTypenameProperty,
+  type TypenameFieldInfo,
+  type TypenameFieldName,
+} from "./typename-types.js";
 
 /**
  * Information about where an auto-generated type was generated from.
@@ -40,7 +66,11 @@ import {
 export interface GeneratedFromInfo {
   readonly parentTypeName: string | null;
   readonly fieldPath: ReadonlyArray<string>;
-  readonly context: "typeField" | "inputField" | "resolverArg";
+  readonly context:
+    | "typeField"
+    | "inputField"
+    | "resolverArg"
+    | "resolverPayload";
 }
 
 /**
@@ -72,21 +102,31 @@ export interface AutoGeneratedEnumValue {
  */
 export interface AutoGeneratedType {
   readonly name: string;
-  readonly kind: "Object" | "InputObject" | "Enum";
-  /** Fields for Object/InputObject kinds (null for Enum) */
+  readonly kind:
+    | "Object"
+    | "InputObject"
+    | "Enum"
+    | "Union"
+    | "OneOfInputObject";
+  /** Fields for Object/InputObject/OneOfInputObject kinds (null for Enum/Union) */
   readonly fields: ReadonlyArray<AutoGeneratedField> | null;
-  /** Enum values for Enum kind (null for Object/InputObject) */
+  /** Enum values for Enum kind (null for Object/InputObject/Union/OneOfInputObject) */
   readonly enumValues: ReadonlyArray<AutoGeneratedEnumValue> | null;
+  /** Union members for Union kind (null for Object/InputObject/Enum/OneOfInputObject) */
+  readonly unionMembers: ReadonlyArray<string> | null;
   /** True if enum needs value mapping (at least one value converted) */
   readonly needsStringEnumMapping: boolean;
   readonly sourceLocation: SourceLocation;
   readonly generatedFrom: GeneratedFromInfo;
   readonly description: string | null;
+  /** For Union types from resolverPayload context: the field pattern for resolveType */
+  readonly resolveTypeFieldPattern: ResolveTypeFieldPattern | null;
 }
 
 export interface AutoTypeGeneratorInput {
   readonly extractedTypes: ReadonlyArray<ExtractedTypeInfo>;
   readonly resolversResult: ExtractResolversResult;
+  readonly knownTypeNames: ReadonlySet<string>;
 }
 
 export interface AutoTypeGeneratorResult {
@@ -101,10 +141,70 @@ interface InlineObjectWithContext {
   readonly context: AutoTypeNameContext;
   readonly sourceLocation: SourceLocation;
   readonly nullable: boolean;
+  /** TSDoc description from the inline object type alias (Requirement 7.2) */
+  readonly description: string | null;
+  /** @deprecated tag from the inline object type alias (Requirement 7.3) */
+  readonly deprecated: DeprecationInfo | null;
 }
 
-function isInputTypeName(name: string): boolean {
-  return name.endsWith("Input");
+type ContextBuilderFn = (
+  nestedPath: ReadonlyArray<string>,
+) => AutoTypeNameContext;
+
+interface ExtractNestedInlineObjectsParams {
+  readonly properties: ReadonlyArray<InlineObjectPropertyDef>;
+  readonly currentPath: ReadonlyArray<string>;
+  readonly sourceLocation: SourceLocation;
+  readonly buildContext: ContextBuilderFn;
+  readonly preserveDocumentation: boolean;
+  readonly results: InlineObjectWithContext[];
+}
+
+function extractNestedInlineObjectsRecursively(
+  params: ExtractNestedInlineObjectsParams,
+): void {
+  const {
+    properties,
+    currentPath,
+    sourceLocation,
+    buildContext,
+    preserveDocumentation,
+    results,
+  } = params;
+
+  for (const prop of properties) {
+    if (
+      prop.tsType.kind === "inlineObject" &&
+      prop.tsType.inlineObjectProperties
+    ) {
+      const nestedPath = [...currentPath, prop.name];
+      const nestedContext = buildContext(nestedPath);
+      // Use property's source location if available for more accurate diagnostics
+      const nestedSourceLocation = prop.sourceLocation ?? sourceLocation;
+
+      results.push({
+        properties: prop.tsType.inlineObjectProperties,
+        context: nestedContext,
+        sourceLocation: nestedSourceLocation,
+        nullable: prop.tsType.nullable,
+        description: preserveDocumentation
+          ? prop.tsType.inlineObjectDescription
+          : null,
+        deprecated: preserveDocumentation
+          ? prop.tsType.inlineObjectDeprecated
+          : null,
+      });
+
+      extractNestedInlineObjectsRecursively({
+        properties: prop.tsType.inlineObjectProperties,
+        currentPath: nestedPath,
+        sourceLocation: nestedSourceLocation,
+        buildContext,
+        preserveDocumentation,
+        results,
+      });
+    }
+  }
 }
 
 function getContextKey(context: AutoTypeNameContext): string {
@@ -115,6 +215,8 @@ function getContextKey(context: AutoTypeNameContext): string {
       return `inputField:${context.parentTypeName}:${context.fieldPath.join(".")}`;
     case "resolverArg":
       return `resolverArg:${context.resolverType}:${context.parentTypeName ?? ""}:${context.fieldName}:${context.argName}:${context.fieldPath.join(".")}`;
+    case "resolverPayload":
+      return `resolverPayload:${context.resolverType}:${context.parentTypeName ?? ""}:${context.fieldName}:${context.fieldPath.join(".")}`;
   }
 }
 
@@ -128,6 +230,8 @@ function mapContextKindToGeneratedFromContext(
       return "inputField";
     case "resolverArg":
       return "resolverArg";
+    case "resolverPayload":
+      return "resolverPayload";
   }
 }
 
@@ -153,27 +257,33 @@ function collectInlineObjectsFromType(
   const isInput = isInputTypeName(typeInfo.metadata.name);
 
   for (const field of typeInfo.fields) {
-    collectInlineObjectsFromField(
+    collectInlineObjectsFromField({
       field,
-      typeInfo.metadata.name,
-      [],
+      parentTypeName: typeInfo.metadata.name,
+      parentPath: [],
       isInput,
-      typeInfo.metadata.sourceFile,
+      sourceFile: typeInfo.metadata.sourceFile,
       results,
-    );
+    });
   }
 
   return results;
 }
 
+interface CollectInlineObjectsFromFieldParams {
+  readonly field: FieldDefinition;
+  readonly parentTypeName: string;
+  readonly parentPath: ReadonlyArray<string>;
+  readonly isInput: boolean;
+  readonly sourceFile: string;
+  readonly results: InlineObjectWithContext[];
+}
+
 function collectInlineObjectsFromField(
-  field: FieldDefinition,
-  parentTypeName: string,
-  parentPath: ReadonlyArray<string>,
-  isInput: boolean,
-  sourceFile: string,
-  results: InlineObjectWithContext[],
+  params: CollectInlineObjectsFromFieldParams,
 ): void {
+  const { field, parentTypeName, parentPath, isInput, sourceFile, results } =
+    params;
   const tsType = field.tsType;
 
   if (tsType.kind !== "inlineObject" || !tsType.inlineObjectProperties) {
@@ -194,100 +304,31 @@ function collectInlineObjectsFromField(
         fieldPath,
       };
 
+  const sourceLocation = getSourceLocationOrDefault(
+    field.sourceLocation,
+    sourceFile,
+  );
+
   results.push({
     properties: tsType.inlineObjectProperties,
     context,
-    sourceLocation: field.sourceLocation ?? {
-      file: sourceFile,
-      line: 1,
-      column: 1,
-    },
+    sourceLocation,
     nullable: tsType.nullable,
+    description: tsType.inlineObjectDescription,
+    deprecated: tsType.inlineObjectDeprecated,
   });
 
-  for (const prop of tsType.inlineObjectProperties) {
-    if (
-      prop.tsType.kind === "inlineObject" &&
-      prop.tsType.inlineObjectProperties
-    ) {
-      const nestedPath = [...fieldPath, prop.name];
-      const nestedContext: AutoTypeNameContext = isInput
-        ? {
-            kind: "inputField",
-            parentTypeName,
-            fieldPath: nestedPath,
-          }
-        : {
-            kind: "objectField",
-            parentTypeName,
-            fieldPath: nestedPath,
-          };
-
-      extractNestedInlineObjects(
-        prop.tsType.inlineObjectProperties,
-        nestedContext,
-        nestedPath,
-        parentTypeName,
-        isInput,
-        sourceFile,
-        prop.sourceLocation,
-        results,
-      );
-    }
-  }
-}
-
-function extractNestedInlineObjects(
-  properties: ReadonlyArray<InlineObjectPropertyDef>,
-  context: AutoTypeNameContext,
-  currentPath: ReadonlyArray<string>,
-  parentTypeName: string,
-  isInput: boolean,
-  sourceFile: string,
-  parentSourceLocation: SourceLocation | null,
-  results: InlineObjectWithContext[],
-): void {
-  results.push({
-    properties,
-    context,
-    sourceLocation: parentSourceLocation ?? {
-      file: sourceFile,
-      line: 1,
-      column: 1,
-    },
-    nullable: false,
+  extractNestedInlineObjectsRecursively({
+    properties: tsType.inlineObjectProperties,
+    currentPath: fieldPath,
+    sourceLocation,
+    buildContext: (nestedPath) =>
+      isInput
+        ? { kind: "inputField", parentTypeName, fieldPath: nestedPath }
+        : { kind: "objectField", parentTypeName, fieldPath: nestedPath },
+    preserveDocumentation: true,
+    results,
   });
-
-  for (const prop of properties) {
-    if (
-      prop.tsType.kind === "inlineObject" &&
-      prop.tsType.inlineObjectProperties
-    ) {
-      const nestedPath = [...currentPath, prop.name];
-      const nestedContext: AutoTypeNameContext = isInput
-        ? {
-            kind: "inputField",
-            parentTypeName,
-            fieldPath: nestedPath,
-          }
-        : {
-            kind: "objectField",
-            parentTypeName,
-            fieldPath: nestedPath,
-          };
-
-      extractNestedInlineObjects(
-        prop.tsType.inlineObjectProperties,
-        nestedContext,
-        nestedPath,
-        parentTypeName,
-        isInput,
-        sourceFile,
-        prop.sourceLocation,
-        results,
-      );
-    }
-  }
 }
 
 function collectInlineObjectsFromResolvers(
@@ -295,24 +336,17 @@ function collectInlineObjectsFromResolvers(
 ): InlineObjectWithContext[] {
   const results: InlineObjectWithContext[] = [];
 
-  for (const field of resolversResult.queryFields.fields) {
-    collectInlineObjectsFromResolverArgs(field, "query", null, results);
-  }
-
-  for (const field of resolversResult.mutationFields.fields) {
-    collectInlineObjectsFromResolverArgs(field, "mutation", null, results);
-  }
-
-  for (const ext of resolversResult.typeExtensions) {
-    for (const field of ext.fields) {
+  forEachResolverField(
+    resolversResult,
+    ({ field, resolverType, parentTypeName }) => {
       collectInlineObjectsFromResolverArgs(
         field,
-        "field",
-        ext.targetTypeName,
+        resolverType,
+        parentTypeName,
         results,
       );
-    }
-  }
+    },
+  );
 
   return results;
 }
@@ -342,65 +376,87 @@ function collectInlineObjectsFromResolverArgs(
       context,
       sourceLocation: field.sourceLocation,
       nullable: arg.type.nullable,
+      description: null,
+      deprecated: null,
     });
 
-    extractNestedInlineObjectsFromArg(
-      arg.inlineObjectProperties,
-      resolverType,
-      field.name,
-      arg.name,
-      parentTypeName,
-      [],
-      field.sourceLocation,
-      results,
-    );
-  }
-}
-
-function extractNestedInlineObjectsFromArg(
-  properties: ReadonlyArray<InlineObjectPropertyDef>,
-  resolverType: "query" | "mutation" | "field",
-  fieldName: string,
-  argName: string,
-  parentTypeName: string | null,
-  currentPath: ReadonlyArray<string>,
-  sourceLocation: SourceLocation,
-  results: InlineObjectWithContext[],
-): void {
-  for (const prop of properties) {
-    if (
-      prop.tsType.kind === "inlineObject" &&
-      prop.tsType.inlineObjectProperties
-    ) {
-      const nestedPath = [...currentPath, prop.name];
-      const nestedContext: AutoTypeNameContext = {
+    extractNestedInlineObjectsRecursively({
+      properties: arg.inlineObjectProperties,
+      currentPath: [],
+      sourceLocation: field.sourceLocation,
+      buildContext: (nestedPath) => ({
         kind: "resolverArg",
         resolverType,
-        fieldName,
-        argName,
+        fieldName: field.name,
+        argName: arg.name,
         parentTypeName,
         fieldPath: nestedPath,
-      };
+      }),
+      preserveDocumentation: false,
+      results,
+    });
+  }
+}
 
-      results.push({
-        properties: prop.tsType.inlineObjectProperties,
-        context: nestedContext,
-        sourceLocation,
-        nullable: prop.tsType.nullable,
-      });
+function collectInlinePayloadsFromResolvers(
+  resolversResult: ExtractResolversResult,
+): InlineObjectWithContext[] {
+  const results: InlineObjectWithContext[] = [];
 
-      extractNestedInlineObjectsFromArg(
-        prop.tsType.inlineObjectProperties,
+  forEachResolverField(
+    resolversResult,
+    ({ field, resolverType, parentTypeName }) => {
+      collectInlinePayloadFromReturnType(
+        field,
         resolverType,
-        fieldName,
-        argName,
         parentTypeName,
-        nestedPath,
-        sourceLocation,
         results,
       );
-    }
-  }
+    },
+  );
+
+  return results;
+}
+
+function collectInlinePayloadFromReturnType(
+  field: GraphQLFieldDefinition,
+  resolverType: "query" | "mutation" | "field",
+  parentTypeName: string | null,
+  results: InlineObjectWithContext[],
+): void {
+  if (!field.returnTypeInlineObjectProperties) return;
+
+  const context: AutoTypeNameContext = {
+    kind: "resolverPayload",
+    resolverType,
+    fieldName: field.name,
+    parentTypeName,
+    fieldPath: [],
+  };
+
+  results.push({
+    properties: field.returnTypeInlineObjectProperties,
+    context,
+    sourceLocation: field.sourceLocation,
+    nullable: field.type.nullable,
+    description: field.returnTypeInlineObjectDescription,
+    deprecated: field.returnTypeInlineObjectDeprecated,
+  });
+
+  extractNestedInlineObjectsRecursively({
+    properties: field.returnTypeInlineObjectProperties,
+    currentPath: [],
+    sourceLocation: field.sourceLocation,
+    buildContext: (nestedPath) => ({
+      kind: "resolverPayload",
+      resolverType,
+      fieldName: field.name,
+      parentTypeName,
+      fieldPath: nestedPath,
+    }),
+    preserveDocumentation: true,
+    results,
+  });
 }
 
 interface GenerateAutoTypeResult {
@@ -412,12 +468,14 @@ interface GenerateAutoTypeParams {
   readonly inlineObj: InlineObjectWithContext;
   readonly generatedTypeNames: Map<string, string>;
   readonly enumTypeNames: Map<string, string>;
+  readonly unionTypeNames: Map<string, string>;
 }
 
 function generateAutoType(
   params: GenerateAutoTypeParams,
 ): GenerateAutoTypeResult {
-  const { inlineObj, generatedTypeNames, enumTypeNames } = params;
+  const { inlineObj, generatedTypeNames, enumTypeNames, unionTypeNames } =
+    params;
   const name = generateAutoTypeName(inlineObj.context);
   const isInput =
     inlineObj.context.kind === "inputField" ||
@@ -427,9 +485,10 @@ function generateAutoType(
   const diagnostics: Diagnostic[] = [];
 
   for (const prop of inlineObj.properties) {
-    const eligibility = isInput
-      ? isEligibleAsInputObjectField(prop.name)
-      : isEligibleAsObjectField(prop.name);
+    const eligibility = isEligibleField({
+      fieldName: prop.name,
+      kind: isInput ? "input" : "object",
+    });
 
     if (!eligibility.eligible) {
       diagnostics.push({
@@ -445,6 +504,7 @@ function generateAutoType(
       prop,
       generatedTypeNames,
       enumTypeNames,
+      unionTypeNames,
       parentContext: inlineObj.context,
     });
     fields.push({
@@ -463,10 +523,12 @@ function generateAutoType(
       kind: isInput ? "InputObject" : "Object",
       fields,
       enumValues: null,
+      unionMembers: null,
       needsStringEnumMapping: false,
       sourceLocation: inlineObj.sourceLocation,
       generatedFrom: buildGeneratedFromInfo(inlineObj.context),
-      description: null,
+      description: inlineObj.description,
+      resolveTypeFieldPattern: null,
     },
     diagnostics,
   };
@@ -476,49 +538,63 @@ interface ResolveFieldTypeParams {
   readonly prop: InlineObjectPropertyDef;
   readonly generatedTypeNames: Map<string, string>;
   readonly enumTypeNames: Map<string, string>;
+  readonly unionTypeNames: Map<string, string>;
   readonly parentContext: AutoTypeNameContext;
 }
 
+function tryResolveNestedType(
+  prop: InlineObjectPropertyDef,
+  parentContext: AutoTypeNameContext,
+  typeNamesMap: ReadonlyMap<string, string>,
+): GraphQLFieldType | null {
+  const nestedPath = [...parentContext.fieldPath, prop.name];
+  const nestedContext: AutoTypeNameContext = {
+    ...parentContext,
+    fieldPath: nestedPath,
+  };
+  const contextKey = getContextKey(nestedContext);
+  const resolvedTypeName = typeNamesMap.get(contextKey);
+
+  if (resolvedTypeName) {
+    return {
+      typeName: resolvedTypeName,
+      nullable: prop.tsType.nullable || prop.optional,
+      list: false,
+      listItemNullable: null,
+    };
+  }
+  return null;
+}
+
 function resolveFieldType(params: ResolveFieldTypeParams): GraphQLFieldType {
-  const { prop, generatedTypeNames, enumTypeNames, parentContext } = params;
+  const {
+    prop,
+    generatedTypeNames,
+    enumTypeNames,
+    unionTypeNames,
+    parentContext,
+  } = params;
 
   if (
     prop.tsType.kind === "inlineObject" &&
     prop.tsType.inlineObjectProperties
   ) {
-    const nestedPath = [...parentContext.fieldPath, prop.name];
-    const nestedContext: AutoTypeNameContext = {
-      ...parentContext,
-      fieldPath: nestedPath,
-    };
-    const contextKey = getContextKey(nestedContext);
-    const resolvedTypeName = generatedTypeNames.get(contextKey);
-    if (resolvedTypeName) {
-      return {
-        typeName: resolvedTypeName,
-        nullable: prop.tsType.nullable || prop.optional,
-        list: false,
-        listItemNullable: null,
-      };
-    }
+    const result = tryResolveNestedType(
+      prop,
+      parentContext,
+      generatedTypeNames,
+    );
+    if (result) return result;
   }
 
   if (prop.tsType.kind === "inlineEnum" && prop.tsType.inlineEnumMembers) {
-    const nestedPath = [...parentContext.fieldPath, prop.name];
-    const nestedContext: AutoTypeNameContext = {
-      ...parentContext,
-      fieldPath: nestedPath,
-    };
-    const contextKey = getContextKey(nestedContext);
-    const resolvedTypeName = enumTypeNames.get(contextKey);
-    if (resolvedTypeName) {
-      return {
-        typeName: resolvedTypeName,
-        nullable: prop.tsType.nullable || prop.optional,
-        list: false,
-        listItemNullable: null,
-      };
-    }
+    const result = tryResolveNestedType(prop, parentContext, enumTypeNames);
+    if (result) return result;
+  }
+
+  if (prop.tsType.kind === "union" && prop.tsType.members) {
+    const result = tryResolveNestedType(prop, parentContext, unionTypeNames);
+    if (result) return result;
   }
 
   return convertTsTypeToGraphQLType(prop.tsType, prop.optional);
@@ -527,6 +603,7 @@ function resolveFieldType(params: ResolveFieldTypeParams): GraphQLFieldType {
 interface UpdateTypeNamesParams {
   readonly generatedTypeNames: Map<string, string>;
   readonly enumTypeNames: Map<string, string>;
+  readonly unionTypeNames: Map<string, string>;
 }
 
 function updateExtractedTypes(
@@ -550,7 +627,7 @@ function updateField(
   parentTypeName: string,
   isInput: boolean,
 ): FieldDefinition {
-  const { generatedTypeNames, enumTypeNames } = params;
+  const { generatedTypeNames, enumTypeNames, unionTypeNames } = params;
   const context = buildFieldContext(parentTypeName, [field.name], isInput);
   const contextKey = getContextKey(context);
 
@@ -606,6 +683,20 @@ function updateField(
     }
   }
 
+  // Handle inline union types
+  if (field.tsType.kind === "union" && field.tsType.members) {
+    const resolvedTypeName = unionTypeNames.get(contextKey);
+    if (resolvedTypeName) {
+      return {
+        ...field,
+        tsType: createReferenceType({
+          name: resolvedTypeName,
+          nullable: field.tsType.nullable,
+        }),
+      };
+    }
+  }
+
   return field;
 }
 
@@ -640,9 +731,55 @@ function updateResolverField(
   resolverType: "query" | "mutation" | "field",
   parentTypeName: string | null,
 ): GraphQLFieldDefinition {
-  if (!field.args) return field;
+  const { generatedTypeNames, enumTypeNames, unionTypeNames } = params;
 
-  const { generatedTypeNames, enumTypeNames } = params;
+  let updatedType = field.type;
+
+  // Create payload context once for all inline return type checks
+  const hasInlinePayload =
+    field.returnTypeInlineObjectProperties ||
+    field.returnTypeInlineEnumMembers ||
+    field.returnTypeInlineUnionMembers;
+
+  if (hasInlinePayload) {
+    const payloadContext: AutoTypeNameContext = {
+      kind: "resolverPayload",
+      resolverType,
+      fieldName: field.name,
+      parentTypeName,
+      fieldPath: [],
+    };
+    const payloadContextKey = getContextKey(payloadContext);
+
+    // These are mutually exclusive - a return type can only be one of:
+    // inline object, inline enum, or inline union
+    if (field.returnTypeInlineObjectProperties) {
+      // Handle inline payload objects in return type
+      const resolvedTypeName = generatedTypeNames.get(payloadContextKey);
+      if (resolvedTypeName) {
+        updatedType = { ...field.type, typeName: resolvedTypeName };
+      }
+    } else if (field.returnTypeInlineEnumMembers) {
+      // Handle inline enum in return type
+      const resolvedTypeName = enumTypeNames.get(payloadContextKey);
+      if (resolvedTypeName) {
+        updatedType = { ...field.type, typeName: resolvedTypeName };
+      }
+    } else if (field.returnTypeInlineUnionMembers) {
+      // Handle inline union in return type
+      const resolvedTypeName = unionTypeNames.get(payloadContextKey);
+      if (resolvedTypeName) {
+        updatedType = { ...field.type, typeName: resolvedTypeName };
+      }
+    }
+  }
+
+  if (!field.args) {
+    return {
+      ...field,
+      type: updatedType,
+    };
+  }
 
   const updatedArgs = field.args.map((arg) => {
     const context: AutoTypeNameContext = {
@@ -683,11 +820,26 @@ function updateResolverField(
       }
     }
 
+    // Handle inline unions (OneOf input objects)
+    if (arg.inlineUnionMembers) {
+      const resolvedTypeName = unionTypeNames.get(contextKey);
+      if (resolvedTypeName) {
+        return {
+          ...arg,
+          type: {
+            ...arg.type,
+            typeName: resolvedTypeName,
+          },
+        };
+      }
+    }
+
     return arg;
   });
 
   return {
     ...field,
+    type: updatedType,
     args: updatedArgs,
   };
 }
@@ -706,14 +858,6 @@ function buildGeneratedTypeNamesMap(
   return map;
 }
 
-function toScreamingSnakeCase(value: string): string {
-  return value
-    .replace(/[-\s]+/g, "_")
-    .replace(/([a-z])([A-Z])/g, "$1_$2")
-    .replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2")
-    .toUpperCase();
-}
-
 interface ConvertInlineEnumMembersParams {
   readonly members: ReadonlyArray<InlineEnumMemberInfo>;
   readonly enumName: string;
@@ -726,6 +870,11 @@ interface ConvertEnumMembersWithDiagnosticsResult {
   readonly diagnostics: ReadonlyArray<Diagnostic>;
 }
 
+interface ConvertedMemberInfo {
+  readonly convertedName: string;
+  readonly member: InlineEnumMemberInfo;
+}
+
 function convertInlineEnumMembers(
   params: ConvertInlineEnumMembersParams,
 ): ConvertEnumMembersWithDiagnosticsResult {
@@ -734,32 +883,46 @@ function convertInlineEnumMembers(
   const enumValues: AutoGeneratedEnumValue[] = [];
   const diagnostics: Diagnostic[] = [];
 
-  const convertedNameToOriginals = new Map<string, string[]>();
+  const convertedMembers: ConvertedMemberInfo[] = [];
 
   for (const member of members) {
     const convertedName = toScreamingSnakeCase(member.value);
+    convertedMembers.push({ convertedName, member });
+  }
+
+  const prefixDetectionResult = detectEnumPrefix({
+    enumName,
+    memberValues: convertedMembers.map((m) => m.convertedName),
+  });
+
+  const finalNameToOriginals = new Map<string, string[]>();
 
-    if (convertedName !== member.value) {
+  for (const { convertedName, member } of convertedMembers) {
+    let finalName = convertedName;
+    if (prefixDetectionResult.shouldStrip && prefixDetectionResult.prefix) {
+      finalName = stripEnumPrefix(convertedName, prefixDetectionResult.prefix);
+      needsStringEnumMapping = true;
+    } else if (convertedName !== member.value) {
       needsStringEnumMapping = true;
     }
 
-    const originals = convertedNameToOriginals.get(convertedName) ?? [];
+    const originals = finalNameToOriginals.get(finalName) ?? [];
     originals.push(member.value);
-    convertedNameToOriginals.set(convertedName, originals);
+    finalNameToOriginals.set(finalName, originals);
 
     enumValues.push({
-      name: convertedName,
+      name: finalName,
       originalValue: member.value,
       description: member.description,
       deprecated: member.deprecated,
     });
   }
 
-  for (const [convertedName, originals] of convertedNameToOriginals) {
+  for (const [finalName, originals] of finalNameToOriginals) {
     if (originals.length > 1) {
       diagnostics.push({
         code: "DUPLICATE_ENUM_VALUE_AFTER_CONVERSION",
-        message: `Enum '${enumName}' has duplicate value '${convertedName}' after conversion (from '${originals.join("' and '")}')`,
+        message: `Enum '${enumName}' has duplicate value '${finalName}' after conversion (from '${originals.join("' and '")}')`,
         severity: "error",
         location: sourceLocation,
       });
@@ -791,10 +954,12 @@ function generateAutoEnumType(
       kind: "Enum",
       fields: null,
       enumValues,
+      unionMembers: null,
       needsStringEnumMapping,
       sourceLocation: inlineEnum.sourceLocation,
       generatedFrom: buildGeneratedFromInfo(inlineEnum.context),
       description: inlineEnum.externalEnumDescription,
+      resolveTypeFieldPattern: null,
     },
     diagnostics,
   };
@@ -850,6 +1015,534 @@ function buildEnumTypeNamesMap(
   };
 }
 
+function buildUnionTypeNamesMap(
+  inlineUnions: InlineUnionWithContext[],
+): Map<string, string> {
+  const unionTypeNames = new Map<string, string>();
+
+  for (const inlineUnion of inlineUnions) {
+    const contextKey = getContextKey(inlineUnion.context);
+    const typeName = generateAutoTypeName(inlineUnion.context);
+    unionTypeNames.set(contextKey, typeName);
+  }
+
+  return unionTypeNames;
+}
+
+interface ProcessInlineUnionsParams {
+  readonly inlineUnions: ReadonlyArray<InlineUnionWithContext>;
+  readonly knownTypeNames: ReadonlySet<string>;
+  readonly generatedTypeNames: Map<string, string>;
+  readonly enumTypeNames: Map<string, string>;
+  readonly unionTypeNames: Map<string, string>;
+  readonly extractedTypes: ReadonlyArray<ExtractedTypeInfo>;
+}
+
+interface ProcessInlineUnionsResult {
+  readonly types: AutoGeneratedType[];
+  readonly diagnostics: Diagnostic[];
+}
+
+interface ProcessOneOfInputObjectsParams {
+  readonly inlineUnions: ReadonlyArray<InlineUnionWithContext>;
+  readonly knownTypeNames: ReadonlySet<string>;
+  readonly typeMap: ReadonlyMap<string, ExtractedTypeInfo>;
+  readonly unionTypeNames: Map<string, string>;
+}
+
+function processOneOfInputObjects(
+  params: ProcessOneOfInputObjectsParams,
+): ProcessInlineUnionsResult {
+  const { inlineUnions, knownTypeNames, typeMap, unionTypeNames } = params;
+  const types: AutoGeneratedType[] = [];
+  const diagnostics: Diagnostic[] = [];
+
+  for (const inlineUnion of inlineUnions) {
+    const contextKey = getContextKey(inlineUnion.context);
+    const typeName = generateAutoTypeName(inlineUnion.context);
+
+    const validationResult = validateOneOfMembers({
+      members: inlineUnion.members,
+      typeName,
+      sourceLocation: inlineUnion.sourceLocation,
+      typeMap,
+    });
+
+    diagnostics.push(...validationResult.diagnostics);
+
+    if (!validationResult.valid) {
+      continue;
+    }
+
+    const fields = generateOneOfFields({
+      members: inlineUnion.members,
+      knownTypeNames,
+    });
+
+    types.push({
+      name: typeName,
+      kind: "OneOfInputObject",
+      fields,
+      enumValues: null,
+      unionMembers: null,
+      needsStringEnumMapping: false,
+      sourceLocation: inlineUnion.sourceLocation,
+      generatedFrom: buildGeneratedFromInfo(inlineUnion.context),
+      description: null,
+      resolveTypeFieldPattern: null,
+    });
+
+    unionTypeNames.set(contextKey, typeName);
+  }
+
+  return { types, diagnostics };
+}
+
+interface ProcessUnionTypesParams {
+  readonly inlineUnions: ReadonlyArray<InlineUnionWithContext>;
+  readonly knownTypeNames: ReadonlySet<string>;
+  readonly generatedTypeNames: Map<string, string>;
+  readonly enumTypeNames: Map<string, string>;
+  readonly unionTypeNames: Map<string, string>;
+  readonly typeMap: ReadonlyMap<string, ExtractedTypeInfo>;
+}
+
+function processUnionTypes(
+  params: ProcessUnionTypesParams,
+): ProcessInlineUnionsResult {
+  const {
+    inlineUnions,
+    knownTypeNames,
+    generatedTypeNames,
+    enumTypeNames,
+    unionTypeNames,
+    typeMap,
+  } = params;
+  const types: AutoGeneratedType[] = [];
+  const diagnostics: Diagnostic[] = [];
+  const generatedTypenameTypes = new Map<
+    string,
+    ReadonlyArray<AutoGeneratedField>
+  >();
+
+  for (const inlineUnion of inlineUnions) {
+    const contextKey = getContextKey(inlineUnion.context);
+    const typeName = generateAutoTypeName(inlineUnion.context);
+
+    const validationResult = validateUnionMembers({
+      members: inlineUnion.members,
+      typeName,
+      sourceLocation: inlineUnion.sourceLocation,
+      typeMap,
+    });
+
+    diagnostics.push(...validationResult.diagnostics);
+
+    if (!validationResult.valid) {
+      continue;
+    }
+
+    let resolveTypeFieldPattern: AutoGeneratedType["resolveTypeFieldPattern"] =
+      null;
+
+    if (inlineUnion.context.kind === "resolverPayload") {
+      const typenameValidationResult = validateUnionMemberTypenames({
+        members: inlineUnion.members,
+        unionTypeName: typeName,
+        sourceLocation: inlineUnion.sourceLocation,
+        typeMap,
+      });
+
+      diagnostics.push(...typenameValidationResult.diagnostics);
+
+      if (!typenameValidationResult.valid) {
+        continue;
+      }
+
+      if (typenameValidationResult.allMembersHaveTypename) {
+        resolveTypeFieldPattern = determineFieldPattern(
+          typenameValidationResult.memberTypenames,
+        );
+      }
+    }
+
+    const memberNames = resolveMemberNames({
+      members: inlineUnion.members,
+      knownTypeNames,
+      generatedTypeNames,
+      enumTypeNames,
+      parentContext: inlineUnion.context,
+      unionTypeNames,
+      types,
+      diagnostics,
+      generatedTypenameTypes,
+      sourceLocation: inlineUnion.sourceLocation,
+    });
+
+    types.push({
+      name: typeName,
+      kind: "Union",
+      fields: null,
+      enumValues: null,
+      unionMembers: memberNames,
+      needsStringEnumMapping: false,
+      sourceLocation: inlineUnion.sourceLocation,
+      generatedFrom: buildGeneratedFromInfo(inlineUnion.context),
+      description: null,
+      resolveTypeFieldPattern,
+    });
+
+    unionTypeNames.set(contextKey, typeName);
+  }
+
+  return { types, diagnostics };
+}
+
+/**
+ * Determine the field pattern for resolveType based on the typename fields used by members.
+ */
+function determineFieldPattern(
+  memberTypenames: ReadonlyMap<number, ValidatedTypenameInfo>,
+): ResolveTypeFieldPattern {
+  const fieldNames = new Set<TypenameFieldName>();
+  for (const info of memberTypenames.values()) {
+    fieldNames.add(info.fieldName);
+  }
+
+  if (fieldNames.size === 0) {
+    return { usedFieldNames: createFieldNameSet(["__typename"]) };
+  }
+
+  return { usedFieldNames: fieldNames };
+}
+
+function processInlineUnions(
+  params: ProcessInlineUnionsParams,
+): ProcessInlineUnionsResult {
+  const {
+    inlineUnions,
+    knownTypeNames,
+    generatedTypeNames,
+    enumTypeNames,
+    unionTypeNames,
+    extractedTypes,
+  } = params;
+
+  const typeMap = new Map<string, ExtractedTypeInfo>();
+  for (const typeInfo of extractedTypes) {
+    typeMap.set(typeInfo.metadata.name, typeInfo);
+  }
+
+  const inputUnions = inlineUnions.filter((u) => u.isInputContext);
+  const outputUnions = inlineUnions.filter((u) => !u.isInputContext);
+
+  const oneOfResult = processOneOfInputObjects({
+    inlineUnions: inputUnions,
+    knownTypeNames,
+    typeMap,
+    unionTypeNames,
+  });
+
+  const unionResult = processUnionTypes({
+    inlineUnions: outputUnions,
+    knownTypeNames,
+    generatedTypeNames,
+    enumTypeNames,
+    unionTypeNames,
+    typeMap,
+  });
+
+  return {
+    types: [...oneOfResult.types, ...unionResult.types],
+    diagnostics: [...oneOfResult.diagnostics, ...unionResult.diagnostics],
+  };
+}
+
+interface GenerateOneOfFieldsParams {
+  readonly members: ReadonlyArray<InlineUnionMemberInfo>;
+  readonly knownTypeNames: ReadonlySet<string>;
+}
+
+function generateOneOfFields(
+  params: GenerateOneOfFieldsParams,
+): AutoGeneratedField[] {
+  const { members, knownTypeNames } = params;
+
+  const fields: AutoGeneratedField[] = [];
+
+  for (const member of members) {
+    const memberType = member.memberType;
+
+    if (
+      memberType.kind === "inlineObject" &&
+      memberType.inlineObjectProperties
+    ) {
+      for (const prop of memberType.inlineObjectProperties) {
+        const fieldType = convertTsTypeToGraphQLType(
+          prop.tsType,
+          prop.optional,
+        );
+        fields.push({
+          name: prop.name,
+          type: {
+            ...fieldType,
+            nullable: true,
+          },
+          description: prop.description,
+          deprecated: prop.deprecated,
+          directives: prop.directives,
+          defaultValue: prop.defaultValue,
+        });
+      }
+    } else if (memberType.kind === "reference" && memberType.name) {
+      if (knownTypeNames.has(memberType.name)) {
+        const camelCaseName =
+          memberType.name.charAt(0).toLowerCase() + memberType.name.slice(1);
+        fields.push({
+          name: camelCaseName,
+          type: {
+            typeName: memberType.name,
+            nullable: true,
+            list: false,
+            listItemNullable: null,
+          },
+          description: null,
+          deprecated: null,
+          directives: null,
+          defaultValue: null,
+        });
+      }
+    }
+  }
+
+  return fields;
+}
+
+interface ResolveMemberNamesParams {
+  readonly members: ReadonlyArray<InlineUnionMemberInfo>;
+  readonly knownTypeNames: ReadonlySet<string>;
+  readonly generatedTypeNames: Map<string, string>;
+  readonly enumTypeNames: Map<string, string>;
+  readonly parentContext: AutoTypeNameContext;
+  readonly unionTypeNames: Map<string, string>;
+  readonly types: AutoGeneratedType[];
+  readonly diagnostics: Diagnostic[];
+  readonly generatedTypenameTypes: Map<
+    string,
+    ReadonlyArray<AutoGeneratedField>
+  >;
+  readonly sourceLocation: SourceLocation;
+}
+
+/**
+ * Extract __typename or $typeName property value from inline object properties.
+ * Returns null if neither is found or neither is a valid string literal.
+ * __typename takes priority over $typeName if both are present.
+ */
+function extractTypenameFromInlineObject(
+  properties: ReadonlyArray<InlineObjectPropertyDef>,
+): TypenameFieldInfo | null {
+  const found = findTypenameProperty(properties, (p) => p.name);
+  if (!found) {
+    return null;
+  }
+
+  const { property, fieldName } = found;
+  const { tsType } = property;
+
+  if (tsType.kind === "literal" && tsType.name !== null) {
+    return { typeName: tsType.name, fieldName };
+  }
+
+  return null;
+}
+
+function resolveMemberNames(params: ResolveMemberNamesParams): string[] {
+  const {
+    members,
+    generatedTypeNames,
+    parentContext,
+    types,
+    generatedTypenameTypes,
+    diagnostics,
+    sourceLocation,
+  } = params;
+
+  const memberNames: string[] = [];
+
+  for (let i = 0; i < members.length; i++) {
+    const member = members[i]!;
+    const memberType = member.memberType;
+
+    if (memberType.kind === "reference" && memberType.name) {
+      memberNames.push(memberType.name);
+    } else if (
+      memberType.kind === "inlineObject" &&
+      memberType.inlineObjectProperties
+    ) {
+      // Only extract __typename or $typeName for resolverPayload context
+      // For other contexts (resolverArg, objectField, inputField), these fields
+      // should be treated as regular fields, not as type discriminators
+      const extractedInfo =
+        parentContext.kind === "resolverPayload"
+          ? extractTypenameFromInlineObject(memberType.inlineObjectProperties)
+          : null;
+
+      let memberTypeName: string;
+      let contextKey: string;
+
+      if (extractedInfo !== null) {
+        memberTypeName = extractedInfo.typeName;
+        const nestedContext: AutoTypeNameContext = {
+          ...parentContext,
+          fieldPath: [...parentContext.fieldPath, extractedInfo.typeName],
+        };
+        contextKey = getContextKey(nestedContext);
+      } else {
+        const nestedContext: AutoTypeNameContext = {
+          ...parentContext,
+          fieldPath: [...parentContext.fieldPath, `member${i}`],
+        };
+        memberTypeName = generateAutoTypeName(nestedContext);
+        contextKey = getContextKey(nestedContext);
+      }
+
+      // Only filter out __typename or $typeName for resolverPayload context
+      // For other contexts, these are regular fields that should be preserved
+      const typenameFieldToFilter = extractedInfo?.fieldName ?? null;
+      const fields: AutoGeneratedField[] = memberType.inlineObjectProperties
+        .filter(
+          (prop) =>
+            parentContext.kind !== "resolverPayload" ||
+            prop.name !== typenameFieldToFilter,
+        )
+        .map((prop) => {
+          const fieldType = convertTsTypeToGraphQLType(
+            prop.tsType,
+            prop.optional,
+          );
+          return {
+            name: prop.name,
+            type: fieldType,
+            description: prop.description,
+            deprecated: prop.deprecated,
+            directives: prop.directives,
+            defaultValue: prop.defaultValue,
+          };
+        });
+
+      // Check if this typename was already seen with a different field structure
+      if (extractedInfo !== null) {
+        const existingFields = generatedTypenameTypes.get(
+          extractedInfo.typeName,
+        );
+        if (existingFields !== undefined) {
+          // Compare field structures
+          if (!areFieldStructuresEqual(existingFields, fields)) {
+            diagnostics.push({
+              code: "TYPENAME_FIELD_STRUCTURE_MISMATCH",
+              message: `Type with ${extractedInfo.fieldName} '${extractedInfo.typeName}' has inconsistent field structures across different union members. All types with the same ${extractedInfo.fieldName} must have identical field definitions.`,
+              severity: "error",
+              location: sourceLocation,
+            });
+          }
+          // Skip generating duplicate type and avoid adding duplicate union member
+          if (!memberNames.includes(memberTypeName)) {
+            memberNames.push(memberTypeName);
+          }
+          continue;
+        }
+      }
+
+      const nestedContext: AutoTypeNameContext = {
+        ...parentContext,
+        fieldPath: [
+          ...parentContext.fieldPath,
+          extractedInfo?.typeName ?? `member${i}`,
+        ],
+      };
+
+      types.push({
+        name: memberTypeName,
+        kind: "Object",
+        fields,
+        enumValues: null,
+        unionMembers: null,
+        needsStringEnumMapping: false,
+        sourceLocation: {
+          file: "",
+          line: 1,
+          column: 1,
+        },
+        generatedFrom: buildGeneratedFromInfo(nestedContext),
+        description: memberType.inlineObjectDescription,
+        resolveTypeFieldPattern: null,
+      });
+
+      generatedTypeNames.set(contextKey, memberTypeName);
+      if (extractedInfo !== null) {
+        generatedTypenameTypes.set(extractedInfo.typeName, fields);
+      }
+      memberNames.push(memberTypeName);
+    }
+  }
+
+  return memberNames;
+}
+
+/**
+ * Compare two field structures for equality.
+ * Returns true if both have the same fields with the same types.
+ */
+function areFieldStructuresEqual(
+  fields1: ReadonlyArray<AutoGeneratedField>,
+  fields2: ReadonlyArray<AutoGeneratedField>,
+): boolean {
+  if (fields1.length !== fields2.length) {
+    return false;
+  }
+
+  const sorted1 = [...fields1].sort((a, b) => a.name.localeCompare(b.name));
+  const sorted2 = [...fields2].sort((a, b) => a.name.localeCompare(b.name));
+
+  for (let i = 0; i < sorted1.length; i++) {
+    const f1 = sorted1[i]!;
+    const f2 = sorted2[i]!;
+
+    if (f1.name !== f2.name) {
+      return false;
+    }
+
+    if (!areGraphQLTypesEqual(f1.type, f2.type)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Compare two GraphQL type references for equality.
+ */
+function areGraphQLTypesEqual(
+  type1: GraphQLFieldType,
+  type2: GraphQLFieldType,
+): boolean {
+  if (type1.typeName !== type2.typeName) {
+    return false;
+  }
+  if (type1.nullable !== type2.nullable) {
+    return false;
+  }
+  if (type1.list !== type2.list) {
+    return false;
+  }
+  if (type1.listItemNullable !== type2.listItemNullable) {
+    return false;
+  }
+  return true;
+}
+
 export function generateAutoTypes(
   input: AutoTypeGeneratorInput,
 ): AutoTypeGeneratorResult {
@@ -862,9 +1555,14 @@ export function generateAutoTypes(
     input.resolversResult,
   );
 
+  const inlinePayloadsFromResolvers = collectInlinePayloadsFromResolvers(
+    input.resolversResult,
+  );
+
   const allInlineObjects = [
     ...inlineObjectsFromTypes,
     ...inlineObjectsFromResolvers,
+    ...inlinePayloadsFromResolvers,
   ];
 
   const generatedTypeNames = buildGeneratedTypeNamesMap(allInlineObjects);
@@ -872,14 +1570,43 @@ export function generateAutoTypes(
   const inlineEnumsFromTypes = collectInlineEnumsFromTypes(
     input.extractedTypes,
   );
-  const inlineEnumsFromResolvers = collectInlineEnumsFromResolvers(
-    input.resolversResult,
-  );
-  const allInlineEnums = [...inlineEnumsFromTypes, ...inlineEnumsFromResolvers];
+  const inlineEnumsFromResolvers = collectInlineEnumsFromResolvers({
+    resolversResult: input.resolversResult,
+  });
+  const inlineEnumsFromPayloads = collectInlineEnumsFromPayloads({
+    resolversResult: input.resolversResult,
+  });
+  const allInlineEnums = [
+    ...inlineEnumsFromTypes,
+    ...inlineEnumsFromResolvers,
+    ...inlineEnumsFromPayloads,
+  ];
 
   const { enumTypeNames, uniqueInlineEnums } =
     buildEnumTypeNamesMap(allInlineEnums);
 
+  // Collect inline unions from types, resolvers, and payloads
+  const inlineUnionsFromTypes = collectInlineUnionsFromTypes({
+    extractedTypes: input.extractedTypes,
+    knownTypeNames: input.knownTypeNames,
+  });
+  const inlineUnionsFromResolvers = collectInlineUnionsFromResolvers({
+    resolversResult: input.resolversResult,
+    knownTypeNames: input.knownTypeNames,
+  });
+  const inlineUnionsFromPayloads = collectInlineUnionsFromPayloads({
+    resolversResult: input.resolversResult,
+    knownTypeNames: input.knownTypeNames,
+  });
+  const allInlineUnions = [
+    ...inlineUnionsFromTypes,
+    ...inlineUnionsFromResolvers,
+    ...inlineUnionsFromPayloads,
+  ];
+
+  // Build union type names map before generating auto types
+  const unionTypeNames = buildUnionTypeNamesMap(allInlineUnions);
+
   const autoGeneratedTypes: AutoGeneratedType[] = [];
   const diagnostics: Diagnostic[] = [];
 
@@ -888,6 +1615,7 @@ export function generateAutoTypes(
       inlineObj,
       generatedTypeNames,
       enumTypeNames,
+      unionTypeNames,
     });
     autoGeneratedTypes.push(result.type);
     diagnostics.push(...result.diagnostics);
@@ -901,9 +1629,23 @@ export function generateAutoTypes(
     diagnostics.push(...result.diagnostics);
   }
 
+  // Process inline unions
+  const { types: unionTypes, diagnostics: unionDiagnostics } =
+    processInlineUnions({
+      inlineUnions: allInlineUnions,
+      knownTypeNames: input.knownTypeNames,
+      generatedTypeNames,
+      enumTypeNames,
+      unionTypeNames,
+      extractedTypes: input.extractedTypes,
+    });
+  autoGeneratedTypes.push(...unionTypes);
+  diagnostics.push(...unionDiagnostics);
+
   const updateParams: UpdateTypeNamesParams = {
     generatedTypeNames,
     enumTypeNames,
+    unionTypeNames,
   };
 
   const updatedExtractedTypes = updateExtractedTypes(