@kubb/plugin-oas 3.0.0-alpha.1 → 3.0.0-alpha.11

package/dist/{chunk-DRLYORTT.cjs → chunk-47SNBYWH.cjs}

@@ -1,18 +1,21 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+'use strict';
 
+var chunkXQPCA75E_cjs = require('./chunk-XQPCA75E.cjs');
+var core = require('@kubb/core');
+var transformers = require('@kubb/core/transformers');
+var utils = require('@kubb/core/utils');
+var oas = require('@kubb/oas');
+var remeda = require('remeda');
+var react = require('@kubb/react');
 
-var _chunkCJXRFYEFcjs = require('./chunk-CJXRFYEF.cjs');
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-
-
-
-var _chunkP42X362Ucjs = require('./chunk-P42X362U.cjs');
+var transformers__default = /*#__PURE__*/_interopDefault(transformers);
 
 // ../../node_modules/.pnpm/react@18.3.1/node_modules/react/cjs/react.production.min.js
-var require_react_production_min = _chunkP42X362Ucjs.__commonJS.call(void 0, {
+var require_react_production_min = chunkXQPCA75E_cjs.__commonJS({
   "../../node_modules/.pnpm/react@18.3.1/node_modules/react/cjs/react.production.min.js"(exports) {
-    "use strict";
-    _chunkP42X362Ucjs.init_cjs_shims.call(void 0, );
+    chunkXQPCA75E_cjs.init_cjs_shims();
     var l = Symbol.for("react.element");
     var n = Symbol.for("react.portal");
     var p = Symbol.for("react.fragment");
@@ -283,13 +286,11 @@ var require_react_production_min = _chunkP42X362Ucjs.__commonJS.call(void 0, {
 });
 
 // ../../node_modules/.pnpm/react@18.3.1/node_modules/react/cjs/react.development.js
-var require_react_development = _chunkP42X362Ucjs.__commonJS.call(void 0, {
+var require_react_development = chunkXQPCA75E_cjs.__commonJS({
   "../../node_modules/.pnpm/react@18.3.1/node_modules/react/cjs/react.development.js"(exports, module) {
-    "use strict";
-    _chunkP42X362Ucjs.init_cjs_shims.call(void 0, );
+    chunkXQPCA75E_cjs.init_cjs_shims();
     if (process.env.NODE_ENV !== "production") {
       (function() {
-        "use strict";
         if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function") {
           __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
         }
@@ -2158,10 +2159,9 @@ var require_react_development = _chunkP42X362Ucjs.__commonJS.call(void 0, {
 });
 
 // ../../node_modules/.pnpm/react@18.3.1/node_modules/react/index.js
-var require_react = _chunkP42X362Ucjs.__commonJS.call(void 0, {
+var require_react = chunkXQPCA75E_cjs.__commonJS({
   "../../node_modules/.pnpm/react@18.3.1/node_modules/react/index.js"(exports, module) {
-    "use strict";
-    _chunkP42X362Ucjs.init_cjs_shims.call(void 0, );
+    chunkXQPCA75E_cjs.init_cjs_shims();
     if (process.env.NODE_ENV === "production") {
       module.exports = require_react_production_min();
     } else {
@@ -2171,10 +2171,9 @@ var require_react = _chunkP42X362Ucjs.__commonJS.call(void 0, {
 });
 
 // ../../node_modules/.pnpm/react@18.3.1/node_modules/react/cjs/react-jsx-runtime.production.min.js
-var require_react_jsx_runtime_production_min = _chunkP42X362Ucjs.__commonJS.call(void 0, {
+var require_react_jsx_runtime_production_min = chunkXQPCA75E_cjs.__commonJS({
   "../../node_modules/.pnpm/react@18.3.1/node_modules/react/cjs/react-jsx-runtime.production.min.js"(exports) {
-    "use strict";
-    _chunkP42X362Ucjs.init_cjs_shims.call(void 0, );
+    chunkXQPCA75E_cjs.init_cjs_shims();
     var f = require_react();
     var k = Symbol.for("react.element");
     var l = Symbol.for("react.fragment");
@@ -2197,13 +2196,11 @@ var require_react_jsx_runtime_production_min = _chunkP42X362Ucjs.__commonJS.call
 });
 
 // ../../node_modules/.pnpm/react@18.3.1/node_modules/react/cjs/react-jsx-runtime.development.js
-var require_react_jsx_runtime_development = _chunkP42X362Ucjs.__commonJS.call(void 0, {
+var require_react_jsx_runtime_development = chunkXQPCA75E_cjs.__commonJS({
   "../../node_modules/.pnpm/react@18.3.1/node_modules/react/cjs/react-jsx-runtime.development.js"(exports) {
-    "use strict";
-    _chunkP42X362Ucjs.init_cjs_shims.call(void 0, );
+    chunkXQPCA75E_cjs.init_cjs_shims();
     if (process.env.NODE_ENV !== "production") {
       (function() {
-        "use strict";
         var React = require_react();
         var REACT_ELEMENT_TYPE = Symbol.for("react.element");
         var REACT_PORTAL_TYPE = Symbol.for("react.portal");
@@ -2876,11 +2873,6 @@ var require_react_jsx_runtime_development = _chunkP42X362Ucjs.__commonJS.call(vo
         }
         function getSourceInfoErrorAddendum(source) {
           {
-            if (source !== void 0) {
-              var fileName = source.fileName.replace(/^.*[\\\/]/, "");
-              var lineNumber = source.lineNumber;
-              return "\n\nCheck your code at " + fileName + ":" + lineNumber + ".";
-            }
             return "";
           }
         }
@@ -3006,7 +2998,7 @@ var require_react_jsx_runtime_development = _chunkP42X362Ucjs.__commonJS.call(vo
               if (type === void 0 || typeof type === "object" && type !== null && Object.keys(type).length === 0) {
                 info += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.";
               }
-              var sourceInfo = getSourceInfoErrorAddendum(source);
+              var sourceInfo = getSourceInfoErrorAddendum();
               if (sourceInfo) {
                 info += sourceInfo;
               } else {
@@ -3091,10 +3083,9 @@ var require_react_jsx_runtime_development = _chunkP42X362Ucjs.__commonJS.call(vo
 });
 
 // ../../node_modules/.pnpm/react@18.3.1/node_modules/react/jsx-runtime.js
-var require_jsx_runtime = _chunkP42X362Ucjs.__commonJS.call(void 0, {
+var require_jsx_runtime = chunkXQPCA75E_cjs.__commonJS({
   "../../node_modules/.pnpm/react@18.3.1/node_modules/react/jsx-runtime.js"(exports, module) {
-    "use strict";
-    _chunkP42X362Ucjs.init_cjs_shims.call(void 0, );
+    chunkXQPCA75E_cjs.init_cjs_shims();
     if (process.env.NODE_ENV === "production") {
       module.exports = require_react_jsx_runtime_production_min();
     } else {
@@ -3103,25 +3094,709 @@ var require_jsx_runtime = _chunkP42X362Ucjs.__commonJS.call(void 0, {
   }
 });
 
+// src/SchemaMapper.ts
+chunkXQPCA75E_cjs.init_cjs_shims();
+var schemaKeywords = {
+  any: "any",
+  strict: "strict",
+  unknown: "unknown",
+  number: "number",
+  integer: "integer",
+  string: "string",
+  boolean: "boolean",
+  undefined: "undefined",
+  nullable: "nullable",
+  null: "null",
+  nullish: "nullish",
+  array: "array",
+  tuple: "tuple",
+  enum: "enum",
+  union: "union",
+  datetime: "datetime",
+  date: "date",
+  email: "email",
+  uuid: "uuid",
+  url: "url",
+  /* intersection */
+  default: "default",
+  const: "const",
+  and: "and",
+  describe: "describe",
+  min: "min",
+  max: "max",
+  optional: "optional",
+  readOnly: "readOnly",
+  // custom ones
+  object: "object",
+  ref: "ref",
+  matches: "matches",
+  firstName: "firstName",
+  lastName: "lastName",
+  password: "password",
+  phone: "phone",
+  blob: "blob",
+  deprecated: "deprecated",
+  example: "example",
+  schema: "schema",
+  catchall: "catchall",
+  time: "time",
+  name: "name"
+};
+function isKeyword(meta, keyword) {
+  return meta.keyword === keyword;
+}
+
+// src/SchemaGenerator.ts
+chunkXQPCA75E_cjs.init_cjs_shims();
+var SchemaGenerator = class _SchemaGenerator extends core.BaseGenerator {
+  // Collect the types of all referenced schemas, so we can export them later
+  refs = {};
+  // Keep track of already used type aliases
+  #usedAliasNames = {};
+  /**
+   * Creates a type node from a given schema.
+   * Delegates to getBaseTypeFromSchema internally and
+   * optionally adds a union with null.
+   */
+  parse(props) {
+    const options = this.#getOptions(props);
+    const defaultSchemas = this.#parseSchemaObject(props);
+    const schemas = options.transformers?.schema?.(props, defaultSchemas) || defaultSchemas || [];
+    return remeda.uniqueWith(schemas, remeda.isDeepEqual);
+  }
+  deepSearch(tree, keyword) {
+    return _SchemaGenerator.deepSearch(tree, keyword);
+  }
+  find(tree, keyword) {
+    return _SchemaGenerator.find(tree, keyword);
+  }
+  static deepSearch(tree, keyword) {
+    const foundItems = [];
+    tree?.forEach((schema) => {
+      if (schema.keyword === keyword) {
+        foundItems.push(schema);
+      }
+      if (schema.keyword === schemaKeywords.object) {
+        const subItem = schema;
+        Object.values(subItem.args?.properties || {}).forEach((entrySchema) => {
+          foundItems.push(..._SchemaGenerator.deepSearch(entrySchema, keyword));
+        });
+        Object.values(subItem.args?.additionalProperties || {}).forEach((entrySchema) => {
+          foundItems.push(..._SchemaGenerator.deepSearch([entrySchema], keyword));
+        });
+      }
+      if (schema.keyword === schemaKeywords.array) {
+        const subItem = schema;
+        subItem.args.items.forEach((entrySchema) => {
+          foundItems.push(..._SchemaGenerator.deepSearch([entrySchema], keyword));
+        });
+      }
+      if (schema.keyword === schemaKeywords.and) {
+        const subItem = schema;
+        subItem.args.forEach((entrySchema) => {
+          foundItems.push(..._SchemaGenerator.deepSearch([entrySchema], keyword));
+        });
+      }
+      if (schema.keyword === schemaKeywords.tuple) {
+        const subItem = schema;
+        subItem.args.items.forEach((entrySchema) => {
+          foundItems.push(..._SchemaGenerator.deepSearch([entrySchema], keyword));
+        });
+      }
+      if (schema.keyword === schemaKeywords.union) {
+        const subItem = schema;
+        subItem.args.forEach((entrySchema) => {
+          foundItems.push(..._SchemaGenerator.deepSearch([entrySchema], keyword));
+        });
+      }
+    });
+    return foundItems;
+  }
+  static findInObject(tree, keyword) {
+    let foundItem = void 0;
+    tree?.forEach((schema) => {
+      if (!foundItem && schema.keyword === keyword) {
+        foundItem = schema;
+      }
+      if (schema.keyword === schemaKeywords.object) {
+        const subItem = schema;
+        Object.values(subItem.args?.properties || {}).forEach((entrySchema) => {
+          if (!foundItem) {
+            foundItem = _SchemaGenerator.find(entrySchema, keyword);
+          }
+        });
+        Object.values(subItem.args?.additionalProperties || {}).forEach((entrySchema) => {
+          if (!foundItem) {
+            foundItem = _SchemaGenerator.find([entrySchema], keyword);
+          }
+        });
+      }
+    });
+    return foundItem;
+  }
+  static find(tree, keyword) {
+    let foundItem = void 0;
+    tree?.forEach((schema) => {
+      if (!foundItem && schema.keyword === keyword) {
+        foundItem = schema;
+      }
+      if (schema.keyword === schemaKeywords.array) {
+        const subItem = schema;
+        subItem.args.items.forEach((entrySchema) => {
+          if (!foundItem) {
+            foundItem = _SchemaGenerator.find([entrySchema], keyword);
+          }
+        });
+      }
+      if (schema.keyword === schemaKeywords.and) {
+        const subItem = schema;
+        subItem.args.forEach((entrySchema) => {
+          if (!foundItem) {
+            foundItem = _SchemaGenerator.find([entrySchema], keyword);
+          }
+        });
+      }
+      if (schema.keyword === schemaKeywords.tuple) {
+        const subItem = schema;
+        subItem.args.items.forEach((entrySchema) => {
+          if (!foundItem) {
+            foundItem = _SchemaGenerator.find([entrySchema], keyword);
+          }
+        });
+      }
+      if (schema.keyword === schemaKeywords.union) {
+        const subItem = schema;
+        subItem.args.forEach((entrySchema) => {
+          if (!foundItem) {
+            foundItem = _SchemaGenerator.find([entrySchema], keyword);
+          }
+        });
+      }
+    });
+    return foundItem;
+  }
+  #getUsedEnumNames(props) {
+    const options = this.#getOptions(props);
+    return options.usedEnumNames || {};
+  }
+  #getOptions({ name }) {
+    const { override = [] } = this.context;
+    return {
+      ...this.options,
+      ...override.find(({ pattern, type }) => {
+        if (name && type === "schemaName") {
+          return !!name.match(pattern);
+        }
+        return false;
+      })?.options || {}
+    };
+  }
+  #getUnknownReturn(props) {
+    const options = this.#getOptions(props);
+    if (options.unknownType === "any") {
+      return schemaKeywords.any;
+    }
+    return schemaKeywords.unknown;
+  }
+  /**
+   * Recursively creates a type literal with the given props.
+   */
+  #parseProperties({ schema, name }) {
+    const properties = schema?.properties || {};
+    const additionalProperties = schema?.additionalProperties;
+    const required = schema?.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({
+        keyword: schemaKeywords.name,
+        args: propertyName
+      });
+      if (!isRequired && nullable) {
+        validationFunctions.push({ keyword: schemaKeywords.nullish });
+      } else if (!isRequired) {
+        validationFunctions.push({ keyword: schemaKeywords.optional });
+      }
+      return {
+        [propertyName]: validationFunctions
+      };
+    }).reduce((acc, curr) => ({ ...acc, ...curr }), {});
+    let additionalPropertiesSchemas = [];
+    if (additionalProperties) {
+      additionalPropertiesSchemas = additionalProperties === true ? [{ keyword: this.#getUnknownReturn({ schema, name }) }] : this.parse({ schema: additionalProperties, parentName: name });
+    }
+    return [
+      {
+        keyword: schemaKeywords.object,
+        args: {
+          properties: propertiesSchemas,
+          additionalProperties: additionalPropertiesSchemas
+        }
+      }
+    ];
+  }
+  /**
+   * Create a type alias for the schema referenced by the given ReferenceObject
+   */
+  #getRefAlias(obj) {
+    const { $ref } = obj;
+    let ref = this.refs[$ref];
+    const originalName = utils.getUniqueName($ref.replace(/.+\//, ""), this.#usedAliasNames);
+    const propertyName = this.context.pluginManager.resolveName({
+      name: originalName,
+      pluginKey: this.context.plugin.key,
+      type: "function"
+    });
+    if (ref) {
+      return [
+        {
+          keyword: schemaKeywords.ref,
+          args: { name: ref.propertyName, path: ref.path }
+        }
+      ];
+    }
+    const fileName = this.context.pluginManager.resolveName({
+      name: originalName,
+      pluginKey: this.context.plugin.key,
+      type: "file"
+    });
+    const file = this.context.pluginManager.getFile({
+      name: fileName,
+      pluginKey: this.context.plugin.key,
+      extName: ".ts"
+    });
+    ref = this.refs[$ref] = {
+      propertyName,
+      originalName,
+      path: file.path
+    };
+    return [
+      {
+        keyword: schemaKeywords.ref,
+        args: { name: ref.propertyName, path: ref?.path }
+      }
+    ];
+  }
+  #getParsedSchemaObject(schema) {
+    const parsedSchema = chunkXQPCA75E_cjs.getSchemaFactory(this.context.oas)(schema);
+    return parsedSchema;
+  }
+  /**
+   * 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) {
+      return [{ keyword: unknownReturn }];
+    }
+    const baseItems = [
+      {
+        keyword: schemaKeywords.schema,
+        args: {
+          type: schema.type,
+          format: schema.format
+        }
+      }
+    ];
+    const min = schema.minimum ?? schema.minLength ?? schema.minItems ?? void 0;
+    const max = schema.maximum ?? schema.maxLength ?? schema.maxItems ?? void 0;
+    const nullable = schema.nullable ?? schema["x-nullable"] ?? false;
+    if (schema.default !== void 0 && !Array.isArray(schema.default)) {
+      if (typeof schema.default === "string") {
+        baseItems.push({
+          keyword: schemaKeywords.default,
+          args: transformers__default.default.stringify(schema.default)
+        });
+      } else if (typeof schema.default === "boolean") {
+        baseItems.push({
+          keyword: schemaKeywords.default,
+          args: schema.default ?? false
+        });
+      } else {
+        baseItems.push({
+          keyword: schemaKeywords.default,
+          args: schema.default
+        });
+      }
+    }
+    if (schema.description) {
+      baseItems.push({
+        keyword: schemaKeywords.describe,
+        args: schema.description
+      });
+    }
+    if (schema.pattern) {
+      baseItems.unshift({
+        keyword: schemaKeywords.matches,
+        args: schema.pattern
+      });
+    }
+    if (max !== void 0) {
+      baseItems.unshift({ keyword: schemaKeywords.max, args: max });
+    }
+    if (min !== void 0) {
+      baseItems.unshift({ keyword: schemaKeywords.min, args: min });
+    }
+    if (nullable) {
+      baseItems.push({ keyword: schemaKeywords.nullable });
+    }
+    if (schema.type && Array.isArray(schema.type)) {
+      const [_schema2, nullable2] = schema.type;
+      if (nullable2 === "null") {
+        baseItems.push({ keyword: schemaKeywords.nullable });
+      }
+    }
+    if (schema.readOnly) {
+      baseItems.push({ keyword: schemaKeywords.readOnly });
+    }
+    if (oas.isReference(schema)) {
+      return [
+        ...this.#getRefAlias(schema),
+        nullable && { keyword: schemaKeywords.nullable },
+        {
+          keyword: schemaKeywords.schema,
+          args: {
+            type: schema.type,
+            format: schema.format
+          }
+        }
+      ].filter(Boolean);
+    }
+    if (schema.oneOf) {
+      const schemaWithoutOneOf = { ...schema, 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;
+        })
+      };
+      if (schemaWithoutOneOf.properties) {
+        return [...this.parse({ schema: schemaWithoutOneOf, name, parentName }), union, ...baseItems];
+      }
+      return [union, ...baseItems];
+    }
+    if (schema.anyOf) {
+      const schemaWithoutAnyOf = { ...schema, 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) => {
+          if (isKeyword(item, schemaKeywords.object)) {
+            return {
+              ...item,
+              args: {
+                ...item.args,
+                strict: true
+              }
+            };
+          }
+          return item;
+        })
+      };
+      if (schemaWithoutAnyOf.properties) {
+        return [...this.parse({ schema: schemaWithoutAnyOf, name, parentName }), union, ...baseItems];
+      }
+      return [union, ...baseItems];
+    }
+    if (schema.allOf) {
+      const schemaWithoutAllOf = { ...schema, 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;
+        })
+      };
+      if (schemaWithoutAllOf.properties) {
+        return [
+          {
+            ...and,
+            args: [...and.args || [], ...this.parse({ schema: schemaWithoutAllOf, name, parentName })]
+          },
+          ...baseItems
+        ];
+      }
+      return [and, ...baseItems];
+    }
+    if (schema.enum) {
+      const enumName = utils.getUniqueName(transformers.pascalCase([parentName, name, options.enumSuffix].join(" ")), this.#getUsedEnumNames({ schema, name }));
+      const typeName = this.context.pluginManager.resolveName({
+        name: enumName,
+        pluginKey: this.context.plugin.key,
+        type: "type"
+      });
+      const nullableEnum = schema.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) => {
+        return [
+          {
+            keyword: schemaKeywords.enum,
+            args: {
+              name,
+              typeName,
+              asConst: false,
+              items: [...new Set(schema[extensionKey])].map((name2, index) => ({
+                name: transformers__default.default.stringify(name2),
+                value: schema.enum?.[index],
+                format: remeda.isNumber(schema.enum?.[index]) ? "number" : "string"
+              }))
+            }
+          },
+          ...baseItems.filter(
+            (item) => item.keyword !== schemaKeywords.min && item.keyword !== schemaKeywords.max && item.keyword !== schemaKeywords.matches
+          )
+        ];
+      });
+      if (schema.type === "number" || schema.type === "integer") {
+        const enumNames = extensionEnums[0]?.find((item) => isKeyword(item, schemaKeywords.enum));
+        return [
+          {
+            keyword: schemaKeywords.enum,
+            args: {
+              name: enumName,
+              typeName,
+              asConst: true,
+              items: enumNames?.args?.items ? [...new Set(enumNames.args.items)].map(({ name: name2, value }) => ({
+                name: name2,
+                value,
+                format: "number"
+              })) : [...new Set(filteredValues)].map((value) => {
+                return {
+                  name: value,
+                  value,
+                  format: "number"
+                };
+              })
+            }
+          },
+          ...baseItems.filter((item) => item.keyword !== schemaKeywords.min && item.keyword !== schemaKeywords.max && item.keyword !== schemaKeywords.matches)
+        ];
+      }
+      if (extensionEnums.length > 0 && extensionEnums[0]) {
+        return extensionEnums[0];
+      }
+      return [
+        {
+          keyword: schemaKeywords.enum,
+          args: {
+            name: enumName,
+            typeName,
+            asConst: false,
+            items: [...new Set(filteredValues)].map((value) => ({
+              name: transformers__default.default.stringify(value),
+              value,
+              format: remeda.isNumber(value) ? "number" : "string"
+            }))
+          }
+        },
+        ...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;
+      return [
+        {
+          keyword: schemaKeywords.tuple,
+          args: {
+            min: min2,
+            max: max2,
+            items: prefixItems.map((item) => {
+              return this.parse({ schema: 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"]) {
+        return [
+          {
+            keyword: schemaKeywords.const,
+            args: {
+              name: schema["const"],
+              format: typeof schema["const"] === "number" ? "number" : "string",
+              value: schema["const"]
+            }
+          },
+          ...baseItems
+        ];
+      }
+      return [{ keyword: schemaKeywords.null }];
+    }
+    if (schema.format) {
+      switch (schema.format) {
+        case "binary":
+          baseItems.push({ keyword: schemaKeywords.blob });
+          return baseItems;
+        case "date-time":
+          if (options.dateType) {
+            if (options.dateType === "date") {
+              baseItems.unshift({ keyword: schemaKeywords.date, args: { type: "date" } });
+              return baseItems;
+            }
+            if (options.dateType === "stringOffset") {
+              baseItems.unshift({ keyword: schemaKeywords.datetime, args: { offset: true } });
+              return baseItems;
+            }
+            if (options.dateType === "stringLocal") {
+              baseItems.unshift({ keyword: schemaKeywords.datetime, args: { local: true } });
+              return baseItems;
+            }
+            baseItems.unshift({ keyword: schemaKeywords.datetime, args: { offset: false } });
+            return baseItems;
+          }
+          break;
+        case "date":
+          if (options.dateType) {
+            if (options.dateType === "date") {
+              baseItems.unshift({ keyword: schemaKeywords.date, args: { type: "date" } });
+              return baseItems;
+            }
+            baseItems.unshift({ keyword: schemaKeywords.date, args: { type: "string" } });
+            return baseItems;
+          }
+          break;
+        case "time":
+          if (options.dateType) {
+            if (options.dateType === "date") {
+              baseItems.unshift({ keyword: schemaKeywords.time, args: { type: "date" } });
+              return baseItems;
+            }
+            baseItems.unshift({ keyword: schemaKeywords.time, args: { type: "string" } });
+            return baseItems;
+          }
+          break;
+        case "uuid":
+          baseItems.unshift({ keyword: schemaKeywords.uuid });
+          break;
+        case "email":
+        case "idn-email":
+          baseItems.unshift({ keyword: schemaKeywords.email });
+          break;
+        case "uri":
+        case "ipv4":
+        case "ipv6":
+        case "uri-reference":
+        case "hostname":
+        case "idn-hostname":
+          baseItems.unshift({ keyword: schemaKeywords.url });
+          break;
+      }
+    }
+    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 });
+      return [
+        {
+          keyword: schemaKeywords.array,
+          args: {
+            items,
+            min: min2,
+            max: max2
+          }
+        },
+        ...baseItems.filter((item) => item.keyword !== schemaKeywords.min && item.keyword !== schemaKeywords.max)
+      ];
+    }
+    if (schema.properties || schema.additionalProperties) {
+      return [...this.#parseProperties({ schema, name }), ...baseItems];
+    }
+    if (schema.type) {
+      if (Array.isArray(schema.type)) {
+        const [type] = schema.type;
+        return [
+          ...this.parse({
+            schema: {
+              ...schema,
+              type
+            },
+            name,
+            parentName
+          }),
+          ...baseItems
+        ].filter(Boolean);
+      }
+      if (!["boolean", "object", "number", "string", "integer"].includes(schema.type)) {
+        this.context.pluginManager.logger.emit("warning", `Schema type '${schema.type}' is not valid for schema ${parentName}.${name}`);
+      }
+      return [{ keyword: schema.type }, ...baseItems];
+    }
+    return [{ keyword: unknownReturn }];
+  }
+  async build(...generators) {
+    const { oas, contentType, include } = this.context;
+    const schemas = chunkXQPCA75E_cjs.getSchemas({ oas, contentType, includes: include });
+    const promises = Object.entries(schemas).reduce((acc, [name, schema]) => {
+      const options = this.#getOptions({ name });
+      const promiseOperation = this.schema.call(this, name, schema, {
+        ...this.options,
+        ...options
+      });
+      if (promiseOperation) {
+        acc.push(promiseOperation);
+      }
+      generators?.forEach((generator) => {
+        const promise = generator.schema?.({
+          instance: this,
+          name,
+          schema,
+          options: {
+            ...this.options,
+            ...options
+          }
+        });
+        if (promise) {
+          acc.push(promise);
+        }
+      });
+      return acc;
+    }, []);
+    const files = await Promise.all(promises);
+    return files.flat().filter(Boolean);
+  }
+  /**
+   * Schema
+   */
+  async schema(name, object, options) {
+    return [];
+  }
+};
+
 // src/components/Operation.tsx
-_chunkP42X362Ucjs.init_cjs_shims.call(void 0, );
-var import_jsx_runtime = _chunkP42X362Ucjs.__toESM.call(void 0, require_jsx_runtime(), 1);
-var _react = require('@kubb/react');
-var OperationContext = _react.createContext.call(void 0, {});
+chunkXQPCA75E_cjs.init_cjs_shims();
+var import_jsx_runtime = chunkXQPCA75E_cjs.__toESM(require_jsx_runtime(), 1);
+var OperationContext = react.createContext({});
 function Operation({ operation, children }) {
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(OperationContext.Provider, { value: { operation }, children });
 }
 Operation.Context = OperationContext;
 
 // src/hooks/useSchema.ts
-_chunkP42X362Ucjs.init_cjs_shims.call(void 0, );
-
+chunkXQPCA75E_cjs.init_cjs_shims();
 
 // src/components/Schema.tsx
-_chunkP42X362Ucjs.init_cjs_shims.call(void 0, );
-
-var import_jsx_runtime2 = _chunkP42X362Ucjs.__toESM.call(void 0, require_jsx_runtime(), 1);
-var SchemaContext = _react.createContext.call(void 0, {
+chunkXQPCA75E_cjs.init_cjs_shims();
+var import_jsx_runtime2 = chunkXQPCA75E_cjs.__toESM(require_jsx_runtime(), 1);
+var SchemaContext = react.createContext({
   name: "unknown",
   tree: []
 });
@@ -3129,10 +3804,14 @@ function Schema({ name, value, tree = [], children }) {
   return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(SchemaContext.Provider, { value: { name, schema: value, tree }, children });
 }
 Schema.File = function({ output, isTypeOnly, children }) {
-  const { plugin, pluginManager, mode } = _react.useApp.call(void 0, );
+  const { plugin, pluginManager, mode } = react.useApp();
   const { name } = useSchema();
   if (mode === "single") {
-    const baseName2 = output;
+    const baseName2 = `${pluginManager.resolveName({
+      name,
+      pluginKey: plugin.key,
+      type: "file"
+    })}.ts`;
     const resolvedPath2 = pluginManager.resolvePath({
       baseName: "",
       pluginKey: plugin.key
@@ -3140,8 +3819,8 @@ Schema.File = function({ output, isTypeOnly, children }) {
     if (!resolvedPath2) {
       return null;
     }
-    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(_react.Parser, { language: "typescript", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-      _react.File,
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+      react.File,
       {
         baseName: baseName2,
         path: resolvedPath2,
@@ -3150,7 +3829,7 @@ Schema.File = function({ output, isTypeOnly, children }) {
         },
         children
       }
-    ) });
+    );
   }
   const baseName = `${pluginManager.resolveName({
     name,
@@ -3164,8 +3843,8 @@ Schema.File = function({ output, isTypeOnly, children }) {
   if (!resolvedPath) {
     return null;
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(_react.Parser, { language: "typescript", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
-    _react.File,
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+    react.File,
     {
       baseName,
       path: resolvedPath,
@@ -3177,45 +3856,37 @@ Schema.File = function({ output, isTypeOnly, children }) {
         children
       ]
     }
-  ) });
+  );
 };
-Schema.Imports = ({ isTypeOnly, extName }) => {
+Schema.Imports = ({ isTypeOnly }) => {
   const { tree } = useSchema();
-  const { path: root } = _react.useFile.call(void 0, );
-  const refs = _chunkCJXRFYEFcjs.SchemaGenerator.deepSearch(tree, _chunkCJXRFYEFcjs.schemaKeywords.ref);
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_jsx_runtime2.Fragment, { children: _optionalChain([refs, 'optionalAccess', _ => _.map, 'call', _2 => _2((item, i) => {
+  const { path: root } = react.useFile();
+  const refs = SchemaGenerator.deepSearch(tree, schemaKeywords.ref);
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_jsx_runtime2.Fragment, { children: refs?.map((item, i) => {
     if (!item.args.path) {
       return void 0;
     }
-    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(_react.File.Import, { extName, root, name: [item.args.name], path: item.args.path, isTypeOnly: _nullishCoalesce(item.args.isTypeOnly, () => ( isTypeOnly)) }, i);
-  }), 'access', _3 => _3.filter, 'call', _4 => _4(Boolean)]) });
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(react.File.Import, { root, name: [item.args.name], path: item.args.path, isTypeOnly }, i);
+  }).filter(Boolean) });
 };
 Schema.Context = SchemaContext;
 
 // src/hooks/useSchema.ts
 function useSchema() {
-  const props = _react.useContext.call(void 0, Schema.Context);
+  const props = react.useContext(Schema.Context);
   return props;
 }
 
 // src/components/Oas.tsx
-_chunkP42X362Ucjs.init_cjs_shims.call(void 0, );
-
-var import_jsx_runtime3 = _chunkP42X362Ucjs.__toESM.call(void 0, require_jsx_runtime(), 1);
-var OasContext = _react.createContext.call(void 0, {});
+chunkXQPCA75E_cjs.init_cjs_shims();
+var import_jsx_runtime3 = chunkXQPCA75E_cjs.__toESM(require_jsx_runtime(), 1);
+var OasContext = react.createContext({});
 function Oas({ oas, children, operations, generator }) {
   return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(OasContext.Provider, { value: { oas, generator, operations }, children });
 }
 Oas.Context = OasContext;
 Oas.Operation = Operation;
 Oas.Schema = Schema;
-
-
-
-
-
-
-exports.Operation = Operation; exports.useSchema = useSchema; exports.Schema = Schema; exports.Oas = Oas;
 /*! Bundled license information:
 
 react/cjs/react.production.min.js:
@@ -3262,4 +3933,14 @@ react/cjs/react-jsx-runtime.development.js:
    * LICENSE file in the root directory of this source tree.
    *)
 */
-//# sourceMappingURL=chunk-DRLYORTT.cjs.map
+
+exports.Oas = Oas;
+exports.Operation = Operation;
+exports.Schema = Schema;
+exports.SchemaGenerator = SchemaGenerator;
+exports.isKeyword = isKeyword;
+exports.require_jsx_runtime = require_jsx_runtime;
+exports.schemaKeywords = schemaKeywords;
+exports.useSchema = useSchema;
+//# sourceMappingURL=chunk-47SNBYWH.cjs.map
+//# sourceMappingURL=chunk-47SNBYWH.cjs.map