fix: Fix schema generation for oneOf when using TS-FETCH client (#18154)

* fix: Fix schema generation for `oneOf` when using TS-FETCH client

This fixes the following errors:
* Spread types may only be created from object types (on `FromJSONTyped` functions).
* Module '"./BlankEnum"' has no exported member 'instanceOfBlankEnum' (enum templaces don't export function used by other API client files).

* chore: Regenerate samples

Author: giovannicimolin

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

@@ -1,5 +1,9 @@
 {{>modelEnumInterfaces}}
 
+export function instanceOf{{classname}}(value: any): boolean {
+    return Object.values({{classname}}).includes(value);
+}
+
 export function {{classname}}FromJSON(json: any): {{classname}} {
     return {{classname}}FromJSONTyped(json, false);
 }

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

@@ -24,14 +24,14 @@ export function {{classname}}FromJSONTyped(json: any, ignoreDiscriminator: boole
     switch (json['{{discriminator.propertyBaseName}}']) {
 {{#discriminator.mappedModels}}
         case '{{mappingName}}':
-            return {...{{modelName}}FromJSONTyped(json, true), {{discriminator.propertyName}}: '{{mappingName}}'};
+            return Object.assign({}, {{modelName}}FromJSONTyped(json, true), { {{discriminator.propertyName}}: '{{mappingName}}' });
 {{/discriminator.mappedModels}}
         default:
             throw new Error(`No variant of {{classname}} exists with '{{discriminator.propertyName}}=${json['{{discriminator.propertyName}}']}'`);
     }
 {{/discriminator}}
 {{^discriminator}}
-    return { {{#oneOf}}...{{{.}}}FromJSONTyped(json, true){{^-last}}, {{/-last}}{{/oneOf}} };
+    return Object.assign({}, {{#oneOf}}{{{.}}}FromJSONTyped(json, true){{^-last}}, {{/-last}}{{/oneOf}});
 {{/discriminator}}
 }
 

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/EnumClass.ts

@@ -25,6 +25,10 @@ export const EnumClass = {
 export type EnumClass = typeof EnumClass[keyof typeof EnumClass];
 
 
+export function instanceOfEnumClass(value: any): boolean {
+    return Object.values(EnumClass).includes(value);
+}
+
 export function EnumClassFromJSON(json: any): EnumClass {
     return EnumClassFromJSONTyped(json, false);
 }

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/OuterEnum.ts

@@ -25,6 +25,10 @@ export const OuterEnum = {
 export type OuterEnum = typeof OuterEnum[keyof typeof OuterEnum];
 
 
+export function instanceOfOuterEnum(value: any): boolean {
+    return Object.values(OuterEnum).includes(value);
+}
+
 export function OuterEnumFromJSON(json: any): OuterEnum {
     return OuterEnumFromJSONTyped(json, false);
 }

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/OuterEnumDefaultValue.ts

@@ -25,6 +25,10 @@ export const OuterEnumDefaultValue = {
 export type OuterEnumDefaultValue = typeof OuterEnumDefaultValue[keyof typeof OuterEnumDefaultValue];
 
 
+export function instanceOfOuterEnumDefaultValue(value: any): boolean {
+    return Object.values(OuterEnumDefaultValue).includes(value);
+}
+
 export function OuterEnumDefaultValueFromJSON(json: any): OuterEnumDefaultValue {
     return OuterEnumDefaultValueFromJSONTyped(json, false);
 }

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/OuterEnumInteger.ts

@@ -25,6 +25,10 @@ export const OuterEnumInteger = {
 export type OuterEnumInteger = typeof OuterEnumInteger[keyof typeof OuterEnumInteger];
 
 
+export function instanceOfOuterEnumInteger(value: any): boolean {
+    return Object.values(OuterEnumInteger).includes(value);
+}
+
 export function OuterEnumIntegerFromJSON(json: any): OuterEnumInteger {
     return OuterEnumIntegerFromJSONTyped(json, false);
 }

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/OuterEnumIntegerDefaultValue.ts

@@ -25,6 +25,10 @@ export const OuterEnumIntegerDefaultValue = {
 export type OuterEnumIntegerDefaultValue = typeof OuterEnumIntegerDefaultValue[keyof typeof OuterEnumIntegerDefaultValue];
 
 
+export function instanceOfOuterEnumIntegerDefaultValue(value: any): boolean {
+    return Object.values(OuterEnumIntegerDefaultValue).includes(value);
+}
+
 export function OuterEnumIntegerDefaultValueFromJSON(json: any): OuterEnumIntegerDefaultValue {
     return OuterEnumIntegerDefaultValueFromJSONTyped(json, false);
 }

samples/client/petstore/typescript-fetch/builds/default-v3.0/models/SingleRefType.ts

@@ -24,6 +24,10 @@ export const SingleRefType = {
 export type SingleRefType = typeof SingleRefType[keyof typeof SingleRefType];
 
 
+export function instanceOfSingleRefType(value: any): boolean {
+    return Object.values(SingleRefType).includes(value);
+}
+
 export function SingleRefTypeFromJSON(json: any): SingleRefType {
     return SingleRefTypeFromJSONTyped(json, false);
 }

samples/client/petstore/typescript-fetch/builds/enum/models/NumberEnum.ts

@@ -25,6 +25,10 @@ export const NumberEnum = {
 export type NumberEnum = typeof NumberEnum[keyof typeof NumberEnum];
 
 
+export function instanceOfNumberEnum(value: any): boolean {
+    return Object.values(NumberEnum).includes(value);
+}
+
 export function NumberEnumFromJSON(json: any): NumberEnum {
     return NumberEnumFromJSONTyped(json, false);
 }

samples/client/petstore/typescript-fetch/builds/enum/models/StringEnum.ts

@@ -25,6 +25,10 @@ export const StringEnum = {
 export type StringEnum = typeof StringEnum[keyof typeof StringEnum];
 
 
+export function instanceOfStringEnum(value: any): boolean {
+    return Object.values(StringEnum).includes(value);
+}
+
 export function StringEnumFromJSON(json: any): StringEnum {
     return StringEnumFromJSONTyped(json, false);
 }