@kubb/plugin-oas 3.0.0-alpha.6 → 3.0.0-alpha.8

package/dist/{chunk-RQZBFORW.cjs → chunk-VSVVTCQB.cjs}

@@ -1,19 +1,16 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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; } var _class;
 
 
 
 
 
-
-
-
-var _chunkP42X362Ucjs = require('./chunk-P42X362U.cjs');
+var _chunkNU4F7G47cjs = require('./chunk-NU4F7G47.cjs');
 
 // ../../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 = _chunkNU4F7G47cjs.__commonJS.call(void 0, {
   "../../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, );
+    _chunkNU4F7G47cjs.init_cjs_shims.call(void 0, );
     var l = Symbol.for("react.element");
     var n = Symbol.for("react.portal");
     var p = Symbol.for("react.fragment");
@@ -284,10 +281,10 @@ 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 = _chunkNU4F7G47cjs.__commonJS.call(void 0, {
   "../../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, );
+    _chunkNU4F7G47cjs.init_cjs_shims.call(void 0, );
     if (process.env.NODE_ENV !== "production") {
       (function() {
         "use strict";
@@ -2159,10 +2156,10 @@ 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 = _chunkNU4F7G47cjs.__commonJS.call(void 0, {
   "../../node_modules/.pnpm/react@18.3.1/node_modules/react/index.js"(exports, module) {
     "use strict";
-    _chunkP42X362Ucjs.init_cjs_shims.call(void 0, );
+    _chunkNU4F7G47cjs.init_cjs_shims.call(void 0, );
     if (process.env.NODE_ENV === "production") {
       module.exports = require_react_production_min();
     } else {
@@ -2172,10 +2169,10 @@ 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 = _chunkNU4F7G47cjs.__commonJS.call(void 0, {
   "../../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, );
+    _chunkNU4F7G47cjs.init_cjs_shims.call(void 0, );
     var f = require_react();
     var k = Symbol.for("react.element");
     var l = Symbol.for("react.fragment");
@@ -2198,10 +2195,10 @@ 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 = _chunkNU4F7G47cjs.__commonJS.call(void 0, {
   "../../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, );
+    _chunkNU4F7G47cjs.init_cjs_shims.call(void 0, );
     if (process.env.NODE_ENV !== "production") {
       (function() {
         "use strict";
@@ -3092,10 +3089,10 @@ 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 = _chunkNU4F7G47cjs.__commonJS.call(void 0, {
   "../../node_modules/.pnpm/react@18.3.1/node_modules/react/jsx-runtime.js"(exports, module) {
     "use strict";
-    _chunkP42X362Ucjs.init_cjs_shims.call(void 0, );
+    _chunkNU4F7G47cjs.init_cjs_shims.call(void 0, );
     if (process.env.NODE_ENV === "production") {
       module.exports = require_react_jsx_runtime_production_min();
     } else {
@@ -3105,7 +3102,7 @@ var require_jsx_runtime = _chunkP42X362Ucjs.__commonJS.call(void 0, {
 });
 
 // src/SchemaMapper.ts
-_chunkP42X362Ucjs.init_cjs_shims.call(void 0, );
+_chunkNU4F7G47cjs.init_cjs_shims.call(void 0, );
 var schemaKeywords = {
   any: "any",
   strict: "strict",
@@ -3157,30 +3154,25 @@ function isKeyword(meta, keyword) {
 }
 
 // src/SchemaGenerator.ts
-_chunkP42X362Ucjs.init_cjs_shims.call(void 0, );
+_chunkNU4F7G47cjs.init_cjs_shims.call(void 0, );
 var _core = require('@kubb/core');
 var _transformers = require('@kubb/core/transformers'); var _transformers2 = _interopRequireDefault(_transformers);
 var _utils = require('@kubb/core/utils');
 var _oas = require('@kubb/oas');
 var _remeda = require('remeda');
-var _usedAliasNames, _SchemaGenerator_instances, getUsedEnumNames_fn, getOptions_fn, getUnknownReturn_fn, parseProperties_fn, getRefAlias_fn, getParsedSchemaObject_fn, parseSchemaObject_fn;
-var _SchemaGenerator = class _SchemaGenerator extends _core.Generator {
-  constructor() {
-    super(...arguments);
-    _chunkP42X362Ucjs.__privateAdd.call(void 0, this, _SchemaGenerator_instances);
-    // Collect the types of all referenced schemas, so we can export them later
-    this.refs = {};
-    // Keep track of already used type aliases
-    _chunkP42X362Ucjs.__privateAdd.call(void 0, this, _usedAliasNames, {});
-  }
+var SchemaGenerator = (_class = class _SchemaGenerator extends _core.Generator {constructor(...args2) { super(...args2); _class.prototype.__init.call(this); }
+  // Collect the types of all referenced schemas, so we can export them later
+  __init() {this.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 = _chunkP42X362Ucjs.__privateMethod.call(void 0, this, _SchemaGenerator_instances, getOptions_fn).call(this, props);
-    const defaultSchemas = _chunkP42X362Ucjs.__privateMethod.call(void 0, this, _SchemaGenerator_instances, parseSchemaObject_fn).call(this, props);
+    const options = this.#getOptions(props);
+    const defaultSchemas = this.#parseSchemaObject(props);
     const schemas = _optionalChain([options, 'access', _ => _.transformers, 'optionalAccess', _2 => _2.schema, 'optionalCall', _3 => _3(props, defaultSchemas)]) || defaultSchemas || [];
     return _remeda.uniqueWith.call(void 0, schemas, _remeda.isDeepEqual);
   }
@@ -3295,231 +3287,132 @@ var _SchemaGenerator = class _SchemaGenerator extends _core.Generator {
     })]);
     return foundItem;
   }
-  async build(...parsers) {
-    const { oas, contentType, include } = this.context;
-    const schemas = _chunkP42X362Ucjs.getSchemas.call(void 0, { oas, contentType, includes: include });
-    const promises = Object.entries(schemas).reduce((acc, [name, schema]) => {
-      const options = _chunkP42X362Ucjs.__privateMethod.call(void 0, this, _SchemaGenerator_instances, getOptions_fn).call(this, { name });
-      const promiseOperation = this.schema.call(this, name, schema, {
-        ...this.options,
-        ...options
-      });
-      if (promiseOperation) {
-        acc.push(promiseOperation);
-      }
-      _optionalChain([parsers, 'optionalAccess', _18 => _18.forEach, 'call', _19 => _19((parser) => {
-        const promise = _optionalChain([parser, 'access', _20 => _20.schema, 'optionalCall', _21 => _21({
-          instance: this,
-          name,
-          schema,
-          options: {
-            ...this.options,
-            ...options
-          }
-        })]);
-        if (promise) {
-          acc.push(promise);
+  #getUsedEnumNames(props) {
+    const options = this.#getOptions(props);
+    return options.usedEnumNames || {};
+  }
+  #getOptions({ name }) {
+    const { override = [] } = this.context;
+    return {
+      ...this.options,
+      ..._optionalChain([override, 'access', _18 => _18.find, 'call', _19 => _19(({ pattern, type }) => {
+        if (name && type === "schemaName") {
+          return !!name.match(pattern);
         }
-      })]);
-      return acc;
-    }, []);
-    const files = await Promise.all(promises);
-    return files.flat().filter(Boolean);
+        return false;
+      }), 'optionalAccess', _20 => _20.options]) || {}
+    };
+  }
+  #getUnknownReturn(props) {
+    const options = this.#getOptions(props);
+    if (options.unknownType === "any") {
+      return schemaKeywords.any;
+    }
+    return schemaKeywords.unknown;
   }
   /**
-   * Schema
+   * Recursively creates a type literal with the given props.
    */
-  async schema(name, object, options) {
-    return [];
-  }
-};
-_usedAliasNames = new WeakMap();
-_SchemaGenerator_instances = new WeakSet();
-getUsedEnumNames_fn = function(props) {
-  const options = _chunkP42X362Ucjs.__privateMethod.call(void 0, this, _SchemaGenerator_instances, getOptions_fn).call(this, props);
-  return options.usedEnumNames || {};
-};
-getOptions_fn = function({ name }) {
-  const { override = [] } = this.context;
-  return {
-    ...this.options,
-    ..._optionalChain([override, 'access', _22 => _22.find, 'call', _23 => _23(({ pattern, type }) => {
-      if (name && type === "schemaName") {
-        return !!name.match(pattern);
+  #parseProperties({ schema, name }) {
+    const properties = _optionalChain([schema, 'optionalAccess', _21 => _21.properties]) || {};
+    const additionalProperties = _optionalChain([schema, 'optionalAccess', _22 => _22.additionalProperties]);
+    const required = _optionalChain([schema, 'optionalAccess', _23 => _23.required]);
+    const propertiesSchemas = Object.keys(properties).map((propertyName) => {
+      const validationFunctions = [];
+      const propertySchema = properties[propertyName];
+      const isRequired = Array.isArray(required) ? _optionalChain([required, 'optionalAccess', _24 => _24.includes, 'call', _25 => _25(propertyName)]) : !!required;
+      const nullable = _nullishCoalesce(_nullishCoalesce(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 false;
-    }), 'optionalAccess', _24 => _24.options]) || {}
-  };
-};
-getUnknownReturn_fn = function(props) {
-  const options = _chunkP42X362Ucjs.__privateMethod.call(void 0, this, _SchemaGenerator_instances, getOptions_fn).call(this, props);
-  if (options.unknownType === "any") {
-    return schemaKeywords.any;
+      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
+        }
+      }
+    ];
   }
-  return schemaKeywords.unknown;
-};
-/**
- * Recursively creates a type literal with the given props.
- */
-parseProperties_fn = function({ schema, name }) {
-  const properties = _optionalChain([schema, 'optionalAccess', _25 => _25.properties]) || {};
-  const additionalProperties = _optionalChain([schema, 'optionalAccess', _26 => _26.additionalProperties]);
-  const required = _optionalChain([schema, 'optionalAccess', _27 => _27.required]);
-  const propertiesSchemas = Object.keys(properties).map((propertyName) => {
-    const validationFunctions = [];
-    const propertySchema = properties[propertyName];
-    const isRequired = Array.isArray(required) ? _optionalChain([required, 'optionalAccess', _28 => _28.includes, 'call', _29 => _29(propertyName)]) : !!required;
-    const nullable = _nullishCoalesce(_nullishCoalesce(propertySchema.nullable, () => ( propertySchema["x-nullable"])), () => ( false));
-    validationFunctions.push(...this.parse({ schema: propertySchema, name: propertyName, parentName: name }));
-    validationFunctions.push({
-      keyword: schemaKeywords.name,
-      args: propertyName
+  /**
+   * 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.call(void 0, $ref.replace(/.+\//, ""), this.#usedAliasNames);
+    const propertyName = this.context.pluginManager.resolveName({
+      name: originalName,
+      pluginKey: this.context.plugin.key,
+      type: "function"
     });
-    if (!isRequired && nullable) {
-      validationFunctions.push({ keyword: schemaKeywords.nullish });
-    } else if (!isRequired) {
-      validationFunctions.push({ keyword: schemaKeywords.optional });
+    if (ref) {
+      return [
+        {
+          keyword: schemaKeywords.ref,
+          args: { name: ref.propertyName, path: ref.path }
+        }
+      ];
     }
-    return {
-      [propertyName]: validationFunctions
+    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
     };
-  }).reduce((acc, curr) => ({ ...acc, ...curr }), {});
-  let additionalPropertiesSchemas = [];
-  if (additionalProperties) {
-    additionalPropertiesSchemas = additionalProperties === true ? [{ keyword: _chunkP42X362Ucjs.__privateMethod.call(void 0, this, _SchemaGenerator_instances, getUnknownReturn_fn).call(this, { 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_fn = function(obj) {
-  const { $ref } = obj;
-  let ref = this.refs[$ref];
-  const originalName = _utils.getUniqueName.call(void 0, $ref.replace(/.+\//, ""), _chunkP42X362Ucjs.__privateGet.call(void 0, 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 }
+        args: { name: ref.propertyName, path: _optionalChain([ref, 'optionalAccess', _26 => _26.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: _optionalChain([ref, 'optionalAccess', _30 => _30.path]), isTypeOnly: false }
-    }
-  ];
-};
-getParsedSchemaObject_fn = function(schema) {
-  const parsedSchema = _chunkP42X362Ucjs.getSchemaFactory.call(void 0, 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_fn = function({ schema: _schema, name, parentName }) {
-  const options = _chunkP42X362Ucjs.__privateMethod.call(void 0, this, _SchemaGenerator_instances, getOptions_fn).call(this, { schema: _schema, name });
-  const unknownReturn = _chunkP42X362Ucjs.__privateMethod.call(void 0, this, _SchemaGenerator_instances, getUnknownReturn_fn).call(this, { schema: _schema, name });
-  const { schema, version } = _chunkP42X362Ucjs.__privateMethod.call(void 0, this, _SchemaGenerator_instances, getParsedSchemaObject_fn).call(this, _schema);
-  const resolvedName = this.context.pluginManager.resolveName({
-    name: `${parentName || ""} ${name}`,
-    pluginKey: this.context.plugin.key,
-    type: "type"
-  });
-  if (!schema) {
-    return [{ keyword: unknownReturn }];
+  #getParsedSchemaObject(schema) {
+    const parsedSchema = _chunkNU4F7G47cjs.getSchemaFactory.call(void 0, this.context.oas)(schema);
+    return parsedSchema;
   }
-  const baseItems = [
-    {
-      keyword: schemaKeywords.schema,
-      args: {
-        type: schema.type,
-        format: schema.format
-      }
-    }
-  ];
-  const min = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(schema.minimum, () => ( schema.minLength)), () => ( schema.minItems)), () => ( void 0));
-  const max = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(schema.maximum, () => ( schema.maxLength)), () => ( schema.maxItems)), () => ( void 0));
-  const nullable = _nullishCoalesce(_nullishCoalesce(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: _transformers2.default.stringify(schema.default)
-      });
-    }
-    if (typeof schema.default === "boolean") {
-      baseItems.push({
-        keyword: schemaKeywords.default,
-        args: _nullishCoalesce(schema.default, () => ( false))
-      });
-    }
-  }
-  if (schema.description) {
-    baseItems.push({
-      keyword: schemaKeywords.describe,
-      args: schema.description
-    });
-  }
-  if (schema.pattern) {
-    baseItems.unshift({
-      keyword: schemaKeywords.matches,
-      args: schema.pattern
+  /**
+   * 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);
+    const resolvedName = this.context.pluginManager.resolveName({
+      name: `${parentName || ""} ${name}`,
+      pluginKey: this.context.plugin.key,
+      type: "type"
     });
-  }
-  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) {
+      return [{ keyword: unknownReturn }];
     }
-  }
-  if (schema.readOnly) {
-    baseItems.push({ keyword: schemaKeywords.readOnly });
-  }
-  if (_oas.isReference.call(void 0, schema)) {
-    return [
-      ..._chunkP42X362Ucjs.__privateMethod.call(void 0, this, _SchemaGenerator_instances, getRefAlias_fn).call(this, schema),
-      nullable && { keyword: schemaKeywords.nullable },
+    const baseItems = [
       {
         keyword: schemaKeywords.schema,
         args: {
@@ -3527,289 +3420,385 @@ parseSchemaObject_fn = function({ schema: _schema, name, parentName }) {
           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];
+    ];
+    const min = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(schema.minimum, () => ( schema.minLength)), () => ( schema.minItems)), () => ( void 0));
+    const max = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(schema.maximum, () => ( schema.maxLength)), () => ( schema.maxItems)), () => ( void 0));
+    const nullable = _nullishCoalesce(_nullishCoalesce(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: _transformers2.default.stringify(schema.default)
+        });
+      }
+      if (typeof schema.default === "boolean") {
+        baseItems.push({
+          keyword: schemaKeywords.default,
+          args: _nullishCoalesce(schema.default, () => ( false))
+        });
+      }
     }
-    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];
+    if (schema.description) {
+      baseItems.push({
+        keyword: schemaKeywords.describe,
+        args: schema.description
+      });
     }
-    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
-      ];
+    if (schema.pattern) {
+      baseItems.unshift({
+        keyword: schemaKeywords.matches,
+        args: schema.pattern
+      });
     }
-    return [and, ...baseItems];
-  }
-  if (schema.enum) {
-    const enumName = _utils.getUniqueName.call(void 0, _transformers.pascalCase.call(void 0, [parentName, name, options.enumSuffix].join(" ")), _chunkP42X362Ucjs.__privateMethod.call(void 0, this, _SchemaGenerator_instances, getUsedEnumNames_fn).call(this, { 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) {
+    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 });
     }
-    const filteredValues = schema.enum.filter((value) => value !== null);
-    const extensionEnums = ["x-enumNames", "x-enum-varnames"].filter((extensionKey) => extensionKey in schema).map((extensionKey) => {
+    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.call(void 0, schema)) {
       return [
+        ...this.#getRefAlias(schema),
+        nullable && { keyword: schemaKeywords.nullable },
         {
-          keyword: schemaKeywords.enum,
+          keyword: schemaKeywords.schema,
           args: {
-            name,
-            typeName,
-            asConst: false,
-            items: [...new Set(schema[extensionKey])].map((name2, index) => ({
-              name: _transformers2.default.stringify(name2),
-              value: _optionalChain([schema, 'access', _31 => _31.enum, 'optionalAccess', _32 => _32[index]]),
-              format: _remeda.isNumber.call(void 0, _optionalChain([schema, 'access', _33 => _33.enum, 'optionalAccess', _34 => _34[index]])) ? "number" : "string"
-            }))
+            type: schema.type,
+            format: schema.format
           }
-        },
-        ...baseItems.filter(
-          (item) => item.keyword !== schemaKeywords.min && item.keyword !== schemaKeywords.max && item.keyword !== schemaKeywords.matches
-        )
-      ];
-    });
-    if (schema.type === "number" || schema.type === "integer") {
-      const enumNames = _optionalChain([extensionEnums, 'access', _35 => _35[0], 'optionalAccess', _36 => _36.find, 'call', _37 => _37((item) => isKeyword(item, schemaKeywords.enum))]);
+        }
+      ].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.call(void 0, _transformers.pascalCase.call(void 0, [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: _transformers2.default.stringify(name2),
+                value: _optionalChain([schema, 'access', _27 => _27.enum, 'optionalAccess', _28 => _28[index]]),
+                format: _remeda.isNumber.call(void 0, _optionalChain([schema, 'access', _29 => _29.enum, 'optionalAccess', _30 => _30[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 = _optionalChain([extensionEnums, 'access', _31 => _31[0], 'optionalAccess', _32 => _32.find, 'call', _33 => _33((item) => isKeyword(item, schemaKeywords.enum))]);
+        return [
+          {
+            keyword: schemaKeywords.enum,
+            args: {
+              name: enumName,
+              typeName,
+              asConst: true,
+              items: _optionalChain([enumNames, 'optionalAccess', _34 => _34.args, 'optionalAccess', _35 => _35.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: true,
-            items: _optionalChain([enumNames, 'optionalAccess', _38 => _38.args, 'optionalAccess', _39 => _39.items]) ? [...new Set(enumNames.args.items)].map(({ name: name2, value }) => ({
-              name: name2,
+            asConst: false,
+            items: [...new Set(filteredValues)].map((value) => ({
+              name: _transformers2.default.stringify(value),
               value,
-              format: "number"
-            })) : [...new Set(filteredValues)].map((value) => {
-              return {
-                name: value,
-                value,
-                format: "number"
-              };
-            })
+              format: _remeda.isNumber.call(void 0, value) ? "number" : "string"
+            }))
           }
         },
         ...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: _transformers2.default.stringify(value),
-            value,
-            format: _remeda.isNumber.call(void 0, 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 = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(schema.minimum, () => ( schema.minLength)), () => ( schema.minItems)), () => ( void 0));
-    const max2 = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(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"]) {
+    if ("prefixItems" in schema) {
+      const prefixItems = schema.prefixItems;
+      const min2 = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(schema.minimum, () => ( schema.minLength)), () => ( schema.minItems)), () => ( void 0));
+      const max2 = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(schema.maximum, () => ( schema.maxLength)), () => ( schema.maxItems)), () => ( void 0));
       return [
         {
-          keyword: schemaKeywords.const,
+          keyword: schemaKeywords.tuple,
           args: {
-            name: schema["const"],
-            format: typeof schema["const"] === "number" ? "number" : "string",
-            value: schema["const"]
+            min: min2,
+            max: max2,
+            items: prefixItems.map((item) => {
+              return this.parse({ schema: item, name, parentName })[0];
+            }).filter(Boolean)
           }
         },
-        ...baseItems
+        ...baseItems.filter((item) => item.keyword !== schemaKeywords.min && item.keyword !== schemaKeywords.max)
       ];
     }
-    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 } });
+    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;
           }
-          if (options.dateType === "stringLocal") {
-            baseItems.unshift({ keyword: schemaKeywords.datetime, args: { local: true } });
+          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;
           }
-          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" } });
+          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;
           }
-          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;
+          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;
+        default:
+          break;
+      }
+    }
+    if ("items" in schema || schema.type === "array") {
+      const min2 = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(schema.minimum, () => ( schema.minLength)), () => ( schema.minItems)), () => ( void 0));
+      const max2 = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(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.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;
-      default:
-        break;
+        },
+        ...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 }];
   }
-  if ("items" in schema || schema.type === "array") {
-    const min2 = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(schema.minimum, () => ( schema.minLength)), () => ( schema.minItems)), () => ( void 0));
-    const max2 = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(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
+  async build(...parsers) {
+    const { oas, contentType, include } = this.context;
+    const schemas = _chunkNU4F7G47cjs.getSchemas.call(void 0, { 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);
+      }
+      _optionalChain([parsers, 'optionalAccess', _36 => _36.forEach, 'call', _37 => _37((parser) => {
+        const promise = _optionalChain([parser, 'access', _38 => _38.schema, 'optionalCall', _39 => _39({
+          instance: this,
+          name,
+          schema,
+          options: {
+            ...this.options,
+            ...options
+          }
+        })]);
+        if (promise) {
+          acc.push(promise);
         }
-      },
-      ...baseItems.filter((item) => item.keyword !== schemaKeywords.min && item.keyword !== schemaKeywords.max)
-    ];
-  }
-  if (schema.properties || schema.additionalProperties) {
-    return [..._chunkP42X362Ucjs.__privateMethod.call(void 0, this, _SchemaGenerator_instances, parseProperties_fn).call(this, { schema, name }), ...baseItems];
+      })]);
+      return acc;
+    }, []);
+    const files = await Promise.all(promises);
+    return files.flat().filter(Boolean);
   }
-  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];
+  /**
+   * Schema
+   */
+  async schema(name, object, options) {
+    return [];
   }
-  return [{ keyword: unknownReturn }];
-};
-var SchemaGenerator = _SchemaGenerator;
+}, _class);
 
 // src/components/Operation.tsx
-_chunkP42X362Ucjs.init_cjs_shims.call(void 0, );
-var import_jsx_runtime = _chunkP42X362Ucjs.__toESM.call(void 0, require_jsx_runtime(), 1);
+_chunkNU4F7G47cjs.init_cjs_shims.call(void 0, );
+var import_jsx_runtime = _chunkNU4F7G47cjs.__toESM.call(void 0, require_jsx_runtime(), 1);
 var _react = require('@kubb/react');
 var OperationContext = _react.createContext.call(void 0, {});
 function Operation({ operation, children }) {
@@ -3818,13 +3807,13 @@ function Operation({ operation, children }) {
 Operation.Context = OperationContext;
 
 // src/hooks/useSchema.ts
-_chunkP42X362Ucjs.init_cjs_shims.call(void 0, );
+_chunkNU4F7G47cjs.init_cjs_shims.call(void 0, );
 
 
 // src/components/Schema.tsx
-_chunkP42X362Ucjs.init_cjs_shims.call(void 0, );
+_chunkNU4F7G47cjs.init_cjs_shims.call(void 0, );
 
-var import_jsx_runtime2 = _chunkP42X362Ucjs.__toESM.call(void 0, require_jsx_runtime(), 1);
+var import_jsx_runtime2 = _chunkNU4F7G47cjs.__toESM.call(void 0, require_jsx_runtime(), 1);
 var SchemaContext = _react.createContext.call(void 0, {
   name: "unknown",
   tree: []
@@ -3836,7 +3825,11 @@ Schema.File = function({ output, isTypeOnly, children }) {
   const { plugin, pluginManager, mode } = _react.useApp.call(void 0, );
   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
@@ -3883,7 +3876,7 @@ Schema.File = function({ output, isTypeOnly, children }) {
     }
   );
 };
-Schema.Imports = ({ isTypeOnly, extName }) => {
+Schema.Imports = ({ isTypeOnly }) => {
   const { tree } = useSchema();
   const { path: root } = _react.useFile.call(void 0, );
   const refs = SchemaGenerator.deepSearch(tree, schemaKeywords.ref);
@@ -3891,7 +3884,7 @@ Schema.Imports = ({ isTypeOnly, extName }) => {
     if (!item.args.path) {
       return void 0;
     }
-    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(_react.File.Import, { root, name: [item.args.name], path: item.args.path, isTypeOnly: _nullishCoalesce(item.args.isTypeOnly, () => ( isTypeOnly)) }, i);
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(_react.File.Import, { root, name: [item.args.name], path: item.args.path, isTypeOnly }, i);
   }), 'access', _42 => _42.filter, 'call', _43 => _43(Boolean)]) });
 };
 Schema.Context = SchemaContext;
@@ -3903,9 +3896,9 @@ function useSchema() {
 }
 
 // src/components/Oas.tsx
-_chunkP42X362Ucjs.init_cjs_shims.call(void 0, );
+_chunkNU4F7G47cjs.init_cjs_shims.call(void 0, );
 
-var import_jsx_runtime3 = _chunkP42X362Ucjs.__toESM.call(void 0, require_jsx_runtime(), 1);
+var import_jsx_runtime3 = _chunkNU4F7G47cjs.__toESM.call(void 0, require_jsx_runtime(), 1);
 var OasContext = _react.createContext.call(void 0, {});
 function Oas({ oas, children, operations, generator }) {
   return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(OasContext.Provider, { value: { oas, generator, operations }, children });
@@ -3970,4 +3963,4 @@ react/cjs/react-jsx-runtime.development.js:
    * LICENSE file in the root directory of this source tree.
    *)
 */
-//# sourceMappingURL=chunk-RQZBFORW.cjs.map
+//# sourceMappingURL=chunk-VSVVTCQB.cjs.map