@kubb/plugin-oas 3.10.1 → 3.10.3

package/dist/{chunk-72MVTXCW.js → chunk-5JWN6NVC.js}

@@ -1,8 +1,8 @@
-import { getSchemaFactory, getSchemas } from './chunk-3Y4QGY6D.js';
+import { getSchemaFactory, getSchemas } from './chunk-PORSNYI5.js';
 import { BaseGenerator } from '@kubb/core';
 import transformers, { pascalCase } from '@kubb/core/transformers';
 import { getUniqueName } from '@kubb/core/utils';
-import { isNullable, isReference } from '@kubb/oas';
+import { isDiscriminator, isNullable, isReference } from '@kubb/oas';
 import { uniqueWith, isDeepEqual, isNumber } from 'remeda';
 
 // src/SchemaMapper.ts
@@ -203,16 +203,16 @@ var SchemaGenerator = class _SchemaGenerator extends BaseGenerator {
   /**
    * Recursively creates a type literal with the given props.
    */
-  #parseProperties({ schema, name }) {
-    const properties = schema?.properties || {};
-    const additionalProperties = schema?.additionalProperties;
-    const required = schema?.required;
+  #parseProperties({ schemaObject, name }) {
+    const properties = schemaObject?.properties || {};
+    const additionalProperties = schemaObject?.additionalProperties;
+    const required = schemaObject?.required;
     const propertiesSchemas = Object.keys(properties).map((propertyName) => {
       const validationFunctions = [];
       const propertySchema = properties[propertyName];
       const isRequired = Array.isArray(required) ? required?.includes(propertyName) : !!required;
       const nullable = propertySchema.nullable ?? propertySchema["x-nullable"] ?? false;
-      validationFunctions.push(...this.parse({ schema: propertySchema, name: propertyName, parentName: name }));
+      validationFunctions.push(...this.parse({ schemaObject: propertySchema, name: propertyName, parentName: name }));
       validationFunctions.push({
         keyword: schemaKeywords.name,
         args: propertyName
@@ -228,7 +228,7 @@ var SchemaGenerator = class _SchemaGenerator extends BaseGenerator {
     }).reduce((acc, curr) => ({ ...acc, ...curr }), {});
     let additionalPropertiesSchemas = [];
     if (additionalProperties) {
-      additionalPropertiesSchemas = additionalProperties === true || !Object.keys(additionalProperties).length ? [{ keyword: this.#getUnknownReturn({ schema, name }) }] : this.parse({ schema: additionalProperties, parentName: name });
+      additionalPropertiesSchemas = additionalProperties === true || !Object.keys(additionalProperties).length ? [{ keyword: this.#getUnknownReturn({ schemaObject, name }) }] : this.parse({ schemaObject: additionalProperties, parentName: name });
     }
     return [
       {
@@ -243,23 +243,57 @@ var SchemaGenerator = class _SchemaGenerator extends BaseGenerator {
   /**
    * Create a type alias for the schema referenced by the given ReferenceObject
    */
-  #getRefAlias(obj) {
-    const { $ref } = obj;
-    let ref = this.refs[$ref];
-    const originalName = getUniqueName($ref.replace(/.+\//, ""), this.#usedAliasNames);
-    const propertyName = this.context.pluginManager.resolveName({
-      name: originalName,
-      pluginKey: this.context.plugin.key,
-      type: "function"
-    });
+  #getRefAlias(schemaObject, name) {
+    const { $ref } = schemaObject;
+    const ref = this.refs[$ref];
     if (ref) {
+      const dereferencedSchema = this.context.oas.dereferenceWithRef(schemaObject);
+      if (dereferencedSchema && isDiscriminator(dereferencedSchema)) {
+        const [key] = Object.entries(dereferencedSchema.discriminator.mapping || {}).find(([_key, value]) => value.replace(/.+\//, "") === name) || [];
+        if (key) {
+          return [
+            {
+              keyword: schemaKeywords.and,
+              args: [
+                {
+                  keyword: schemaKeywords.ref,
+                  args: { name: ref.propertyName, $ref, path: ref.path, isImportable: !!this.context.oas.get($ref) }
+                },
+                {
+                  keyword: schemaKeywords.object,
+                  args: {
+                    properties: {
+                      [dereferencedSchema.discriminator.propertyName]: [
+                        {
+                          keyword: schemaKeywords.const,
+                          args: {
+                            name: key,
+                            format: "string",
+                            value: key
+                          }
+                        }
+                      ]
+                    }
+                  }
+                }
+              ]
+            }
+          ];
+        }
+      }
       return [
         {
           keyword: schemaKeywords.ref,
-          args: { name: ref.propertyName, path: ref.path, isImportable: !!this.context.oas.get($ref) }
+          args: { name: ref.propertyName, $ref, path: ref.path, isImportable: !!this.context.oas.get($ref) }
         }
       ];
     }
+    const originalName = getUniqueName($ref.replace(/.+\//, ""), this.#usedAliasNames);
+    const propertyName = this.context.pluginManager.resolveName({
+      name: originalName,
+      pluginKey: this.context.plugin.key,
+      type: "function"
+    });
     const fileName = this.context.pluginManager.resolveName({
       name: originalName,
       pluginKey: this.context.plugin.key,
@@ -270,73 +304,116 @@ var SchemaGenerator = class _SchemaGenerator extends BaseGenerator {
       pluginKey: this.context.plugin.key,
       extname: ".ts"
     });
-    ref = this.refs[$ref] = {
+    this.refs[$ref] = {
       propertyName,
       originalName,
       path: file.path
     };
-    return [
-      {
-        keyword: schemaKeywords.ref,
-        args: { name: ref.propertyName, path: ref?.path, isImportable: !!this.context.oas.get($ref) }
-      }
-    ];
+    return this.#getRefAlias(schemaObject, name);
   }
   #getParsedSchemaObject(schema) {
-    const parsedSchema = getSchemaFactory(this.context.oas)(schema);
-    return parsedSchema;
+    return getSchemaFactory(this.context.oas)(schema);
+  }
+  #addDiscriminatorToSchema({
+    schema,
+    schemaObject,
+    discriminator
+  }) {
+    if (!isKeyword(schema, schemaKeywords.union)) {
+      return schema;
+    }
+    const objectPropertySchema = _SchemaGenerator.find(this.parse({ schemaObject }), schemaKeywords.object);
+    return {
+      ...schema,
+      args: schema.args.map((arg) => {
+        const isRef = isKeyword(arg, schemaKeywords.ref);
+        if (isRef) {
+          const [key] = Object.entries(discriminator.mapping || {}).find(([_key, value]) => value === arg.args.$ref) || [];
+          if (!key) {
+            throw new Error(`Can not find a key in discriminator ${JSON.stringify(schema)}`);
+          }
+          return {
+            keyword: schemaKeywords.and,
+            args: [
+              arg,
+              {
+                keyword: schemaKeywords.object,
+                args: {
+                  properties: {
+                    ...objectPropertySchema?.args?.properties || {},
+                    [discriminator.propertyName]: [
+                      {
+                        keyword: schemaKeywords.const,
+                        args: {
+                          name: key,
+                          format: "string",
+                          value: key
+                        }
+                      },
+                      //enum and literal will conflict
+                      ...objectPropertySchema?.args?.properties[discriminator.propertyName] || []
+                    ].filter((item) => !isKeyword(item, schemaKeywords.enum))
+                  }
+                }
+              }
+            ]
+          };
+        }
+        return arg;
+      })
+    };
   }
   /**
    * This is the very core of the OpenAPI to TS conversion - it takes a
    * schema and returns the appropriate type.
    */
-  #parseSchemaObject({ schema: _schema, name, parentName }) {
-    const options = this.#getOptions({ schema: _schema, name });
-    const unknownReturn = this.#getUnknownReturn({ schema: _schema, name });
-    const { schema, version } = this.#getParsedSchemaObject(_schema);
-    if (!schema) {
+  #parseSchemaObject({ schemaObject: _schemaObject, name, parentName }) {
+    const { schemaObject, version } = this.#getParsedSchemaObject(_schemaObject);
+    const options = this.#getOptions({ schemaObject, name });
+    const unknownReturn = this.#getUnknownReturn({ schemaObject, name });
+    if (!schemaObject) {
       return [{ keyword: unknownReturn }];
     }
     const baseItems = [
       {
         keyword: schemaKeywords.schema,
         args: {
-          type: schema.type,
-          format: schema.format
+          type: schemaObject.type,
+          format: schemaObject.format
         }
       }
     ];
-    const min = schema.minimum ?? schema.minLength ?? schema.minItems ?? void 0;
-    const max = schema.maximum ?? schema.maxLength ?? schema.maxItems ?? void 0;
-    const nullable = isNullable(schema);
-    const defaultNullAndNullable = schema.default === null && nullable;
-    if (schema.default !== void 0 && !defaultNullAndNullable && !Array.isArray(schema.default)) {
-      if (typeof schema.default === "string") {
+    const min = schemaObject.minimum ?? schemaObject.minLength ?? schemaObject.minItems ?? void 0;
+    const max = schemaObject.maximum ?? schemaObject.maxLength ?? schemaObject.maxItems ?? void 0;
+    const nullable = isNullable(schemaObject);
+    const defaultNullAndNullable = schemaObject.default === null && nullable;
+    if (schemaObject.default !== void 0 && !defaultNullAndNullable && !Array.isArray(schemaObject.default)) {
+      if (typeof schemaObject.default === "string") {
         baseItems.push({
           keyword: schemaKeywords.default,
-          args: transformers.stringify(schema.default)
+          args: transformers.stringify(schemaObject.default)
         });
-      } else if (typeof schema.default === "boolean") {
+      } else if (typeof schemaObject.default === "boolean") {
         baseItems.push({
           keyword: schemaKeywords.default,
-          args: schema.default ?? false
+          args: schemaObject.default ?? false
         });
       } else {
         baseItems.push({
           keyword: schemaKeywords.default,
-          args: schema.default
+          args: schemaObject.default
         });
       }
     }
-    if (schema.deprecated) {
+    if (schemaObject.deprecated) {
       baseItems.push({
         keyword: schemaKeywords.deprecated
       });
     }
-    if (schema.description) {
+    if (schemaObject.description) {
       baseItems.push({
         keyword: schemaKeywords.describe,
-        args: schema.description
+        args: schemaObject.description
       });
     }
     if (max !== void 0) {
@@ -348,49 +425,51 @@ var SchemaGenerator = class _SchemaGenerator extends BaseGenerator {
     if (nullable) {
       baseItems.push({ keyword: schemaKeywords.nullable });
     }
-    if (schema.type && Array.isArray(schema.type)) {
-      const [_schema2, nullable2] = schema.type;
+    if (schemaObject.type && Array.isArray(schemaObject.type)) {
+      const [_schema, nullable2] = schemaObject.type;
       if (nullable2 === "null") {
         baseItems.push({ keyword: schemaKeywords.nullable });
       }
     }
-    if (schema.readOnly) {
+    if (schemaObject.readOnly) {
       baseItems.push({ keyword: schemaKeywords.readOnly });
     }
-    if (schema.writeOnly) {
+    if (schemaObject.writeOnly) {
       baseItems.push({ keyword: schemaKeywords.writeOnly });
     }
-    if (isReference(schema)) {
+    if (isReference(schemaObject)) {
       return [
-        ...this.#getRefAlias(schema),
-        schema.description && {
+        ...this.#getRefAlias(schemaObject, name),
+        schemaObject.description && {
           keyword: schemaKeywords.describe,
-          args: schema.description
+          args: schemaObject.description
         },
         nullable && { keyword: schemaKeywords.nullable },
-        schema.readOnly && { keyword: schemaKeywords.readOnly },
-        schema.writeOnly && { keyword: schemaKeywords.writeOnly },
+        schemaObject.readOnly && { keyword: schemaKeywords.readOnly },
+        schemaObject.writeOnly && { keyword: schemaKeywords.writeOnly },
         {
           keyword: schemaKeywords.schema,
           args: {
-            type: schema.type,
-            format: schema.format
+            type: schemaObject.type,
+            format: schemaObject.format
           }
         }
       ].filter(Boolean);
     }
-    if (schema.oneOf) {
-      const schemaWithoutOneOf = { ...schema, oneOf: void 0 };
+    if (schemaObject.oneOf) {
+      const schemaWithoutOneOf = { ...schemaObject, oneOf: void 0 };
       const union = {
         keyword: schemaKeywords.union,
-        args: schema.oneOf.map((item) => {
-          return item && this.parse({ schema: item, name, parentName })[0];
-        }).filter(Boolean).filter((item) => {
-          return item && item.keyword !== unknownReturn;
-        })
+        args: schemaObject.oneOf.map((item) => {
+          return item && this.parse({ schemaObject: item, name, parentName })[0];
+        }).filter(Boolean).filter((item) => !isKeyword(item, schemaKeywords.unknown))
       };
+      const discriminator = this.context.oas.getDiscriminator(schemaObject);
+      if (discriminator) {
+        return [this.#addDiscriminatorToSchema({ schemaObject: schemaWithoutOneOf, schema: union, discriminator }), ...baseItems];
+      }
       if (schemaWithoutOneOf.properties) {
-        const propertySchemas = this.parse({ schema: schemaWithoutOneOf, name, parentName });
+        const propertySchemas = this.parse({ schemaObject: schemaWithoutOneOf, name, parentName });
         union.args = [
           ...union.args.map((arg) => {
             return {
@@ -399,18 +478,17 @@ var SchemaGenerator = class _SchemaGenerator extends BaseGenerator {
             };
           })
         ];
+        return [union, ...baseItems];
       }
       return [union, ...baseItems];
     }
-    if (schema.anyOf) {
-      const schemaWithoutAnyOf = { ...schema, anyOf: void 0 };
+    if (schemaObject.anyOf) {
+      const schemaWithoutAnyOf = { ...schemaObject, anyOf: void 0 };
       const union = {
         keyword: schemaKeywords.union,
-        args: schema.anyOf.map((item) => {
-          return item && this.parse({ schema: item, name, parentName })[0];
-        }).filter(Boolean).filter((item) => {
-          return item && item.keyword !== unknownReturn;
-        }).map((item) => {
+        args: schemaObject.anyOf.map((item) => {
+          return item && this.parse({ schemaObject: item, name, parentName })[0];
+        }).filter(Boolean).filter((item) => !isKeyword(item, schemaKeywords.unknown)).map((item) => {
           if (isKeyword(item, schemaKeywords.object)) {
             return {
               ...item,
@@ -423,23 +501,34 @@ var SchemaGenerator = class _SchemaGenerator extends BaseGenerator {
           return item;
         })
       };
+      const discriminator = this.context.oas.getDiscriminator(schemaObject);
+      if (discriminator) {
+        return [this.#addDiscriminatorToSchema({ schemaObject: schemaWithoutAnyOf, schema: union, discriminator }), ...baseItems];
+      }
       if (schemaWithoutAnyOf.properties) {
-        return [...this.parse({ schema: schemaWithoutAnyOf, name, parentName }), union, ...baseItems];
+        const propertySchemas = this.parse({ schemaObject: schemaWithoutAnyOf, name, parentName });
+        union.args = [
+          ...union.args.map((arg) => {
+            return {
+              keyword: schemaKeywords.and,
+              args: [arg, ...propertySchemas]
+            };
+          })
+        ];
+        return [union, ...baseItems];
       }
       return [union, ...baseItems];
     }
-    if (schema.allOf) {
-      const schemaWithoutAllOf = { ...schema, allOf: void 0 };
+    if (schemaObject.allOf) {
+      const schemaWithoutAllOf = { ...schemaObject, allOf: void 0 };
       const and = {
         keyword: schemaKeywords.and,
-        args: schema.allOf.map((item) => {
-          return item && this.parse({ schema: item, name, parentName })[0];
-        }).filter(Boolean).filter((item) => {
-          return item && item.keyword !== unknownReturn;
-        })
+        args: schemaObject.allOf.map((item) => {
+          return item && this.parse({ schemaObject: item, name, parentName })[0];
+        }).filter(Boolean).filter((item) => !isKeyword(item, schemaKeywords.unknown))
       };
       if (schemaWithoutAllOf.required) {
-        const schemas = schema.allOf.map((item) => {
+        const schemas = schemaObject.allOf.map((item) => {
           if (isReference(item)) {
             return this.context.oas.get(item.$ref);
           }
@@ -450,40 +539,40 @@ var SchemaGenerator = class _SchemaGenerator extends BaseGenerator {
           }
           return true;
         }).map((key) => {
-          const schema2 = schemas.find((item) => item.properties && Object.keys(item.properties).find((propertyKey) => propertyKey === key));
-          if (schema2?.properties?.[key]) {
+          const schema = schemas.find((item) => item.properties && Object.keys(item.properties).find((propertyKey) => propertyKey === key));
+          if (schema?.properties?.[key]) {
             return {
-              ...schema2,
+              ...schema,
               properties: {
-                [key]: schema2.properties[key]
+                [key]: schema.properties[key]
               },
               required: [key]
             };
           }
         }).filter(Boolean);
-        and.args = [...and.args || [], ...items.flatMap((item) => this.parse({ schema: item, name, parentName }))];
+        and.args = [...and.args || [], ...items.flatMap((item) => this.parse({ schemaObject: item, name, parentName }))];
       }
       if (schemaWithoutAllOf.properties) {
-        and.args = [...and.args || [], ...this.parse({ schema: schemaWithoutAllOf, name, parentName })];
+        and.args = [...and.args || [], ...this.parse({ schemaObject: schemaWithoutAllOf, name, parentName })];
       }
       return [and, ...baseItems];
     }
-    if (schema.enum) {
+    if (schemaObject.enum) {
       if (options.enumSuffix === "") {
-        throw new Error("EnumSuffix set to an empty string does not work");
+        this.context.pluginManager.logger.emit("info", "EnumSuffix set to an empty string does not work");
       }
-      const enumName = getUniqueName(pascalCase([parentName, name, options.enumSuffix].join(" ")), this.#getUsedEnumNames({ schema, name }));
+      const enumName = getUniqueName(pascalCase([parentName, name, options.enumSuffix].join(" ")), this.#getUsedEnumNames({ schemaObject, name }));
       const typeName = this.context.pluginManager.resolveName({
         name: enumName,
         pluginKey: this.context.plugin.key,
         type: "type"
       });
-      const nullableEnum = schema.enum.includes(null);
+      const nullableEnum = schemaObject.enum.includes(null);
       if (nullableEnum) {
         baseItems.push({ keyword: schemaKeywords.nullable });
       }
-      const filteredValues = schema.enum.filter((value) => value !== null);
-      const extensionEnums = ["x-enumNames", "x-enum-varnames"].filter((extensionKey) => extensionKey in schema).map((extensionKey) => {
+      const filteredValues = schemaObject.enum.filter((value) => value !== null);
+      const extensionEnums = ["x-enumNames", "x-enum-varnames"].filter((extensionKey) => extensionKey in schemaObject).map((extensionKey) => {
         return [
           {
             keyword: schemaKeywords.enum,
@@ -491,10 +580,10 @@ var SchemaGenerator = class _SchemaGenerator extends BaseGenerator {
               name,
               typeName,
               asConst: false,
-              items: [...new Set(schema[extensionKey])].map((name2, index) => ({
+              items: [...new Set(schemaObject[extensionKey])].map((name2, index) => ({
                 name: transformers.stringify(name2),
-                value: schema.enum?.[index],
-                format: isNumber(schema.enum?.[index]) ? "number" : "string"
+                value: schemaObject.enum?.[index],
+                format: isNumber(schemaObject.enum?.[index]) ? "number" : "string"
               }))
             }
           },
@@ -503,7 +592,7 @@ var SchemaGenerator = class _SchemaGenerator extends BaseGenerator {
           )
         ];
       });
-      if (schema.type === "number" || schema.type === "integer") {
+      if (schemaObject.type === "number" || schemaObject.type === "integer") {
         const enumNames = extensionEnums[0]?.find((item) => isKeyword(item, schemaKeywords.enum));
         return [
           {
@@ -528,7 +617,7 @@ var SchemaGenerator = class _SchemaGenerator extends BaseGenerator {
           ...baseItems.filter((item) => item.keyword !== schemaKeywords.min && item.keyword !== schemaKeywords.max && item.keyword !== schemaKeywords.matches)
         ];
       }
-      if (schema.type === "boolean") {
+      if (schemaObject.type === "boolean") {
         const enumNames = extensionEnums[0]?.find((item) => isKeyword(item, schemaKeywords.enum));
         return [
           {
@@ -573,10 +662,10 @@ var SchemaGenerator = class _SchemaGenerator extends BaseGenerator {
         ...baseItems.filter((item) => item.keyword !== schemaKeywords.min && item.keyword !== schemaKeywords.max && item.keyword !== schemaKeywords.matches)
       ];
     }
-    if ("prefixItems" in schema) {
-      const prefixItems = schema.prefixItems;
-      const min2 = schema.minimum ?? schema.minLength ?? schema.minItems ?? void 0;
-      const max2 = schema.maximum ?? schema.maxLength ?? schema.maxItems ?? void 0;
+    if ("prefixItems" in schemaObject) {
+      const prefixItems = schemaObject.prefixItems;
+      const min2 = schemaObject.minimum ?? schemaObject.minLength ?? schemaObject.minItems ?? void 0;
+      const max2 = schemaObject.maximum ?? schemaObject.maxLength ?? schemaObject.maxItems ?? void 0;
       return [
         {
           keyword: schemaKeywords.tuple,
@@ -584,22 +673,22 @@ var SchemaGenerator = class _SchemaGenerator extends BaseGenerator {
             min: min2,
             max: max2,
             items: prefixItems.map((item) => {
-              return this.parse({ schema: item, name, parentName })[0];
+              return this.parse({ schemaObject: item, name, parentName })[0];
             }).filter(Boolean)
           }
         },
         ...baseItems.filter((item) => item.keyword !== schemaKeywords.min && item.keyword !== schemaKeywords.max)
       ];
     }
-    if (version === "3.1" && "const" in schema) {
-      if (schema["const"]) {
+    if (version === "3.1" && "const" in schemaObject) {
+      if (schemaObject["const"]) {
         return [
           {
             keyword: schemaKeywords.const,
             args: {
-              name: schema["const"],
-              format: typeof schema["const"] === "number" ? "number" : "string",
-              value: schema["const"]
+              name: schemaObject["const"],
+              format: typeof schemaObject["const"] === "number" ? "number" : "string",
+              value: schemaObject["const"]
             }
           },
           ...baseItems
@@ -607,8 +696,8 @@ var SchemaGenerator = class _SchemaGenerator extends BaseGenerator {
       }
       return [{ keyword: schemaKeywords.null }];
     }
-    if (schema.format) {
-      switch (schema.format) {
+    if (schemaObject.format) {
+      switch (schemaObject.format) {
         case "binary":
           baseItems.push({ keyword: schemaKeywords.blob });
           return baseItems;
@@ -667,18 +756,18 @@ var SchemaGenerator = class _SchemaGenerator extends BaseGenerator {
           return baseItems;
       }
     }
-    if (schema.pattern) {
+    if (schemaObject.pattern) {
       baseItems.unshift({
         keyword: schemaKeywords.matches,
-        args: schema.pattern
+        args: schemaObject.pattern
       });
       return baseItems;
     }
-    if ("items" in schema || schema.type === "array") {
-      const min2 = schema.minimum ?? schema.minLength ?? schema.minItems ?? void 0;
-      const max2 = schema.maximum ?? schema.maxLength ?? schema.maxItems ?? void 0;
-      const items = this.parse({ schema: "items" in schema ? schema.items : [], name, parentName });
-      const unique = !!schema.uniqueItems;
+    if ("items" in schemaObject || schemaObject.type === "array") {
+      const min2 = schemaObject.minimum ?? schemaObject.minLength ?? schemaObject.minItems ?? void 0;
+      const max2 = schemaObject.maximum ?? schemaObject.maxLength ?? schemaObject.maxItems ?? void 0;
+      const items = this.parse({ schemaObject: "items" in schemaObject ? schemaObject.items : [], name, parentName });
+      const unique = !!schemaObject.uniqueItems;
       return [
         {
           keyword: schemaKeywords.array,
@@ -692,16 +781,40 @@ var SchemaGenerator = class _SchemaGenerator extends BaseGenerator {
         ...baseItems.filter((item) => item.keyword !== schemaKeywords.min && item.keyword !== schemaKeywords.max)
       ];
     }
-    if (schema.properties || schema.additionalProperties) {
-      return [...this.#parseProperties({ schema, name }), ...baseItems];
+    if (schemaObject.properties || schemaObject.additionalProperties) {
+      if (isDiscriminator(schemaObject)) {
+        const schemaObjectOverriden = Object.keys(schemaObject.properties || {}).reduce((acc, propertyName) => {
+          if (acc.properties?.[propertyName] && propertyName === schemaObject.discriminator.propertyName) {
+            return {
+              ...acc,
+              properties: {
+                ...acc.properties,
+                [propertyName]: {
+                  ...acc.properties[propertyName] || {},
+                  enum: schemaObject.discriminator.mapping ? Object.keys(schemaObject.discriminator.mapping) : void 0
+                }
+              }
+            };
+          }
+          return acc;
+        }, schemaObject || {});
+        return [
+          ...this.#parseProperties({
+            schemaObject: schemaObjectOverriden,
+            name
+          }),
+          ...baseItems
+        ];
+      }
+      return [...this.#parseProperties({ schemaObject, name }), ...baseItems];
     }
-    if (schema.type) {
-      if (Array.isArray(schema.type)) {
-        const [type] = schema.type;
+    if (schemaObject.type) {
+      if (Array.isArray(schemaObject.type)) {
+        const [type] = schemaObject.type;
         return [
           ...this.parse({
-            schema: {
-              ...schema,
+            schemaObject: {
+              ...schemaObject,
               type
             },
             name,
@@ -710,16 +823,15 @@ var SchemaGenerator = class _SchemaGenerator extends BaseGenerator {
           ...baseItems
         ].filter(Boolean);
       }
-      if (!["boolean", "object", "number", "string", "integer", "null"].includes(schema.type)) {
-        this.context.pluginManager.logger.emit("warning", `Schema type '${schema.type}' is not valid for schema ${parentName}.${name}`);
+      if (!["boolean", "object", "number", "string", "integer", "null"].includes(schemaObject.type)) {
+        this.context.pluginManager.logger.emit("warning", `Schema type '${schemaObject.type}' is not valid for schema ${parentName}.${name}`);
       }
-      return [{ keyword: schema.type }, ...baseItems];
+      return [{ keyword: schemaObject.type }, ...baseItems];
     }
     return [{ keyword: unknownReturn }];
   }
   async build(...generators) {
     const { oas, contentType, include } = this.context;
-    oas.resolveDiscriminators();
     const schemas = getSchemas({ oas, contentType, includes: include });
     const promises = Object.entries(schemas).reduce((acc, [name, value]) => {
       if (!value) {
@@ -734,7 +846,7 @@ var SchemaGenerator = class _SchemaGenerator extends BaseGenerator {
         acc.push(promiseOperation);
       }
       generators?.forEach((generator) => {
-        const tree = this.parse({ schema: value, name });
+        const tree = this.parse({ schemaObject: value, name });
         const promise = generator.schema?.({
           instance: this,
           schema: {
@@ -765,5 +877,5 @@ var SchemaGenerator = class _SchemaGenerator extends BaseGenerator {
 };
 
 export { SchemaGenerator, isKeyword, schemaKeywords };
-//# sourceMappingURL=chunk-72MVTXCW.js.map
-//# sourceMappingURL=chunk-72MVTXCW.js.map
+//# sourceMappingURL=chunk-5JWN6NVC.js.map
+//# sourceMappingURL=chunk-5JWN6NVC.js.map