Revert "Merge branch 'fix-nested-oneof'"

This reverts commit 4a46c59, reversing
changes made to 37bad16.

Author: jasperpatterson

modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/TypeScriptFetchClientCodegen.java

@@ -460,22 +460,6 @@ public Map<String, ModelsMap> postProcessAllModels(Map<String, ModelsMap> objs)
             }
         }
 
-        // Build a set of classnames that are oneOf models (union types)
-        Set<String> oneOfModelNames = allModels.stream()
-                .filter(m -> !m.oneOf.isEmpty())
-                .map(m -> m.classname)
-                .collect(Collectors.toSet());
-
-        // Mark models whose parent is a oneOf model — these cannot use
-        // "interface X extends Parent" because TypeScript does not allow
-        // an interface to extend a union type.  They use
-        // "type X = Parent & { ... }" instead.
-        for (ExtendedCodegenModel m : allModels) {
-            if (m.parent != null && oneOfModelNames.contains(m.parent)) {
-                m.parentIsOneOf = true;
-            }
-        }
-
         for (ExtendedCodegenModel rootModel : allModels) {
             for (String curImport : rootModel.imports) {
                 boolean isModelImport = false;
@@ -1561,8 +1545,6 @@ public class ExtendedCodegenModel extends CodegenModel {
         public Set<CodegenProperty> oneOfPrimitives = new HashSet<>();
         @Getter @Setter
         public CodegenDiscriminator.MappedModel selfReferencingDiscriminatorMapping;
-        @Getter @Setter
-        public boolean parentIsOneOf; // true when this model's parent is a oneOf union type
 
         public boolean isEntity; // Is a model containing an "id" property marked as isUniqueId
         public String returnPassthrough;

modules/openapi-generator/src/main/resources/typescript-fetch/modelGenericInterfaces.mustache

@@ -1,15 +1,9 @@
 /**
  * {{#lambda.indented_star_1}}{{{unescapedDescription}}}{{/lambda.indented_star_1}}
  * @export
-{{^parentIsOneOf}}
  * @interface {{classname}}
  */
 export interface {{classname}} {{#parent}}extends {{{.}}} {{/parent}}{
-{{/parentIsOneOf}}
-{{#parentIsOneOf}}
- */
-export type {{classname}} = {{{parent}}} & {
-{{/parentIsOneOf}}
 {{#additionalPropertiesType}}
     [key: string]: {{{additionalPropertiesType}}}{{#hasVars}} | any{{/hasVars}};
 {{/additionalPropertiesType}}
@@ -24,7 +18,7 @@ export type {{classname}} = {{{parent}}} & {
      */
     {{#isReadOnly}}readonly {{/isReadOnly}}{{name}}{{^required}}?{{/required}}: {{{datatypeWithEnum}}}{{#isNullable}} | null{{/isNullable}};
 {{/vars}}
-}{{#parentIsOneOf}};{{/parentIsOneOf}}{{#hasEnums}}
+}{{#hasEnums}}
 
 {{#vars}}
 {{#isEnum}}

modules/openapi-generator/src/test/java/org/openapitools/codegen/typescript/fetch/TypeScriptFetchClientCodegenTest.java

@@ -563,43 +563,6 @@ public void testRequestOptsNotInInterfaceWhenDisabled() throws IOException {
         assertThat(classSection).contains("async addPetRequestOpts(");
     }
 
-    /**
-     * When a oneOf variant uses allOf to reference another oneOf (nested discriminated unions),
-     * the child model must be generated as a type alias with intersection rather than an
-     * interface with extends, because TypeScript does not allow interfaces to extend union types.
-     */
-    @Test(description = "Verify nested oneOf generates type alias instead of interface extends")
-    public void testNestedOneOfGeneratesTypeAliasForOneOfParent() throws IOException {
-        File output = generate(
-            Collections.emptyMap(),
-            "src/test/resources/3_0/typescript-fetch/nested-oneOf.yaml"
-        );
-
-        // OuterComposed's parent is Inner (a oneOf union type), so it must use
-        // "type OuterComposed = Inner & { ... }" instead of "interface OuterComposed extends Inner"
-        Path outerComposed = Paths.get(output + "/models/OuterComposed.ts");
-        TestUtils.assertFileExists(outerComposed);
-        TestUtils.assertFileContains(outerComposed, "export type OuterComposed = Inner & {");
-        TestUtils.assertFileNotContains(outerComposed, "export interface OuterComposed extends Inner");
-
-        // Inner should still be a proper oneOf union type with discriminator dispatch
-        Path inner = Paths.get(output + "/models/Inner.ts");
-        TestUtils.assertFileExists(inner);
-        TestUtils.assertFileContains(inner, "export type Inner = { innerDiscriminator: 'a' } & InnerA | { innerDiscriminator: 'b' } & InnerB");
-        TestUtils.assertFileContains(inner, "switch (json['innerDiscriminator'])");
-
-        // Outer should dispatch on outerDiscriminator, including the composed variant
-        Path outer = Paths.get(output + "/models/Outer.ts");
-        TestUtils.assertFileExists(outer);
-        TestUtils.assertFileContains(outer, "switch (json['outerDiscriminator'])");
-        TestUtils.assertFileContains(outer, "case 'composed':");
-
-        // Regular models (not extending a oneOf parent) should still use interface
-        Path outerPlain = Paths.get(output + "/models/OuterPlain.ts");
-        TestUtils.assertFileExists(outerPlain);
-        TestUtils.assertFileContains(outerPlain, "export interface OuterPlain {");
-    }
-
     private static File generate(
         Map<String, Object> properties
     ) throws IOException {