Use exists() to check for properties (#17798)

* Use `exists()` to check for existing properties.

* Generate Petstore code.

* Fix use of `null` instead of `undefined`.

* Enhance function code.

* Regenerate Petstore code.

* Use `exists()` in generated API clients.

* Use `exists()` in generated API clients.

* Refer to properties differently.

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

@@ -24,7 +24,7 @@ import {
 {{#allParams.0}}
 export interface {{#prefixParameterInterfaces}}{{classname}}{{/prefixParameterInterfaces}}{{operationIdCamelCase}}Request {
 {{#allParams}}
-    {{paramName}}{{^required}}?{{/required}}: {{#isEnum}}{{{datatypeWithEnum}}}{{/isEnum}}{{^isEnum}}{{{dataType}}}{{#isNullable}} | null{{/isNullable}}{{/isEnum}};
+    {{paramName}}{{^required}}?{{/required}}: {{#isEnum}}{{{datatypeWithEnum}}}{{/isEnum}}{{^isEnum}}{{{dataType}}}{{#isNullable}}{{#required}} | null{{/required}}{{/isNullable}}{{/isEnum}};
 {{/allParams}}
 }
 
@@ -70,7 +70,7 @@ export interface {{classname}}Interface {
      {{/isDeprecated}}
      */
     {{^useSingleRequestParameter}}
-    {{nickname}}({{#allParams}}{{paramName}}{{^required}}?{{/required}}: {{#isEnum}}{{{datatypeWithEnum}}}{{/isEnum}}{{^isEnum}}{{{dataType}}}{{#isNullable}} | null{{/isNullable}}{{/isEnum}}, {{/allParams}}initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<{{{returnType}}}{{^returnType}}void{{/returnType}}>;
+    {{nickname}}({{#allParams}}{{paramName}}{{^required}}?{{/required}}: {{#isEnum}}{{{datatypeWithEnum}}}{{/isEnum}}{{^isEnum}}{{{dataType}}}{{#isNullable}}{{#required}} | null{{/required}}{{/isNullable}}{{/isEnum}}, {{/allParams}}initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<{{{returnType}}}{{^returnType}}void{{/returnType}}>;
     {{/useSingleRequestParameter}}
     {{#useSingleRequestParameter}}
     {{nickname}}({{#allParams.0}}requestParameters: {{#prefixParameterInterfaces}}{{classname}}{{/prefixParameterInterfaces}}{{operationIdCamelCase}}Request, {{/allParams.0}}initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<{{{returnType}}}{{^returnType}}void{{/returnType}}>;
@@ -107,8 +107,11 @@ export class {{classname}} extends runtime.BaseAPI {
     async {{nickname}}Raw({{#allParams.0}}requestParameters: {{#prefixParameterInterfaces}}{{classname}}{{/prefixParameterInterfaces}}{{operationIdCamelCase}}Request, {{/allParams.0}}initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<{{{returnType}}}{{^returnType}}void{{/returnType}}>> {
         {{#allParams}}
         {{#required}}
-        if (requestParameters.{{paramName}} === null || requestParameters.{{paramName}} === undefined) {
-            throw new runtime.RequiredError('{{paramName}}','Required parameter requestParameters.{{paramName}} was null or undefined when calling {{nickname}}.');
+        if (!runtime.exists(requestParameters, '{{paramName}}')) {
+            throw new runtime.RequiredError(
+                '{{paramName}}',
+                'Required parameter "{{paramName}}" was null or undefined when calling {{nickname}}().'
+            );
         }
 
         {{/required}}
@@ -117,27 +120,27 @@ export class {{classname}} extends runtime.BaseAPI {
 
         {{#queryParams}}
         {{#isArray}}
-        if (requestParameters.{{paramName}}) {
+        if (runtime.exists(requestParameters, '{{paramName}}')) {
             {{#isCollectionFormatMulti}}
-            queryParameters['{{baseName}}'] = requestParameters.{{paramName}};
+            queryParameters['{{baseName}}'] = requestParameters['{{paramName}}'];
             {{/isCollectionFormatMulti}}
             {{^isCollectionFormatMulti}}
-            queryParameters['{{baseName}}'] = {{#uniqueItems}}Array.from({{/uniqueItems}}requestParameters.{{paramName}}{{#uniqueItems}}){{/uniqueItems}}.join(runtime.COLLECTION_FORMATS["{{collectionFormat}}"]);
+            queryParameters['{{baseName}}'] = {{#uniqueItems}}Array.from({{/uniqueItems}}requestParameters['{{paramName}}']{{#uniqueItems}}){{/uniqueItems}}!.join(runtime.COLLECTION_FORMATS["{{collectionFormat}}"]);
             {{/isCollectionFormatMulti}}
         }
 
         {{/isArray}}
         {{^isArray}}
-        if (requestParameters.{{paramName}} !== undefined) {
+        if (runtime.exists(requestParameters, '{{paramName}}')) {
             {{#isDateTimeType}}
-            queryParameters['{{baseName}}'] = (requestParameters.{{paramName}} as any).toISOString();
+            queryParameters['{{baseName}}'] = (requestParameters['{{paramName}}'] as any).toISOString();
             {{/isDateTimeType}}
             {{^isDateTimeType}}
             {{#isDateType}}
-            queryParameters['{{baseName}}'] = (requestParameters.{{paramName}} as any).toISOString().substring(0,10);
+            queryParameters['{{baseName}}'] = (requestParameters['{{paramName}}'] as any).toISOString().substring(0,10);
             {{/isDateType}}
             {{^isDateType}}
-            queryParameters['{{baseName}}'] = requestParameters.{{paramName}};
+            queryParameters['{{baseName}}'] = requestParameters['{{paramName}}'];
             {{/isDateType}}
             {{/isDateTimeType}}
         }
@@ -158,14 +161,14 @@ export class {{classname}} extends runtime.BaseAPI {
         {{/bodyParam}}
         {{#headerParams}}
         {{#isArray}}
-        if (requestParameters.{{paramName}}) {
-            headerParameters['{{baseName}}'] = {{#uniqueItems}}Array.from({{/uniqueItems}}requestParameters.{{paramName}}{{#uniqueItems}}){{/uniqueItems}}.join(runtime.COLLECTION_FORMATS["{{collectionFormat}}"]);
+        if (runtime.exists(requestParameters, '{{paramName}}')) {
+            headerParameters['{{baseName}}'] = {{#uniqueItems}}Array.from({{/uniqueItems}}requestParameters['{{paramName}}']{{#uniqueItems}}){{/uniqueItems}}!.join(runtime.COLLECTION_FORMATS["{{collectionFormat}}"]);
         }
 
         {{/isArray}}
         {{^isArray}}
-        if (requestParameters.{{paramName}} !== undefined && requestParameters.{{paramName}} !== null) {
-            headerParameters['{{baseName}}'] = String(requestParameters.{{paramName}});
+        if (runtime.exists(requestParameters, '{{paramName}}')) {
+            headerParameters['{{baseName}}'] = String(requestParameters['{{paramName}}']);
         }
 
         {{/isArray}}
@@ -235,28 +238,28 @@ export class {{classname}} extends runtime.BaseAPI {
 
         {{#formParams}}
         {{#isArray}}
-        if (requestParameters.{{paramName}}) {
+        if (runtime.exists(requestParameters, '{{paramName}}')) {
             {{#isCollectionFormatMulti}}
-            requestParameters.{{paramName}}.forEach((element) => {
+            requestParameters['{{paramName}}'].forEach((element) => {
                 formParams.append('{{baseName}}', element as any);
             })
             {{/isCollectionFormatMulti}}
             {{^isCollectionFormatMulti}}
-            formParams.append('{{baseName}}', {{#uniqueItems}}Array.from({{/uniqueItems}}requestParameters.{{paramName}}{{#uniqueItems}}){{/uniqueItems}}.join(runtime.COLLECTION_FORMATS["{{collectionFormat}}"]));
+            formParams.append('{{baseName}}', {{#uniqueItems}}Array.from({{/uniqueItems}}requestParameters['{{paramName}}']{{#uniqueItems}}){{/uniqueItems}}!.join(runtime.COLLECTION_FORMATS["{{collectionFormat}}"]));
             {{/isCollectionFormatMulti}}
         }
 
         {{/isArray}}
         {{^isArray}}
-        if (requestParameters.{{paramName}} !== undefined) {
+        if (runtime.exists(requestParameters, '{{paramName}}')) {
             {{#isPrimitiveType}}
-            formParams.append('{{baseName}}', requestParameters.{{paramName}} as any);
+            formParams.append('{{baseName}}', requestParameters['{{paramName}}'] as any);
             {{/isPrimitiveType}}
             {{^isPrimitiveType}}
             {{^withoutRuntimeChecks}}
-            formParams.append('{{baseName}}', new Blob([JSON.stringify({{{dataType}}}ToJSON(requestParameters.{{paramName}}))], { type: "application/json", }));
+            formParams.append('{{baseName}}', new Blob([JSON.stringify({{{dataType}}}ToJSON(requestParameters['{{paramName}}']))], { type: "application/json", }));
             {{/withoutRuntimeChecks}}{{#withoutRuntimeChecks}}
-            formParams.append('{{baseName}}', new Blob([JSON.stringify(requestParameters.{{paramName}})], { type: "application/json", }));
+            formParams.append('{{baseName}}', new Blob([JSON.stringify(requestParameters['{{paramName}}'])], { type: "application/json", }));
             {{/withoutRuntimeChecks}}
             {{/isPrimitiveType}}
         }
@@ -265,7 +268,7 @@ export class {{classname}} extends runtime.BaseAPI {
         {{/formParams}}
         {{/hasFormParams}}
         const response = await this.request({
-            path: `{{{path}}}`{{#pathParams}}.replace(`{${"{{baseName}}"}}`, encodeURIComponent(String(requestParameters.{{paramName}}))){{/pathParams}},
+            path: `{{{path}}}`{{#pathParams}}.replace(`{${"{{baseName}}"}}`, encodeURIComponent(String(requestParameters['{{paramName}}']))){{/pathParams}},
             method: '{{httpMethod}}',
             headers: headerParameters,
             query: queryParameters,
@@ -273,23 +276,23 @@ export class {{classname}} extends runtime.BaseAPI {
             {{#bodyParam}}
             {{#isContainer}}
             {{^withoutRuntimeChecks}}
-            body: requestParameters.{{paramName}}{{#isArray}}{{#items}}{{^isPrimitiveType}}.map({{datatype}}ToJSON){{/isPrimitiveType}}{{/items}}{{/isArray}},
+            body: requestParameters['{{paramName}}']{{#isArray}}{{#items}}{{^isPrimitiveType}}!.map({{datatype}}ToJSON){{/isPrimitiveType}}{{/items}}{{/isArray}},
             {{/withoutRuntimeChecks}}
             {{#withoutRuntimeChecks}}
-            body: requestParameters.{{paramName}},
+            body: requestParameters['{{paramName}}'],
             {{/withoutRuntimeChecks}}
             {{/isContainer}}
             {{^isContainer}}
             {{^isPrimitiveType}}
             {{^withoutRuntimeChecks}}
-            body: {{dataType}}ToJSON(requestParameters.{{paramName}}),
+            body: {{dataType}}ToJSON(requestParameters['{{paramName}}']),
             {{/withoutRuntimeChecks}}
             {{#withoutRuntimeChecks}}
-            body: requestParameters.{{paramName}},
+            body: requestParameters['{{paramName}}'],
             {{/withoutRuntimeChecks}}
             {{/isPrimitiveType}}
             {{#isPrimitiveType}}
-            body: requestParameters.{{paramName}} as any,
+            body: requestParameters['{{paramName}}'] as any,
             {{/isPrimitiveType}}
             {{/isContainer}}
             {{/bodyParam}}
@@ -351,7 +354,7 @@ export class {{classname}} extends runtime.BaseAPI {
      {{/isDeprecated}}
      */
     {{^useSingleRequestParameter}}
-    async {{nickname}}({{#allParams}}{{paramName}}{{^required}}?{{/required}}: {{#isEnum}}{{{datatypeWithEnum}}}{{/isEnum}}{{^isEnum}}{{{dataType}}}{{#isNullable}} | null{{/isNullable}}{{/isEnum}}, {{/allParams}}initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<{{{returnType}}}{{#returnType}}{{#isResponseOptional}} | null | undefined {{/isResponseOptional}}{{/returnType}}{{^returnType}}void{{/returnType}}> {
+    async {{nickname}}({{#allParams}}{{paramName}}{{^required}}?{{/required}}: {{#isEnum}}{{{datatypeWithEnum}}}{{/isEnum}}{{^isEnum}}{{{dataType}}}{{#isNullable}}{{#required}} | null{{/required}}{{/isNullable}}{{/isEnum}}, {{/allParams}}initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<{{{returnType}}}{{#returnType}}{{#isResponseOptional}} | null | undefined {{/isResponseOptional}}{{/returnType}}{{^returnType}}void{{/returnType}}> {
         {{#returnType}}
         const response = await this.{{nickname}}Raw({{#allParams.0}}{ {{#allParams}}{{paramName}}: {{paramName}}{{^-last}}, {{/-last}}{{/allParams}} }, {{/allParams.0}}initOverrides);
         {{#isResponseOptional}}

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

@@ -24,14 +24,12 @@ import {
  * Check if a given object implements the {{classname}} interface.
  */
 export function instanceOf{{classname}}(value: object): boolean {
-    let isInstance = true;
     {{#vars}}
     {{#required}}
-    isInstance = isInstance && "{{name}}" in value;
+    if (!('{{name}}' in value)) return false;
     {{/required}}
     {{/vars}}
-
-    return isInstance;
+    return true;
 }
 
 export function {{classname}}FromJSON(json: any): {{classname}} {
@@ -40,7 +38,7 @@ export function {{classname}}FromJSON(json: any): {{classname}} {
 
 export function {{classname}}FromJSONTyped(json: any, ignoreDiscriminator: boolean): {{classname}} {
     {{#hasVars}}
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
 {{#discriminator}}
@@ -60,10 +58,10 @@ export function {{classname}}FromJSONTyped(json: any, ignoreDiscriminator: boole
         {{#vars}}
         {{#isPrimitiveType}}
         {{#isDateType}}
-        '{{name}}': {{^required}}!exists(json, '{{baseName}}') ? undefined : {{/required}}({{#isNullable}}json['{{baseName}}'] === null ? null : {{/isNullable}}new Date(json['{{baseName}}'])),
+        '{{name}}': {{^required}}!exists(json, '{{baseName}}') ? undefined : {{/required}}({{#required}}{{#isNullable}}!exists(json, '{{baseName}}') ? null : {{/isNullable}}{{/required}}new Date(json['{{baseName}}'])),
         {{/isDateType}}
         {{#isDateTimeType}}
-        '{{name}}': {{^required}}!exists(json, '{{baseName}}') ? undefined : {{/required}}({{#isNullable}}json['{{baseName}}'] === null ? null : {{/isNullable}}new Date(json['{{baseName}}'])),
+        '{{name}}': {{^required}}!exists(json, '{{baseName}}') ? undefined : {{/required}}({{#required}}{{#isNullable}}!exists(json, '{{baseName}}') ? null : {{/isNullable}}{{/required}}new Date(json['{{baseName}}'])),
         {{/isDateTimeType}}
         {{^isDateType}}
         {{^isDateTimeType}}
@@ -74,14 +72,14 @@ export function {{classname}}FromJSONTyped(json: any, ignoreDiscriminator: boole
         {{^isPrimitiveType}}
         {{#isArray}}
         {{#uniqueItems}}
-        '{{name}}': {{^required}}!exists(json, '{{baseName}}') ? undefined : {{/required}}({{#isNullable}}json['{{baseName}}'] === null ? null : {{/isNullable}}new Set((json['{{baseName}}'] as Array<any>).map({{#items}}{{datatype}}{{/items}}FromJSON))),
+        '{{name}}': {{^required}}!exists(json, '{{baseName}}') ? undefined : {{/required}}{{#required}}({{#isNullable}}!exists(json, '{{baseName}}') ? null : {{/isNullable}}{{/required}}new Set((json['{{baseName}}'] as Array<any>).map({{#items}}{{datatype}}{{/items}}FromJSON))),
         {{/uniqueItems}}
         {{^uniqueItems}}
-        '{{name}}': {{^required}}!exists(json, '{{baseName}}') ? undefined : {{/required}}({{#isNullable}}json['{{baseName}}'] === null ? null : {{/isNullable}}(json['{{baseName}}'] as Array<any>).map({{#items}}{{datatype}}{{/items}}FromJSON)),
+        '{{name}}': {{^required}}!exists(json, '{{baseName}}') ? undefined : {{/required}}({{#required}}{{#isNullable}}!exists(json, '{{baseName}}') ? null : {{/isNullable}}{{/required}}(json['{{baseName}}'] as Array<any>).map({{#items}}{{datatype}}{{/items}}FromJSON)),
         {{/uniqueItems}}
         {{/isArray}}
         {{#isMap}}
-        '{{name}}': {{^required}}!exists(json, '{{baseName}}') ? undefined : {{/required}}({{#isNullable}}json['{{baseName}}'] === null ? null : {{/isNullable}}mapValues(json['{{baseName}}'], {{#items}}{{datatype}}{{/items}}FromJSON)),
+        '{{name}}': {{^required}}!exists(json, '{{baseName}}') ? undefined : {{/required}}({{#required}}{{#isNullable}}!exists(json, '{{baseName}}') ? null : {{/isNullable}}{{/required}}mapValues(json['{{baseName}}'], {{#items}}{{datatype}}{{/items}}FromJSON)),
         {{/isMap}}
         {{^isArray}}
         {{^isMap}}
@@ -119,18 +117,18 @@ export function {{classname}}ToJSON(value?: {{classname}} | null): any {
         {{^isReadOnly}}
         {{#isPrimitiveType}}
         {{#isDateType}}
-        '{{baseName}}': {{^required}}value.{{name}} === undefined ? undefined : {{/required}}({{#isNullable}}value.{{name}} === null ? null : {{/isNullable}}value.{{name}}.toISOString().substring(0,10)),
+        '{{baseName}}': {{^required}}!exists(value, '{{name}}') ? undefined : {{/required}}({{#required}}{{#isNullable}}!exists(value, '{{name}}') ? null : {{/isNullable}}{{/required}}(value['{{name}}']{{#isNullable}} as any{{/isNullable}}).toISOString().substring(0,10)),
         {{/isDateType}}
         {{#isDateTimeType}}
-        '{{baseName}}': {{^required}}value.{{name}} === undefined ? undefined : {{/required}}({{#isNullable}}value.{{name}} === null ? null : {{/isNullable}}value.{{name}}.toISOString()),
+        '{{baseName}}': {{^required}}!exists(value, '{{name}}') ? undefined : {{/required}}({{#required}}{{#isNullable}}!exists(value, '{{name}}') ? null : {{/isNullable}}{{/required}}(value['{{name}}']{{#isNullable}} as any{{/isNullable}}).toISOString()),
         {{/isDateTimeType}}
         {{#isArray}}
-        '{{baseName}}': {{#uniqueItems}}{{^required}}value.{{name}} === undefined ? undefined : {{/required}}{{#isNullable}}value.{{name}} === null ? null : {{/isNullable}}Array.from(value.{{name}} as Set<any>){{/uniqueItems}}{{^uniqueItems}}value.{{name}}{{/uniqueItems}},
+        '{{baseName}}': {{#uniqueItems}}{{^required}}!exists(value, '{{name}}') ? undefined : {{/required}}{{#required}}{{#isNullable}}!exists(value, '{{name}}') ? null : {{/isNullable}}{{/required}}Array.from(value['{{name}}'] as Set<any>){{/uniqueItems}}{{^uniqueItems}}value['{{name}}']{{/uniqueItems}},
         {{/isArray}}
         {{^isDateType}}
         {{^isDateTimeType}}
         {{^isArray}}
-        '{{baseName}}': value.{{name}},
+        '{{baseName}}': value['{{name}}'],
         {{/isArray}}
         {{/isDateTimeType}}
         {{/isDateType}}
@@ -138,22 +136,22 @@ export function {{classname}}ToJSON(value?: {{classname}} | null): any {
         {{^isPrimitiveType}}
         {{#isArray}}
         {{#uniqueItems}}
-        '{{baseName}}': {{^required}}value.{{name}} === undefined ? undefined : {{/required}}({{#isNullable}}value.{{name}} === null ? null : {{/isNullable}}Array.from(value.{{name}} as Set<any>).map({{#items}}{{datatype}}{{/items}}ToJSON)),
+        '{{baseName}}': {{^required}}!exists(value, '{{name}}') ? undefined : {{/required}}({{#required}}{{#isNullable}}!exists(value, '{{name}}') ? null : {{/isNullable}}{{/required}}Array.from(value['{{name}}'] as Set<any>).map({{#items}}{{datatype}}{{/items}}ToJSON)),
         {{/uniqueItems}}
         {{^uniqueItems}}
-        '{{baseName}}': {{^required}}value.{{name}} === undefined ? undefined : {{/required}}({{#isNullable}}value.{{name}} === null ? null : {{/isNullable}}(value.{{name}} as Array<any>).map({{#items}}{{datatype}}{{/items}}ToJSON)),
+        '{{baseName}}': {{^required}}!exists(value, '{{name}}') ? undefined : {{/required}}({{#required}}{{#isNullable}}!exists(value, '{{name}}') ? null : {{/isNullable}}{{/required}}(value['{{name}}'] as Array<any>).map({{#items}}{{datatype}}{{/items}}ToJSON)),
         {{/uniqueItems}}
         {{/isArray}}
         {{#isMap}}
-        '{{baseName}}': {{^required}}value.{{name}} === undefined ? undefined : {{/required}}({{#isNullable}}value.{{name}} === null ? null : {{/isNullable}}mapValues(value.{{name}}, {{#items}}{{datatype}}{{/items}}ToJSON)),
+        '{{baseName}}': {{^required}}!exists(value, '{{name}}') ? undefined : {{/required}}({{#required}}{{#isNullable}}!exists(value, '{{name}}') ? null : {{/isNullable}}{{/required}}mapValues(value['{{name}}'], {{#items}}{{datatype}}{{/items}}ToJSON)),
         {{/isMap}}
         {{^isArray}}
         {{^isMap}}
         {{^isFreeFormObject}}
-        '{{baseName}}': {{datatype}}ToJSON(value.{{name}}),
+        '{{baseName}}': {{datatype}}ToJSON(value['{{name}}']),
         {{/isFreeFormObject}}
         {{#isFreeFormObject}}
-        '{{baseName}}': value.{{name}},
+        '{{baseName}}': value['{{name}}'],
         {{/isFreeFormObject}}
         {{/isMap}}
         {{/isArray}}

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

@@ -16,7 +16,7 @@ export interface {{classname}} {{#parent}}extends {{{.}}} {{/parent}}{
      * @deprecated
     {{/deprecated}}
      */
-    {{#isReadOnly}}readonly {{/isReadOnly}}{{name}}{{^required}}?{{/required}}: {{#isEnum}}{{{datatypeWithEnum}}}{{#isNullable}} | null{{/isNullable}}{{/isEnum}}{{^isEnum}}{{{datatype}}}{{#isNullable}} | null{{/isNullable}}{{/isEnum}};
+    {{#isReadOnly}}readonly {{/isReadOnly}}{{name}}{{^required}}?{{/required}}: {{#isEnum}}{{{datatypeWithEnum}}}{{#isNullable}}{{#required}} | null{{/required}}{{/isNullable}}{{/isEnum}}{{^isEnum}}{{{datatype}}}{{#isNullable}}{{#required}} | null{{/required}}{{/isNullable}}{{/isEnum}};
 {{/vars}}
 }{{#hasEnums}}
 

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

@@ -17,7 +17,7 @@ export function {{classname}}FromJSON(json: any): {{classname}} {
 }
 
 export function {{classname}}FromJSONTyped(json: any, ignoreDiscriminator: boolean): {{classname}} {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
 {{#discriminator}}

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

@@ -98,23 +98,23 @@ class {{classname}}RecordUtils extends ApiRecordUtils<{{classname}}, {{classname
         {{#isUniqueId}}
         {{#isArray}}
         {{#items.isArray}}
-        {{^required}}if (apiObject.{{name}}) { {{/required}}(apiObject as any).{{name}} = apiObject.{{name}}.map(item => item.map(item2 => item2?.toString()));{{^required}} } {{/required}}
+        {{^required}}if (apiObject['{{name}}']) { {{/required}}(apiObject as any)['{{name}}'] = apiObject['{{name}}'].map(item => item.map(item2 => item2?.toString()));{{^required}} } {{/required}}
         {{/items.isArray}}
         {{^items.isArray}}
-        {{^required}}if (apiObject.{{name}}) { {{/required}}(apiObject as any).{{name}} = apiObject.{{name}}.map(item => item?.toString());{{^required}} } {{/required}}
+        {{^required}}if (apiObject['{{name}}']) { {{/required}}(apiObject as any)['{{name}}'] = apiObject['{{name}}'].map(item => item?.toString());{{^required}} } {{/required}}
         {{/items.isArray}}
         {{/isArray}}
         {{^isArray}}
-        {{^required}}if (apiObject.{{name}}) { {{/required}}(apiObject as any).{{name}} = apiObject.{{name}}.toString();{{^required}} } {{/required}}
+        {{^required}}if (apiObject['{{name}}']) { {{/required}}(apiObject as any)['{{name}}'] = apiObject['{{name}}'].toString();{{^required}} } {{/required}}
         {{/isArray}}
         {{/isUniqueId}}
         {{^keepAsJSObject}}
         {{#isModel}}
-        {{^required}}if (apiObject.{{name}}) { {{/required}}{{#lambda.camelcase}}{{{dataTypeAlternate}}}{{/lambda.camelcase}}Utils.normalize(apiObject.{{name}});{{^required}} } {{/required}}
+        {{^required}}if (apiObject['{{name}}']) { {{/required}}{{#lambda.camelcase}}{{{dataTypeAlternate}}}{{/lambda.camelcase}}Utils.normalize(apiObject['{{name}}']);{{^required}} } {{/required}}
         {{/isModel}}
         {{#isArray}}
         {{#items.isModel}}
-        {{^required}}if (apiObject.{{name}}) { {{/required}}{{#lambda.camelcase}}{{items.dataType}}{{/lambda.camelcase}}RecordUtils.normalizeArray(apiObject.{{name}});{{^required}} } {{/required}}
+        {{^required}}if (apiObject['{{name}}']) { {{/required}}{{#lambda.camelcase}}{{items.dataType}}{{/lambda.camelcase}}RecordUtils.normalizeArray(apiObject['{{name}}']);{{^required}} } {{/required}}
         {{/items.isModel}}
         {{/isArray}}
         {{/keepAsJSObject}}
@@ -172,14 +172,14 @@ class {{classname}}RecordUtils extends ApiRecordUtils<{{classname}}, {{classname
 {{#isEntity}}
 {{^keepAsJSObject}}
             // @ts-ignore
-            {{name}}: {{^required}}entity.{{name}} ? {{/required}}yield call({{#lambda.camelcase}}{{{dataTypeAlternate}}}{{/lambda.camelcase}}Utils.toInlined, entity.{{name}}){{^required}} : null{{/required}},
+            {{name}}: {{^required}}entity['{{name}}'] ? {{/required}}yield call({{#lambda.camelcase}}{{{dataTypeAlternate}}}{{/lambda.camelcase}}Utils.toInlined, entity['{{name}}']){{^required}} : null{{/required}},
 {{/keepAsJSObject}}
 {{/isEntity}}
 {{#isArray}}
 {{#items.isEntity}}
 {{^keepAsJSObject}}
             // @ts-ignore
-            {{name}}: {{^required}}entity.{{name}} ? {{/required}}yield call({{#lambda.camelcase}}{{items.dataType}}{{/lambda.camelcase}}RecordUtils.toInlinedArray, entity.{{name}}){{^required}} : null{{/required}},
+            {{name}}: {{^required}}entity['{{name}}'] ? {{/required}}yield call({{#lambda.camelcase}}{{items.dataType}}{{/lambda.camelcase}}RecordUtils.toInlinedArray, entity['{{name}}']){{^required}} : null{{/required}},
 {{/keepAsJSObject}}
 {{/items.isEntity}}
 {{/isArray}}
@@ -212,23 +212,23 @@ class {{classname}}RecordUtils extends ApiRecordUtils<{{classname}}, {{classname
         {{#isUniqueId}}
         {{#isArray}}
         {{#items.isArray}}
-        {{^required}}if (record.{{name}}) { {{/required}}apiObject.{{name}} = {{#isArray}}record.{{name}}.map(item => item.toArray().map(item2 => (item2 ? parseFloat(item2) : null) as number)).toArray(){{/isArray}};{{^required}} } {{/required}}
+        {{^required}}if (record['{{name}}']) { {{/required}}apiObject['{{name}}'] = {{#isArray}}record['{{name}}'].map(item => item.toArray().map(item2 => (item2 ? parseFloat(item2) : null) as number)).toArray(){{/isArray}};{{^required}} } {{/required}}
         {{/items.isArray}}
         {{^items.isArray}}
-        {{^required}}if (record.{{name}}) { {{/required}}apiObject.{{name}} = {{#isArray}}record.{{name}}.map(item => (item ? parseFloat(item) : null) as number).toArray(){{/isArray}};{{^required}} } {{/required}}
+        {{^required}}if (record['{{name}}']) { {{/required}}apiObject['{{name}}'] = {{#isArray}}record['{{name}}'].map(item => (item ? parseFloat(item) : null) as number).toArray(){{/isArray}};{{^required}} } {{/required}}
         {{/items.isArray}}
         {{/isArray}}
         {{^isArray}}
-        {{^required}}if (record.{{name}}) { {{/required}}apiObject.{{name}} = {{^isArray}}parseFloat(record.{{name}}){{/isArray}};{{^required}} } {{/required}}
+        {{^required}}if (record['{{name}}']) { {{/required}}apiObject['{{name}}'] = {{^isArray}}parseFloat(record['{{name}}']){{/isArray}};{{^required}} } {{/required}}
         {{/isArray}}
         {{/isUniqueId}}
         {{^keepAsJSObject}}
         {{#isModel}}
-        {{^required}}if (record.{{name}}) { {{/required}}apiObject.{{name}} = {{#lambda.camelcase}}{{{dataTypeAlternate}}}{{/lambda.camelcase}}Utils.toApi(record.{{name}});{{^required}} } {{/required}}
+        {{^required}}if (record['{{name}}']) { {{/required}}apiObject['{{name}}'] = {{#lambda.camelcase}}{{{dataTypeAlternate}}}{{/lambda.camelcase}}Utils.toApi(record['{{name}}']);{{^required}} } {{/required}}
         {{/isModel}}
         {{#isArray}}
         {{#items.isModel}}
-        {{^required}}if (record.{{name}}) { {{/required}}apiObject.{{name}} = {{#lambda.camelcase}}{{items.dataType}}{{/lambda.camelcase}}RecordUtils.toApiArray(record.{{name}});{{^required}} } {{/required}}
+        {{^required}}if (record['{{name}}']) { {{/required}}apiObject['{{name}}'] = {{#lambda.camelcase}}{{items.dataType}}{{/lambda.camelcase}}RecordUtils.toApiArray(record['{{name}}']);{{^required}} } {{/required}}
         {{/items.isModel}}
         {{/isArray}}
         {{/keepAsJSObject}}

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

@@ -300,9 +300,9 @@ export interface RequestOpts {
 }
 
 {{^withoutRuntimeChecks}}
-export function exists(json: any, key: string) {
+export function exists(json: any, key: string): boolean {
     const value = json[key];
-    return value !== null && value !== undefined;
+    return value !== undefined && value !== null;
 }
 {{/withoutRuntimeChecks}}
 

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

@@ -105,7 +105,7 @@ export function *{{nickname}}SagaImp(_action_: Action<Payload{{#lambda.titlecase
 
         yield put({{nickname}}Request({{#allParams.0}}{{#returnTypeSupportsEntities}}requestPayload{{/returnTypeSupportsEntities}}{{^returnTypeSupportsEntities}}_action_.payload{{/returnTypeSupportsEntities}}{{/allParams.0}}));
 
-        const response{{#returnType}}: Required<{{{returnType}}}>{{/returnType}} = yield apiCall(Api.{{#lambda.camelcase}}{{classname}}{{/lambda.camelcase}}, Api.{{#lambda.camelcase}}{{classname}}{{/lambda.camelcase}}.{{nickname}},
+        const response{{#returnType}}: Required<{{{returnType}}}>{{/returnType}} = yield apiCall(Api.{{#lambda.camelcase}}{{classname}}{{/lambda.camelcase}}, Api.{{#lambda.camelcase}}{{classname}}{{/lambda.camelcase}}['{{nickname}}'],
 {{#allParams.0}}
 {{#allParams}}
 {{#isUniqueId}}

samples/client/petstore/typescript-fetch/builds/allOf-nullable/apis/DefaultApi.ts

@@ -34,8 +34,11 @@ export class DefaultApi extends runtime.BaseAPI {
     /**
      */
     async listRaw(requestParameters: ListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Club>> {
-        if (requestParameters.personId === null || requestParameters.personId === undefined) {
-            throw new runtime.RequiredError('personId','Required parameter requestParameters.personId was null or undefined when calling list.');
+        if (!runtime.exists(requestParameters, 'personId')) {
+            throw new runtime.RequiredError(
+                'personId',
+                'Required parameter "personId" was null or undefined when calling list().'
+            );
         }
 
         const queryParameters: any = {};
@@ -43,7 +46,7 @@ export class DefaultApi extends runtime.BaseAPI {
         const headerParameters: runtime.HTTPHeaders = {};
 
         const response = await this.request({
-            path: `/person/display/{personId}`.replace(`{${"personId"}}`, encodeURIComponent(String(requestParameters.personId))),
+            path: `/person/display/{personId}`.replace(`{${"personId"}}`, encodeURIComponent(String(requestParameters['personId']))),
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,

samples/client/petstore/typescript-fetch/builds/allOf-nullable/models/Club.ts

@@ -31,16 +31,14 @@ export interface Club {
      * @type {Owner}
      * @memberof Club
      */
-    owner?: Owner | null;
+    owner?: Owner;
 }
 
 /**
  * Check if a given object implements the Club interface.
  */
 export function instanceOfClub(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function ClubFromJSON(json: any): Club {
@@ -48,7 +46,7 @@ export function ClubFromJSON(json: any): Club {
 }
 
 export function ClubFromJSONTyped(json: any, ignoreDiscriminator: boolean): Club {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -66,7 +64,7 @@ export function ClubToJSON(value?: Club | null): any {
     }
     return {
         
-        'owner': OwnerToJSON(value.owner),
+        'owner': OwnerToJSON(value['owner']),
     };
 }
 

samples/client/petstore/typescript-fetch/builds/allOf-nullable/models/Owner.ts

@@ -31,9 +31,7 @@ export interface Owner {
  * Check if a given object implements the Owner interface.
  */
 export function instanceOfOwner(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function OwnerFromJSON(json: any): Owner {
@@ -41,7 +39,7 @@ export function OwnerFromJSON(json: any): Owner {
 }
 
 export function OwnerFromJSONTyped(json: any, ignoreDiscriminator: boolean): Owner {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -59,7 +57,7 @@ export function OwnerToJSON(value?: Owner | null): any {
     }
     return {
         
-        'name': value.name,
+        'name': value['name'],
     };
 }
 

samples/client/petstore/typescript-fetch/builds/allOf-nullable/runtime.ts

@@ -310,9 +310,9 @@ export interface RequestOpts {
     body?: HTTPBody;
 }
 
-export function exists(json: any, key: string) {
+export function exists(json: any, key: string): boolean {
     const value = json[key];
-    return value !== null && value !== undefined;
+    return value !== undefined && value !== null;
 }
 
 export function querystring(params: HTTPQuery, prefix: string = ''): string {

samples/client/petstore/typescript-fetch/builds/allOf-readonly/apis/DefaultApi.ts

@@ -34,8 +34,11 @@ export class DefaultApi extends runtime.BaseAPI {
     /**
      */
     async listRaw(requestParameters: ListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Club>> {
-        if (requestParameters.personId === null || requestParameters.personId === undefined) {
-            throw new runtime.RequiredError('personId','Required parameter requestParameters.personId was null or undefined when calling list.');
+        if (!runtime.exists(requestParameters, 'personId')) {
+            throw new runtime.RequiredError(
+                'personId',
+                'Required parameter "personId" was null or undefined when calling list().'
+            );
         }
 
         const queryParameters: any = {};
@@ -43,7 +46,7 @@ export class DefaultApi extends runtime.BaseAPI {
         const headerParameters: runtime.HTTPHeaders = {};
 
         const response = await this.request({
-            path: `/person/display/{personId}`.replace(`{${"personId"}}`, encodeURIComponent(String(requestParameters.personId))),
+            path: `/person/display/{personId}`.replace(`{${"personId"}}`, encodeURIComponent(String(requestParameters['personId']))),
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,

samples/client/petstore/typescript-fetch/builds/allOf-readonly/models/Club.ts

@@ -38,9 +38,7 @@ export interface Club {
  * Check if a given object implements the Club interface.
  */
 export function instanceOfClub(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function ClubFromJSON(json: any): Club {
@@ -48,7 +46,7 @@ export function ClubFromJSON(json: any): Club {
 }
 
 export function ClubFromJSONTyped(json: any, ignoreDiscriminator: boolean): Club {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {

samples/client/petstore/typescript-fetch/builds/allOf-readonly/models/Owner.ts

@@ -31,9 +31,7 @@ export interface Owner {
  * Check if a given object implements the Owner interface.
  */
 export function instanceOfOwner(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function OwnerFromJSON(json: any): Owner {
@@ -41,7 +39,7 @@ export function OwnerFromJSON(json: any): Owner {
 }
 
 export function OwnerFromJSONTyped(json: any, ignoreDiscriminator: boolean): Owner {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -59,7 +57,7 @@ export function OwnerToJSON(value?: Owner | null): any {
     }
     return {
         
-        'name': value.name,
+        'name': value['name'],
     };
 }
 

samples/client/petstore/typescript-fetch/builds/allOf-readonly/runtime.ts

@@ -310,9 +310,9 @@ export interface RequestOpts {
     body?: HTTPBody;
 }
 
-export function exists(json: any, key: string) {
+export function exists(json: any, key: string): boolean {
     const value = json[key];
-    return value !== null && value !== undefined;
+    return value !== undefined && value !== null;
 }
 
 export function querystring(params: HTTPQuery, prefix: string = ''): string {

samples/client/petstore/typescript-fetch/builds/default-v3.0/apis/AnotherFakeApi.ts

@@ -36,8 +36,11 @@ export class AnotherFakeApi extends runtime.BaseAPI {
      * To test special tags
      */
     async _123testSpecialTagsRaw(requestParameters: 123testSpecialTagsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Client>> {
-        if (requestParameters.client === null || requestParameters.client === undefined) {
-            throw new runtime.RequiredError('client','Required parameter requestParameters.client was null or undefined when calling _123testSpecialTags.');
+        if (!runtime.exists(requestParameters, 'client')) {
+            throw new runtime.RequiredError(
+                'client',
+                'Required parameter "client" was null or undefined when calling _123testSpecialTags().'
+            );
         }
 
         const queryParameters: any = {};
@@ -51,7 +54,7 @@ export class AnotherFakeApi extends runtime.BaseAPI {
             method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
-            body: ClientToJSON(requestParameters.client),
+            body: ClientToJSON(requestParameters['client']),
         }, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => ClientFromJSON(jsonValue));

samples/client/petstore/typescript-fetch/builds/default-v3.0/apis/FakeApi.ts

@@ -229,22 +229,25 @@ export class FakeApi extends runtime.BaseAPI {
      * test http signature authentication
      */
     async fakeHttpSignatureTestRaw(requestParameters: FakeHttpSignatureTestRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.pet === null || requestParameters.pet === undefined) {
-            throw new runtime.RequiredError('pet','Required parameter requestParameters.pet was null or undefined when calling fakeHttpSignatureTest.');
+        if (!runtime.exists(requestParameters, 'pet')) {
+            throw new runtime.RequiredError(
+                'pet',
+                'Required parameter "pet" was null or undefined when calling fakeHttpSignatureTest().'
+            );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters.query1 !== undefined) {
-            queryParameters['query_1'] = requestParameters.query1;
+        if (runtime.exists(requestParameters, 'query1')) {
+            queryParameters['query_1'] = requestParameters['query1'];
         }
 
         const headerParameters: runtime.HTTPHeaders = {};
 
         headerParameters['Content-Type'] = 'application/json';
 
-        if (requestParameters.header1 !== undefined && requestParameters.header1 !== null) {
-            headerParameters['header_1'] = String(requestParameters.header1);
+        if (runtime.exists(requestParameters, 'header1')) {
+            headerParameters['header_1'] = String(requestParameters['header1']);
         }
 
         const response = await this.request({
@@ -252,7 +255,7 @@ export class FakeApi extends runtime.BaseAPI {
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: PetToJSON(requestParameters.pet),
+            body: PetToJSON(requestParameters['pet']),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
@@ -280,7 +283,7 @@ export class FakeApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: requestParameters.body as any,
+            body: requestParameters['body'] as any,
         }, initOverrides);
 
         if (this.isJsonMime(response.headers.get('content-type'))) {
@@ -313,7 +316,7 @@ export class FakeApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: OuterCompositeToJSON(requestParameters.outerComposite),
+            body: OuterCompositeToJSON(requestParameters['outerComposite']),
         }, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => OuterCompositeFromJSON(jsonValue));
@@ -342,7 +345,7 @@ export class FakeApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: requestParameters.body as any,
+            body: requestParameters['body'] as any,
         }, initOverrides);
 
         if (this.isJsonMime(response.headers.get('content-type'))) {
@@ -375,7 +378,7 @@ export class FakeApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: requestParameters.body as any,
+            body: requestParameters['body'] as any,
         }, initOverrides);
 
         if (this.isJsonMime(response.headers.get('content-type'))) {
@@ -397,8 +400,11 @@ export class FakeApi extends runtime.BaseAPI {
      * Test serialization of enum (int) properties with examples
      */
     async fakePropertyEnumIntegerSerializeRaw(requestParameters: FakePropertyEnumIntegerSerializeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OuterObjectWithEnumProperty>> {
-        if (requestParameters.outerObjectWithEnumProperty === null || requestParameters.outerObjectWithEnumProperty === undefined) {
-            throw new runtime.RequiredError('outerObjectWithEnumProperty','Required parameter requestParameters.outerObjectWithEnumProperty was null or undefined when calling fakePropertyEnumIntegerSerialize.');
+        if (!runtime.exists(requestParameters, 'outerObjectWithEnumProperty')) {
+            throw new runtime.RequiredError(
+                'outerObjectWithEnumProperty',
+                'Required parameter "outerObjectWithEnumProperty" was null or undefined when calling fakePropertyEnumIntegerSerialize().'
+            );
         }
 
         const queryParameters: any = {};
@@ -412,7 +418,7 @@ export class FakeApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: OuterObjectWithEnumPropertyToJSON(requestParameters.outerObjectWithEnumProperty),
+            body: OuterObjectWithEnumPropertyToJSON(requestParameters['outerObjectWithEnumProperty']),
         }, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => OuterObjectWithEnumPropertyFromJSON(jsonValue));
@@ -431,8 +437,11 @@ export class FakeApi extends runtime.BaseAPI {
      * test referenced additionalProperties
      */
     async testAdditionalPropertiesReferenceRaw(requestParameters: TestAdditionalPropertiesReferenceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.requestBody === null || requestParameters.requestBody === undefined) {
-            throw new runtime.RequiredError('requestBody','Required parameter requestParameters.requestBody was null or undefined when calling testAdditionalPropertiesReference.');
+        if (!runtime.exists(requestParameters, 'requestBody')) {
+            throw new runtime.RequiredError(
+                'requestBody',
+                'Required parameter "requestBody" was null or undefined when calling testAdditionalPropertiesReference().'
+            );
         }
 
         const queryParameters: any = {};
@@ -446,7 +455,7 @@ export class FakeApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: requestParameters.requestBody,
+            body: requestParameters['requestBody'],
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
@@ -464,8 +473,11 @@ export class FakeApi extends runtime.BaseAPI {
      * For this test, the body has to be a binary file.
      */
     async testBodyWithBinaryRaw(requestParameters: TestBodyWithBinaryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.body === null || requestParameters.body === undefined) {
-            throw new runtime.RequiredError('body','Required parameter requestParameters.body was null or undefined when calling testBodyWithBinary.');
+        if (!runtime.exists(requestParameters, 'body')) {
+            throw new runtime.RequiredError(
+                'body',
+                'Required parameter "body" was null or undefined when calling testBodyWithBinary().'
+            );
         }
 
         const queryParameters: any = {};
@@ -479,7 +491,7 @@ export class FakeApi extends runtime.BaseAPI {
             method: 'PUT',
             headers: headerParameters,
             query: queryParameters,
-            body: requestParameters.body as any,
+            body: requestParameters['body'] as any,
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
@@ -496,8 +508,11 @@ export class FakeApi extends runtime.BaseAPI {
      * For this test, the body for this request must reference a schema named `File`.
      */
     async testBodyWithFileSchemaRaw(requestParameters: TestBodyWithFileSchemaRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.fileSchemaTestClass === null || requestParameters.fileSchemaTestClass === undefined) {
-            throw new runtime.RequiredError('fileSchemaTestClass','Required parameter requestParameters.fileSchemaTestClass was null or undefined when calling testBodyWithFileSchema.');
+        if (!runtime.exists(requestParameters, 'fileSchemaTestClass')) {
+            throw new runtime.RequiredError(
+                'fileSchemaTestClass',
+                'Required parameter "fileSchemaTestClass" was null or undefined when calling testBodyWithFileSchema().'
+            );
         }
 
         const queryParameters: any = {};
@@ -511,7 +526,7 @@ export class FakeApi extends runtime.BaseAPI {
             method: 'PUT',
             headers: headerParameters,
             query: queryParameters,
-            body: FileSchemaTestClassToJSON(requestParameters.fileSchemaTestClass),
+            body: FileSchemaTestClassToJSON(requestParameters['fileSchemaTestClass']),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
@@ -527,18 +542,24 @@ export class FakeApi extends runtime.BaseAPI {
     /**
      */
     async testBodyWithQueryParamsRaw(requestParameters: TestBodyWithQueryParamsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.query === null || requestParameters.query === undefined) {
-            throw new runtime.RequiredError('query','Required parameter requestParameters.query was null or undefined when calling testBodyWithQueryParams.');
+        if (!runtime.exists(requestParameters, 'query')) {
+            throw new runtime.RequiredError(
+                'query',
+                'Required parameter "query" was null or undefined when calling testBodyWithQueryParams().'
+            );
         }
 
-        if (requestParameters.user === null || requestParameters.user === undefined) {
-            throw new runtime.RequiredError('user','Required parameter requestParameters.user was null or undefined when calling testBodyWithQueryParams.');
+        if (!runtime.exists(requestParameters, 'user')) {
+            throw new runtime.RequiredError(
+                'user',
+                'Required parameter "user" was null or undefined when calling testBodyWithQueryParams().'
+            );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters.query !== undefined) {
-            queryParameters['query'] = requestParameters.query;
+        if (runtime.exists(requestParameters, 'query')) {
+            queryParameters['query'] = requestParameters['query'];
         }
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -550,7 +571,7 @@ export class FakeApi extends runtime.BaseAPI {
             method: 'PUT',
             headers: headerParameters,
             query: queryParameters,
-            body: UserToJSON(requestParameters.user),
+            body: UserToJSON(requestParameters['user']),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
@@ -567,8 +588,11 @@ export class FakeApi extends runtime.BaseAPI {
      * To test \"client\" model
      */
     async testClientModelRaw(requestParameters: TestClientModelRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Client>> {
-        if (requestParameters.client === null || requestParameters.client === undefined) {
-            throw new runtime.RequiredError('client','Required parameter requestParameters.client was null or undefined when calling testClientModel.');
+        if (!runtime.exists(requestParameters, 'client')) {
+            throw new runtime.RequiredError(
+                'client',
+                'Required parameter "client" was null or undefined when calling testClientModel().'
+            );
         }
 
         const queryParameters: any = {};
@@ -582,7 +606,7 @@ export class FakeApi extends runtime.BaseAPI {
             method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
-            body: ClientToJSON(requestParameters.client),
+            body: ClientToJSON(requestParameters['client']),
         }, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => ClientFromJSON(jsonValue));
@@ -602,20 +626,32 @@ export class FakeApi extends runtime.BaseAPI {
      * Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 
      */
     async testEndpointParametersRaw(requestParameters: TestEndpointParametersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.number === null || requestParameters.number === undefined) {
-            throw new runtime.RequiredError('number','Required parameter requestParameters.number was null or undefined when calling testEndpointParameters.');
+        if (!runtime.exists(requestParameters, 'number')) {
+            throw new runtime.RequiredError(
+                'number',
+                'Required parameter "number" was null or undefined when calling testEndpointParameters().'
+            );
         }
 
-        if (requestParameters._double === null || requestParameters._double === undefined) {
-            throw new runtime.RequiredError('_double','Required parameter requestParameters._double was null or undefined when calling testEndpointParameters.');
+        if (!runtime.exists(requestParameters, '_double')) {
+            throw new runtime.RequiredError(
+                '_double',
+                'Required parameter "_double" was null or undefined when calling testEndpointParameters().'
+            );
         }
 
-        if (requestParameters.patternWithoutDelimiter === null || requestParameters.patternWithoutDelimiter === undefined) {
-            throw new runtime.RequiredError('patternWithoutDelimiter','Required parameter requestParameters.patternWithoutDelimiter was null or undefined when calling testEndpointParameters.');
+        if (!runtime.exists(requestParameters, 'patternWithoutDelimiter')) {
+            throw new runtime.RequiredError(
+                'patternWithoutDelimiter',
+                'Required parameter "patternWithoutDelimiter" was null or undefined when calling testEndpointParameters().'
+            );
         }
 
-        if (requestParameters._byte === null || requestParameters._byte === undefined) {
-            throw new runtime.RequiredError('_byte','Required parameter requestParameters._byte was null or undefined when calling testEndpointParameters.');
+        if (!runtime.exists(requestParameters, '_byte')) {
+            throw new runtime.RequiredError(
+                '_byte',
+                'Required parameter "_byte" was null or undefined when calling testEndpointParameters().'
+            );
         }
 
         const queryParameters: any = {};
@@ -641,60 +677,60 @@ export class FakeApi extends runtime.BaseAPI {
             formParams = new URLSearchParams();
         }
 
-        if (requestParameters.integer !== undefined) {
-            formParams.append('integer', requestParameters.integer as any);
+        if (runtime.exists(requestParameters, 'integer')) {
+            formParams.append('integer', requestParameters['integer'] as any);
         }
 
-        if (requestParameters.int32 !== undefined) {
-            formParams.append('int32', requestParameters.int32 as any);
+        if (runtime.exists(requestParameters, 'int32')) {
+            formParams.append('int32', requestParameters['int32'] as any);
         }
 
-        if (requestParameters.int64 !== undefined) {
-            formParams.append('int64', requestParameters.int64 as any);
+        if (runtime.exists(requestParameters, 'int64')) {
+            formParams.append('int64', requestParameters['int64'] as any);
         }
 
-        if (requestParameters.number !== undefined) {
-            formParams.append('number', requestParameters.number as any);
+        if (runtime.exists(requestParameters, 'number')) {
+            formParams.append('number', requestParameters['number'] as any);
         }
 
-        if (requestParameters._float !== undefined) {
-            formParams.append('float', requestParameters._float as any);
+        if (runtime.exists(requestParameters, '_float')) {
+            formParams.append('float', requestParameters['_float'] as any);
         }
 
-        if (requestParameters._double !== undefined) {
-            formParams.append('double', requestParameters._double as any);
+        if (runtime.exists(requestParameters, '_double')) {
+            formParams.append('double', requestParameters['_double'] as any);
         }
 
-        if (requestParameters.string !== undefined) {
-            formParams.append('string', requestParameters.string as any);
+        if (runtime.exists(requestParameters, 'string')) {
+            formParams.append('string', requestParameters['string'] as any);
         }
 
-        if (requestParameters.patternWithoutDelimiter !== undefined) {
-            formParams.append('pattern_without_delimiter', requestParameters.patternWithoutDelimiter as any);
+        if (runtime.exists(requestParameters, 'patternWithoutDelimiter')) {
+            formParams.append('pattern_without_delimiter', requestParameters['patternWithoutDelimiter'] as any);
         }
 
-        if (requestParameters._byte !== undefined) {
-            formParams.append('byte', requestParameters._byte as any);
+        if (runtime.exists(requestParameters, '_byte')) {
+            formParams.append('byte', requestParameters['_byte'] as any);
         }
 
-        if (requestParameters.binary !== undefined) {
-            formParams.append('binary', requestParameters.binary as any);
+        if (runtime.exists(requestParameters, 'binary')) {
+            formParams.append('binary', requestParameters['binary'] as any);
         }
 
-        if (requestParameters.date !== undefined) {
-            formParams.append('date', requestParameters.date as any);
+        if (runtime.exists(requestParameters, 'date')) {
+            formParams.append('date', requestParameters['date'] as any);
         }
 
-        if (requestParameters.dateTime !== undefined) {
-            formParams.append('dateTime', requestParameters.dateTime as any);
+        if (runtime.exists(requestParameters, 'dateTime')) {
+            formParams.append('dateTime', requestParameters['dateTime'] as any);
         }
 
-        if (requestParameters.password !== undefined) {
-            formParams.append('password', requestParameters.password as any);
+        if (runtime.exists(requestParameters, 'password')) {
+            formParams.append('password', requestParameters['password'] as any);
         }
 
-        if (requestParameters.callback !== undefined) {
-            formParams.append('callback', requestParameters.callback as any);
+        if (runtime.exists(requestParameters, 'callback')) {
+            formParams.append('callback', requestParameters['callback'] as any);
         }
 
         const response = await this.request({
@@ -723,34 +759,34 @@ export class FakeApi extends runtime.BaseAPI {
     async testEnumParametersRaw(requestParameters: TestEnumParametersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
         const queryParameters: any = {};
 
-        if (requestParameters.enumQueryStringArray) {
-            queryParameters['enum_query_string_array'] = requestParameters.enumQueryStringArray;
+        if (runtime.exists(requestParameters, 'enumQueryStringArray')) {
+            queryParameters['enum_query_string_array'] = requestParameters['enumQueryStringArray'];
         }
 
-        if (requestParameters.enumQueryString !== undefined) {
-            queryParameters['enum_query_string'] = requestParameters.enumQueryString;
+        if (runtime.exists(requestParameters, 'enumQueryString')) {
+            queryParameters['enum_query_string'] = requestParameters['enumQueryString'];
         }
 
-        if (requestParameters.enumQueryInteger !== undefined) {
-            queryParameters['enum_query_integer'] = requestParameters.enumQueryInteger;
+        if (runtime.exists(requestParameters, 'enumQueryInteger')) {
+            queryParameters['enum_query_integer'] = requestParameters['enumQueryInteger'];
         }
 
-        if (requestParameters.enumQueryDouble !== undefined) {
-            queryParameters['enum_query_double'] = requestParameters.enumQueryDouble;
+        if (runtime.exists(requestParameters, 'enumQueryDouble')) {
+            queryParameters['enum_query_double'] = requestParameters['enumQueryDouble'];
         }
 
-        if (requestParameters.enumQueryModelArray) {
-            queryParameters['enum_query_model_array'] = requestParameters.enumQueryModelArray;
+        if (runtime.exists(requestParameters, 'enumQueryModelArray')) {
+            queryParameters['enum_query_model_array'] = requestParameters['enumQueryModelArray'];
         }
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        if (requestParameters.enumHeaderStringArray) {
-            headerParameters['enum_header_string_array'] = requestParameters.enumHeaderStringArray.join(runtime.COLLECTION_FORMATS["csv"]);
+        if (runtime.exists(requestParameters, 'enumHeaderStringArray')) {
+            headerParameters['enum_header_string_array'] = requestParameters['enumHeaderStringArray']!.join(runtime.COLLECTION_FORMATS["csv"]);
         }
 
-        if (requestParameters.enumHeaderString !== undefined && requestParameters.enumHeaderString !== null) {
-            headerParameters['enum_header_string'] = String(requestParameters.enumHeaderString);
+        if (runtime.exists(requestParameters, 'enumHeaderString')) {
+            headerParameters['enum_header_string'] = String(requestParameters['enumHeaderString']);
         }
 
         const consumes: runtime.Consume[] = [
@@ -767,12 +803,12 @@ export class FakeApi extends runtime.BaseAPI {
             formParams = new URLSearchParams();
         }
 
-        if (requestParameters.enumFormStringArray) {
-            formParams.append('enum_form_string_array', requestParameters.enumFormStringArray.join(runtime.COLLECTION_FORMATS["csv"]));
+        if (runtime.exists(requestParameters, 'enumFormStringArray')) {
+            formParams.append('enum_form_string_array', requestParameters['enumFormStringArray']!.join(runtime.COLLECTION_FORMATS["csv"]));
         }
 
-        if (requestParameters.enumFormString !== undefined) {
-            formParams.append('enum_form_string', requestParameters.enumFormString as any);
+        if (runtime.exists(requestParameters, 'enumFormString')) {
+            formParams.append('enum_form_string', requestParameters['enumFormString'] as any);
         }
 
         const response = await this.request({
@@ -799,44 +835,53 @@ export class FakeApi extends runtime.BaseAPI {
      * Fake endpoint to test group parameters (optional)
      */
     async testGroupParametersRaw(requestParameters: TestGroupParametersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.requiredStringGroup === null || requestParameters.requiredStringGroup === undefined) {
-            throw new runtime.RequiredError('requiredStringGroup','Required parameter requestParameters.requiredStringGroup was null or undefined when calling testGroupParameters.');
+        if (!runtime.exists(requestParameters, 'requiredStringGroup')) {
+            throw new runtime.RequiredError(
+                'requiredStringGroup',
+                'Required parameter "requiredStringGroup" was null or undefined when calling testGroupParameters().'
+            );
         }
 
-        if (requestParameters.requiredBooleanGroup === null || requestParameters.requiredBooleanGroup === undefined) {
-            throw new runtime.RequiredError('requiredBooleanGroup','Required parameter requestParameters.requiredBooleanGroup was null or undefined when calling testGroupParameters.');
+        if (!runtime.exists(requestParameters, 'requiredBooleanGroup')) {
+            throw new runtime.RequiredError(
+                'requiredBooleanGroup',
+                'Required parameter "requiredBooleanGroup" was null or undefined when calling testGroupParameters().'
+            );
         }
 
-        if (requestParameters.requiredInt64Group === null || requestParameters.requiredInt64Group === undefined) {
-            throw new runtime.RequiredError('requiredInt64Group','Required parameter requestParameters.requiredInt64Group was null or undefined when calling testGroupParameters.');
+        if (!runtime.exists(requestParameters, 'requiredInt64Group')) {
+            throw new runtime.RequiredError(
+                'requiredInt64Group',
+                'Required parameter "requiredInt64Group" was null or undefined when calling testGroupParameters().'
+            );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters.requiredStringGroup !== undefined) {
-            queryParameters['required_string_group'] = requestParameters.requiredStringGroup;
+        if (runtime.exists(requestParameters, 'requiredStringGroup')) {
+            queryParameters['required_string_group'] = requestParameters['requiredStringGroup'];
         }
 
-        if (requestParameters.requiredInt64Group !== undefined) {
-            queryParameters['required_int64_group'] = requestParameters.requiredInt64Group;
+        if (runtime.exists(requestParameters, 'requiredInt64Group')) {
+            queryParameters['required_int64_group'] = requestParameters['requiredInt64Group'];
         }
 
-        if (requestParameters.stringGroup !== undefined) {
-            queryParameters['string_group'] = requestParameters.stringGroup;
+        if (runtime.exists(requestParameters, 'stringGroup')) {
+            queryParameters['string_group'] = requestParameters['stringGroup'];
         }
 
-        if (requestParameters.int64Group !== undefined) {
-            queryParameters['int64_group'] = requestParameters.int64Group;
+        if (runtime.exists(requestParameters, 'int64Group')) {
+            queryParameters['int64_group'] = requestParameters['int64Group'];
         }
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        if (requestParameters.requiredBooleanGroup !== undefined && requestParameters.requiredBooleanGroup !== null) {
-            headerParameters['required_boolean_group'] = String(requestParameters.requiredBooleanGroup);
+        if (runtime.exists(requestParameters, 'requiredBooleanGroup')) {
+            headerParameters['required_boolean_group'] = String(requestParameters['requiredBooleanGroup']);
         }
 
-        if (requestParameters.booleanGroup !== undefined && requestParameters.booleanGroup !== null) {
-            headerParameters['boolean_group'] = String(requestParameters.booleanGroup);
+        if (runtime.exists(requestParameters, 'booleanGroup')) {
+            headerParameters['boolean_group'] = String(requestParameters['booleanGroup']);
         }
 
         if (this.configuration && this.configuration.accessToken) {
@@ -870,8 +915,11 @@ export class FakeApi extends runtime.BaseAPI {
      * test inline additionalProperties
      */
     async testInlineAdditionalPropertiesRaw(requestParameters: TestInlineAdditionalPropertiesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.requestBody === null || requestParameters.requestBody === undefined) {
-            throw new runtime.RequiredError('requestBody','Required parameter requestParameters.requestBody was null or undefined when calling testInlineAdditionalProperties.');
+        if (!runtime.exists(requestParameters, 'requestBody')) {
+            throw new runtime.RequiredError(
+                'requestBody',
+                'Required parameter "requestBody" was null or undefined when calling testInlineAdditionalProperties().'
+            );
         }
 
         const queryParameters: any = {};
@@ -885,7 +933,7 @@ export class FakeApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: requestParameters.requestBody,
+            body: requestParameters['requestBody'],
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
@@ -904,8 +952,11 @@ export class FakeApi extends runtime.BaseAPI {
      * test inline free-form additionalProperties
      */
     async testInlineFreeformAdditionalPropertiesRaw(requestParameters: TestInlineFreeformAdditionalPropertiesOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.testInlineFreeformAdditionalPropertiesRequest === null || requestParameters.testInlineFreeformAdditionalPropertiesRequest === undefined) {
-            throw new runtime.RequiredError('testInlineFreeformAdditionalPropertiesRequest','Required parameter requestParameters.testInlineFreeformAdditionalPropertiesRequest was null or undefined when calling testInlineFreeformAdditionalProperties.');
+        if (!runtime.exists(requestParameters, 'testInlineFreeformAdditionalPropertiesRequest')) {
+            throw new runtime.RequiredError(
+                'testInlineFreeformAdditionalPropertiesRequest',
+                'Required parameter "testInlineFreeformAdditionalPropertiesRequest" was null or undefined when calling testInlineFreeformAdditionalProperties().'
+            );
         }
 
         const queryParameters: any = {};
@@ -919,7 +970,7 @@ export class FakeApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: TestInlineFreeformAdditionalPropertiesRequestToJSON(requestParameters.testInlineFreeformAdditionalPropertiesRequest),
+            body: TestInlineFreeformAdditionalPropertiesRequestToJSON(requestParameters['testInlineFreeformAdditionalPropertiesRequest']),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
@@ -938,12 +989,18 @@ export class FakeApi extends runtime.BaseAPI {
      * test json serialization of form data
      */
     async testJsonFormDataRaw(requestParameters: TestJsonFormDataRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.param === null || requestParameters.param === undefined) {
-            throw new runtime.RequiredError('param','Required parameter requestParameters.param was null or undefined when calling testJsonFormData.');
+        if (!runtime.exists(requestParameters, 'param')) {
+            throw new runtime.RequiredError(
+                'param',
+                'Required parameter "param" was null or undefined when calling testJsonFormData().'
+            );
         }
 
-        if (requestParameters.param2 === null || requestParameters.param2 === undefined) {
-            throw new runtime.RequiredError('param2','Required parameter requestParameters.param2 was null or undefined when calling testJsonFormData.');
+        if (!runtime.exists(requestParameters, 'param2')) {
+            throw new runtime.RequiredError(
+                'param2',
+                'Required parameter "param2" was null or undefined when calling testJsonFormData().'
+            );
         }
 
         const queryParameters: any = {};
@@ -964,12 +1021,12 @@ export class FakeApi extends runtime.BaseAPI {
             formParams = new URLSearchParams();
         }
 
-        if (requestParameters.param !== undefined) {
-            formParams.append('param', requestParameters.param as any);
+        if (runtime.exists(requestParameters, 'param')) {
+            formParams.append('param', requestParameters['param'] as any);
         }
 
-        if (requestParameters.param2 !== undefined) {
-            formParams.append('param2', requestParameters.param2 as any);
+        if (runtime.exists(requestParameters, 'param2')) {
+            formParams.append('param2', requestParameters['param2'] as any);
         }
 
         const response = await this.request({
@@ -996,8 +1053,11 @@ export class FakeApi extends runtime.BaseAPI {
      * test nullable parent property
      */
     async testNullableRaw(requestParameters: TestNullableRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.childWithNullable === null || requestParameters.childWithNullable === undefined) {
-            throw new runtime.RequiredError('childWithNullable','Required parameter requestParameters.childWithNullable was null or undefined when calling testNullable.');
+        if (!runtime.exists(requestParameters, 'childWithNullable')) {
+            throw new runtime.RequiredError(
+                'childWithNullable',
+                'Required parameter "childWithNullable" was null or undefined when calling testNullable().'
+            );
         }
 
         const queryParameters: any = {};
@@ -1011,7 +1071,7 @@ export class FakeApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: ChildWithNullableToJSON(requestParameters.childWithNullable),
+            body: ChildWithNullableToJSON(requestParameters['childWithNullable']),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
@@ -1029,58 +1089,76 @@ export class FakeApi extends runtime.BaseAPI {
      * To test the collection format in query parameters
      */
     async testQueryParameterCollectionFormatRaw(requestParameters: TestQueryParameterCollectionFormatRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.pipe === null || requestParameters.pipe === undefined) {
-            throw new runtime.RequiredError('pipe','Required parameter requestParameters.pipe was null or undefined when calling testQueryParameterCollectionFormat.');
+        if (!runtime.exists(requestParameters, 'pipe')) {
+            throw new runtime.RequiredError(
+                'pipe',
+                'Required parameter "pipe" was null or undefined when calling testQueryParameterCollectionFormat().'
+            );
         }
 
-        if (requestParameters.ioutil === null || requestParameters.ioutil === undefined) {
-            throw new runtime.RequiredError('ioutil','Required parameter requestParameters.ioutil was null or undefined when calling testQueryParameterCollectionFormat.');
+        if (!runtime.exists(requestParameters, 'ioutil')) {
+            throw new runtime.RequiredError(
+                'ioutil',
+                'Required parameter "ioutil" was null or undefined when calling testQueryParameterCollectionFormat().'
+            );
         }
 
-        if (requestParameters.http === null || requestParameters.http === undefined) {
-            throw new runtime.RequiredError('http','Required parameter requestParameters.http was null or undefined when calling testQueryParameterCollectionFormat.');
+        if (!runtime.exists(requestParameters, 'http')) {
+            throw new runtime.RequiredError(
+                'http',
+                'Required parameter "http" was null or undefined when calling testQueryParameterCollectionFormat().'
+            );
         }
 
-        if (requestParameters.url === null || requestParameters.url === undefined) {
-            throw new runtime.RequiredError('url','Required parameter requestParameters.url was null or undefined when calling testQueryParameterCollectionFormat.');
+        if (!runtime.exists(requestParameters, 'url')) {
+            throw new runtime.RequiredError(
+                'url',
+                'Required parameter "url" was null or undefined when calling testQueryParameterCollectionFormat().'
+            );
         }
 
-        if (requestParameters.context === null || requestParameters.context === undefined) {
-            throw new runtime.RequiredError('context','Required parameter requestParameters.context was null or undefined when calling testQueryParameterCollectionFormat.');
+        if (!runtime.exists(requestParameters, 'context')) {
+            throw new runtime.RequiredError(
+                'context',
+                'Required parameter "context" was null or undefined when calling testQueryParameterCollectionFormat().'
+            );
         }
 
-        if (requestParameters.allowEmpty === null || requestParameters.allowEmpty === undefined) {
-            throw new runtime.RequiredError('allowEmpty','Required parameter requestParameters.allowEmpty was null or undefined when calling testQueryParameterCollectionFormat.');
+        if (!runtime.exists(requestParameters, 'allowEmpty')) {
+            throw new runtime.RequiredError(
+                'allowEmpty',
+                'Required parameter "allowEmpty" was null or undefined when calling testQueryParameterCollectionFormat().'
+            );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters.pipe) {
-            queryParameters['pipe'] = requestParameters.pipe.join(runtime.COLLECTION_FORMATS["pipes"]);
+        if (runtime.exists(requestParameters, 'pipe')) {
+            queryParameters['pipe'] = requestParameters['pipe']!.join(runtime.COLLECTION_FORMATS["pipes"]);
         }
 
-        if (requestParameters.ioutil) {
-            queryParameters['ioutil'] = requestParameters.ioutil.join(runtime.COLLECTION_FORMATS["csv"]);
+        if (runtime.exists(requestParameters, 'ioutil')) {
+            queryParameters['ioutil'] = requestParameters['ioutil']!.join(runtime.COLLECTION_FORMATS["csv"]);
         }
 
-        if (requestParameters.http) {
-            queryParameters['http'] = requestParameters.http.join(runtime.COLLECTION_FORMATS["ssv"]);
+        if (runtime.exists(requestParameters, 'http')) {
+            queryParameters['http'] = requestParameters['http']!.join(runtime.COLLECTION_FORMATS["ssv"]);
         }
 
-        if (requestParameters.url) {
-            queryParameters['url'] = requestParameters.url.join(runtime.COLLECTION_FORMATS["csv"]);
+        if (runtime.exists(requestParameters, 'url')) {
+            queryParameters['url'] = requestParameters['url']!.join(runtime.COLLECTION_FORMATS["csv"]);
         }
 
-        if (requestParameters.context) {
-            queryParameters['context'] = requestParameters.context;
+        if (runtime.exists(requestParameters, 'context')) {
+            queryParameters['context'] = requestParameters['context'];
         }
 
-        if (requestParameters.language !== undefined) {
-            queryParameters['language'] = requestParameters.language;
+        if (runtime.exists(requestParameters, 'language')) {
+            queryParameters['language'] = requestParameters['language'];
         }
 
-        if (requestParameters.allowEmpty !== undefined) {
-            queryParameters['allowEmpty'] = requestParameters.allowEmpty;
+        if (runtime.exists(requestParameters, 'allowEmpty')) {
+            queryParameters['allowEmpty'] = requestParameters['allowEmpty'];
         }
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -1107,8 +1185,11 @@ export class FakeApi extends runtime.BaseAPI {
      * test referenced string map
      */
     async testStringMapReferenceRaw(requestParameters: TestStringMapReferenceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.requestBody === null || requestParameters.requestBody === undefined) {
-            throw new runtime.RequiredError('requestBody','Required parameter requestParameters.requestBody was null or undefined when calling testStringMapReference.');
+        if (!runtime.exists(requestParameters, 'requestBody')) {
+            throw new runtime.RequiredError(
+                'requestBody',
+                'Required parameter "requestBody" was null or undefined when calling testStringMapReference().'
+            );
         }
 
         const queryParameters: any = {};
@@ -1122,7 +1203,7 @@ export class FakeApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: requestParameters.requestBody,
+            body: requestParameters['requestBody'],
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);

samples/client/petstore/typescript-fetch/builds/default-v3.0/apis/FakeClassnameTags123Api.ts

@@ -36,8 +36,11 @@ export class FakeClassnameTags123Api extends runtime.BaseAPI {
      * To test class name in snake case
      */
     async testClassnameRaw(requestParameters: TestClassnameRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Client>> {
-        if (requestParameters.client === null || requestParameters.client === undefined) {
-            throw new runtime.RequiredError('client','Required parameter requestParameters.client was null or undefined when calling testClassname.');
+        if (!runtime.exists(requestParameters, 'client')) {
+            throw new runtime.RequiredError(
+                'client',
+                'Required parameter "client" was null or undefined when calling testClassname().'
+            );
         }
 
         const queryParameters: any = {};
@@ -55,7 +58,7 @@ export class FakeClassnameTags123Api extends runtime.BaseAPI {
             method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
-            body: ClientToJSON(requestParameters.client),
+            body: ClientToJSON(requestParameters['client']),
         }, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => ClientFromJSON(jsonValue));

samples/client/petstore/typescript-fetch/builds/default-v3.0/apis/PetApi.ts

@@ -78,8 +78,11 @@ export class PetApi extends runtime.BaseAPI {
      * Add a new pet to the store
      */
     async addPetRaw(requestParameters: AddPetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.pet === null || requestParameters.pet === undefined) {
-            throw new runtime.RequiredError('pet','Required parameter requestParameters.pet was null or undefined when calling addPet.');
+        if (!runtime.exists(requestParameters, 'pet')) {
+            throw new runtime.RequiredError(
+                'pet',
+                'Required parameter "pet" was null or undefined when calling addPet().'
+            );
         }
 
         const queryParameters: any = {};
@@ -98,7 +101,7 @@ export class PetApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: PetToJSON(requestParameters.pet),
+            body: PetToJSON(requestParameters['pet']),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
@@ -117,16 +120,19 @@ export class PetApi extends runtime.BaseAPI {
      * Deletes a pet
      */
     async deletePetRaw(requestParameters: DeletePetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.petId === null || requestParameters.petId === undefined) {
-            throw new runtime.RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling deletePet.');
+        if (!runtime.exists(requestParameters, 'petId')) {
+            throw new runtime.RequiredError(
+                'petId',
+                'Required parameter "petId" was null or undefined when calling deletePet().'
+            );
         }
 
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        if (requestParameters.apiKey !== undefined && requestParameters.apiKey !== null) {
-            headerParameters['api_key'] = String(requestParameters.apiKey);
+        if (runtime.exists(requestParameters, 'apiKey')) {
+            headerParameters['api_key'] = String(requestParameters['apiKey']);
         }
 
         if (this.configuration && this.configuration.accessToken) {
@@ -135,7 +141,7 @@ export class PetApi extends runtime.BaseAPI {
         }
 
         const response = await this.request({
-            path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
+            path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters['petId']))),
             method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
@@ -157,14 +163,17 @@ export class PetApi extends runtime.BaseAPI {
      * Finds Pets by status
      */
     async findPetsByStatusRaw(requestParameters: FindPetsByStatusRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<Pet>>> {
-        if (requestParameters.status === null || requestParameters.status === undefined) {
-            throw new runtime.RequiredError('status','Required parameter requestParameters.status was null or undefined when calling findPetsByStatus.');
+        if (!runtime.exists(requestParameters, 'status')) {
+            throw new runtime.RequiredError(
+                'status',
+                'Required parameter "status" was null or undefined when calling findPetsByStatus().'
+            );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters.status) {
-            queryParameters['status'] = requestParameters.status.join(runtime.COLLECTION_FORMATS["csv"]);
+        if (runtime.exists(requestParameters, 'status')) {
+            queryParameters['status'] = requestParameters['status']!.join(runtime.COLLECTION_FORMATS["csv"]);
         }
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -199,14 +208,17 @@ export class PetApi extends runtime.BaseAPI {
      * @deprecated
      */
     async findPetsByTagsRaw(requestParameters: FindPetsByTagsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Set<Pet>>> {
-        if (requestParameters.tags === null || requestParameters.tags === undefined) {
-            throw new runtime.RequiredError('tags','Required parameter requestParameters.tags was null or undefined when calling findPetsByTags.');
+        if (!runtime.exists(requestParameters, 'tags')) {
+            throw new runtime.RequiredError(
+                'tags',
+                'Required parameter "tags" was null or undefined when calling findPetsByTags().'
+            );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters.tags) {
-            queryParameters['tags'] = Array.from(requestParameters.tags).join(runtime.COLLECTION_FORMATS["csv"]);
+        if (runtime.exists(requestParameters, 'tags')) {
+            queryParameters['tags'] = Array.from(requestParameters['tags'])!.join(runtime.COLLECTION_FORMATS["csv"]);
         }
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -241,8 +253,11 @@ export class PetApi extends runtime.BaseAPI {
      * Find pet by ID
      */
     async getPetByIdRaw(requestParameters: GetPetByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Pet>> {
-        if (requestParameters.petId === null || requestParameters.petId === undefined) {
-            throw new runtime.RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling getPetById.');
+        if (!runtime.exists(requestParameters, 'petId')) {
+            throw new runtime.RequiredError(
+                'petId',
+                'Required parameter "petId" was null or undefined when calling getPetById().'
+            );
         }
 
         const queryParameters: any = {};
@@ -254,7 +269,7 @@ export class PetApi extends runtime.BaseAPI {
         }
 
         const response = await this.request({
-            path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
+            path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters['petId']))),
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
@@ -277,8 +292,11 @@ export class PetApi extends runtime.BaseAPI {
      * Update an existing pet
      */
     async updatePetRaw(requestParameters: UpdatePetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.pet === null || requestParameters.pet === undefined) {
-            throw new runtime.RequiredError('pet','Required parameter requestParameters.pet was null or undefined when calling updatePet.');
+        if (!runtime.exists(requestParameters, 'pet')) {
+            throw new runtime.RequiredError(
+                'pet',
+                'Required parameter "pet" was null or undefined when calling updatePet().'
+            );
         }
 
         const queryParameters: any = {};
@@ -297,7 +315,7 @@ export class PetApi extends runtime.BaseAPI {
             method: 'PUT',
             headers: headerParameters,
             query: queryParameters,
-            body: PetToJSON(requestParameters.pet),
+            body: PetToJSON(requestParameters['pet']),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
@@ -316,8 +334,11 @@ export class PetApi extends runtime.BaseAPI {
      * Updates a pet in the store with form data
      */
     async updatePetWithFormRaw(requestParameters: UpdatePetWithFormRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.petId === null || requestParameters.petId === undefined) {
-            throw new runtime.RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling updatePetWithForm.');
+        if (!runtime.exists(requestParameters, 'petId')) {
+            throw new runtime.RequiredError(
+                'petId',
+                'Required parameter "petId" was null or undefined when calling updatePetWithForm().'
+            );
         }
 
         const queryParameters: any = {};
@@ -343,16 +364,16 @@ export class PetApi extends runtime.BaseAPI {
             formParams = new URLSearchParams();
         }
 
-        if (requestParameters.name !== undefined) {
-            formParams.append('name', requestParameters.name as any);
+        if (runtime.exists(requestParameters, 'name')) {
+            formParams.append('name', requestParameters['name'] as any);
         }
 
-        if (requestParameters.status !== undefined) {
-            formParams.append('status', requestParameters.status as any);
+        if (runtime.exists(requestParameters, 'status')) {
+            formParams.append('status', requestParameters['status'] as any);
         }
 
         const response = await this.request({
-            path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
+            path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters['petId']))),
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
@@ -375,8 +396,11 @@ export class PetApi extends runtime.BaseAPI {
      * uploads an image
      */
     async uploadFileRaw(requestParameters: UploadFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ModelApiResponse>> {
-        if (requestParameters.petId === null || requestParameters.petId === undefined) {
-            throw new runtime.RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling uploadFile.');
+        if (!runtime.exists(requestParameters, 'petId')) {
+            throw new runtime.RequiredError(
+                'petId',
+                'Required parameter "petId" was null or undefined when calling uploadFile().'
+            );
         }
 
         const queryParameters: any = {};
@@ -404,16 +428,16 @@ export class PetApi extends runtime.BaseAPI {
             formParams = new URLSearchParams();
         }
 
-        if (requestParameters.additionalMetadata !== undefined) {
-            formParams.append('additionalMetadata', requestParameters.additionalMetadata as any);
+        if (runtime.exists(requestParameters, 'additionalMetadata')) {
+            formParams.append('additionalMetadata', requestParameters['additionalMetadata'] as any);
         }
 
-        if (requestParameters.file !== undefined) {
-            formParams.append('file', requestParameters.file as any);
+        if (runtime.exists(requestParameters, 'file')) {
+            formParams.append('file', requestParameters['file'] as any);
         }
 
         const response = await this.request({
-            path: `/pet/{petId}/uploadImage`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
+            path: `/pet/{petId}/uploadImage`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters['petId']))),
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
@@ -437,12 +461,18 @@ export class PetApi extends runtime.BaseAPI {
      * uploads an image (required)
      */
     async uploadFileWithRequiredFileRaw(requestParameters: UploadFileWithRequiredFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ModelApiResponse>> {
-        if (requestParameters.petId === null || requestParameters.petId === undefined) {
-            throw new runtime.RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling uploadFileWithRequiredFile.');
+        if (!runtime.exists(requestParameters, 'petId')) {
+            throw new runtime.RequiredError(
+                'petId',
+                'Required parameter "petId" was null or undefined when calling uploadFileWithRequiredFile().'
+            );
         }
 
-        if (requestParameters.requiredFile === null || requestParameters.requiredFile === undefined) {
-            throw new runtime.RequiredError('requiredFile','Required parameter requestParameters.requiredFile was null or undefined when calling uploadFileWithRequiredFile.');
+        if (!runtime.exists(requestParameters, 'requiredFile')) {
+            throw new runtime.RequiredError(
+                'requiredFile',
+                'Required parameter "requiredFile" was null or undefined when calling uploadFileWithRequiredFile().'
+            );
         }
 
         const queryParameters: any = {};
@@ -470,16 +500,16 @@ export class PetApi extends runtime.BaseAPI {
             formParams = new URLSearchParams();
         }
 
-        if (requestParameters.additionalMetadata !== undefined) {
-            formParams.append('additionalMetadata', requestParameters.additionalMetadata as any);
+        if (runtime.exists(requestParameters, 'additionalMetadata')) {
+            formParams.append('additionalMetadata', requestParameters['additionalMetadata'] as any);
         }
 
-        if (requestParameters.requiredFile !== undefined) {
-            formParams.append('requiredFile', requestParameters.requiredFile as any);
+        if (runtime.exists(requestParameters, 'requiredFile')) {
+            formParams.append('requiredFile', requestParameters['requiredFile'] as any);
         }
 
         const response = await this.request({
-            path: `/fake/{petId}/uploadImageWithRequiredFile`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
+            path: `/fake/{petId}/uploadImageWithRequiredFile`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters['petId']))),
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,

samples/client/petstore/typescript-fetch/builds/default-v3.0/apis/StoreApi.ts

@@ -44,8 +44,11 @@ export class StoreApi extends runtime.BaseAPI {
      * Delete purchase order by ID
      */
     async deleteOrderRaw(requestParameters: DeleteOrderRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.orderId === null || requestParameters.orderId === undefined) {
-            throw new runtime.RequiredError('orderId','Required parameter requestParameters.orderId was null or undefined when calling deleteOrder.');
+        if (!runtime.exists(requestParameters, 'orderId')) {
+            throw new runtime.RequiredError(
+                'orderId',
+                'Required parameter "orderId" was null or undefined when calling deleteOrder().'
+            );
         }
 
         const queryParameters: any = {};
@@ -53,7 +56,7 @@ export class StoreApi extends runtime.BaseAPI {
         const headerParameters: runtime.HTTPHeaders = {};
 
         const response = await this.request({
-            path: `/store/order/{order_id}`.replace(`{${"order_id"}}`, encodeURIComponent(String(requestParameters.orderId))),
+            path: `/store/order/{order_id}`.replace(`{${"order_id"}}`, encodeURIComponent(String(requestParameters['orderId']))),
             method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
@@ -107,8 +110,11 @@ export class StoreApi extends runtime.BaseAPI {
      * Find purchase order by ID
      */
     async getOrderByIdRaw(requestParameters: GetOrderByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Order>> {
-        if (requestParameters.orderId === null || requestParameters.orderId === undefined) {
-            throw new runtime.RequiredError('orderId','Required parameter requestParameters.orderId was null or undefined when calling getOrderById.');
+        if (!runtime.exists(requestParameters, 'orderId')) {
+            throw new runtime.RequiredError(
+                'orderId',
+                'Required parameter "orderId" was null or undefined when calling getOrderById().'
+            );
         }
 
         const queryParameters: any = {};
@@ -116,7 +122,7 @@ export class StoreApi extends runtime.BaseAPI {
         const headerParameters: runtime.HTTPHeaders = {};
 
         const response = await this.request({
-            path: `/store/order/{order_id}`.replace(`{${"order_id"}}`, encodeURIComponent(String(requestParameters.orderId))),
+            path: `/store/order/{order_id}`.replace(`{${"order_id"}}`, encodeURIComponent(String(requestParameters['orderId']))),
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
@@ -139,8 +145,11 @@ export class StoreApi extends runtime.BaseAPI {
      * Place an order for a pet
      */
     async placeOrderRaw(requestParameters: PlaceOrderRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Order>> {
-        if (requestParameters.order === null || requestParameters.order === undefined) {
-            throw new runtime.RequiredError('order','Required parameter requestParameters.order was null or undefined when calling placeOrder.');
+        if (!runtime.exists(requestParameters, 'order')) {
+            throw new runtime.RequiredError(
+                'order',
+                'Required parameter "order" was null or undefined when calling placeOrder().'
+            );
         }
 
         const queryParameters: any = {};
@@ -154,7 +163,7 @@ export class StoreApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: OrderToJSON(requestParameters.order),
+            body: OrderToJSON(requestParameters['order']),
         }, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => OrderFromJSON(jsonValue));

samples/client/petstore/typescript-fetch/builds/default-v3.0/apis/UserApi.ts

@@ -62,8 +62,11 @@ export class UserApi extends runtime.BaseAPI {
      * Create user
      */
     async createUserRaw(requestParameters: CreateUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.user === null || requestParameters.user === undefined) {
-            throw new runtime.RequiredError('user','Required parameter requestParameters.user was null or undefined when calling createUser.');
+        if (!runtime.exists(requestParameters, 'user')) {
+            throw new runtime.RequiredError(
+                'user',
+                'Required parameter "user" was null or undefined when calling createUser().'
+            );
         }
 
         const queryParameters: any = {};
@@ -77,7 +80,7 @@ export class UserApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: UserToJSON(requestParameters.user),
+            body: UserToJSON(requestParameters['user']),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
@@ -96,8 +99,11 @@ export class UserApi extends runtime.BaseAPI {
      * Creates list of users with given input array
      */
     async createUsersWithArrayInputRaw(requestParameters: CreateUsersWithArrayInputRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.user === null || requestParameters.user === undefined) {
-            throw new runtime.RequiredError('user','Required parameter requestParameters.user was null or undefined when calling createUsersWithArrayInput.');
+        if (!runtime.exists(requestParameters, 'user')) {
+            throw new runtime.RequiredError(
+                'user',
+                'Required parameter "user" was null or undefined when calling createUsersWithArrayInput().'
+            );
         }
 
         const queryParameters: any = {};
@@ -111,7 +117,7 @@ export class UserApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: requestParameters.user.map(UserToJSON),
+            body: requestParameters['user']!.map(UserToJSON),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
@@ -130,8 +136,11 @@ export class UserApi extends runtime.BaseAPI {
      * Creates list of users with given input array
      */
     async createUsersWithListInputRaw(requestParameters: CreateUsersWithListInputRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.user === null || requestParameters.user === undefined) {
-            throw new runtime.RequiredError('user','Required parameter requestParameters.user was null or undefined when calling createUsersWithListInput.');
+        if (!runtime.exists(requestParameters, 'user')) {
+            throw new runtime.RequiredError(
+                'user',
+                'Required parameter "user" was null or undefined when calling createUsersWithListInput().'
+            );
         }
 
         const queryParameters: any = {};
@@ -145,7 +154,7 @@ export class UserApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: requestParameters.user.map(UserToJSON),
+            body: requestParameters['user']!.map(UserToJSON),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
@@ -164,8 +173,11 @@ export class UserApi extends runtime.BaseAPI {
      * Delete user
      */
     async deleteUserRaw(requestParameters: DeleteUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.username === null || requestParameters.username === undefined) {
-            throw new runtime.RequiredError('username','Required parameter requestParameters.username was null or undefined when calling deleteUser.');
+        if (!runtime.exists(requestParameters, 'username')) {
+            throw new runtime.RequiredError(
+                'username',
+                'Required parameter "username" was null or undefined when calling deleteUser().'
+            );
         }
 
         const queryParameters: any = {};
@@ -173,7 +185,7 @@ export class UserApi extends runtime.BaseAPI {
         const headerParameters: runtime.HTTPHeaders = {};
 
         const response = await this.request({
-            path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters.username))),
+            path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters['username']))),
             method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
@@ -195,8 +207,11 @@ export class UserApi extends runtime.BaseAPI {
      * Get user by user name
      */
     async getUserByNameRaw(requestParameters: GetUserByNameRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<User>> {
-        if (requestParameters.username === null || requestParameters.username === undefined) {
-            throw new runtime.RequiredError('username','Required parameter requestParameters.username was null or undefined when calling getUserByName.');
+        if (!runtime.exists(requestParameters, 'username')) {
+            throw new runtime.RequiredError(
+                'username',
+                'Required parameter "username" was null or undefined when calling getUserByName().'
+            );
         }
 
         const queryParameters: any = {};
@@ -204,7 +219,7 @@ export class UserApi extends runtime.BaseAPI {
         const headerParameters: runtime.HTTPHeaders = {};
 
         const response = await this.request({
-            path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters.username))),
+            path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters['username']))),
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
@@ -227,22 +242,28 @@ export class UserApi extends runtime.BaseAPI {
      * Logs user into the system
      */
     async loginUserRaw(requestParameters: LoginUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<string>> {
-        if (requestParameters.username === null || requestParameters.username === undefined) {
-            throw new runtime.RequiredError('username','Required parameter requestParameters.username was null or undefined when calling loginUser.');
+        if (!runtime.exists(requestParameters, 'username')) {
+            throw new runtime.RequiredError(
+                'username',
+                'Required parameter "username" was null or undefined when calling loginUser().'
+            );
         }
 
-        if (requestParameters.password === null || requestParameters.password === undefined) {
-            throw new runtime.RequiredError('password','Required parameter requestParameters.password was null or undefined when calling loginUser.');
+        if (!runtime.exists(requestParameters, 'password')) {
+            throw new runtime.RequiredError(
+                'password',
+                'Required parameter "password" was null or undefined when calling loginUser().'
+            );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters.username !== undefined) {
-            queryParameters['username'] = requestParameters.username;
+        if (runtime.exists(requestParameters, 'username')) {
+            queryParameters['username'] = requestParameters['username'];
         }
 
-        if (requestParameters.password !== undefined) {
-            queryParameters['password'] = requestParameters.password;
+        if (runtime.exists(requestParameters, 'password')) {
+            queryParameters['password'] = requestParameters['password'];
         }
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -302,12 +323,18 @@ export class UserApi extends runtime.BaseAPI {
      * Updated user
      */
     async updateUserRaw(requestParameters: UpdateUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.username === null || requestParameters.username === undefined) {
-            throw new runtime.RequiredError('username','Required parameter requestParameters.username was null or undefined when calling updateUser.');
+        if (!runtime.exists(requestParameters, 'username')) {
+            throw new runtime.RequiredError(
+                'username',
+                'Required parameter "username" was null or undefined when calling updateUser().'
+            );
         }
 
-        if (requestParameters.user === null || requestParameters.user === undefined) {
-            throw new runtime.RequiredError('user','Required parameter requestParameters.user was null or undefined when calling updateUser.');
+        if (!runtime.exists(requestParameters, 'user')) {
+            throw new runtime.RequiredError(
+                'user',
+                'Required parameter "user" was null or undefined when calling updateUser().'
+            );
         }
 
         const queryParameters: any = {};
@@ -317,11 +344,11 @@ export class UserApi extends runtime.BaseAPI {
         headerParameters['Content-Type'] = 'application/json';
 
         const response = await this.request({
-            path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters.username))),
+            path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters['username']))),
             method: 'PUT',
             headers: headerParameters,
             query: queryParameters,
-            body: UserToJSON(requestParameters.user),
+            body: UserToJSON(requestParameters['user']),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);

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

@@ -37,9 +37,7 @@ export interface AdditionalPropertiesClass {
  * Check if a given object implements the AdditionalPropertiesClass interface.
  */
 export function instanceOfAdditionalPropertiesClass(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function AdditionalPropertiesClassFromJSON(json: any): AdditionalPropertiesClass {
@@ -47,7 +45,7 @@ export function AdditionalPropertiesClassFromJSON(json: any): AdditionalProperti
 }
 
 export function AdditionalPropertiesClassFromJSONTyped(json: any, ignoreDiscriminator: boolean): AdditionalPropertiesClass {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -66,8 +64,8 @@ export function AdditionalPropertiesClassToJSON(value?: AdditionalPropertiesClas
     }
     return {
         
-        'map_property': value.mapProperty,
-        'map_of_map_property': value.mapOfMapProperty,
+        'map_property': value['mapProperty'],
+        'map_of_map_property': value['mapOfMapProperty'],
     };
 }
 

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

@@ -44,9 +44,7 @@ export interface AllOfWithSingleRef {
  * Check if a given object implements the AllOfWithSingleRef interface.
  */
 export function instanceOfAllOfWithSingleRef(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function AllOfWithSingleRefFromJSON(json: any): AllOfWithSingleRef {
@@ -54,7 +52,7 @@ export function AllOfWithSingleRefFromJSON(json: any): AllOfWithSingleRef {
 }
 
 export function AllOfWithSingleRefFromJSONTyped(json: any, ignoreDiscriminator: boolean): AllOfWithSingleRef {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -73,8 +71,8 @@ export function AllOfWithSingleRefToJSON(value?: AllOfWithSingleRef | null): any
     }
     return {
         
-        'username': value.username,
-        'SingleRefType': SingleRefTypeToJSON(value.singleRefType),
+        'username': value['username'],
+        'SingleRefType': SingleRefTypeToJSON(value['singleRefType']),
     };
 }
 

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

@@ -42,10 +42,8 @@ export interface Animal {
  * Check if a given object implements the Animal interface.
  */
 export function instanceOfAnimal(value: object): boolean {
-    let isInstance = true;
-    isInstance = isInstance && "className" in value;
-
-    return isInstance;
+    if (!('className' in value)) return false;
+    return true;
 }
 
 export function AnimalFromJSON(json: any): Animal {
@@ -53,7 +51,7 @@ export function AnimalFromJSON(json: any): Animal {
 }
 
 export function AnimalFromJSONTyped(json: any, ignoreDiscriminator: boolean): Animal {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     if (!ignoreDiscriminator) {
@@ -80,8 +78,8 @@ export function AnimalToJSON(value?: Animal | null): any {
     }
     return {
         
-        'className': value.className,
-        'color': value.color,
+        'className': value['className'],
+        'color': value['color'],
     };
 }
 

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

@@ -31,9 +31,7 @@ export interface ArrayOfArrayOfNumberOnly {
  * Check if a given object implements the ArrayOfArrayOfNumberOnly interface.
  */
 export function instanceOfArrayOfArrayOfNumberOnly(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function ArrayOfArrayOfNumberOnlyFromJSON(json: any): ArrayOfArrayOfNumberOnly {
@@ -41,7 +39,7 @@ export function ArrayOfArrayOfNumberOnlyFromJSON(json: any): ArrayOfArrayOfNumbe
 }
 
 export function ArrayOfArrayOfNumberOnlyFromJSONTyped(json: any, ignoreDiscriminator: boolean): ArrayOfArrayOfNumberOnly {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -59,7 +57,7 @@ export function ArrayOfArrayOfNumberOnlyToJSON(value?: ArrayOfArrayOfNumberOnly
     }
     return {
         
-        'ArrayArrayNumber': value.arrayArrayNumber,
+        'ArrayArrayNumber': value['arrayArrayNumber'],
     };
 }
 

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

@@ -31,9 +31,7 @@ export interface ArrayOfNumberOnly {
  * Check if a given object implements the ArrayOfNumberOnly interface.
  */
 export function instanceOfArrayOfNumberOnly(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function ArrayOfNumberOnlyFromJSON(json: any): ArrayOfNumberOnly {
@@ -41,7 +39,7 @@ export function ArrayOfNumberOnlyFromJSON(json: any): ArrayOfNumberOnly {
 }
 
 export function ArrayOfNumberOnlyFromJSONTyped(json: any, ignoreDiscriminator: boolean): ArrayOfNumberOnly {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -59,7 +57,7 @@ export function ArrayOfNumberOnlyToJSON(value?: ArrayOfNumberOnly | null): any {
     }
     return {
         
-        'ArrayNumber': value.arrayNumber,
+        'ArrayNumber': value['arrayNumber'],
     };
 }
 

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

@@ -50,9 +50,7 @@ export interface ArrayTest {
  * Check if a given object implements the ArrayTest interface.
  */
 export function instanceOfArrayTest(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function ArrayTestFromJSON(json: any): ArrayTest {
@@ -60,7 +58,7 @@ export function ArrayTestFromJSON(json: any): ArrayTest {
 }
 
 export function ArrayTestFromJSONTyped(json: any, ignoreDiscriminator: boolean): ArrayTest {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -80,9 +78,9 @@ export function ArrayTestToJSON(value?: ArrayTest | null): any {
     }
     return {
         
-        'array_of_string': value.arrayOfString,
-        'array_array_of_integer': value.arrayArrayOfInteger,
-        'array_array_of_model': value.arrayArrayOfModel,
+        'array_of_string': value['arrayOfString'],
+        'array_array_of_integer': value['arrayArrayOfInteger'],
+        'array_array_of_model': value['arrayArrayOfModel'],
     };
 }
 

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

@@ -62,9 +62,7 @@ export interface Capitalization {
  * Check if a given object implements the Capitalization interface.
  */
 export function instanceOfCapitalization(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function CapitalizationFromJSON(json: any): Capitalization {
@@ -72,7 +70,7 @@ export function CapitalizationFromJSON(json: any): Capitalization {
 }
 
 export function CapitalizationFromJSONTyped(json: any, ignoreDiscriminator: boolean): Capitalization {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -95,12 +93,12 @@ export function CapitalizationToJSON(value?: Capitalization | null): any {
     }
     return {
         
-        'smallCamel': value.smallCamel,
-        'CapitalCamel': value.capitalCamel,
-        'small_Snake': value.smallSnake,
-        'Capital_Snake': value.capitalSnake,
-        'SCA_ETH_Flow_Points': value.sCAETHFlowPoints,
-        'ATT_NAME': value.aTTNAME,
+        'smallCamel': value['smallCamel'],
+        'CapitalCamel': value['capitalCamel'],
+        'small_Snake': value['smallSnake'],
+        'Capital_Snake': value['capitalSnake'],
+        'SCA_ETH_Flow_Points': value['sCAETHFlowPoints'],
+        'ATT_NAME': value['aTTNAME'],
     };
 }
 

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

@@ -38,9 +38,7 @@ export interface Cat extends Animal {
  * Check if a given object implements the Cat interface.
  */
 export function instanceOfCat(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function CatFromJSON(json: any): Cat {
@@ -48,7 +46,7 @@ export function CatFromJSON(json: any): Cat {
 }
 
 export function CatFromJSONTyped(json: any, ignoreDiscriminator: boolean): Cat {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -66,7 +64,7 @@ export function CatToJSON(value?: Cat | null): any {
     }
     return {
         ...AnimalToJSON(value),
-        'declawed': value.declawed,
+        'declawed': value['declawed'],
     };
 }
 

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

@@ -37,10 +37,8 @@ export interface Category {
  * Check if a given object implements the Category interface.
  */
 export function instanceOfCategory(value: object): boolean {
-    let isInstance = true;
-    isInstance = isInstance && "name" in value;
-
-    return isInstance;
+    if (!('name' in value)) return false;
+    return true;
 }
 
 export function CategoryFromJSON(json: any): Category {
@@ -48,7 +46,7 @@ export function CategoryFromJSON(json: any): Category {
 }
 
 export function CategoryFromJSONTyped(json: any, ignoreDiscriminator: boolean): Category {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -67,8 +65,8 @@ export function CategoryToJSON(value?: Category | null): any {
     }
     return {
         
-        'id': value.id,
-        'name': value.name,
+        'id': value['id'],
+        'name': value['name'],
     };
 }
 

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

@@ -40,9 +40,7 @@ export interface ChildWithNullable extends ParentWithNullable {
  * Check if a given object implements the ChildWithNullable interface.
  */
 export function instanceOfChildWithNullable(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function ChildWithNullableFromJSON(json: any): ChildWithNullable {
@@ -50,7 +48,7 @@ export function ChildWithNullableFromJSON(json: any): ChildWithNullable {
 }
 
 export function ChildWithNullableFromJSONTyped(json: any, ignoreDiscriminator: boolean): ChildWithNullable {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -68,7 +66,7 @@ export function ChildWithNullableToJSON(value?: ChildWithNullable | null): any {
     }
     return {
         ...ParentWithNullableToJSON(value),
-        'otherProperty': value.otherProperty,
+        'otherProperty': value['otherProperty'],
     };
 }
 

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

@@ -31,9 +31,7 @@ export interface ClassModel {
  * Check if a given object implements the ClassModel interface.
  */
 export function instanceOfClassModel(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function ClassModelFromJSON(json: any): ClassModel {
@@ -41,7 +39,7 @@ export function ClassModelFromJSON(json: any): ClassModel {
 }
 
 export function ClassModelFromJSONTyped(json: any, ignoreDiscriminator: boolean): ClassModel {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -59,7 +57,7 @@ export function ClassModelToJSON(value?: ClassModel | null): any {
     }
     return {
         
-        '_class': value._class,
+        '_class': value['_class'],
     };
 }
 

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

@@ -31,9 +31,7 @@ export interface Client {
  * Check if a given object implements the Client interface.
  */
 export function instanceOfClient(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function ClientFromJSON(json: any): Client {
@@ -41,7 +39,7 @@ export function ClientFromJSON(json: any): Client {
 }
 
 export function ClientFromJSONTyped(json: any, ignoreDiscriminator: boolean): Client {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -59,7 +57,7 @@ export function ClientToJSON(value?: Client | null): any {
     }
     return {
         
-        'client': value.client,
+        'client': value['client'],
     };
 }
 

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

@@ -31,9 +31,7 @@ export interface DeprecatedObject {
  * Check if a given object implements the DeprecatedObject interface.
  */
 export function instanceOfDeprecatedObject(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function DeprecatedObjectFromJSON(json: any): DeprecatedObject {
@@ -41,7 +39,7 @@ export function DeprecatedObjectFromJSON(json: any): DeprecatedObject {
 }
 
 export function DeprecatedObjectFromJSONTyped(json: any, ignoreDiscriminator: boolean): DeprecatedObject {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -59,7 +57,7 @@ export function DeprecatedObjectToJSON(value?: DeprecatedObject | null): any {
     }
     return {
         
-        'name': value.name,
+        'name': value['name'],
     };
 }
 

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

@@ -38,9 +38,7 @@ export interface Dog extends Animal {
  * Check if a given object implements the Dog interface.
  */
 export function instanceOfDog(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function DogFromJSON(json: any): Dog {
@@ -48,7 +46,7 @@ export function DogFromJSON(json: any): Dog {
 }
 
 export function DogFromJSONTyped(json: any, ignoreDiscriminator: boolean): Dog {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -66,7 +64,7 @@ export function DogToJSON(value?: Dog | null): any {
     }
     return {
         ...AnimalToJSON(value),
-        'breed': value.breed,
+        'breed': value['breed'],
     };
 }
 

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

@@ -57,9 +57,7 @@ export type EnumArraysArrayEnumEnum = typeof EnumArraysArrayEnumEnum[keyof typeo
  * Check if a given object implements the EnumArrays interface.
  */
 export function instanceOfEnumArrays(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function EnumArraysFromJSON(json: any): EnumArrays {
@@ -67,7 +65,7 @@ export function EnumArraysFromJSON(json: any): EnumArrays {
 }
 
 export function EnumArraysFromJSONTyped(json: any, ignoreDiscriminator: boolean): EnumArrays {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -86,8 +84,8 @@ export function EnumArraysToJSON(value?: EnumArrays | null): any {
     }
     return {
         
-        'just_symbol': value.justSymbol,
-        'array_enum': value.arrayEnum,
+        'just_symbol': value['justSymbol'],
+        'array_enum': value['arrayEnum'],
     };
 }
 

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

@@ -73,7 +73,7 @@ export interface EnumTest {
      * @type {OuterEnum}
      * @memberof EnumTest
      */
-    outerEnum?: OuterEnum | null;
+    outerEnum?: OuterEnum;
     /**
      * 
      * @type {OuterEnumInteger}
@@ -138,10 +138,8 @@ export type EnumTestEnumNumberEnum = typeof EnumTestEnumNumberEnum[keyof typeof
  * Check if a given object implements the EnumTest interface.
  */
 export function instanceOfEnumTest(value: object): boolean {
-    let isInstance = true;
-    isInstance = isInstance && "enumStringRequired" in value;
-
-    return isInstance;
+    if (!('enumStringRequired' in value)) return false;
+    return true;
 }
 
 export function EnumTestFromJSON(json: any): EnumTest {
@@ -149,7 +147,7 @@ export function EnumTestFromJSON(json: any): EnumTest {
 }
 
 export function EnumTestFromJSONTyped(json: any, ignoreDiscriminator: boolean): EnumTest {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -174,14 +172,14 @@ export function EnumTestToJSON(value?: EnumTest | null): any {
     }
     return {
         
-        'enum_string': value.enumString,
-        'enum_string_required': value.enumStringRequired,
-        'enum_integer': value.enumInteger,
-        'enum_number': value.enumNumber,
-        'outerEnum': OuterEnumToJSON(value.outerEnum),
-        'outerEnumInteger': OuterEnumIntegerToJSON(value.outerEnumInteger),
-        'outerEnumDefaultValue': OuterEnumDefaultValueToJSON(value.outerEnumDefaultValue),
-        'outerEnumIntegerDefaultValue': OuterEnumIntegerDefaultValueToJSON(value.outerEnumIntegerDefaultValue),
+        'enum_string': value['enumString'],
+        'enum_string_required': value['enumStringRequired'],
+        'enum_integer': value['enumInteger'],
+        'enum_number': value['enumNumber'],
+        'outerEnum': OuterEnumToJSON(value['outerEnum']),
+        'outerEnumInteger': OuterEnumIntegerToJSON(value['outerEnumInteger']),
+        'outerEnumDefaultValue': OuterEnumDefaultValueToJSON(value['outerEnumDefaultValue']),
+        'outerEnumIntegerDefaultValue': OuterEnumIntegerDefaultValueToJSON(value['outerEnumIntegerDefaultValue']),
     };
 }
 

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

@@ -37,9 +37,7 @@ export interface FakeBigDecimalMap200Response {
  * Check if a given object implements the FakeBigDecimalMap200Response interface.
  */
 export function instanceOfFakeBigDecimalMap200Response(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function FakeBigDecimalMap200ResponseFromJSON(json: any): FakeBigDecimalMap200Response {
@@ -47,7 +45,7 @@ export function FakeBigDecimalMap200ResponseFromJSON(json: any): FakeBigDecimalM
 }
 
 export function FakeBigDecimalMap200ResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): FakeBigDecimalMap200Response {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -66,8 +64,8 @@ export function FakeBigDecimalMap200ResponseToJSON(value?: FakeBigDecimalMap200R
     }
     return {
         
-        'someId': value.someId,
-        'someMap': value.someMap,
+        'someId': value['someId'],
+        'someMap': value['someMap'],
     };
 }
 

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

@@ -37,9 +37,7 @@ export interface FileSchemaTestClass {
  * Check if a given object implements the FileSchemaTestClass interface.
  */
 export function instanceOfFileSchemaTestClass(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function FileSchemaTestClassFromJSON(json: any): FileSchemaTestClass {
@@ -47,7 +45,7 @@ export function FileSchemaTestClassFromJSON(json: any): FileSchemaTestClass {
 }
 
 export function FileSchemaTestClassFromJSONTyped(json: any, ignoreDiscriminator: boolean): FileSchemaTestClass {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -66,8 +64,8 @@ export function FileSchemaTestClassToJSON(value?: FileSchemaTestClass | null): a
     }
     return {
         
-        'file': value.file,
-        'files': value.files,
+        'file': value['file'],
+        'files': value['files'],
     };
 }
 

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

@@ -31,9 +31,7 @@ export interface Foo {
  * Check if a given object implements the Foo interface.
  */
 export function instanceOfFoo(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function FooFromJSON(json: any): Foo {
@@ -41,7 +39,7 @@ export function FooFromJSON(json: any): Foo {
 }
 
 export function FooFromJSONTyped(json: any, ignoreDiscriminator: boolean): Foo {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -59,7 +57,7 @@ export function FooToJSON(value?: Foo | null): any {
     }
     return {
         
-        'bar': value.bar,
+        'bar': value['bar'],
     };
 }
 

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

@@ -38,9 +38,7 @@ export interface FooGetDefaultResponse {
  * Check if a given object implements the FooGetDefaultResponse interface.
  */
 export function instanceOfFooGetDefaultResponse(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function FooGetDefaultResponseFromJSON(json: any): FooGetDefaultResponse {
@@ -48,7 +46,7 @@ export function FooGetDefaultResponseFromJSON(json: any): FooGetDefaultResponse
 }
 
 export function FooGetDefaultResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): FooGetDefaultResponse {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -66,7 +64,7 @@ export function FooGetDefaultResponseToJSON(value?: FooGetDefaultResponse | null
     }
     return {
         
-        'string': FooToJSON(value.string),
+        'string': FooToJSON(value['string']),
     };
 }
 

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

@@ -128,13 +128,11 @@ export interface FormatTest {
  * Check if a given object implements the FormatTest interface.
  */
 export function instanceOfFormatTest(value: object): boolean {
-    let isInstance = true;
-    isInstance = isInstance && "number" in value;
-    isInstance = isInstance && "_byte" in value;
-    isInstance = isInstance && "date" in value;
-    isInstance = isInstance && "password" in value;
-
-    return isInstance;
+    if (!('number' in value)) return false;
+    if (!('_byte' in value)) return false;
+    if (!('date' in value)) return false;
+    if (!('password' in value)) return false;
+    return true;
 }
 
 export function FormatTestFromJSON(json: any): FormatTest {
@@ -142,7 +140,7 @@ export function FormatTestFromJSON(json: any): FormatTest {
 }
 
 export function FormatTestFromJSONTyped(json: any, ignoreDiscriminator: boolean): FormatTest {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -175,22 +173,22 @@ export function FormatTestToJSON(value?: FormatTest | null): any {
     }
     return {
         
-        'integer': value.integer,
-        'int32': value.int32,
-        'int64': value.int64,
-        'number': value.number,
-        'float': value._float,
-        'double': value._double,
-        'decimal': DecimalToJSON(value.decimal),
-        'string': value.string,
-        'byte': value._byte,
-        'binary': value.binary,
-        'date': (value.date.toISOString().substring(0,10)),
-        'dateTime': value.dateTime === undefined ? undefined : (value.dateTime.toISOString()),
-        'uuid': value.uuid,
-        'password': value.password,
-        'pattern_with_digits': value.patternWithDigits,
-        'pattern_with_digits_and_delimiter': value.patternWithDigitsAndDelimiter,
+        'integer': value['integer'],
+        'int32': value['int32'],
+        'int64': value['int64'],
+        'number': value['number'],
+        'float': value['_float'],
+        'double': value['_double'],
+        'decimal': DecimalToJSON(value['decimal']),
+        'string': value['string'],
+        'byte': value['_byte'],
+        'binary': value['binary'],
+        'date': ((value['date']).toISOString().substring(0,10)),
+        'dateTime': !exists(value, 'dateTime') ? undefined : ((value['dateTime']).toISOString()),
+        'uuid': value['uuid'],
+        'password': value['password'],
+        'pattern_with_digits': value['patternWithDigits'],
+        'pattern_with_digits_and_delimiter': value['patternWithDigitsAndDelimiter'],
     };
 }
 

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

@@ -37,9 +37,7 @@ export interface HasOnlyReadOnly {
  * Check if a given object implements the HasOnlyReadOnly interface.
  */
 export function instanceOfHasOnlyReadOnly(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function HasOnlyReadOnlyFromJSON(json: any): HasOnlyReadOnly {
@@ -47,7 +45,7 @@ export function HasOnlyReadOnlyFromJSON(json: any): HasOnlyReadOnly {
 }
 
 export function HasOnlyReadOnlyFromJSONTyped(json: any, ignoreDiscriminator: boolean): HasOnlyReadOnly {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {

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

@@ -24,16 +24,14 @@ export interface HealthCheckResult {
      * @type {string}
      * @memberof HealthCheckResult
      */
-    nullableMessage?: string | null;
+    nullableMessage?: string;
 }
 
 /**
  * Check if a given object implements the HealthCheckResult interface.
  */
 export function instanceOfHealthCheckResult(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function HealthCheckResultFromJSON(json: any): HealthCheckResult {
@@ -41,7 +39,7 @@ export function HealthCheckResultFromJSON(json: any): HealthCheckResult {
 }
 
 export function HealthCheckResultFromJSONTyped(json: any, ignoreDiscriminator: boolean): HealthCheckResult {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -59,7 +57,7 @@ export function HealthCheckResultToJSON(value?: HealthCheckResult | null): any {
     }
     return {
         
-        'NullableMessage': value.nullableMessage,
+        'NullableMessage': value['nullableMessage'],
     };
 }
 

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

@@ -31,9 +31,7 @@ export interface List {
  * Check if a given object implements the List interface.
  */
 export function instanceOfList(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function ListFromJSON(json: any): List {
@@ -41,7 +39,7 @@ export function ListFromJSON(json: any): List {
 }
 
 export function ListFromJSONTyped(json: any, ignoreDiscriminator: boolean): List {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -59,7 +57,7 @@ export function ListToJSON(value?: List | null): any {
     }
     return {
         
-        '123-list': value._123list,
+        '123-list': value['_123list'],
     };
 }
 

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

@@ -60,9 +60,7 @@ export type MapTestMapOfEnumStringEnum = typeof MapTestMapOfEnumStringEnum[keyof
  * Check if a given object implements the MapTest interface.
  */
 export function instanceOfMapTest(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function MapTestFromJSON(json: any): MapTest {
@@ -70,7 +68,7 @@ export function MapTestFromJSON(json: any): MapTest {
 }
 
 export function MapTestFromJSONTyped(json: any, ignoreDiscriminator: boolean): MapTest {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -91,10 +89,10 @@ export function MapTestToJSON(value?: MapTest | null): any {
     }
     return {
         
-        'map_map_of_string': value.mapMapOfString,
-        'map_of_enum_string': value.mapOfEnumString,
-        'direct_map': value.directMap,
-        'indirect_map': value.indirectMap,
+        'map_map_of_string': value['mapMapOfString'],
+        'map_of_enum_string': value['mapOfEnumString'],
+        'direct_map': value['directMap'],
+        'indirect_map': value['indirectMap'],
     };
 }
 

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

@@ -50,9 +50,7 @@ export interface MixedPropertiesAndAdditionalPropertiesClass {
  * Check if a given object implements the MixedPropertiesAndAdditionalPropertiesClass interface.
  */
 export function instanceOfMixedPropertiesAndAdditionalPropertiesClass(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function MixedPropertiesAndAdditionalPropertiesClassFromJSON(json: any): MixedPropertiesAndAdditionalPropertiesClass {
@@ -60,7 +58,7 @@ export function MixedPropertiesAndAdditionalPropertiesClassFromJSON(json: any):
 }
 
 export function MixedPropertiesAndAdditionalPropertiesClassFromJSONTyped(json: any, ignoreDiscriminator: boolean): MixedPropertiesAndAdditionalPropertiesClass {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -80,9 +78,9 @@ export function MixedPropertiesAndAdditionalPropertiesClassToJSON(value?: MixedP
     }
     return {
         
-        'uuid': value.uuid,
-        'dateTime': value.dateTime === undefined ? undefined : (value.dateTime.toISOString()),
-        'map': value.map === undefined ? undefined : (mapValues(value.map, AnimalToJSON)),
+        'uuid': value['uuid'],
+        'dateTime': !exists(value, 'dateTime') ? undefined : ((value['dateTime']).toISOString()),
+        'map': !exists(value, 'map') ? undefined : (mapValues(value['map'], AnimalToJSON)),
     };
 }
 

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

@@ -37,9 +37,7 @@ export interface Model200Response {
  * Check if a given object implements the Model200Response interface.
  */
 export function instanceOfModel200Response(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function Model200ResponseFromJSON(json: any): Model200Response {
@@ -47,7 +45,7 @@ export function Model200ResponseFromJSON(json: any): Model200Response {
 }
 
 export function Model200ResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): Model200Response {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -66,8 +64,8 @@ export function Model200ResponseToJSON(value?: Model200Response | null): any {
     }
     return {
         
-        'name': value.name,
-        'class': value._class,
+        'name': value['name'],
+        'class': value['_class'],
     };
 }
 

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

@@ -43,9 +43,7 @@ export interface ModelApiResponse {
  * Check if a given object implements the ModelApiResponse interface.
  */
 export function instanceOfModelApiResponse(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function ModelApiResponseFromJSON(json: any): ModelApiResponse {
@@ -53,7 +51,7 @@ export function ModelApiResponseFromJSON(json: any): ModelApiResponse {
 }
 
 export function ModelApiResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): ModelApiResponse {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -73,9 +71,9 @@ export function ModelApiResponseToJSON(value?: ModelApiResponse | null): any {
     }
     return {
         
-        'code': value.code,
-        'type': value.type,
-        'message': value.message,
+        'code': value['code'],
+        'type': value['type'],
+        'message': value['message'],
     };
 }
 

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

@@ -31,9 +31,7 @@ export interface ModelFile {
  * Check if a given object implements the ModelFile interface.
  */
 export function instanceOfModelFile(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function ModelFileFromJSON(json: any): ModelFile {
@@ -41,7 +39,7 @@ export function ModelFileFromJSON(json: any): ModelFile {
 }
 
 export function ModelFileFromJSONTyped(json: any, ignoreDiscriminator: boolean): ModelFile {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -59,7 +57,7 @@ export function ModelFileToJSON(value?: ModelFile | null): any {
     }
     return {
         
-        'sourceURI': value.sourceURI,
+        'sourceURI': value['sourceURI'],
     };
 }
 

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

@@ -49,10 +49,8 @@ export interface Name {
  * Check if a given object implements the Name interface.
  */
 export function instanceOfName(value: object): boolean {
-    let isInstance = true;
-    isInstance = isInstance && "name" in value;
-
-    return isInstance;
+    if (!('name' in value)) return false;
+    return true;
 }
 
 export function NameFromJSON(json: any): Name {
@@ -60,7 +58,7 @@ export function NameFromJSON(json: any): Name {
 }
 
 export function NameFromJSONTyped(json: any, ignoreDiscriminator: boolean): Name {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -81,8 +79,8 @@ export function NameToJSON(value?: Name | null): any {
     }
     return {
         
-        'name': value.name,
-        'property': value.property,
+        'name': value['name'],
+        'property': value['property'],
     };
 }
 

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

@@ -25,49 +25,49 @@ export interface NullableClass {
      * @type {number}
      * @memberof NullableClass
      */
-    integerProp?: number | null;
+    integerProp?: number;
     /**
      * 
      * @type {number}
      * @memberof NullableClass
      */
-    numberProp?: number | null;
+    numberProp?: number;
     /**
      * 
      * @type {boolean}
      * @memberof NullableClass
      */
-    booleanProp?: boolean | null;
+    booleanProp?: boolean;
     /**
      * 
      * @type {string}
      * @memberof NullableClass
      */
-    stringProp?: string | null;
+    stringProp?: string;
     /**
      * 
      * @type {Date}
      * @memberof NullableClass
      */
-    dateProp?: Date | null;
+    dateProp?: Date;
     /**
      * 
      * @type {Date}
      * @memberof NullableClass
      */
-    datetimeProp?: Date | null;
+    datetimeProp?: Date;
     /**
      * 
      * @type {Array<object>}
      * @memberof NullableClass
      */
-    arrayNullableProp?: Array<object> | null;
+    arrayNullableProp?: Array<object>;
     /**
      * 
      * @type {Array<object>}
      * @memberof NullableClass
      */
-    arrayAndItemsNullableProp?: Array<object> | null;
+    arrayAndItemsNullableProp?: Array<object>;
     /**
      * 
      * @type {Array<object>}
@@ -79,13 +79,13 @@ export interface NullableClass {
      * @type {{ [key: string]: object; }}
      * @memberof NullableClass
      */
-    objectNullableProp?: { [key: string]: object; } | null;
+    objectNullableProp?: { [key: string]: object; };
     /**
      * 
      * @type {{ [key: string]: object | null; }}
      * @memberof NullableClass
      */
-    objectAndItemsNullableProp?: { [key: string]: object | null; } | null;
+    objectAndItemsNullableProp?: { [key: string]: object | null; };
     /**
      * 
      * @type {{ [key: string]: object | null; }}
@@ -98,9 +98,7 @@ export interface NullableClass {
  * Check if a given object implements the NullableClass interface.
  */
 export function instanceOfNullableClass(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function NullableClassFromJSON(json: any): NullableClass {
@@ -108,7 +106,7 @@ export function NullableClassFromJSON(json: any): NullableClass {
 }
 
 export function NullableClassFromJSONTyped(json: any, ignoreDiscriminator: boolean): NullableClass {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -118,8 +116,8 @@ export function NullableClassFromJSONTyped(json: any, ignoreDiscriminator: boole
         'numberProp': !exists(json, 'number_prop') ? undefined : json['number_prop'],
         'booleanProp': !exists(json, 'boolean_prop') ? undefined : json['boolean_prop'],
         'stringProp': !exists(json, 'string_prop') ? undefined : json['string_prop'],
-        'dateProp': !exists(json, 'date_prop') ? undefined : (json['date_prop'] === null ? null : new Date(json['date_prop'])),
-        'datetimeProp': !exists(json, 'datetime_prop') ? undefined : (json['datetime_prop'] === null ? null : new Date(json['datetime_prop'])),
+        'dateProp': !exists(json, 'date_prop') ? undefined : (new Date(json['date_prop'])),
+        'datetimeProp': !exists(json, 'datetime_prop') ? undefined : (new Date(json['datetime_prop'])),
         'arrayNullableProp': !exists(json, 'array_nullable_prop') ? undefined : json['array_nullable_prop'],
         'arrayAndItemsNullableProp': !exists(json, 'array_and_items_nullable_prop') ? undefined : json['array_and_items_nullable_prop'],
         'arrayItemsNullable': !exists(json, 'array_items_nullable') ? undefined : json['array_items_nullable'],
@@ -139,18 +137,18 @@ export function NullableClassToJSON(value?: NullableClass | null): any {
     return {
         
             ...value,
-        'integer_prop': value.integerProp,
-        'number_prop': value.numberProp,
-        'boolean_prop': value.booleanProp,
-        'string_prop': value.stringProp,
-        'date_prop': value.dateProp === undefined ? undefined : (value.dateProp === null ? null : value.dateProp.toISOString().substring(0,10)),
-        'datetime_prop': value.datetimeProp === undefined ? undefined : (value.datetimeProp === null ? null : value.datetimeProp.toISOString()),
-        'array_nullable_prop': value.arrayNullableProp,
-        'array_and_items_nullable_prop': value.arrayAndItemsNullableProp,
-        'array_items_nullable': value.arrayItemsNullable,
-        'object_nullable_prop': value.objectNullableProp,
-        'object_and_items_nullable_prop': value.objectAndItemsNullableProp,
-        'object_items_nullable': value.objectItemsNullable,
+        'integer_prop': value['integerProp'],
+        'number_prop': value['numberProp'],
+        'boolean_prop': value['booleanProp'],
+        'string_prop': value['stringProp'],
+        'date_prop': !exists(value, 'dateProp') ? undefined : ((value['dateProp'] as any).toISOString().substring(0,10)),
+        'datetime_prop': !exists(value, 'datetimeProp') ? undefined : ((value['datetimeProp'] as any).toISOString()),
+        'array_nullable_prop': value['arrayNullableProp'],
+        'array_and_items_nullable_prop': value['arrayAndItemsNullableProp'],
+        'array_items_nullable': value['arrayItemsNullable'],
+        'object_nullable_prop': value['objectNullableProp'],
+        'object_and_items_nullable_prop': value['objectAndItemsNullableProp'],
+        'object_items_nullable': value['objectItemsNullable'],
     };
 }
 

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

@@ -31,9 +31,7 @@ export interface NumberOnly {
  * Check if a given object implements the NumberOnly interface.
  */
 export function instanceOfNumberOnly(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function NumberOnlyFromJSON(json: any): NumberOnly {
@@ -41,7 +39,7 @@ export function NumberOnlyFromJSON(json: any): NumberOnly {
 }
 
 export function NumberOnlyFromJSONTyped(json: any, ignoreDiscriminator: boolean): NumberOnly {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -59,7 +57,7 @@ export function NumberOnlyToJSON(value?: NumberOnly | null): any {
     }
     return {
         
-        'JustNumber': value.justNumber,
+        'JustNumber': value['justNumber'],
     };
 }
 

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

@@ -59,9 +59,7 @@ export interface ObjectWithDeprecatedFields {
  * Check if a given object implements the ObjectWithDeprecatedFields interface.
  */
 export function instanceOfObjectWithDeprecatedFields(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function ObjectWithDeprecatedFieldsFromJSON(json: any): ObjectWithDeprecatedFields {
@@ -69,7 +67,7 @@ export function ObjectWithDeprecatedFieldsFromJSON(json: any): ObjectWithDepreca
 }
 
 export function ObjectWithDeprecatedFieldsFromJSONTyped(json: any, ignoreDiscriminator: boolean): ObjectWithDeprecatedFields {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -90,10 +88,10 @@ export function ObjectWithDeprecatedFieldsToJSON(value?: ObjectWithDeprecatedFie
     }
     return {
         
-        'uuid': value.uuid,
-        'id': value.id,
-        'deprecatedRef': DeprecatedObjectToJSON(value.deprecatedRef),
-        'bars': value.bars,
+        'uuid': value['uuid'],
+        'id': value['id'],
+        'deprecatedRef': DeprecatedObjectToJSON(value['deprecatedRef']),
+        'bars': value['bars'],
     };
 }
 

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

@@ -73,9 +73,7 @@ export type OrderStatusEnum = typeof OrderStatusEnum[keyof typeof OrderStatusEnu
  * Check if a given object implements the Order interface.
  */
 export function instanceOfOrder(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function OrderFromJSON(json: any): Order {
@@ -83,7 +81,7 @@ export function OrderFromJSON(json: any): Order {
 }
 
 export function OrderFromJSONTyped(json: any, ignoreDiscriminator: boolean): Order {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -106,12 +104,12 @@ export function OrderToJSON(value?: Order | null): any {
     }
     return {
         
-        'id': value.id,
-        'petId': value.petId,
-        'quantity': value.quantity,
-        'shipDate': value.shipDate === undefined ? undefined : (value.shipDate.toISOString()),
-        'status': value.status,
-        'complete': value.complete,
+        'id': value['id'],
+        'petId': value['petId'],
+        'quantity': value['quantity'],
+        'shipDate': !exists(value, 'shipDate') ? undefined : ((value['shipDate']).toISOString()),
+        'status': value['status'],
+        'complete': value['complete'],
     };
 }
 

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

@@ -43,9 +43,7 @@ export interface OuterComposite {
  * Check if a given object implements the OuterComposite interface.
  */
 export function instanceOfOuterComposite(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function OuterCompositeFromJSON(json: any): OuterComposite {
@@ -53,7 +51,7 @@ export function OuterCompositeFromJSON(json: any): OuterComposite {
 }
 
 export function OuterCompositeFromJSONTyped(json: any, ignoreDiscriminator: boolean): OuterComposite {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -73,9 +71,9 @@ export function OuterCompositeToJSON(value?: OuterComposite | null): any {
     }
     return {
         
-        'my_number': value.myNumber,
-        'my_string': value.myString,
-        'my_boolean': value.myBoolean,
+        'my_number': value['myNumber'],
+        'my_string': value['myString'],
+        'my_boolean': value['myBoolean'],
     };
 }
 

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

@@ -38,10 +38,8 @@ export interface OuterObjectWithEnumProperty {
  * Check if a given object implements the OuterObjectWithEnumProperty interface.
  */
 export function instanceOfOuterObjectWithEnumProperty(value: object): boolean {
-    let isInstance = true;
-    isInstance = isInstance && "value" in value;
-
-    return isInstance;
+    if (!('value' in value)) return false;
+    return true;
 }
 
 export function OuterObjectWithEnumPropertyFromJSON(json: any): OuterObjectWithEnumProperty {
@@ -49,7 +47,7 @@ export function OuterObjectWithEnumPropertyFromJSON(json: any): OuterObjectWithE
 }
 
 export function OuterObjectWithEnumPropertyFromJSONTyped(json: any, ignoreDiscriminator: boolean): OuterObjectWithEnumProperty {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -67,7 +65,7 @@ export function OuterObjectWithEnumPropertyToJSON(value?: OuterObjectWithEnumPro
     }
     return {
         
-        'value': OuterEnumIntegerToJSON(value.value),
+        'value': OuterEnumIntegerToJSON(value['value']),
     };
 }
 

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

@@ -34,7 +34,7 @@ export interface ParentWithNullable {
      * @type {string}
      * @memberof ParentWithNullable
      */
-    nullableProperty?: string | null;
+    nullableProperty?: string;
 }
 
 
@@ -51,9 +51,7 @@ export type ParentWithNullableTypeEnum = typeof ParentWithNullableTypeEnum[keyof
  * Check if a given object implements the ParentWithNullable interface.
  */
 export function instanceOfParentWithNullable(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function ParentWithNullableFromJSON(json: any): ParentWithNullable {
@@ -61,7 +59,7 @@ export function ParentWithNullableFromJSON(json: any): ParentWithNullable {
 }
 
 export function ParentWithNullableFromJSONTyped(json: any, ignoreDiscriminator: boolean): ParentWithNullable {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     if (!ignoreDiscriminator) {
@@ -85,8 +83,8 @@ export function ParentWithNullableToJSON(value?: ParentWithNullable | null): any
     }
     return {
         
-        'type': value.type,
-        'nullableProperty': value.nullableProperty,
+        'type': value['type'],
+        'nullableProperty': value['nullableProperty'],
     };
 }
 

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

@@ -86,11 +86,9 @@ export type PetStatusEnum = typeof PetStatusEnum[keyof typeof PetStatusEnum];
  * Check if a given object implements the Pet interface.
  */
 export function instanceOfPet(value: object): boolean {
-    let isInstance = true;
-    isInstance = isInstance && "name" in value;
-    isInstance = isInstance && "photoUrls" in value;
-
-    return isInstance;
+    if (!('name' in value)) return false;
+    if (!('photoUrls' in value)) return false;
+    return true;
 }
 
 export function PetFromJSON(json: any): Pet {
@@ -98,7 +96,7 @@ export function PetFromJSON(json: any): Pet {
 }
 
 export function PetFromJSONTyped(json: any, ignoreDiscriminator: boolean): Pet {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -121,12 +119,12 @@ export function PetToJSON(value?: Pet | null): any {
     }
     return {
         
-        'id': value.id,
-        'category': CategoryToJSON(value.category),
-        'name': value.name,
-        'photoUrls': Array.from(value.photoUrls as Set<any>),
-        'tags': value.tags === undefined ? undefined : ((value.tags as Array<any>).map(TagToJSON)),
-        'status': value.status,
+        'id': value['id'],
+        'category': CategoryToJSON(value['category']),
+        'name': value['name'],
+        'photoUrls': Array.from(value['photoUrls'] as Set<any>),
+        'tags': !exists(value, 'tags') ? undefined : ((value['tags'] as Array<any>).map(TagToJSON)),
+        'status': value['status'],
     };
 }
 

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

@@ -37,9 +37,7 @@ export interface ReadOnlyFirst {
  * Check if a given object implements the ReadOnlyFirst interface.
  */
 export function instanceOfReadOnlyFirst(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function ReadOnlyFirstFromJSON(json: any): ReadOnlyFirst {
@@ -47,7 +45,7 @@ export function ReadOnlyFirstFromJSON(json: any): ReadOnlyFirst {
 }
 
 export function ReadOnlyFirstFromJSONTyped(json: any, ignoreDiscriminator: boolean): ReadOnlyFirst {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -66,7 +64,7 @@ export function ReadOnlyFirstToJSON(value?: ReadOnlyFirst | null): any {
     }
     return {
         
-        'baz': value.baz,
+        'baz': value['baz'],
     };
 }
 

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

@@ -31,9 +31,7 @@ export interface Return {
  * Check if a given object implements the Return interface.
  */
 export function instanceOfReturn(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function ReturnFromJSON(json: any): Return {
@@ -41,7 +39,7 @@ export function ReturnFromJSON(json: any): Return {
 }
 
 export function ReturnFromJSONTyped(json: any, ignoreDiscriminator: boolean): Return {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -59,7 +57,7 @@ export function ReturnToJSON(value?: Return | null): any {
     }
     return {
         
-        'return': value._return,
+        'return': value['_return'],
     };
 }
 

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

@@ -31,9 +31,7 @@ export interface SpecialModelName {
  * Check if a given object implements the SpecialModelName interface.
  */
 export function instanceOfSpecialModelName(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function SpecialModelNameFromJSON(json: any): SpecialModelName {
@@ -41,7 +39,7 @@ export function SpecialModelNameFromJSON(json: any): SpecialModelName {
 }
 
 export function SpecialModelNameFromJSONTyped(json: any, ignoreDiscriminator: boolean): SpecialModelName {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -59,7 +57,7 @@ export function SpecialModelNameToJSON(value?: SpecialModelName | null): any {
     }
     return {
         
-        '$special[property.name]': value.$specialPropertyName,
+        '$special[property.name]': value['$specialPropertyName'],
     };
 }
 

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

@@ -37,9 +37,7 @@ export interface Tag {
  * Check if a given object implements the Tag interface.
  */
 export function instanceOfTag(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function TagFromJSON(json: any): Tag {
@@ -47,7 +45,7 @@ export function TagFromJSON(json: any): Tag {
 }
 
 export function TagFromJSONTyped(json: any, ignoreDiscriminator: boolean): Tag {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -66,8 +64,8 @@ export function TagToJSON(value?: Tag | null): any {
     }
     return {
         
-        'id': value.id,
-        'name': value.name,
+        'id': value['id'],
+        'name': value['name'],
     };
 }
 

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

@@ -32,9 +32,7 @@ export interface TestInlineFreeformAdditionalPropertiesRequest {
  * Check if a given object implements the TestInlineFreeformAdditionalPropertiesRequest interface.
  */
 export function instanceOfTestInlineFreeformAdditionalPropertiesRequest(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function TestInlineFreeformAdditionalPropertiesRequestFromJSON(json: any): TestInlineFreeformAdditionalPropertiesRequest {
@@ -42,7 +40,7 @@ export function TestInlineFreeformAdditionalPropertiesRequestFromJSON(json: any)
 }
 
 export function TestInlineFreeformAdditionalPropertiesRequestFromJSONTyped(json: any, ignoreDiscriminator: boolean): TestInlineFreeformAdditionalPropertiesRequest {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -62,7 +60,7 @@ export function TestInlineFreeformAdditionalPropertiesRequestToJSON(value?: Test
     return {
         
             ...value,
-        'someProperty': value.someProperty,
+        'someProperty': value['someProperty'],
     };
 }
 

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

@@ -73,9 +73,7 @@ export interface User {
  * Check if a given object implements the User interface.
  */
 export function instanceOfUser(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function UserFromJSON(json: any): User {
@@ -83,7 +81,7 @@ export function UserFromJSON(json: any): User {
 }
 
 export function UserFromJSONTyped(json: any, ignoreDiscriminator: boolean): User {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -108,14 +106,14 @@ export function UserToJSON(value?: User | null): any {
     }
     return {
         
-        'id': value.id,
-        'username': value.username,
-        'firstName': value.firstName,
-        'lastName': value.lastName,
-        'email': value.email,
-        'password': value.password,
-        'phone': value.phone,
-        'userStatus': value.userStatus,
+        'id': value['id'],
+        'username': value['username'],
+        'firstName': value['firstName'],
+        'lastName': value['lastName'],
+        'email': value['email'],
+        'password': value['password'],
+        'phone': value['phone'],
+        'userStatus': value['userStatus'],
     };
 }
 

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

@@ -310,9 +310,9 @@ export interface RequestOpts {
     body?: HTTPBody;
 }
 
-export function exists(json: any, key: string) {
+export function exists(json: any, key: string): boolean {
     const value = json[key];
-    return value !== null && value !== undefined;
+    return value !== undefined && value !== null;
 }
 
 export function querystring(params: HTTPQuery, prefix: string = ''): string {

samples/client/petstore/typescript-fetch/builds/default/apis/PetApi.ts

@@ -71,8 +71,11 @@ export class PetApi extends runtime.BaseAPI {
      * Add a new pet to the store
      */
     async addPetRaw(requestParameters: AddPetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.body === null || requestParameters.body === undefined) {
-            throw new runtime.RequiredError('body','Required parameter requestParameters.body was null or undefined when calling addPet.');
+        if (!runtime.exists(requestParameters, 'body')) {
+            throw new runtime.RequiredError(
+                'body',
+                'Required parameter "body" was null or undefined when calling addPet().'
+            );
         }
 
         const queryParameters: any = {};
@@ -91,7 +94,7 @@ export class PetApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: PetToJSON(requestParameters.body),
+            body: PetToJSON(requestParameters['body']),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
@@ -108,16 +111,19 @@ export class PetApi extends runtime.BaseAPI {
      * Deletes a pet
      */
     async deletePetRaw(requestParameters: DeletePetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.petId === null || requestParameters.petId === undefined) {
-            throw new runtime.RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling deletePet.');
+        if (!runtime.exists(requestParameters, 'petId')) {
+            throw new runtime.RequiredError(
+                'petId',
+                'Required parameter "petId" was null or undefined when calling deletePet().'
+            );
         }
 
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        if (requestParameters.apiKey !== undefined && requestParameters.apiKey !== null) {
-            headerParameters['api_key'] = String(requestParameters.apiKey);
+        if (runtime.exists(requestParameters, 'apiKey')) {
+            headerParameters['api_key'] = String(requestParameters['apiKey']);
         }
 
         if (this.configuration && this.configuration.accessToken) {
@@ -126,7 +132,7 @@ export class PetApi extends runtime.BaseAPI {
         }
 
         const response = await this.request({
-            path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
+            path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters['petId']))),
             method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
@@ -147,14 +153,17 @@ export class PetApi extends runtime.BaseAPI {
      * Finds Pets by status
      */
     async findPetsByStatusRaw(requestParameters: FindPetsByStatusRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<Pet>>> {
-        if (requestParameters.status === null || requestParameters.status === undefined) {
-            throw new runtime.RequiredError('status','Required parameter requestParameters.status was null or undefined when calling findPetsByStatus.');
+        if (!runtime.exists(requestParameters, 'status')) {
+            throw new runtime.RequiredError(
+                'status',
+                'Required parameter "status" was null or undefined when calling findPetsByStatus().'
+            );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters.status) {
-            queryParameters['status'] = requestParameters.status.join(runtime.COLLECTION_FORMATS["csv"]);
+        if (runtime.exists(requestParameters, 'status')) {
+            queryParameters['status'] = requestParameters['status']!.join(runtime.COLLECTION_FORMATS["csv"]);
         }
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -189,14 +198,17 @@ export class PetApi extends runtime.BaseAPI {
      * @deprecated
      */
     async findPetsByTagsRaw(requestParameters: FindPetsByTagsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<Pet>>> {
-        if (requestParameters.tags === null || requestParameters.tags === undefined) {
-            throw new runtime.RequiredError('tags','Required parameter requestParameters.tags was null or undefined when calling findPetsByTags.');
+        if (!runtime.exists(requestParameters, 'tags')) {
+            throw new runtime.RequiredError(
+                'tags',
+                'Required parameter "tags" was null or undefined when calling findPetsByTags().'
+            );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters.tags) {
-            queryParameters['tags'] = requestParameters.tags.join(runtime.COLLECTION_FORMATS["csv"]);
+        if (runtime.exists(requestParameters, 'tags')) {
+            queryParameters['tags'] = requestParameters['tags']!.join(runtime.COLLECTION_FORMATS["csv"]);
         }
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -231,8 +243,11 @@ export class PetApi extends runtime.BaseAPI {
      * Find pet by ID
      */
     async getPetByIdRaw(requestParameters: GetPetByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Pet>> {
-        if (requestParameters.petId === null || requestParameters.petId === undefined) {
-            throw new runtime.RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling getPetById.');
+        if (!runtime.exists(requestParameters, 'petId')) {
+            throw new runtime.RequiredError(
+                'petId',
+                'Required parameter "petId" was null or undefined when calling getPetById().'
+            );
         }
 
         const queryParameters: any = {};
@@ -244,7 +259,7 @@ export class PetApi extends runtime.BaseAPI {
         }
 
         const response = await this.request({
-            path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
+            path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters['petId']))),
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
@@ -266,8 +281,11 @@ export class PetApi extends runtime.BaseAPI {
      * Update an existing pet
      */
     async updatePetRaw(requestParameters: UpdatePetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.body === null || requestParameters.body === undefined) {
-            throw new runtime.RequiredError('body','Required parameter requestParameters.body was null or undefined when calling updatePet.');
+        if (!runtime.exists(requestParameters, 'body')) {
+            throw new runtime.RequiredError(
+                'body',
+                'Required parameter "body" was null or undefined when calling updatePet().'
+            );
         }
 
         const queryParameters: any = {};
@@ -286,7 +304,7 @@ export class PetApi extends runtime.BaseAPI {
             method: 'PUT',
             headers: headerParameters,
             query: queryParameters,
-            body: PetToJSON(requestParameters.body),
+            body: PetToJSON(requestParameters['body']),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
@@ -303,8 +321,11 @@ export class PetApi extends runtime.BaseAPI {
      * Updates a pet in the store with form data
      */
     async updatePetWithFormRaw(requestParameters: UpdatePetWithFormRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.petId === null || requestParameters.petId === undefined) {
-            throw new runtime.RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling updatePetWithForm.');
+        if (!runtime.exists(requestParameters, 'petId')) {
+            throw new runtime.RequiredError(
+                'petId',
+                'Required parameter "petId" was null or undefined when calling updatePetWithForm().'
+            );
         }
 
         const queryParameters: any = {};
@@ -330,16 +351,16 @@ export class PetApi extends runtime.BaseAPI {
             formParams = new URLSearchParams();
         }
 
-        if (requestParameters.name !== undefined) {
-            formParams.append('name', requestParameters.name as any);
+        if (runtime.exists(requestParameters, 'name')) {
+            formParams.append('name', requestParameters['name'] as any);
         }
 
-        if (requestParameters.status !== undefined) {
-            formParams.append('status', requestParameters.status as any);
+        if (runtime.exists(requestParameters, 'status')) {
+            formParams.append('status', requestParameters['status'] as any);
         }
 
         const response = await this.request({
-            path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
+            path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters['petId']))),
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
@@ -360,8 +381,11 @@ export class PetApi extends runtime.BaseAPI {
      * uploads an image
      */
     async uploadFileRaw(requestParameters: UploadFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ModelApiResponse>> {
-        if (requestParameters.petId === null || requestParameters.petId === undefined) {
-            throw new runtime.RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling uploadFile.');
+        if (!runtime.exists(requestParameters, 'petId')) {
+            throw new runtime.RequiredError(
+                'petId',
+                'Required parameter "petId" was null or undefined when calling uploadFile().'
+            );
         }
 
         const queryParameters: any = {};
@@ -389,16 +413,16 @@ export class PetApi extends runtime.BaseAPI {
             formParams = new URLSearchParams();
         }
 
-        if (requestParameters.additionalMetadata !== undefined) {
-            formParams.append('additionalMetadata', requestParameters.additionalMetadata as any);
+        if (runtime.exists(requestParameters, 'additionalMetadata')) {
+            formParams.append('additionalMetadata', requestParameters['additionalMetadata'] as any);
         }
 
-        if (requestParameters.file !== undefined) {
-            formParams.append('file', requestParameters.file as any);
+        if (runtime.exists(requestParameters, 'file')) {
+            formParams.append('file', requestParameters['file'] as any);
         }
 
         const response = await this.request({
-            path: `/pet/{petId}/uploadImage`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
+            path: `/pet/{petId}/uploadImage`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters['petId']))),
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,

samples/client/petstore/typescript-fetch/builds/default/apis/StoreApi.ts

@@ -44,8 +44,11 @@ export class StoreApi extends runtime.BaseAPI {
      * Delete purchase order by ID
      */
     async deleteOrderRaw(requestParameters: DeleteOrderRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.orderId === null || requestParameters.orderId === undefined) {
-            throw new runtime.RequiredError('orderId','Required parameter requestParameters.orderId was null or undefined when calling deleteOrder.');
+        if (!runtime.exists(requestParameters, 'orderId')) {
+            throw new runtime.RequiredError(
+                'orderId',
+                'Required parameter "orderId" was null or undefined when calling deleteOrder().'
+            );
         }
 
         const queryParameters: any = {};
@@ -53,7 +56,7 @@ export class StoreApi extends runtime.BaseAPI {
         const headerParameters: runtime.HTTPHeaders = {};
 
         const response = await this.request({
-            path: `/store/order/{orderId}`.replace(`{${"orderId"}}`, encodeURIComponent(String(requestParameters.orderId))),
+            path: `/store/order/{orderId}`.replace(`{${"orderId"}}`, encodeURIComponent(String(requestParameters['orderId']))),
             method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
@@ -107,8 +110,11 @@ export class StoreApi extends runtime.BaseAPI {
      * Find purchase order by ID
      */
     async getOrderByIdRaw(requestParameters: GetOrderByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Order>> {
-        if (requestParameters.orderId === null || requestParameters.orderId === undefined) {
-            throw new runtime.RequiredError('orderId','Required parameter requestParameters.orderId was null or undefined when calling getOrderById.');
+        if (!runtime.exists(requestParameters, 'orderId')) {
+            throw new runtime.RequiredError(
+                'orderId',
+                'Required parameter "orderId" was null or undefined when calling getOrderById().'
+            );
         }
 
         const queryParameters: any = {};
@@ -116,7 +122,7 @@ export class StoreApi extends runtime.BaseAPI {
         const headerParameters: runtime.HTTPHeaders = {};
 
         const response = await this.request({
-            path: `/store/order/{orderId}`.replace(`{${"orderId"}}`, encodeURIComponent(String(requestParameters.orderId))),
+            path: `/store/order/{orderId}`.replace(`{${"orderId"}}`, encodeURIComponent(String(requestParameters['orderId']))),
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
@@ -138,8 +144,11 @@ export class StoreApi extends runtime.BaseAPI {
      * Place an order for a pet
      */
     async placeOrderRaw(requestParameters: PlaceOrderRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Order>> {
-        if (requestParameters.body === null || requestParameters.body === undefined) {
-            throw new runtime.RequiredError('body','Required parameter requestParameters.body was null or undefined when calling placeOrder.');
+        if (!runtime.exists(requestParameters, 'body')) {
+            throw new runtime.RequiredError(
+                'body',
+                'Required parameter "body" was null or undefined when calling placeOrder().'
+            );
         }
 
         const queryParameters: any = {};
@@ -153,7 +162,7 @@ export class StoreApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: OrderToJSON(requestParameters.body),
+            body: OrderToJSON(requestParameters['body']),
         }, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => OrderFromJSON(jsonValue));

samples/client/petstore/typescript-fetch/builds/default/apis/UserApi.ts

@@ -62,8 +62,11 @@ export class UserApi extends runtime.BaseAPI {
      * Create user
      */
     async createUserRaw(requestParameters: CreateUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.body === null || requestParameters.body === undefined) {
-            throw new runtime.RequiredError('body','Required parameter requestParameters.body was null or undefined when calling createUser.');
+        if (!runtime.exists(requestParameters, 'body')) {
+            throw new runtime.RequiredError(
+                'body',
+                'Required parameter "body" was null or undefined when calling createUser().'
+            );
         }
 
         const queryParameters: any = {};
@@ -77,7 +80,7 @@ export class UserApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: UserToJSON(requestParameters.body),
+            body: UserToJSON(requestParameters['body']),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
@@ -95,8 +98,11 @@ export class UserApi extends runtime.BaseAPI {
      * Creates list of users with given input array
      */
     async createUsersWithArrayInputRaw(requestParameters: CreateUsersWithArrayInputRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.body === null || requestParameters.body === undefined) {
-            throw new runtime.RequiredError('body','Required parameter requestParameters.body was null or undefined when calling createUsersWithArrayInput.');
+        if (!runtime.exists(requestParameters, 'body')) {
+            throw new runtime.RequiredError(
+                'body',
+                'Required parameter "body" was null or undefined when calling createUsersWithArrayInput().'
+            );
         }
 
         const queryParameters: any = {};
@@ -110,7 +116,7 @@ export class UserApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: requestParameters.body.map(UserToJSON),
+            body: requestParameters['body']!.map(UserToJSON),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
@@ -127,8 +133,11 @@ export class UserApi extends runtime.BaseAPI {
      * Creates list of users with given input array
      */
     async createUsersWithListInputRaw(requestParameters: CreateUsersWithListInputRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.body === null || requestParameters.body === undefined) {
-            throw new runtime.RequiredError('body','Required parameter requestParameters.body was null or undefined when calling createUsersWithListInput.');
+        if (!runtime.exists(requestParameters, 'body')) {
+            throw new runtime.RequiredError(
+                'body',
+                'Required parameter "body" was null or undefined when calling createUsersWithListInput().'
+            );
         }
 
         const queryParameters: any = {};
@@ -142,7 +151,7 @@ export class UserApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: requestParameters.body.map(UserToJSON),
+            body: requestParameters['body']!.map(UserToJSON),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
@@ -160,8 +169,11 @@ export class UserApi extends runtime.BaseAPI {
      * Delete user
      */
     async deleteUserRaw(requestParameters: DeleteUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.username === null || requestParameters.username === undefined) {
-            throw new runtime.RequiredError('username','Required parameter requestParameters.username was null or undefined when calling deleteUser.');
+        if (!runtime.exists(requestParameters, 'username')) {
+            throw new runtime.RequiredError(
+                'username',
+                'Required parameter "username" was null or undefined when calling deleteUser().'
+            );
         }
 
         const queryParameters: any = {};
@@ -169,7 +181,7 @@ export class UserApi extends runtime.BaseAPI {
         const headerParameters: runtime.HTTPHeaders = {};
 
         const response = await this.request({
-            path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters.username))),
+            path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters['username']))),
             method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
@@ -190,8 +202,11 @@ export class UserApi extends runtime.BaseAPI {
      * Get user by user name
      */
     async getUserByNameRaw(requestParameters: GetUserByNameRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<User>> {
-        if (requestParameters.username === null || requestParameters.username === undefined) {
-            throw new runtime.RequiredError('username','Required parameter requestParameters.username was null or undefined when calling getUserByName.');
+        if (!runtime.exists(requestParameters, 'username')) {
+            throw new runtime.RequiredError(
+                'username',
+                'Required parameter "username" was null or undefined when calling getUserByName().'
+            );
         }
 
         const queryParameters: any = {};
@@ -199,7 +214,7 @@ export class UserApi extends runtime.BaseAPI {
         const headerParameters: runtime.HTTPHeaders = {};
 
         const response = await this.request({
-            path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters.username))),
+            path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters['username']))),
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
@@ -220,22 +235,28 @@ export class UserApi extends runtime.BaseAPI {
      * Logs user into the system
      */
     async loginUserRaw(requestParameters: LoginUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<string>> {
-        if (requestParameters.username === null || requestParameters.username === undefined) {
-            throw new runtime.RequiredError('username','Required parameter requestParameters.username was null or undefined when calling loginUser.');
+        if (!runtime.exists(requestParameters, 'username')) {
+            throw new runtime.RequiredError(
+                'username',
+                'Required parameter "username" was null or undefined when calling loginUser().'
+            );
         }
 
-        if (requestParameters.password === null || requestParameters.password === undefined) {
-            throw new runtime.RequiredError('password','Required parameter requestParameters.password was null or undefined when calling loginUser.');
+        if (!runtime.exists(requestParameters, 'password')) {
+            throw new runtime.RequiredError(
+                'password',
+                'Required parameter "password" was null or undefined when calling loginUser().'
+            );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters.username !== undefined) {
-            queryParameters['username'] = requestParameters.username;
+        if (runtime.exists(requestParameters, 'username')) {
+            queryParameters['username'] = requestParameters['username'];
         }
 
-        if (requestParameters.password !== undefined) {
-            queryParameters['password'] = requestParameters.password;
+        if (runtime.exists(requestParameters, 'password')) {
+            queryParameters['password'] = requestParameters['password'];
         }
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -292,12 +313,18 @@ export class UserApi extends runtime.BaseAPI {
      * Updated user
      */
     async updateUserRaw(requestParameters: UpdateUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.username === null || requestParameters.username === undefined) {
-            throw new runtime.RequiredError('username','Required parameter requestParameters.username was null or undefined when calling updateUser.');
+        if (!runtime.exists(requestParameters, 'username')) {
+            throw new runtime.RequiredError(
+                'username',
+                'Required parameter "username" was null or undefined when calling updateUser().'
+            );
         }
 
-        if (requestParameters.body === null || requestParameters.body === undefined) {
-            throw new runtime.RequiredError('body','Required parameter requestParameters.body was null or undefined when calling updateUser.');
+        if (!runtime.exists(requestParameters, 'body')) {
+            throw new runtime.RequiredError(
+                'body',
+                'Required parameter "body" was null or undefined when calling updateUser().'
+            );
         }
 
         const queryParameters: any = {};
@@ -307,11 +334,11 @@ export class UserApi extends runtime.BaseAPI {
         headerParameters['Content-Type'] = 'application/json';
 
         const response = await this.request({
-            path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters.username))),
+            path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters['username']))),
             method: 'PUT',
             headers: headerParameters,
             query: queryParameters,
-            body: UserToJSON(requestParameters.body),
+            body: UserToJSON(requestParameters['body']),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);

samples/client/petstore/typescript-fetch/builds/default/models/Category.ts

@@ -37,9 +37,7 @@ export interface Category {
  * Check if a given object implements the Category interface.
  */
 export function instanceOfCategory(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function CategoryFromJSON(json: any): Category {
@@ -47,7 +45,7 @@ export function CategoryFromJSON(json: any): Category {
 }
 
 export function CategoryFromJSONTyped(json: any, ignoreDiscriminator: boolean): Category {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -66,8 +64,8 @@ export function CategoryToJSON(value?: Category | null): any {
     }
     return {
         
-        'id': value.id,
-        'name': value.name,
+        'id': value['id'],
+        'name': value['name'],
     };
 }
 

samples/client/petstore/typescript-fetch/builds/default/models/ModelApiResponse.ts

@@ -43,9 +43,7 @@ export interface ModelApiResponse {
  * Check if a given object implements the ModelApiResponse interface.
  */
 export function instanceOfModelApiResponse(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function ModelApiResponseFromJSON(json: any): ModelApiResponse {
@@ -53,7 +51,7 @@ export function ModelApiResponseFromJSON(json: any): ModelApiResponse {
 }
 
 export function ModelApiResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): ModelApiResponse {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -73,9 +71,9 @@ export function ModelApiResponseToJSON(value?: ModelApiResponse | null): any {
     }
     return {
         
-        'code': value.code,
-        'type': value.type,
-        'message': value.message,
+        'code': value['code'],
+        'type': value['type'],
+        'message': value['message'],
     };
 }
 

samples/client/petstore/typescript-fetch/builds/default/models/Order.ts

@@ -73,9 +73,7 @@ export type OrderStatusEnum = typeof OrderStatusEnum[keyof typeof OrderStatusEnu
  * Check if a given object implements the Order interface.
  */
 export function instanceOfOrder(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function OrderFromJSON(json: any): Order {
@@ -83,7 +81,7 @@ export function OrderFromJSON(json: any): Order {
 }
 
 export function OrderFromJSONTyped(json: any, ignoreDiscriminator: boolean): Order {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -106,12 +104,12 @@ export function OrderToJSON(value?: Order | null): any {
     }
     return {
         
-        'id': value.id,
-        'petId': value.petId,
-        'quantity': value.quantity,
-        'shipDate': value.shipDate === undefined ? undefined : (value.shipDate.toISOString()),
-        'status': value.status,
-        'complete': value.complete,
+        'id': value['id'],
+        'petId': value['petId'],
+        'quantity': value['quantity'],
+        'shipDate': !exists(value, 'shipDate') ? undefined : ((value['shipDate']).toISOString()),
+        'status': value['status'],
+        'complete': value['complete'],
     };
 }
 

samples/client/petstore/typescript-fetch/builds/default/models/Pet.ts

@@ -86,11 +86,9 @@ export type PetStatusEnum = typeof PetStatusEnum[keyof typeof PetStatusEnum];
  * Check if a given object implements the Pet interface.
  */
 export function instanceOfPet(value: object): boolean {
-    let isInstance = true;
-    isInstance = isInstance && "name" in value;
-    isInstance = isInstance && "photoUrls" in value;
-
-    return isInstance;
+    if (!('name' in value)) return false;
+    if (!('photoUrls' in value)) return false;
+    return true;
 }
 
 export function PetFromJSON(json: any): Pet {
@@ -98,7 +96,7 @@ export function PetFromJSON(json: any): Pet {
 }
 
 export function PetFromJSONTyped(json: any, ignoreDiscriminator: boolean): Pet {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -121,12 +119,12 @@ export function PetToJSON(value?: Pet | null): any {
     }
     return {
         
-        'id': value.id,
-        'category': CategoryToJSON(value.category),
-        'name': value.name,
-        'photoUrls': value.photoUrls,
-        'tags': value.tags === undefined ? undefined : ((value.tags as Array<any>).map(TagToJSON)),
-        'status': value.status,
+        'id': value['id'],
+        'category': CategoryToJSON(value['category']),
+        'name': value['name'],
+        'photoUrls': value['photoUrls'],
+        'tags': !exists(value, 'tags') ? undefined : ((value['tags'] as Array<any>).map(TagToJSON)),
+        'status': value['status'],
     };
 }
 

samples/client/petstore/typescript-fetch/builds/default/models/Tag.ts

@@ -37,9 +37,7 @@ export interface Tag {
  * Check if a given object implements the Tag interface.
  */
 export function instanceOfTag(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function TagFromJSON(json: any): Tag {
@@ -47,7 +45,7 @@ export function TagFromJSON(json: any): Tag {
 }
 
 export function TagFromJSONTyped(json: any, ignoreDiscriminator: boolean): Tag {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -66,8 +64,8 @@ export function TagToJSON(value?: Tag | null): any {
     }
     return {
         
-        'id': value.id,
-        'name': value.name,
+        'id': value['id'],
+        'name': value['name'],
     };
 }
 

samples/client/petstore/typescript-fetch/builds/default/models/User.ts

@@ -73,9 +73,7 @@ export interface User {
  * Check if a given object implements the User interface.
  */
 export function instanceOfUser(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function UserFromJSON(json: any): User {
@@ -83,7 +81,7 @@ export function UserFromJSON(json: any): User {
 }
 
 export function UserFromJSONTyped(json: any, ignoreDiscriminator: boolean): User {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -108,14 +106,14 @@ export function UserToJSON(value?: User | null): any {
     }
     return {
         
-        'id': value.id,
-        'username': value.username,
-        'firstName': value.firstName,
-        'lastName': value.lastName,
-        'email': value.email,
-        'password': value.password,
-        'phone': value.phone,
-        'userStatus': value.userStatus,
+        'id': value['id'],
+        'username': value['username'],
+        'firstName': value['firstName'],
+        'lastName': value['lastName'],
+        'email': value['email'],
+        'password': value['password'],
+        'phone': value['phone'],
+        'userStatus': value['userStatus'],
     };
 }
 

samples/client/petstore/typescript-fetch/builds/default/runtime.ts

@@ -310,9 +310,9 @@ export interface RequestOpts {
     body?: HTTPBody;
 }
 
-export function exists(json: any, key: string) {
+export function exists(json: any, key: string): boolean {
     const value = json[key];
-    return value !== null && value !== undefined;
+    return value !== undefined && value !== null;
 }
 
 export function querystring(params: HTTPQuery, prefix: string = ''): string {

samples/client/petstore/typescript-fetch/builds/enum/apis/DefaultApi.ts

@@ -40,9 +40,9 @@ export interface FakeEnumRequestGetInlineRequest {
 
 export interface FakeEnumRequestGetRefRequest {
     stringEnum?: StringEnum;
-    nullableStringEnum?: StringEnum | null;
+    nullableStringEnum?: StringEnum;
     numberEnum?: NumberEnum;
-    nullableNumberEnum?: NumberEnum | null;
+    nullableNumberEnum?: NumberEnum;
 }
 
 export interface FakeEnumRequestPostInlineRequest {
@@ -63,20 +63,20 @@ export class DefaultApi extends runtime.BaseAPI {
     async fakeEnumRequestGetInlineRaw(requestParameters: FakeEnumRequestGetInlineRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FakeEnumRequestGetInline200Response>> {
         const queryParameters: any = {};
 
-        if (requestParameters.stringEnum !== undefined) {
-            queryParameters['string-enum'] = requestParameters.stringEnum;
+        if (runtime.exists(requestParameters, 'stringEnum')) {
+            queryParameters['string-enum'] = requestParameters['stringEnum'];
         }
 
-        if (requestParameters.nullableStringEnum !== undefined) {
-            queryParameters['nullable-string-enum'] = requestParameters.nullableStringEnum;
+        if (runtime.exists(requestParameters, 'nullableStringEnum')) {
+            queryParameters['nullable-string-enum'] = requestParameters['nullableStringEnum'];
         }
 
-        if (requestParameters.numberEnum !== undefined) {
-            queryParameters['number-enum'] = requestParameters.numberEnum;
+        if (runtime.exists(requestParameters, 'numberEnum')) {
+            queryParameters['number-enum'] = requestParameters['numberEnum'];
         }
 
-        if (requestParameters.nullableNumberEnum !== undefined) {
-            queryParameters['nullable-number-enum'] = requestParameters.nullableNumberEnum;
+        if (runtime.exists(requestParameters, 'nullableNumberEnum')) {
+            queryParameters['nullable-number-enum'] = requestParameters['nullableNumberEnum'];
         }
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -103,20 +103,20 @@ export class DefaultApi extends runtime.BaseAPI {
     async fakeEnumRequestGetRefRaw(requestParameters: FakeEnumRequestGetRefRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<EnumPatternObject>> {
         const queryParameters: any = {};
 
-        if (requestParameters.stringEnum !== undefined) {
-            queryParameters['string-enum'] = requestParameters.stringEnum;
+        if (runtime.exists(requestParameters, 'stringEnum')) {
+            queryParameters['string-enum'] = requestParameters['stringEnum'];
         }
 
-        if (requestParameters.nullableStringEnum !== undefined) {
-            queryParameters['nullable-string-enum'] = requestParameters.nullableStringEnum;
+        if (runtime.exists(requestParameters, 'nullableStringEnum')) {
+            queryParameters['nullable-string-enum'] = requestParameters['nullableStringEnum'];
         }
 
-        if (requestParameters.numberEnum !== undefined) {
-            queryParameters['number-enum'] = requestParameters.numberEnum;
+        if (runtime.exists(requestParameters, 'numberEnum')) {
+            queryParameters['number-enum'] = requestParameters['numberEnum'];
         }
 
-        if (requestParameters.nullableNumberEnum !== undefined) {
-            queryParameters['nullable-number-enum'] = requestParameters.nullableNumberEnum;
+        if (runtime.exists(requestParameters, 'nullableNumberEnum')) {
+            queryParameters['nullable-number-enum'] = requestParameters['nullableNumberEnum'];
         }
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -152,7 +152,7 @@ export class DefaultApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: FakeEnumRequestGetInline200ResponseToJSON(requestParameters.fakeEnumRequestGetInline200Response),
+            body: FakeEnumRequestGetInline200ResponseToJSON(requestParameters['fakeEnumRequestGetInline200Response']),
         }, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => FakeEnumRequestGetInline200ResponseFromJSON(jsonValue));
@@ -179,7 +179,7 @@ export class DefaultApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: EnumPatternObjectToJSON(requestParameters.enumPatternObject),
+            body: EnumPatternObjectToJSON(requestParameters['enumPatternObject']),
         }, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => EnumPatternObjectFromJSON(jsonValue));

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

@@ -43,7 +43,7 @@ export interface EnumPatternObject {
      * @type {StringEnum}
      * @memberof EnumPatternObject
      */
-    nullableStringEnum?: StringEnum | null;
+    nullableStringEnum?: StringEnum;
     /**
      * 
      * @type {NumberEnum}
@@ -55,16 +55,14 @@ export interface EnumPatternObject {
      * @type {NumberEnum}
      * @memberof EnumPatternObject
      */
-    nullableNumberEnum?: NumberEnum | null;
+    nullableNumberEnum?: NumberEnum;
 }
 
 /**
  * Check if a given object implements the EnumPatternObject interface.
  */
 export function instanceOfEnumPatternObject(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function EnumPatternObjectFromJSON(json: any): EnumPatternObject {
@@ -72,7 +70,7 @@ export function EnumPatternObjectFromJSON(json: any): EnumPatternObject {
 }
 
 export function EnumPatternObjectFromJSONTyped(json: any, ignoreDiscriminator: boolean): EnumPatternObject {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -93,10 +91,10 @@ export function EnumPatternObjectToJSON(value?: EnumPatternObject | null): any {
     }
     return {
         
-        'string-enum': StringEnumToJSON(value.stringEnum),
-        'nullable-string-enum': StringEnumToJSON(value.nullableStringEnum),
-        'number-enum': NumberEnumToJSON(value.numberEnum),
-        'nullable-number-enum': NumberEnumToJSON(value.nullableNumberEnum),
+        'string-enum': StringEnumToJSON(value['stringEnum']),
+        'nullable-string-enum': StringEnumToJSON(value['nullableStringEnum']),
+        'number-enum': NumberEnumToJSON(value['numberEnum']),
+        'nullable-number-enum': NumberEnumToJSON(value['nullableNumberEnum']),
     };
 }
 

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

@@ -91,9 +91,7 @@ export type FakeEnumRequestGetInline200ResponseNullableNumberEnumEnum = typeof F
  * Check if a given object implements the FakeEnumRequestGetInline200Response interface.
  */
 export function instanceOfFakeEnumRequestGetInline200Response(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function FakeEnumRequestGetInline200ResponseFromJSON(json: any): FakeEnumRequestGetInline200Response {
@@ -101,7 +99,7 @@ export function FakeEnumRequestGetInline200ResponseFromJSON(json: any): FakeEnum
 }
 
 export function FakeEnumRequestGetInline200ResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): FakeEnumRequestGetInline200Response {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -122,10 +120,10 @@ export function FakeEnumRequestGetInline200ResponseToJSON(value?: FakeEnumReques
     }
     return {
         
-        'string-enum': value.stringEnum,
-        'nullable-string-enum': value.nullableStringEnum,
-        'number-enum': value.numberEnum,
-        'nullable-number-enum': value.nullableNumberEnum,
+        'string-enum': value['stringEnum'],
+        'nullable-string-enum': value['nullableStringEnum'],
+        'number-enum': value['numberEnum'],
+        'nullable-number-enum': value['nullableNumberEnum'],
     };
 }
 

samples/client/petstore/typescript-fetch/builds/enum/runtime.ts

@@ -310,9 +310,9 @@ export interface RequestOpts {
     body?: HTTPBody;
 }
 
-export function exists(json: any, key: string) {
+export function exists(json: any, key: string): boolean {
     const value = json[key];
-    return value !== null && value !== undefined;
+    return value !== undefined && value !== null;
 }
 
 export function querystring(params: HTTPQuery, prefix: string = ''): string {

samples/client/petstore/typescript-fetch/builds/es6-target/src/apis/PetApi.ts

@@ -71,8 +71,11 @@ export class PetApi extends runtime.BaseAPI {
      * Add a new pet to the store
      */
     async addPetRaw(requestParameters: AddPetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.body === null || requestParameters.body === undefined) {
-            throw new runtime.RequiredError('body','Required parameter requestParameters.body was null or undefined when calling addPet.');
+        if (!runtime.exists(requestParameters, 'body')) {
+            throw new runtime.RequiredError(
+                'body',
+                'Required parameter "body" was null or undefined when calling addPet().'
+            );
         }
 
         const queryParameters: any = {};
@@ -91,7 +94,7 @@ export class PetApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: PetToJSON(requestParameters.body),
+            body: PetToJSON(requestParameters['body']),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
@@ -108,16 +111,19 @@ export class PetApi extends runtime.BaseAPI {
      * Deletes a pet
      */
     async deletePetRaw(requestParameters: DeletePetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.petId === null || requestParameters.petId === undefined) {
-            throw new runtime.RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling deletePet.');
+        if (!runtime.exists(requestParameters, 'petId')) {
+            throw new runtime.RequiredError(
+                'petId',
+                'Required parameter "petId" was null or undefined when calling deletePet().'
+            );
         }
 
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        if (requestParameters.apiKey !== undefined && requestParameters.apiKey !== null) {
-            headerParameters['api_key'] = String(requestParameters.apiKey);
+        if (runtime.exists(requestParameters, 'apiKey')) {
+            headerParameters['api_key'] = String(requestParameters['apiKey']);
         }
 
         if (this.configuration && this.configuration.accessToken) {
@@ -126,7 +132,7 @@ export class PetApi extends runtime.BaseAPI {
         }
 
         const response = await this.request({
-            path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
+            path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters['petId']))),
             method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
@@ -147,14 +153,17 @@ export class PetApi extends runtime.BaseAPI {
      * Finds Pets by status
      */
     async findPetsByStatusRaw(requestParameters: FindPetsByStatusRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<Pet>>> {
-        if (requestParameters.status === null || requestParameters.status === undefined) {
-            throw new runtime.RequiredError('status','Required parameter requestParameters.status was null or undefined when calling findPetsByStatus.');
+        if (!runtime.exists(requestParameters, 'status')) {
+            throw new runtime.RequiredError(
+                'status',
+                'Required parameter "status" was null or undefined when calling findPetsByStatus().'
+            );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters.status) {
-            queryParameters['status'] = requestParameters.status.join(runtime.COLLECTION_FORMATS["csv"]);
+        if (runtime.exists(requestParameters, 'status')) {
+            queryParameters['status'] = requestParameters['status']!.join(runtime.COLLECTION_FORMATS["csv"]);
         }
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -189,14 +198,17 @@ export class PetApi extends runtime.BaseAPI {
      * @deprecated
      */
     async findPetsByTagsRaw(requestParameters: FindPetsByTagsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<Pet>>> {
-        if (requestParameters.tags === null || requestParameters.tags === undefined) {
-            throw new runtime.RequiredError('tags','Required parameter requestParameters.tags was null or undefined when calling findPetsByTags.');
+        if (!runtime.exists(requestParameters, 'tags')) {
+            throw new runtime.RequiredError(
+                'tags',
+                'Required parameter "tags" was null or undefined when calling findPetsByTags().'
+            );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters.tags) {
-            queryParameters['tags'] = requestParameters.tags.join(runtime.COLLECTION_FORMATS["csv"]);
+        if (runtime.exists(requestParameters, 'tags')) {
+            queryParameters['tags'] = requestParameters['tags']!.join(runtime.COLLECTION_FORMATS["csv"]);
         }
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -231,8 +243,11 @@ export class PetApi extends runtime.BaseAPI {
      * Find pet by ID
      */
     async getPetByIdRaw(requestParameters: GetPetByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Pet>> {
-        if (requestParameters.petId === null || requestParameters.petId === undefined) {
-            throw new runtime.RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling getPetById.');
+        if (!runtime.exists(requestParameters, 'petId')) {
+            throw new runtime.RequiredError(
+                'petId',
+                'Required parameter "petId" was null or undefined when calling getPetById().'
+            );
         }
 
         const queryParameters: any = {};
@@ -244,7 +259,7 @@ export class PetApi extends runtime.BaseAPI {
         }
 
         const response = await this.request({
-            path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
+            path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters['petId']))),
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
@@ -266,8 +281,11 @@ export class PetApi extends runtime.BaseAPI {
      * Update an existing pet
      */
     async updatePetRaw(requestParameters: UpdatePetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.body === null || requestParameters.body === undefined) {
-            throw new runtime.RequiredError('body','Required parameter requestParameters.body was null or undefined when calling updatePet.');
+        if (!runtime.exists(requestParameters, 'body')) {
+            throw new runtime.RequiredError(
+                'body',
+                'Required parameter "body" was null or undefined when calling updatePet().'
+            );
         }
 
         const queryParameters: any = {};
@@ -286,7 +304,7 @@ export class PetApi extends runtime.BaseAPI {
             method: 'PUT',
             headers: headerParameters,
             query: queryParameters,
-            body: PetToJSON(requestParameters.body),
+            body: PetToJSON(requestParameters['body']),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
@@ -303,8 +321,11 @@ export class PetApi extends runtime.BaseAPI {
      * Updates a pet in the store with form data
      */
     async updatePetWithFormRaw(requestParameters: UpdatePetWithFormRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.petId === null || requestParameters.petId === undefined) {
-            throw new runtime.RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling updatePetWithForm.');
+        if (!runtime.exists(requestParameters, 'petId')) {
+            throw new runtime.RequiredError(
+                'petId',
+                'Required parameter "petId" was null or undefined when calling updatePetWithForm().'
+            );
         }
 
         const queryParameters: any = {};
@@ -330,16 +351,16 @@ export class PetApi extends runtime.BaseAPI {
             formParams = new URLSearchParams();
         }
 
-        if (requestParameters.name !== undefined) {
-            formParams.append('name', requestParameters.name as any);
+        if (runtime.exists(requestParameters, 'name')) {
+            formParams.append('name', requestParameters['name'] as any);
         }
 
-        if (requestParameters.status !== undefined) {
-            formParams.append('status', requestParameters.status as any);
+        if (runtime.exists(requestParameters, 'status')) {
+            formParams.append('status', requestParameters['status'] as any);
         }
 
         const response = await this.request({
-            path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
+            path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters['petId']))),
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
@@ -360,8 +381,11 @@ export class PetApi extends runtime.BaseAPI {
      * uploads an image
      */
     async uploadFileRaw(requestParameters: UploadFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ModelApiResponse>> {
-        if (requestParameters.petId === null || requestParameters.petId === undefined) {
-            throw new runtime.RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling uploadFile.');
+        if (!runtime.exists(requestParameters, 'petId')) {
+            throw new runtime.RequiredError(
+                'petId',
+                'Required parameter "petId" was null or undefined when calling uploadFile().'
+            );
         }
 
         const queryParameters: any = {};
@@ -389,16 +413,16 @@ export class PetApi extends runtime.BaseAPI {
             formParams = new URLSearchParams();
         }
 
-        if (requestParameters.additionalMetadata !== undefined) {
-            formParams.append('additionalMetadata', requestParameters.additionalMetadata as any);
+        if (runtime.exists(requestParameters, 'additionalMetadata')) {
+            formParams.append('additionalMetadata', requestParameters['additionalMetadata'] as any);
         }
 
-        if (requestParameters.file !== undefined) {
-            formParams.append('file', requestParameters.file as any);
+        if (runtime.exists(requestParameters, 'file')) {
+            formParams.append('file', requestParameters['file'] as any);
         }
 
         const response = await this.request({
-            path: `/pet/{petId}/uploadImage`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
+            path: `/pet/{petId}/uploadImage`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters['petId']))),
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,

samples/client/petstore/typescript-fetch/builds/es6-target/src/apis/StoreApi.ts

@@ -44,8 +44,11 @@ export class StoreApi extends runtime.BaseAPI {
      * Delete purchase order by ID
      */
     async deleteOrderRaw(requestParameters: DeleteOrderRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.orderId === null || requestParameters.orderId === undefined) {
-            throw new runtime.RequiredError('orderId','Required parameter requestParameters.orderId was null or undefined when calling deleteOrder.');
+        if (!runtime.exists(requestParameters, 'orderId')) {
+            throw new runtime.RequiredError(
+                'orderId',
+                'Required parameter "orderId" was null or undefined when calling deleteOrder().'
+            );
         }
 
         const queryParameters: any = {};
@@ -53,7 +56,7 @@ export class StoreApi extends runtime.BaseAPI {
         const headerParameters: runtime.HTTPHeaders = {};
 
         const response = await this.request({
-            path: `/store/order/{orderId}`.replace(`{${"orderId"}}`, encodeURIComponent(String(requestParameters.orderId))),
+            path: `/store/order/{orderId}`.replace(`{${"orderId"}}`, encodeURIComponent(String(requestParameters['orderId']))),
             method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
@@ -107,8 +110,11 @@ export class StoreApi extends runtime.BaseAPI {
      * Find purchase order by ID
      */
     async getOrderByIdRaw(requestParameters: GetOrderByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Order>> {
-        if (requestParameters.orderId === null || requestParameters.orderId === undefined) {
-            throw new runtime.RequiredError('orderId','Required parameter requestParameters.orderId was null or undefined when calling getOrderById.');
+        if (!runtime.exists(requestParameters, 'orderId')) {
+            throw new runtime.RequiredError(
+                'orderId',
+                'Required parameter "orderId" was null or undefined when calling getOrderById().'
+            );
         }
 
         const queryParameters: any = {};
@@ -116,7 +122,7 @@ export class StoreApi extends runtime.BaseAPI {
         const headerParameters: runtime.HTTPHeaders = {};
 
         const response = await this.request({
-            path: `/store/order/{orderId}`.replace(`{${"orderId"}}`, encodeURIComponent(String(requestParameters.orderId))),
+            path: `/store/order/{orderId}`.replace(`{${"orderId"}}`, encodeURIComponent(String(requestParameters['orderId']))),
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
@@ -138,8 +144,11 @@ export class StoreApi extends runtime.BaseAPI {
      * Place an order for a pet
      */
     async placeOrderRaw(requestParameters: PlaceOrderRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Order>> {
-        if (requestParameters.body === null || requestParameters.body === undefined) {
-            throw new runtime.RequiredError('body','Required parameter requestParameters.body was null or undefined when calling placeOrder.');
+        if (!runtime.exists(requestParameters, 'body')) {
+            throw new runtime.RequiredError(
+                'body',
+                'Required parameter "body" was null or undefined when calling placeOrder().'
+            );
         }
 
         const queryParameters: any = {};
@@ -153,7 +162,7 @@ export class StoreApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: OrderToJSON(requestParameters.body),
+            body: OrderToJSON(requestParameters['body']),
         }, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => OrderFromJSON(jsonValue));

samples/client/petstore/typescript-fetch/builds/es6-target/src/apis/UserApi.ts

@@ -62,8 +62,11 @@ export class UserApi extends runtime.BaseAPI {
      * Create user
      */
     async createUserRaw(requestParameters: CreateUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.body === null || requestParameters.body === undefined) {
-            throw new runtime.RequiredError('body','Required parameter requestParameters.body was null or undefined when calling createUser.');
+        if (!runtime.exists(requestParameters, 'body')) {
+            throw new runtime.RequiredError(
+                'body',
+                'Required parameter "body" was null or undefined when calling createUser().'
+            );
         }
 
         const queryParameters: any = {};
@@ -77,7 +80,7 @@ export class UserApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: UserToJSON(requestParameters.body),
+            body: UserToJSON(requestParameters['body']),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
@@ -95,8 +98,11 @@ export class UserApi extends runtime.BaseAPI {
      * Creates list of users with given input array
      */
     async createUsersWithArrayInputRaw(requestParameters: CreateUsersWithArrayInputRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.body === null || requestParameters.body === undefined) {
-            throw new runtime.RequiredError('body','Required parameter requestParameters.body was null or undefined when calling createUsersWithArrayInput.');
+        if (!runtime.exists(requestParameters, 'body')) {
+            throw new runtime.RequiredError(
+                'body',
+                'Required parameter "body" was null or undefined when calling createUsersWithArrayInput().'
+            );
         }
 
         const queryParameters: any = {};
@@ -110,7 +116,7 @@ export class UserApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: requestParameters.body.map(UserToJSON),
+            body: requestParameters['body']!.map(UserToJSON),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
@@ -127,8 +133,11 @@ export class UserApi extends runtime.BaseAPI {
      * Creates list of users with given input array
      */
     async createUsersWithListInputRaw(requestParameters: CreateUsersWithListInputRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.body === null || requestParameters.body === undefined) {
-            throw new runtime.RequiredError('body','Required parameter requestParameters.body was null or undefined when calling createUsersWithListInput.');
+        if (!runtime.exists(requestParameters, 'body')) {
+            throw new runtime.RequiredError(
+                'body',
+                'Required parameter "body" was null or undefined when calling createUsersWithListInput().'
+            );
         }
 
         const queryParameters: any = {};
@@ -142,7 +151,7 @@ export class UserApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: requestParameters.body.map(UserToJSON),
+            body: requestParameters['body']!.map(UserToJSON),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
@@ -160,8 +169,11 @@ export class UserApi extends runtime.BaseAPI {
      * Delete user
      */
     async deleteUserRaw(requestParameters: DeleteUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.username === null || requestParameters.username === undefined) {
-            throw new runtime.RequiredError('username','Required parameter requestParameters.username was null or undefined when calling deleteUser.');
+        if (!runtime.exists(requestParameters, 'username')) {
+            throw new runtime.RequiredError(
+                'username',
+                'Required parameter "username" was null or undefined when calling deleteUser().'
+            );
         }
 
         const queryParameters: any = {};
@@ -169,7 +181,7 @@ export class UserApi extends runtime.BaseAPI {
         const headerParameters: runtime.HTTPHeaders = {};
 
         const response = await this.request({
-            path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters.username))),
+            path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters['username']))),
             method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
@@ -190,8 +202,11 @@ export class UserApi extends runtime.BaseAPI {
      * Get user by user name
      */
     async getUserByNameRaw(requestParameters: GetUserByNameRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<User>> {
-        if (requestParameters.username === null || requestParameters.username === undefined) {
-            throw new runtime.RequiredError('username','Required parameter requestParameters.username was null or undefined when calling getUserByName.');
+        if (!runtime.exists(requestParameters, 'username')) {
+            throw new runtime.RequiredError(
+                'username',
+                'Required parameter "username" was null or undefined when calling getUserByName().'
+            );
         }
 
         const queryParameters: any = {};
@@ -199,7 +214,7 @@ export class UserApi extends runtime.BaseAPI {
         const headerParameters: runtime.HTTPHeaders = {};
 
         const response = await this.request({
-            path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters.username))),
+            path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters['username']))),
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
@@ -220,22 +235,28 @@ export class UserApi extends runtime.BaseAPI {
      * Logs user into the system
      */
     async loginUserRaw(requestParameters: LoginUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<string>> {
-        if (requestParameters.username === null || requestParameters.username === undefined) {
-            throw new runtime.RequiredError('username','Required parameter requestParameters.username was null or undefined when calling loginUser.');
+        if (!runtime.exists(requestParameters, 'username')) {
+            throw new runtime.RequiredError(
+                'username',
+                'Required parameter "username" was null or undefined when calling loginUser().'
+            );
         }
 
-        if (requestParameters.password === null || requestParameters.password === undefined) {
-            throw new runtime.RequiredError('password','Required parameter requestParameters.password was null or undefined when calling loginUser.');
+        if (!runtime.exists(requestParameters, 'password')) {
+            throw new runtime.RequiredError(
+                'password',
+                'Required parameter "password" was null or undefined when calling loginUser().'
+            );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters.username !== undefined) {
-            queryParameters['username'] = requestParameters.username;
+        if (runtime.exists(requestParameters, 'username')) {
+            queryParameters['username'] = requestParameters['username'];
         }
 
-        if (requestParameters.password !== undefined) {
-            queryParameters['password'] = requestParameters.password;
+        if (runtime.exists(requestParameters, 'password')) {
+            queryParameters['password'] = requestParameters['password'];
         }
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -292,12 +313,18 @@ export class UserApi extends runtime.BaseAPI {
      * Updated user
      */
     async updateUserRaw(requestParameters: UpdateUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.username === null || requestParameters.username === undefined) {
-            throw new runtime.RequiredError('username','Required parameter requestParameters.username was null or undefined when calling updateUser.');
+        if (!runtime.exists(requestParameters, 'username')) {
+            throw new runtime.RequiredError(
+                'username',
+                'Required parameter "username" was null or undefined when calling updateUser().'
+            );
         }
 
-        if (requestParameters.body === null || requestParameters.body === undefined) {
-            throw new runtime.RequiredError('body','Required parameter requestParameters.body was null or undefined when calling updateUser.');
+        if (!runtime.exists(requestParameters, 'body')) {
+            throw new runtime.RequiredError(
+                'body',
+                'Required parameter "body" was null or undefined when calling updateUser().'
+            );
         }
 
         const queryParameters: any = {};
@@ -307,11 +334,11 @@ export class UserApi extends runtime.BaseAPI {
         headerParameters['Content-Type'] = 'application/json';
 
         const response = await this.request({
-            path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters.username))),
+            path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters['username']))),
             method: 'PUT',
             headers: headerParameters,
             query: queryParameters,
-            body: UserToJSON(requestParameters.body),
+            body: UserToJSON(requestParameters['body']),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);

samples/client/petstore/typescript-fetch/builds/es6-target/src/models/Category.ts

@@ -37,9 +37,7 @@ export interface Category {
  * Check if a given object implements the Category interface.
  */
 export function instanceOfCategory(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function CategoryFromJSON(json: any): Category {
@@ -47,7 +45,7 @@ export function CategoryFromJSON(json: any): Category {
 }
 
 export function CategoryFromJSONTyped(json: any, ignoreDiscriminator: boolean): Category {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -66,8 +64,8 @@ export function CategoryToJSON(value?: Category | null): any {
     }
     return {
         
-        'id': value.id,
-        'name': value.name,
+        'id': value['id'],
+        'name': value['name'],
     };
 }
 

samples/client/petstore/typescript-fetch/builds/es6-target/src/models/ModelApiResponse.ts

@@ -43,9 +43,7 @@ export interface ModelApiResponse {
  * Check if a given object implements the ModelApiResponse interface.
  */
 export function instanceOfModelApiResponse(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function ModelApiResponseFromJSON(json: any): ModelApiResponse {
@@ -53,7 +51,7 @@ export function ModelApiResponseFromJSON(json: any): ModelApiResponse {
 }
 
 export function ModelApiResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): ModelApiResponse {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -73,9 +71,9 @@ export function ModelApiResponseToJSON(value?: ModelApiResponse | null): any {
     }
     return {
         
-        'code': value.code,
-        'type': value.type,
-        'message': value.message,
+        'code': value['code'],
+        'type': value['type'],
+        'message': value['message'],
     };
 }
 

samples/client/petstore/typescript-fetch/builds/es6-target/src/models/Order.ts

@@ -73,9 +73,7 @@ export type OrderStatusEnum = typeof OrderStatusEnum[keyof typeof OrderStatusEnu
  * Check if a given object implements the Order interface.
  */
 export function instanceOfOrder(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function OrderFromJSON(json: any): Order {
@@ -83,7 +81,7 @@ export function OrderFromJSON(json: any): Order {
 }
 
 export function OrderFromJSONTyped(json: any, ignoreDiscriminator: boolean): Order {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -106,12 +104,12 @@ export function OrderToJSON(value?: Order | null): any {
     }
     return {
         
-        'id': value.id,
-        'petId': value.petId,
-        'quantity': value.quantity,
-        'shipDate': value.shipDate === undefined ? undefined : (value.shipDate.toISOString()),
-        'status': value.status,
-        'complete': value.complete,
+        'id': value['id'],
+        'petId': value['petId'],
+        'quantity': value['quantity'],
+        'shipDate': !exists(value, 'shipDate') ? undefined : ((value['shipDate']).toISOString()),
+        'status': value['status'],
+        'complete': value['complete'],
     };
 }
 

samples/client/petstore/typescript-fetch/builds/es6-target/src/models/Pet.ts

@@ -86,11 +86,9 @@ export type PetStatusEnum = typeof PetStatusEnum[keyof typeof PetStatusEnum];
  * Check if a given object implements the Pet interface.
  */
 export function instanceOfPet(value: object): boolean {
-    let isInstance = true;
-    isInstance = isInstance && "name" in value;
-    isInstance = isInstance && "photoUrls" in value;
-
-    return isInstance;
+    if (!('name' in value)) return false;
+    if (!('photoUrls' in value)) return false;
+    return true;
 }
 
 export function PetFromJSON(json: any): Pet {
@@ -98,7 +96,7 @@ export function PetFromJSON(json: any): Pet {
 }
 
 export function PetFromJSONTyped(json: any, ignoreDiscriminator: boolean): Pet {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -121,12 +119,12 @@ export function PetToJSON(value?: Pet | null): any {
     }
     return {
         
-        'id': value.id,
-        'category': CategoryToJSON(value.category),
-        'name': value.name,
-        'photoUrls': value.photoUrls,
-        'tags': value.tags === undefined ? undefined : ((value.tags as Array<any>).map(TagToJSON)),
-        'status': value.status,
+        'id': value['id'],
+        'category': CategoryToJSON(value['category']),
+        'name': value['name'],
+        'photoUrls': value['photoUrls'],
+        'tags': !exists(value, 'tags') ? undefined : ((value['tags'] as Array<any>).map(TagToJSON)),
+        'status': value['status'],
     };
 }
 

samples/client/petstore/typescript-fetch/builds/es6-target/src/models/Tag.ts

@@ -37,9 +37,7 @@ export interface Tag {
  * Check if a given object implements the Tag interface.
  */
 export function instanceOfTag(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function TagFromJSON(json: any): Tag {
@@ -47,7 +45,7 @@ export function TagFromJSON(json: any): Tag {
 }
 
 export function TagFromJSONTyped(json: any, ignoreDiscriminator: boolean): Tag {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -66,8 +64,8 @@ export function TagToJSON(value?: Tag | null): any {
     }
     return {
         
-        'id': value.id,
-        'name': value.name,
+        'id': value['id'],
+        'name': value['name'],
     };
 }
 

samples/client/petstore/typescript-fetch/builds/es6-target/src/models/User.ts

@@ -73,9 +73,7 @@ export interface User {
  * Check if a given object implements the User interface.
  */
 export function instanceOfUser(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function UserFromJSON(json: any): User {
@@ -83,7 +81,7 @@ export function UserFromJSON(json: any): User {
 }
 
 export function UserFromJSONTyped(json: any, ignoreDiscriminator: boolean): User {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -108,14 +106,14 @@ export function UserToJSON(value?: User | null): any {
     }
     return {
         
-        'id': value.id,
-        'username': value.username,
-        'firstName': value.firstName,
-        'lastName': value.lastName,
-        'email': value.email,
-        'password': value.password,
-        'phone': value.phone,
-        'userStatus': value.userStatus,
+        'id': value['id'],
+        'username': value['username'],
+        'firstName': value['firstName'],
+        'lastName': value['lastName'],
+        'email': value['email'],
+        'password': value['password'],
+        'phone': value['phone'],
+        'userStatus': value['userStatus'],
     };
 }
 

samples/client/petstore/typescript-fetch/builds/es6-target/src/runtime.ts

@@ -310,9 +310,9 @@ export interface RequestOpts {
     body?: HTTPBody;
 }
 
-export function exists(json: any, key: string) {
+export function exists(json: any, key: string): boolean {
     const value = json[key];
-    return value !== null && value !== undefined;
+    return value !== undefined && value !== null;
 }
 
 export function querystring(params: HTTPQuery, prefix: string = ''): string {

samples/client/petstore/typescript-fetch/builds/multiple-parameters/apis/PetApi.ts

@@ -71,8 +71,11 @@ export class PetApi extends runtime.BaseAPI {
      * Add a new pet to the store
      */
     async addPetRaw(requestParameters: AddPetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.body === null || requestParameters.body === undefined) {
-            throw new runtime.RequiredError('body','Required parameter requestParameters.body was null or undefined when calling addPet.');
+        if (!runtime.exists(requestParameters, 'body')) {
+            throw new runtime.RequiredError(
+                'body',
+                'Required parameter "body" was null or undefined when calling addPet().'
+            );
         }
 
         const queryParameters: any = {};
@@ -91,7 +94,7 @@ export class PetApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: PetToJSON(requestParameters.body),
+            body: PetToJSON(requestParameters['body']),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
@@ -108,16 +111,19 @@ export class PetApi extends runtime.BaseAPI {
      * Deletes a pet
      */
     async deletePetRaw(requestParameters: DeletePetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.petId === null || requestParameters.petId === undefined) {
-            throw new runtime.RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling deletePet.');
+        if (!runtime.exists(requestParameters, 'petId')) {
+            throw new runtime.RequiredError(
+                'petId',
+                'Required parameter "petId" was null or undefined when calling deletePet().'
+            );
         }
 
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        if (requestParameters.apiKey !== undefined && requestParameters.apiKey !== null) {
-            headerParameters['api_key'] = String(requestParameters.apiKey);
+        if (runtime.exists(requestParameters, 'apiKey')) {
+            headerParameters['api_key'] = String(requestParameters['apiKey']);
         }
 
         if (this.configuration && this.configuration.accessToken) {
@@ -126,7 +132,7 @@ export class PetApi extends runtime.BaseAPI {
         }
 
         const response = await this.request({
-            path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
+            path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters['petId']))),
             method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
@@ -147,14 +153,17 @@ export class PetApi extends runtime.BaseAPI {
      * Finds Pets by status
      */
     async findPetsByStatusRaw(requestParameters: FindPetsByStatusRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<Pet>>> {
-        if (requestParameters.status === null || requestParameters.status === undefined) {
-            throw new runtime.RequiredError('status','Required parameter requestParameters.status was null or undefined when calling findPetsByStatus.');
+        if (!runtime.exists(requestParameters, 'status')) {
+            throw new runtime.RequiredError(
+                'status',
+                'Required parameter "status" was null or undefined when calling findPetsByStatus().'
+            );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters.status) {
-            queryParameters['status'] = requestParameters.status.join(runtime.COLLECTION_FORMATS["csv"]);
+        if (runtime.exists(requestParameters, 'status')) {
+            queryParameters['status'] = requestParameters['status']!.join(runtime.COLLECTION_FORMATS["csv"]);
         }
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -189,14 +198,17 @@ export class PetApi extends runtime.BaseAPI {
      * @deprecated
      */
     async findPetsByTagsRaw(requestParameters: FindPetsByTagsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<Pet>>> {
-        if (requestParameters.tags === null || requestParameters.tags === undefined) {
-            throw new runtime.RequiredError('tags','Required parameter requestParameters.tags was null or undefined when calling findPetsByTags.');
+        if (!runtime.exists(requestParameters, 'tags')) {
+            throw new runtime.RequiredError(
+                'tags',
+                'Required parameter "tags" was null or undefined when calling findPetsByTags().'
+            );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters.tags) {
-            queryParameters['tags'] = requestParameters.tags.join(runtime.COLLECTION_FORMATS["csv"]);
+        if (runtime.exists(requestParameters, 'tags')) {
+            queryParameters['tags'] = requestParameters['tags']!.join(runtime.COLLECTION_FORMATS["csv"]);
         }
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -231,8 +243,11 @@ export class PetApi extends runtime.BaseAPI {
      * Find pet by ID
      */
     async getPetByIdRaw(requestParameters: GetPetByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Pet>> {
-        if (requestParameters.petId === null || requestParameters.petId === undefined) {
-            throw new runtime.RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling getPetById.');
+        if (!runtime.exists(requestParameters, 'petId')) {
+            throw new runtime.RequiredError(
+                'petId',
+                'Required parameter "petId" was null or undefined when calling getPetById().'
+            );
         }
 
         const queryParameters: any = {};
@@ -244,7 +259,7 @@ export class PetApi extends runtime.BaseAPI {
         }
 
         const response = await this.request({
-            path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
+            path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters['petId']))),
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
@@ -266,8 +281,11 @@ export class PetApi extends runtime.BaseAPI {
      * Update an existing pet
      */
     async updatePetRaw(requestParameters: UpdatePetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.body === null || requestParameters.body === undefined) {
-            throw new runtime.RequiredError('body','Required parameter requestParameters.body was null or undefined when calling updatePet.');
+        if (!runtime.exists(requestParameters, 'body')) {
+            throw new runtime.RequiredError(
+                'body',
+                'Required parameter "body" was null or undefined when calling updatePet().'
+            );
         }
 
         const queryParameters: any = {};
@@ -286,7 +304,7 @@ export class PetApi extends runtime.BaseAPI {
             method: 'PUT',
             headers: headerParameters,
             query: queryParameters,
-            body: PetToJSON(requestParameters.body),
+            body: PetToJSON(requestParameters['body']),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
@@ -303,8 +321,11 @@ export class PetApi extends runtime.BaseAPI {
      * Updates a pet in the store with form data
      */
     async updatePetWithFormRaw(requestParameters: UpdatePetWithFormRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.petId === null || requestParameters.petId === undefined) {
-            throw new runtime.RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling updatePetWithForm.');
+        if (!runtime.exists(requestParameters, 'petId')) {
+            throw new runtime.RequiredError(
+                'petId',
+                'Required parameter "petId" was null or undefined when calling updatePetWithForm().'
+            );
         }
 
         const queryParameters: any = {};
@@ -330,16 +351,16 @@ export class PetApi extends runtime.BaseAPI {
             formParams = new URLSearchParams();
         }
 
-        if (requestParameters.name !== undefined) {
-            formParams.append('name', requestParameters.name as any);
+        if (runtime.exists(requestParameters, 'name')) {
+            formParams.append('name', requestParameters['name'] as any);
         }
 
-        if (requestParameters.status !== undefined) {
-            formParams.append('status', requestParameters.status as any);
+        if (runtime.exists(requestParameters, 'status')) {
+            formParams.append('status', requestParameters['status'] as any);
         }
 
         const response = await this.request({
-            path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
+            path: `/pet/{petId}`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters['petId']))),
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
@@ -360,8 +381,11 @@ export class PetApi extends runtime.BaseAPI {
      * uploads an image
      */
     async uploadFileRaw(requestParameters: UploadFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ModelApiResponse>> {
-        if (requestParameters.petId === null || requestParameters.petId === undefined) {
-            throw new runtime.RequiredError('petId','Required parameter requestParameters.petId was null or undefined when calling uploadFile.');
+        if (!runtime.exists(requestParameters, 'petId')) {
+            throw new runtime.RequiredError(
+                'petId',
+                'Required parameter "petId" was null or undefined when calling uploadFile().'
+            );
         }
 
         const queryParameters: any = {};
@@ -389,16 +413,16 @@ export class PetApi extends runtime.BaseAPI {
             formParams = new URLSearchParams();
         }
 
-        if (requestParameters.additionalMetadata !== undefined) {
-            formParams.append('additionalMetadata', requestParameters.additionalMetadata as any);
+        if (runtime.exists(requestParameters, 'additionalMetadata')) {
+            formParams.append('additionalMetadata', requestParameters['additionalMetadata'] as any);
         }
 
-        if (requestParameters.file !== undefined) {
-            formParams.append('file', requestParameters.file as any);
+        if (runtime.exists(requestParameters, 'file')) {
+            formParams.append('file', requestParameters['file'] as any);
         }
 
         const response = await this.request({
-            path: `/pet/{petId}/uploadImage`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters.petId))),
+            path: `/pet/{petId}/uploadImage`.replace(`{${"petId"}}`, encodeURIComponent(String(requestParameters['petId']))),
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,

samples/client/petstore/typescript-fetch/builds/multiple-parameters/apis/StoreApi.ts

@@ -44,8 +44,11 @@ export class StoreApi extends runtime.BaseAPI {
      * Delete purchase order by ID
      */
     async deleteOrderRaw(requestParameters: DeleteOrderRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.orderId === null || requestParameters.orderId === undefined) {
-            throw new runtime.RequiredError('orderId','Required parameter requestParameters.orderId was null or undefined when calling deleteOrder.');
+        if (!runtime.exists(requestParameters, 'orderId')) {
+            throw new runtime.RequiredError(
+                'orderId',
+                'Required parameter "orderId" was null or undefined when calling deleteOrder().'
+            );
         }
 
         const queryParameters: any = {};
@@ -53,7 +56,7 @@ export class StoreApi extends runtime.BaseAPI {
         const headerParameters: runtime.HTTPHeaders = {};
 
         const response = await this.request({
-            path: `/store/order/{orderId}`.replace(`{${"orderId"}}`, encodeURIComponent(String(requestParameters.orderId))),
+            path: `/store/order/{orderId}`.replace(`{${"orderId"}}`, encodeURIComponent(String(requestParameters['orderId']))),
             method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
@@ -107,8 +110,11 @@ export class StoreApi extends runtime.BaseAPI {
      * Find purchase order by ID
      */
     async getOrderByIdRaw(requestParameters: GetOrderByIdRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Order>> {
-        if (requestParameters.orderId === null || requestParameters.orderId === undefined) {
-            throw new runtime.RequiredError('orderId','Required parameter requestParameters.orderId was null or undefined when calling getOrderById.');
+        if (!runtime.exists(requestParameters, 'orderId')) {
+            throw new runtime.RequiredError(
+                'orderId',
+                'Required parameter "orderId" was null or undefined when calling getOrderById().'
+            );
         }
 
         const queryParameters: any = {};
@@ -116,7 +122,7 @@ export class StoreApi extends runtime.BaseAPI {
         const headerParameters: runtime.HTTPHeaders = {};
 
         const response = await this.request({
-            path: `/store/order/{orderId}`.replace(`{${"orderId"}}`, encodeURIComponent(String(requestParameters.orderId))),
+            path: `/store/order/{orderId}`.replace(`{${"orderId"}}`, encodeURIComponent(String(requestParameters['orderId']))),
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
@@ -138,8 +144,11 @@ export class StoreApi extends runtime.BaseAPI {
      * Place an order for a pet
      */
     async placeOrderRaw(requestParameters: PlaceOrderRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Order>> {
-        if (requestParameters.body === null || requestParameters.body === undefined) {
-            throw new runtime.RequiredError('body','Required parameter requestParameters.body was null or undefined when calling placeOrder.');
+        if (!runtime.exists(requestParameters, 'body')) {
+            throw new runtime.RequiredError(
+                'body',
+                'Required parameter "body" was null or undefined when calling placeOrder().'
+            );
         }
 
         const queryParameters: any = {};
@@ -153,7 +162,7 @@ export class StoreApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: OrderToJSON(requestParameters.body),
+            body: OrderToJSON(requestParameters['body']),
         }, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => OrderFromJSON(jsonValue));

samples/client/petstore/typescript-fetch/builds/multiple-parameters/apis/UserApi.ts

@@ -62,8 +62,11 @@ export class UserApi extends runtime.BaseAPI {
      * Create user
      */
     async createUserRaw(requestParameters: CreateUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.body === null || requestParameters.body === undefined) {
-            throw new runtime.RequiredError('body','Required parameter requestParameters.body was null or undefined when calling createUser.');
+        if (!runtime.exists(requestParameters, 'body')) {
+            throw new runtime.RequiredError(
+                'body',
+                'Required parameter "body" was null or undefined when calling createUser().'
+            );
         }
 
         const queryParameters: any = {};
@@ -77,7 +80,7 @@ export class UserApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: UserToJSON(requestParameters.body),
+            body: UserToJSON(requestParameters['body']),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
@@ -95,8 +98,11 @@ export class UserApi extends runtime.BaseAPI {
      * Creates list of users with given input array
      */
     async createUsersWithArrayInputRaw(requestParameters: CreateUsersWithArrayInputRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.body === null || requestParameters.body === undefined) {
-            throw new runtime.RequiredError('body','Required parameter requestParameters.body was null or undefined when calling createUsersWithArrayInput.');
+        if (!runtime.exists(requestParameters, 'body')) {
+            throw new runtime.RequiredError(
+                'body',
+                'Required parameter "body" was null or undefined when calling createUsersWithArrayInput().'
+            );
         }
 
         const queryParameters: any = {};
@@ -110,7 +116,7 @@ export class UserApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: requestParameters.body.map(UserToJSON),
+            body: requestParameters['body']!.map(UserToJSON),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
@@ -127,8 +133,11 @@ export class UserApi extends runtime.BaseAPI {
      * Creates list of users with given input array
      */
     async createUsersWithListInputRaw(requestParameters: CreateUsersWithListInputRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.body === null || requestParameters.body === undefined) {
-            throw new runtime.RequiredError('body','Required parameter requestParameters.body was null or undefined when calling createUsersWithListInput.');
+        if (!runtime.exists(requestParameters, 'body')) {
+            throw new runtime.RequiredError(
+                'body',
+                'Required parameter "body" was null or undefined when calling createUsersWithListInput().'
+            );
         }
 
         const queryParameters: any = {};
@@ -142,7 +151,7 @@ export class UserApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: requestParameters.body.map(UserToJSON),
+            body: requestParameters['body']!.map(UserToJSON),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);
@@ -160,8 +169,11 @@ export class UserApi extends runtime.BaseAPI {
      * Delete user
      */
     async deleteUserRaw(requestParameters: DeleteUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.username === null || requestParameters.username === undefined) {
-            throw new runtime.RequiredError('username','Required parameter requestParameters.username was null or undefined when calling deleteUser.');
+        if (!runtime.exists(requestParameters, 'username')) {
+            throw new runtime.RequiredError(
+                'username',
+                'Required parameter "username" was null or undefined when calling deleteUser().'
+            );
         }
 
         const queryParameters: any = {};
@@ -169,7 +181,7 @@ export class UserApi extends runtime.BaseAPI {
         const headerParameters: runtime.HTTPHeaders = {};
 
         const response = await this.request({
-            path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters.username))),
+            path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters['username']))),
             method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
@@ -190,8 +202,11 @@ export class UserApi extends runtime.BaseAPI {
      * Get user by user name
      */
     async getUserByNameRaw(requestParameters: GetUserByNameRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<User>> {
-        if (requestParameters.username === null || requestParameters.username === undefined) {
-            throw new runtime.RequiredError('username','Required parameter requestParameters.username was null or undefined when calling getUserByName.');
+        if (!runtime.exists(requestParameters, 'username')) {
+            throw new runtime.RequiredError(
+                'username',
+                'Required parameter "username" was null or undefined when calling getUserByName().'
+            );
         }
 
         const queryParameters: any = {};
@@ -199,7 +214,7 @@ export class UserApi extends runtime.BaseAPI {
         const headerParameters: runtime.HTTPHeaders = {};
 
         const response = await this.request({
-            path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters.username))),
+            path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters['username']))),
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
@@ -220,22 +235,28 @@ export class UserApi extends runtime.BaseAPI {
      * Logs user into the system
      */
     async loginUserRaw(requestParameters: LoginUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<string>> {
-        if (requestParameters.username === null || requestParameters.username === undefined) {
-            throw new runtime.RequiredError('username','Required parameter requestParameters.username was null or undefined when calling loginUser.');
+        if (!runtime.exists(requestParameters, 'username')) {
+            throw new runtime.RequiredError(
+                'username',
+                'Required parameter "username" was null or undefined when calling loginUser().'
+            );
         }
 
-        if (requestParameters.password === null || requestParameters.password === undefined) {
-            throw new runtime.RequiredError('password','Required parameter requestParameters.password was null or undefined when calling loginUser.');
+        if (!runtime.exists(requestParameters, 'password')) {
+            throw new runtime.RequiredError(
+                'password',
+                'Required parameter "password" was null or undefined when calling loginUser().'
+            );
         }
 
         const queryParameters: any = {};
 
-        if (requestParameters.username !== undefined) {
-            queryParameters['username'] = requestParameters.username;
+        if (runtime.exists(requestParameters, 'username')) {
+            queryParameters['username'] = requestParameters['username'];
         }
 
-        if (requestParameters.password !== undefined) {
-            queryParameters['password'] = requestParameters.password;
+        if (runtime.exists(requestParameters, 'password')) {
+            queryParameters['password'] = requestParameters['password'];
         }
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -292,12 +313,18 @@ export class UserApi extends runtime.BaseAPI {
      * Updated user
      */
     async updateUserRaw(requestParameters: UpdateUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters.username === null || requestParameters.username === undefined) {
-            throw new runtime.RequiredError('username','Required parameter requestParameters.username was null or undefined when calling updateUser.');
+        if (!runtime.exists(requestParameters, 'username')) {
+            throw new runtime.RequiredError(
+                'username',
+                'Required parameter "username" was null or undefined when calling updateUser().'
+            );
         }
 
-        if (requestParameters.body === null || requestParameters.body === undefined) {
-            throw new runtime.RequiredError('body','Required parameter requestParameters.body was null or undefined when calling updateUser.');
+        if (!runtime.exists(requestParameters, 'body')) {
+            throw new runtime.RequiredError(
+                'body',
+                'Required parameter "body" was null or undefined when calling updateUser().'
+            );
         }
 
         const queryParameters: any = {};
@@ -307,11 +334,11 @@ export class UserApi extends runtime.BaseAPI {
         headerParameters['Content-Type'] = 'application/json';
 
         const response = await this.request({
-            path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters.username))),
+            path: `/user/{username}`.replace(`{${"username"}}`, encodeURIComponent(String(requestParameters['username']))),
             method: 'PUT',
             headers: headerParameters,
             query: queryParameters,
-            body: UserToJSON(requestParameters.body),
+            body: UserToJSON(requestParameters['body']),
         }, initOverrides);
 
         return new runtime.VoidApiResponse(response);

samples/client/petstore/typescript-fetch/builds/multiple-parameters/models/Category.ts

@@ -37,9 +37,7 @@ export interface Category {
  * Check if a given object implements the Category interface.
  */
 export function instanceOfCategory(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function CategoryFromJSON(json: any): Category {
@@ -47,7 +45,7 @@ export function CategoryFromJSON(json: any): Category {
 }
 
 export function CategoryFromJSONTyped(json: any, ignoreDiscriminator: boolean): Category {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -66,8 +64,8 @@ export function CategoryToJSON(value?: Category | null): any {
     }
     return {
         
-        'id': value.id,
-        'name': value.name,
+        'id': value['id'],
+        'name': value['name'],
     };
 }
 

samples/client/petstore/typescript-fetch/builds/multiple-parameters/models/ModelApiResponse.ts

@@ -43,9 +43,7 @@ export interface ModelApiResponse {
  * Check if a given object implements the ModelApiResponse interface.
  */
 export function instanceOfModelApiResponse(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function ModelApiResponseFromJSON(json: any): ModelApiResponse {
@@ -53,7 +51,7 @@ export function ModelApiResponseFromJSON(json: any): ModelApiResponse {
 }
 
 export function ModelApiResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): ModelApiResponse {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -73,9 +71,9 @@ export function ModelApiResponseToJSON(value?: ModelApiResponse | null): any {
     }
     return {
         
-        'code': value.code,
-        'type': value.type,
-        'message': value.message,
+        'code': value['code'],
+        'type': value['type'],
+        'message': value['message'],
     };
 }
 

samples/client/petstore/typescript-fetch/builds/multiple-parameters/models/Order.ts

@@ -73,9 +73,7 @@ export type OrderStatusEnum = typeof OrderStatusEnum[keyof typeof OrderStatusEnu
  * Check if a given object implements the Order interface.
  */
 export function instanceOfOrder(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function OrderFromJSON(json: any): Order {
@@ -83,7 +81,7 @@ export function OrderFromJSON(json: any): Order {
 }
 
 export function OrderFromJSONTyped(json: any, ignoreDiscriminator: boolean): Order {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -106,12 +104,12 @@ export function OrderToJSON(value?: Order | null): any {
     }
     return {
         
-        'id': value.id,
-        'petId': value.petId,
-        'quantity': value.quantity,
-        'shipDate': value.shipDate === undefined ? undefined : (value.shipDate.toISOString()),
-        'status': value.status,
-        'complete': value.complete,
+        'id': value['id'],
+        'petId': value['petId'],
+        'quantity': value['quantity'],
+        'shipDate': !exists(value, 'shipDate') ? undefined : ((value['shipDate']).toISOString()),
+        'status': value['status'],
+        'complete': value['complete'],
     };
 }
 

samples/client/petstore/typescript-fetch/builds/multiple-parameters/models/Pet.ts

@@ -86,11 +86,9 @@ export type PetStatusEnum = typeof PetStatusEnum[keyof typeof PetStatusEnum];
  * Check if a given object implements the Pet interface.
  */
 export function instanceOfPet(value: object): boolean {
-    let isInstance = true;
-    isInstance = isInstance && "name" in value;
-    isInstance = isInstance && "photoUrls" in value;
-
-    return isInstance;
+    if (!('name' in value)) return false;
+    if (!('photoUrls' in value)) return false;
+    return true;
 }
 
 export function PetFromJSON(json: any): Pet {
@@ -98,7 +96,7 @@ export function PetFromJSON(json: any): Pet {
 }
 
 export function PetFromJSONTyped(json: any, ignoreDiscriminator: boolean): Pet {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -121,12 +119,12 @@ export function PetToJSON(value?: Pet | null): any {
     }
     return {
         
-        'id': value.id,
-        'category': CategoryToJSON(value.category),
-        'name': value.name,
-        'photoUrls': value.photoUrls,
-        'tags': value.tags === undefined ? undefined : ((value.tags as Array<any>).map(TagToJSON)),
-        'status': value.status,
+        'id': value['id'],
+        'category': CategoryToJSON(value['category']),
+        'name': value['name'],
+        'photoUrls': value['photoUrls'],
+        'tags': !exists(value, 'tags') ? undefined : ((value['tags'] as Array<any>).map(TagToJSON)),
+        'status': value['status'],
     };
 }
 

samples/client/petstore/typescript-fetch/builds/multiple-parameters/models/Tag.ts

@@ -37,9 +37,7 @@ export interface Tag {
  * Check if a given object implements the Tag interface.
  */
 export function instanceOfTag(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function TagFromJSON(json: any): Tag {
@@ -47,7 +45,7 @@ export function TagFromJSON(json: any): Tag {
 }
 
 export function TagFromJSONTyped(json: any, ignoreDiscriminator: boolean): Tag {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -66,8 +64,8 @@ export function TagToJSON(value?: Tag | null): any {
     }
     return {
         
-        'id': value.id,
-        'name': value.name,
+        'id': value['id'],
+        'name': value['name'],
     };
 }
 

samples/client/petstore/typescript-fetch/builds/multiple-parameters/models/User.ts

@@ -73,9 +73,7 @@ export interface User {
  * Check if a given object implements the User interface.
  */
 export function instanceOfUser(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
+    return true;
 }
 
 export function UserFromJSON(json: any): User {
@@ -83,7 +81,7 @@ export function UserFromJSON(json: any): User {
 }
 
 export function UserFromJSONTyped(json: any, ignoreDiscriminator: boolean): User {
-    if ((json === undefined) || (json === null)) {
+    if (json === undefined || json === null) {
         return json;
     }
     return {
@@ -108,14 +106,14 @@ export function UserToJSON(value?: User | null): any {
     }
     return {
         
-        'id': value.id,
-        'username': value.username,
-        'firstName': value.firstName,
-        'lastName': value.lastName,
-        'email': value.email,
-        'password': value.password,
-        'phone': value.phone,
-        'userStatus': value.userStatus,
+        'id': value['id'],
+        'username': value['username'],
+        'firstName': value['firstName'],
+        'lastName': value['lastName'],
+        'email': value['email'],
+        'password': value['password'],
+        'phone': value['phone'],
+        'userStatus': value['userStatus'],
     };
 }
 

samples/client/petstore/typescript-fetch/builds/multiple-parameters/runtime.ts

@@ -310,9 +310,9 @@ export interface RequestOpts {
     body?: HTTPBody;
 }
 
-export function exists(json: any, key: string) {
+export function exists(json: any, key: string): boolean {
     const value = json[key];
-    return value !== null && value !== undefined;
+    return value !== undefined && value !== null;
 }
 
 export function querystring(params: HTTPQuery, prefix: string = ''): string {