@kubb/swagger-ts 2.6.6 → 2.7.0

package/dist/{chunk-3QUKTW23.cjs → chunk-T5JLEKOF.cjs}

@@ -1,42 +1,4 @@
-'use strict';
-
-var transformers2 = require('@kubb/core/transformers');
-var parser = require('@kubb/parser');
-var factory2 = require('@kubb/parser/factory');
-var react = require('@kubb/react');
-var hooks = require('@kubb/swagger/hooks');
-var swagger = require('@kubb/swagger');
-var utils$1 = require('@kubb/swagger/utils');
-var core = require('@kubb/core');
-var utils = require('@kubb/core/utils');
-var path = require('path');
-var jsxRuntime = require('@kubb/react/jsx-runtime');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var transformers2__default = /*#__PURE__*/_interopDefault(transformers2);
-var factory2__namespace = /*#__PURE__*/_interopNamespace(factory2);
-var path__default = /*#__PURE__*/_interopDefault(path);
-
-var __accessCheck = (obj, member, msg) => {
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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 __accessCheck = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
@@ -53,15 +15,53 @@ var __privateMethod = (obj, member, method) => {
   __accessCheck(obj, member, "access private method");
   return method;
 };
+
+// src/components/Mutation.tsx
+var _transformers = require('@kubb/core/transformers'); var _transformers2 = _interopRequireDefault(_transformers);
+var _parser = require('@kubb/parser');
+var _factory = require('@kubb/parser/factory'); var factory3 = _interopRequireWildcard(_factory); var factory2 = _interopRequireWildcard(_factory); var factory = _interopRequireWildcard(_factory);
+var _react = require('@kubb/react');
+var _hooks = require('@kubb/swagger/hooks');
+
+// src/TypeBuilder.ts
+
+
+var _swagger = require('@kubb/swagger');
+var _utils = require('@kubb/swagger/utils');
+
+// src/TypeGenerator.ts
+var _core = require('@kubb/core');
+
+var _utils3 = require('@kubb/core/utils');
+
+
+
+
+// src/plugin.ts
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+
+
+
+
+
+// src/OperationGenerator.tsx
+
+
+
+// src/components/Oas.tsx
+
+
+
+var _jsxruntime = require('@kubb/react/jsx-runtime');
 function Template({
   name,
   typeName,
   api
 }) {
-  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
     `export const ${name} = ${JSON.stringify(api, void 0, 2)} as const`,
-    /* @__PURE__ */ jsxRuntime.jsx("br", {}),
-    /* @__PURE__ */ jsxRuntime.jsx(react.Type, { name: typeName, export: true, children: `Infer<typeof ${name}>` })
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "br", {}),
+    /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _react.Type, { name: typeName, export: true, children: `Infer<typeof ${name}>` })
   ] });
 }
 var defaultTemplates = { default: Template };
@@ -70,115 +70,123 @@ function Oas({
   typeName,
   Template: Template2 = defaultTemplates.default
 }) {
-  const oas = hooks.useOas();
-  return /* @__PURE__ */ jsxRuntime.jsx(Template2, { name, typeName, api: oas.api });
+  const oas = _hooks.useOas.call(void 0, );
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Template2, { name, typeName, api: oas.api });
 }
 Oas.File = function({ name, typeName, templates = defaultTemplates }) {
-  const { key: pluginKey2 } = react.usePlugin();
-  const file = react.useFile({ name, pluginKey: pluginKey2 });
+  const { key: pluginKey2 } = _react.usePlugin.call(void 0, );
+  const file = _react.useFile.call(void 0, { name, extName: ".ts", pluginKey: pluginKey2 });
   const Template2 = templates.default;
-  return /* @__PURE__ */ jsxRuntime.jsxs(
-    react.File,
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _react.Editor, { language: "typescript", children: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+    _react.File,
     {
       baseName: file.baseName,
       path: file.path,
       meta: file.meta,
       children: [
-        /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { name: ["Infer"], path: "@kubb/swagger-ts/oas", isTypeOnly: true }),
-        /* @__PURE__ */ jsxRuntime.jsx(react.File.Source, { children: /* @__PURE__ */ jsxRuntime.jsx(Oas, { Template: Template2, name, typeName }) })
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _react.File.Import, { name: ["Infer"], path: "@kubb/swagger-ts/oas", isTypeOnly: true }),
+        /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _react.File.Source, { children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Oas, { Template: Template2, name, typeName }) })
       ]
     }
-  );
+  ) });
 };
 Oas.templates = defaultTemplates;
+
+// src/components/Query.tsx
+
+
+
+
+
+
 function printCombinedSchema(name, operation, schemas) {
   const properties = {
-    "response": factory2__namespace.createTypeReferenceNode(
-      factory2__namespace.createIdentifier(schemas.response.name),
+    "response": factory.createTypeReferenceNode(
+      factory.createIdentifier(schemas.response.name),
       void 0
     )
   };
   if (schemas.request) {
-    properties["request"] = factory2__namespace.createTypeReferenceNode(
-      factory2__namespace.createIdentifier(schemas.request.name),
+    properties["request"] = factory.createTypeReferenceNode(
+      factory.createIdentifier(schemas.request.name),
       void 0
     );
   }
   if (schemas.pathParams) {
-    properties["pathParams"] = factory2__namespace.createTypeReferenceNode(
-      factory2__namespace.createIdentifier(schemas.pathParams.name),
+    properties["pathParams"] = factory.createTypeReferenceNode(
+      factory.createIdentifier(schemas.pathParams.name),
       void 0
     );
   }
   if (schemas.queryParams) {
-    properties["queryParams"] = factory2__namespace.createTypeReferenceNode(
-      factory2__namespace.createIdentifier(schemas.queryParams.name),
+    properties["queryParams"] = factory.createTypeReferenceNode(
+      factory.createIdentifier(schemas.queryParams.name),
       void 0
     );
   }
   if (schemas.headerParams) {
-    properties["headerParams"] = factory2__namespace.createTypeReferenceNode(
-      factory2__namespace.createIdentifier(schemas.headerParams.name),
+    properties["headerParams"] = factory.createTypeReferenceNode(
+      factory.createIdentifier(schemas.headerParams.name),
       void 0
     );
   }
   if (schemas.errors) {
-    properties["errors"] = factory2__namespace.createUnionDeclaration({
+    properties["errors"] = factory.createUnionDeclaration({
       nodes: schemas.errors.map((error) => {
-        return factory2__namespace.createTypeReferenceNode(
-          factory2__namespace.createIdentifier(error.name),
+        return factory.createTypeReferenceNode(
+          factory.createIdentifier(error.name),
           void 0
         );
       })
     });
   }
-  const namespaceNode = factory2__namespace.createTypeAliasDeclaration({
+  const namespaceNode = factory.createTypeAliasDeclaration({
     name: operation.method === "get" ? `${name}Query` : `${name}Mutation`,
-    type: factory2__namespace.createTypeLiteralNode(
+    type: factory.createTypeLiteralNode(
       Object.keys(properties).map((key) => {
         const type = properties[key];
         if (!type) {
           return void 0;
         }
-        return factory2__namespace.createPropertySignature(
+        return factory.createPropertySignature(
           {
-            name: transformers2__default.default.pascalCase(key),
+            name: _transformers2.default.pascalCase(key),
             type
           }
         );
       }).filter(Boolean)
     ),
-    modifiers: [factory2__namespace.modifiers.export]
+    modifiers: [factory.modifiers.export]
   });
-  return parser.print(namespaceNode);
+  return _parser.print.call(void 0, namespaceNode);
 }
 function Query({
   builder
 }) {
   const { source } = builder.build();
-  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: source });
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _jsxruntime.Fragment, { children: source });
 }
 Query.File = function({ mode }) {
-  const { options } = react.usePlugin();
-  const schemas = hooks.useSchemas();
-  const pluginManager = react.usePluginManager();
-  const oas = hooks.useOas();
-  const file = hooks.useOperationFile();
-  const factoryName = hooks.useOperationName({ type: "type" });
-  const operation = hooks.useOperation();
+  const { options } = _react.usePlugin.call(void 0, );
+  const schemas = _hooks.useSchemas.call(void 0, );
+  const pluginManager = _react.usePluginManager.call(void 0, );
+  const oas = _hooks.useOas.call(void 0, );
+  const file = _hooks.useOperationFile.call(void 0, );
+  const factoryName = _hooks.useOperationName.call(void 0, { type: "type" });
+  const operation = _hooks.useOperation.call(void 0, );
   const builder = new TypeBuilder(options, { oas, pluginManager }).add(schemas.pathParams).add(schemas.queryParams).add(schemas.headerParams).add(schemas.response).add(schemas.statusCodes);
   const { source, imports } = builder.build();
-  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: /* @__PURE__ */ jsxRuntime.jsxs(
-    react.File,
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _react.Editor, { language: "typescript", children: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+    _react.File,
     {
       baseName: file.baseName,
       path: file.path,
       meta: file.meta,
       children: [
         mode === "directory" && imports.map((item, index) => {
-          return /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { root: file.path, ...item }, index);
+          return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _react.File.Import, { root: file.path, ...item }, index);
         }),
-        /* @__PURE__ */ jsxRuntime.jsxs(react.File.Source, { children: [
+        /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _react.File.Source, { children: [
           source,
           printCombinedSchema(factoryName, operation, schemas)
         ] })
@@ -186,33 +194,36 @@ Query.File = function({ mode }) {
     }
   ) });
 };
-var OperationGenerator = class extends swagger.OperationGenerator {
+
+// src/OperationGenerator.tsx
+
+var OperationGenerator = class extends _swagger.OperationGenerator {
   async all() {
     const { oas, pluginManager, plugin } = this.context;
     if (!plugin.options.oasType) {
       return null;
     }
-    const root = react.createRoot({ logger: pluginManager.logger });
+    const root = _react.createRoot.call(void 0, { logger: pluginManager.logger });
     root.render(
-      /* @__PURE__ */ jsxRuntime.jsx(Oas.File, { name: "oas", typeName: "Oas" }),
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Oas.File, { name: "oas", typeName: "Oas" }),
       { meta: { oas, pluginManager, plugin } }
     );
     return root.files;
   }
   async get(operation, schemas, options) {
     const { oas, pluginManager, plugin, mode = "directory" } = this.context;
-    const root = react.createRoot({ logger: pluginManager.logger });
+    const root = _react.createRoot.call(void 0, { logger: pluginManager.logger });
     root.render(
-      /* @__PURE__ */ jsxRuntime.jsx(Query.File, { mode }),
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Query.File, { mode }),
       { meta: { oas, pluginManager, plugin: { ...plugin, options }, schemas, operation } }
     );
     return root.files;
   }
   async post(operation, schemas, options) {
     const { oas, pluginManager, plugin, mode = "directory" } = this.context;
-    const root = react.createRoot({ logger: pluginManager.logger });
+    const root = _react.createRoot.call(void 0, { logger: pluginManager.logger });
     root.render(
-      /* @__PURE__ */ jsxRuntime.jsx(Mutation.File, { mode }),
+      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Mutation.File, { mode }),
       { meta: { oas, pluginManager, plugin: { ...plugin, options }, schemas, operation } }
     );
     return root.files;
@@ -231,7 +242,7 @@ var OperationGenerator = class extends swagger.OperationGenerator {
 // src/plugin.ts
 var pluginName = "swagger-ts";
 var pluginKey = [pluginName];
-var definePlugin = core.createPlugin((options) => {
+var definePlugin = _core.createPlugin.call(void 0, (options) => {
   const {
     output = { path: "types" },
     group,
@@ -245,7 +256,7 @@ var definePlugin = core.createPlugin((options) => {
     transformers: transformers5 = {},
     oasType = false
   } = options;
-  const template = group?.output ? group.output : `${output.path}/{{tag}}Controller`;
+  const template = _optionalChain([group, 'optionalAccess', _ => _.output]) ? group.output : `${output.path}/{{tag}}Controller`;
   return {
     name: pluginName,
     options: {
@@ -258,23 +269,23 @@ var definePlugin = core.createPlugin((options) => {
       usedEnumNames: {},
       unknownType
     },
-    pre: [swagger.pluginName],
+    pre: [_swagger.pluginName],
     resolvePath(baseName, directory, options2) {
-      const root = path__default.default.resolve(this.config.root, this.config.output.path);
-      const mode = core.FileManager.getMode(path__default.default.resolve(root, output.path));
+      const root = _path2.default.resolve(this.config.root, this.config.output.path);
+      const mode = _core.FileManager.getMode(_path2.default.resolve(root, output.path));
       if (mode === "file") {
-        return path__default.default.resolve(root, output.path);
+        return _path2.default.resolve(root, output.path);
       }
-      if (options2?.tag && group?.type === "tag") {
-        const tag = transformers2.camelCase(options2.tag);
-        return path__default.default.resolve(root, utils.renderTemplate(template, { tag }), baseName);
+      if (_optionalChain([options2, 'optionalAccess', _2 => _2.tag]) && _optionalChain([group, 'optionalAccess', _3 => _3.type]) === "tag") {
+        const tag = _transformers.camelCase.call(void 0, options2.tag);
+        return _path2.default.resolve(root, _utils3.renderTemplate.call(void 0, template, { tag }), baseName);
       }
-      return path__default.default.resolve(root, output.path, baseName);
+      return _path2.default.resolve(root, output.path, baseName);
     },
     resolveName(name, type) {
-      const resolvedName = transformers2.pascalCase(name, { isFile: type === "file" });
+      const resolvedName = _transformers.pascalCase.call(void 0, name, { isFile: type === "file" });
       if (type) {
-        return transformers5?.name?.(resolvedName, type) || resolvedName;
+        return _optionalChain([transformers5, 'optionalAccess', _4 => _4.name, 'optionalCall', _5 => _5(resolvedName, type)]) || resolvedName;
       }
       return resolvedName;
     },
@@ -285,11 +296,11 @@ var definePlugin = core.createPlugin((options) => {
       return this.fileManager.write(source, writePath, { sanity: false });
     },
     async buildStart() {
-      const [swaggerPlugin] = core.PluginManager.getDependedPlugins(this.plugins, [swagger.pluginName]);
+      const [swaggerPlugin] = _core.PluginManager.getDependedPlugins(this.plugins, [_swagger.pluginName]);
       const oas = await swaggerPlugin.api.getOas();
       const schemas = await swaggerPlugin.api.getSchemas();
-      const root = path__default.default.resolve(this.config.root, this.config.output.path);
-      const mode = core.FileManager.getMode(path__default.default.resolve(root, output.path));
+      const root = _path2.default.resolve(this.config.root, this.config.output.path);
+      const mode = _core.FileManager.getMode(_path2.default.resolve(root, output.path));
       const builder = new TypeBuilder(this.plugin.options, { oas, pluginManager: this.pluginManager });
       builder.add(
         Object.entries(schemas).map(([name, schema]) => ({ name, schema }))
@@ -351,7 +362,7 @@ var definePlugin = core.createPlugin((options) => {
       if (this.config.output.write === false) {
         return;
       }
-      const root = path__default.default.resolve(this.config.root, this.config.output.path);
+      const root = _path2.default.resolve(this.config.root, this.config.output.path);
       await this.fileManager.addIndexes({
         root,
         output,
@@ -363,7 +374,7 @@ var definePlugin = core.createPlugin((options) => {
 
 // src/TypeGenerator.ts
 var _usedAliasNames, _getTypeFromProperties, getTypeFromProperties_fn, _getRefAlias, getRefAlias_fn, _getParsedSchema, getParsedSchema_fn, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn, _unknownReturn, unknownReturn_get;
-var TypeGenerator = class extends core.Generator {
+var TypeGenerator = class extends _core.Generator {
   constructor() {
     super(...arguments);
     /**
@@ -401,18 +412,18 @@ var TypeGenerator = class extends core.Generator {
       return this.extraNodes;
     }
     if (optional) {
-      type = factory2__namespace.createUnionDeclaration({ nodes: [type, factory2__namespace.keywordTypeNodes.undefined] });
+      type = factory2.createUnionDeclaration({ nodes: [type, factory2.keywordTypeNodes.undefined] });
     }
-    const node = factory2__namespace.createTypeAliasDeclaration({
-      modifiers: [factory2__namespace.modifiers.export],
+    const node = factory2.createTypeAliasDeclaration({
+      modifiers: [factory2.modifiers.export],
       name: this.context.pluginManager.resolveName({ name: baseName, pluginKey, type: "type" }),
-      type: keysToOmit?.length ? factory2__namespace.createOmitDeclaration({ keys: keysToOmit, type, nonNullable: true }) : type
+      type: _optionalChain([keysToOmit, 'optionalAccess', _6 => _6.length]) ? factory2.createOmitDeclaration({ keys: keysToOmit, type, nonNullable: true }) : type
     });
     if (description) {
       nodes.push(
-        factory2__namespace.appendJSDocToNode({
+        factory2.appendJSDocToNode({
           node,
-          comments: [`@description ${transformers2__default.default.trim(description)}`]
+          comments: [`@description ${_transformers2.default.trim(description)}`]
         })
       );
     } else {
@@ -420,7 +431,7 @@ var TypeGenerator = class extends core.Generator {
     }
     const filterdNodes = nodes.filter(
       (node2) => !this.extraNodes.some(
-        (extraNode) => extraNode?.name?.escapedText === node2?.name?.escapedText
+        (extraNode) => _optionalChain([extraNode, 'optionalAccess', _7 => _7.name, 'optionalAccess', _8 => _8.escapedText]) === _optionalChain([node2, 'optionalAccess', _9 => _9.name, 'optionalAccess', _10 => _10.escapedText])
       )
     );
     return [...this.extraNodes, ...filterdNodes];
@@ -438,16 +449,16 @@ var TypeGenerator = class extends core.Generator {
     if (schema && !schema.nullable) {
       return type;
     }
-    return factory2__namespace.createUnionDeclaration({ nodes: [type, factory2__namespace.keywordTypeNodes.null] });
+    return factory2.createUnionDeclaration({ nodes: [type, factory2.keywordTypeNodes.null] });
   }
 };
 _usedAliasNames = new WeakMap();
 _getTypeFromProperties = new WeakSet();
 getTypeFromProperties_fn = function(baseSchema, baseName) {
   const { optionalType } = this.options;
-  const properties = baseSchema?.properties || {};
-  const required = baseSchema?.required;
-  const additionalProperties = baseSchema?.additionalProperties;
+  const properties = _optionalChain([baseSchema, 'optionalAccess', _11 => _11.properties]) || {};
+  const required = _optionalChain([baseSchema, 'optionalAccess', _12 => _12.required]);
+  const additionalProperties = _optionalChain([baseSchema, 'optionalAccess', _13 => _13.additionalProperties]);
   const members = Object.keys(properties).map((name) => {
     const schema = properties[name];
     const isRequired = Array.isArray(required) ? required.includes(name) : !!required;
@@ -456,19 +467,19 @@ getTypeFromProperties_fn = function(baseSchema, baseName) {
       return null;
     }
     if (!isRequired && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) {
-      type = factory2__namespace.createUnionDeclaration({ nodes: [type, factory2__namespace.keywordTypeNodes.undefined] });
+      type = factory2.createUnionDeclaration({ nodes: [type, factory2.keywordTypeNodes.undefined] });
     }
-    const propertySignature = factory2__namespace.createPropertySignature({
+    const propertySignature = factory2.createPropertySignature({
       questionToken: ["questionToken", "questionTokenAndUndefined"].includes(optionalType) && !isRequired,
       name,
       type,
       readOnly: schema.readOnly
     });
-    return factory2__namespace.appendJSDocToNode({
+    return factory2.appendJSDocToNode({
       node: propertySignature,
       comments: [
         schema.description ? `@description ${schema.description}` : void 0,
-        schema.type ? `@type ${schema.type?.toString()}${isRequired ? "" : " | undefined"} ${schema.format || ""}` : void 0,
+        schema.type ? `@type ${_optionalChain([schema, 'access', _14 => _14.type, 'optionalAccess', _15 => _15.toString, 'call', _16 => _16()])}${isRequired ? "" : " | undefined"} ${schema.format || ""}` : void 0,
         schema.example ? `@example ${schema.example}` : void 0,
         schema.deprecated ? `@deprecated` : void 0,
         schema.default !== void 0 && typeof schema.default === "string" ? `@default '${schema.default}'` : void 0,
@@ -479,19 +490,19 @@ getTypeFromProperties_fn = function(baseSchema, baseName) {
   if (additionalProperties) {
     const type = additionalProperties === true ? __privateGet(this, _unknownReturn, unknownReturn_get) : this.getTypeFromSchema(additionalProperties);
     if (type) {
-      members.push(factory2__namespace.createIndexSignature(type));
+      members.push(factory2.createIndexSignature(type));
     }
   }
-  return factory2__namespace.createTypeLiteralNode(members.filter(Boolean));
+  return factory2.createTypeLiteralNode(members.filter(Boolean));
 };
 _getRefAlias = new WeakSet();
 getRefAlias_fn = function(obj, _baseName) {
   const { $ref } = obj;
   let ref = this.refs[$ref];
   if (ref) {
-    return factory2__namespace.createTypeReferenceNode(ref.propertyName, void 0);
+    return factory2.createTypeReferenceNode(ref.propertyName, void 0);
   }
-  const originalName = utils.getUniqueName($ref.replace(/.+\//, ""), __privateGet(this, _usedAliasNames));
+  const originalName = _utils3.getUniqueName.call(void 0, $ref.replace(/.+\//, ""), __privateGet(this, _usedAliasNames));
   const propertyName = this.context.pluginManager.resolveName({ name: originalName, pluginKey, type: "type" });
   ref = this.refs[$ref] = {
     propertyName,
@@ -504,11 +515,11 @@ getRefAlias_fn = function(obj, _baseName) {
     path: path2 || "",
     isTypeOnly: true
   });
-  return factory2__namespace.createTypeReferenceNode(ref.propertyName, void 0);
+  return factory2.createTypeReferenceNode(ref.propertyName, void 0);
 };
 _getParsedSchema = new WeakSet();
 getParsedSchema_fn = function(schema) {
-  const parsedSchema = utils$1.getSchemaFactory(this.context.oas)(schema);
+  const parsedSchema = _utils.getSchemaFactory.call(void 0, this.context.oas)(schema);
   return parsedSchema;
 };
 _getBaseTypeFromSchema = new WeakSet();
@@ -517,12 +528,12 @@ getBaseTypeFromSchema_fn = function(_schema, baseName) {
   if (!schema) {
     return __privateGet(this, _unknownReturn, unknownReturn_get);
   }
-  if (utils$1.isReference(schema)) {
+  if (_utils.isReference.call(void 0, schema)) {
     return __privateMethod(this, _getRefAlias, getRefAlias_fn).call(this, schema, baseName);
   }
   if (schema.oneOf) {
     const schemaWithoutOneOf = { ...schema, oneOf: void 0 };
-    const union = factory2__namespace.createUnionDeclaration({
+    const union = factory2.createUnionDeclaration({
       withParentheses: true,
       nodes: schema.oneOf.map((item) => {
         return item && this.getTypeFromSchema(item);
@@ -531,7 +542,7 @@ getBaseTypeFromSchema_fn = function(_schema, baseName) {
       })
     });
     if (schemaWithoutOneOf.properties) {
-      return factory2__namespace.createIntersectionDeclaration({
+      return factory2.createIntersectionDeclaration({
         nodes: [this.getTypeFromSchema(schemaWithoutOneOf, baseName), union].filter(Boolean)
       });
     }
@@ -539,7 +550,7 @@ getBaseTypeFromSchema_fn = function(_schema, baseName) {
   }
   if (schema.anyOf) {
     const schemaWithoutAnyOf = { ...schema, anyOf: void 0 };
-    const union = factory2__namespace.createUnionDeclaration({
+    const union = factory2.createUnionDeclaration({
       withParentheses: true,
       nodes: schema.anyOf.map((item) => {
         return item && this.getTypeFromSchema(item);
@@ -548,7 +559,7 @@ getBaseTypeFromSchema_fn = function(_schema, baseName) {
       })
     });
     if (schemaWithoutAnyOf.properties) {
-      return factory2__namespace.createIntersectionDeclaration({
+      return factory2.createIntersectionDeclaration({
         nodes: [this.getTypeFromSchema(schemaWithoutAnyOf, baseName), union].filter(Boolean)
       });
     }
@@ -556,7 +567,7 @@ getBaseTypeFromSchema_fn = function(_schema, baseName) {
   }
   if (schema.allOf) {
     const schemaWithoutAllOf = { ...schema, allOf: void 0 };
-    const and = factory2__namespace.createIntersectionDeclaration({
+    const and = factory2.createIntersectionDeclaration({
       withParentheses: true,
       nodes: schema.allOf.map((item) => {
         return item && this.getTypeFromSchema(item);
@@ -565,47 +576,47 @@ getBaseTypeFromSchema_fn = function(_schema, baseName) {
       })
     });
     if (schemaWithoutAllOf.properties) {
-      return factory2__namespace.createIntersectionDeclaration({
+      return factory2.createIntersectionDeclaration({
         nodes: [this.getTypeFromSchema(schemaWithoutAllOf, baseName), and].filter(Boolean)
       });
     }
     return and;
   }
   if (schema.enum && baseName) {
-    const enumName = utils.getUniqueName(baseName, this.options.usedEnumNames);
+    const enumName = _utils3.getUniqueName.call(void 0, baseName, this.options.usedEnumNames);
     let enums = [...new Set(schema.enum)].map((key) => [key, key]);
     const extensionEnums = ["x-enumNames", "x-enum-varnames"].filter((extensionKey) => extensionKey in schema).map(
-      (extensionKey) => [...new Set(schema[extensionKey])].map((key, index) => [key, schema.enum?.[index]])
+      (extensionKey) => [...new Set(schema[extensionKey])].map((key, index) => [key, _optionalChain([schema, 'access', _17 => _17.enum, 'optionalAccess', _18 => _18[index]])])
     );
     if (extensionEnums.length > 0 && extensionEnums[0]) {
       enums = extensionEnums[0];
     }
     this.extraNodes.push(
-      ...factory2__namespace.createEnumDeclaration({
-        name: transformers2__default.default.camelCase(enumName),
+      ...factory2.createEnumDeclaration({
+        name: _transformers2.default.camelCase(enumName),
         typeName: this.context.pluginManager.resolveName({ name: enumName, pluginKey, type: "type" }),
         enums,
         type: this.options.enumType
       })
     );
-    return factory2__namespace.createTypeReferenceNode(this.context.pluginManager.resolveName({ name: enumName, pluginKey, type: "type" }), void 0);
+    return factory2.createTypeReferenceNode(this.context.pluginManager.resolveName({ name: enumName, pluginKey, type: "type" }), void 0);
   }
   if (schema.enum) {
-    return factory2__namespace.createUnionDeclaration({
+    return factory2.createUnionDeclaration({
       nodes: schema.enum.map((name) => {
-        return factory2__namespace.createLiteralTypeNode(typeof name === "number" ? factory2__namespace.createNumericLiteral(name) : factory2__namespace.createStringLiteral(`${name}`));
+        return factory2.createLiteralTypeNode(typeof name === "number" ? factory2.createNumericLiteral(name) : factory2.createStringLiteral(`${name}`));
       })
     });
   }
   if ("items" in schema) {
     const node = this.getTypeFromSchema(schema.items, baseName);
     if (node) {
-      return factory2__namespace.createArrayTypeNode(node);
+      return factory2.createArrayTypeNode(node);
     }
   }
   if ("prefixItems" in schema) {
     const prefixItems = schema.prefixItems;
-    return factory2__namespace.createTupleDeclaration({
+    return factory2.createTupleDeclaration({
       nodes: prefixItems.map((item) => {
         return this.getTypeFromSchema(item, void 0);
       })
@@ -617,18 +628,18 @@ getBaseTypeFromSchema_fn = function(_schema, baseName) {
   if (version === "3.1" && "const" in schema) {
     if (schema["const"]) {
       if (typeof schema["const"] === "string") {
-        return factory2__namespace.createLiteralTypeNode(factory2__namespace.createStringLiteral(schema["const"]));
+        return factory2.createLiteralTypeNode(factory2.createStringLiteral(schema["const"]));
       } else if (typeof schema["const"] === "number") {
-        return factory2__namespace.createLiteralTypeNode(factory2__namespace.createNumericLiteral(schema["const"]));
+        return factory2.createLiteralTypeNode(factory2.createNumericLiteral(schema["const"]));
       }
     } else {
-      return factory2.keywordTypeNodes.null;
+      return _factory.keywordTypeNodes.null;
     }
   }
   if (schema.type) {
     if (Array.isArray(schema.type)) {
       const [type, nullable] = schema.type;
-      return factory2__namespace.createUnionDeclaration({
+      return factory2.createUnionDeclaration({
         nodes: [
           this.getTypeFromSchema(
             {
@@ -637,38 +648,38 @@ getBaseTypeFromSchema_fn = function(_schema, baseName) {
             },
             baseName
           ),
-          nullable ? factory2__namespace.createLiteralTypeNode(factory2__namespace.createNull()) : void 0
+          nullable ? factory2.createLiteralTypeNode(factory2.createNull()) : void 0
         ].filter(Boolean)
       });
     }
     if (this.options.dateType === "date" && ["date", "date-time"].some((item) => item === schema.format)) {
-      return factory2__namespace.createTypeReferenceNode(factory2__namespace.createIdentifier("Date"));
+      return factory2.createTypeReferenceNode(factory2.createIdentifier("Date"));
     }
-    if (schema.type in factory2__namespace.keywordTypeNodes) {
-      return factory2__namespace.keywordTypeNodes[schema.type];
+    if (schema.type in factory2.keywordTypeNodes) {
+      return factory2.keywordTypeNodes[schema.type];
     }
   }
   if (schema.format === "binary") {
-    return factory2__namespace.createTypeReferenceNode("Blob", []);
+    return factory2.createTypeReferenceNode("Blob", []);
   }
   return __privateGet(this, _unknownReturn, unknownReturn_get);
 };
 _unknownReturn = new WeakSet();
 unknownReturn_get = function() {
   if (this.options.unknownType === "any") {
-    return factory2__namespace.keywordTypeNodes.any;
+    return factory2.keywordTypeNodes.any;
   }
-  return factory2__namespace.keywordTypeNodes.unknown;
+  return factory2.keywordTypeNodes.unknown;
 };
 
 // src/TypeBuilder.ts
-var TypeBuilder = class extends swagger.OasBuilder {
+var TypeBuilder = class extends _swagger.OasBuilder {
   build(name) {
     const importMeta = [];
     const codes = [];
-    const generated = this.items.filter((operationSchema) => name ? operationSchema.name === name : true).sort(transformers2__default.default.nameSorter).map((operationSchema) => {
+    const generated = this.items.filter((operationSchema) => name ? operationSchema.name === name : true).sort(_transformers2.default.nameSorter).map((operationSchema) => {
       const generator = new TypeGenerator(this.options, this.context);
-      const required = Array.isArray(operationSchema.schema?.required) ? !!operationSchema.schema.required.length : !!operationSchema.schema?.required;
+      const required = Array.isArray(_optionalChain([operationSchema, 'access', _19 => _19.schema, 'optionalAccess', _20 => _20.required])) ? !!operationSchema.schema.required.length : !!_optionalChain([operationSchema, 'access', _21 => _21.schema, 'optionalAccess', _22 => _22.required]);
       const sources = generator.build({
         schema: operationSchema.schema,
         baseName: operationSchema.name,
@@ -684,9 +695,9 @@ var TypeBuilder = class extends swagger.OasBuilder {
         },
         sources
       };
-    }).sort(utils$1.refsSorter);
+    }).sort(_utils.refsSorter);
     generated.forEach((item) => {
-      codes.push(parser.print(item.sources));
+      codes.push(_parser.print.call(void 0, item.sources));
     });
     const imports = importMeta.map((item) => {
       return {
@@ -697,98 +708,101 @@ var TypeBuilder = class extends swagger.OasBuilder {
     });
     return {
       imports,
-      source: transformers2__default.default.combineCodes(codes)
+      source: _transformers2.default.combineCodes(codes)
     };
   }
 };
+
+// src/components/Mutation.tsx
+
 function printCombinedSchema2(name, operation, schemas) {
   const properties = {
-    "response": factory2__namespace.createTypeReferenceNode(
-      factory2__namespace.createIdentifier(schemas.response.name),
+    "response": factory3.createTypeReferenceNode(
+      factory3.createIdentifier(schemas.response.name),
       void 0
     )
   };
   if (schemas.request) {
-    properties["request"] = factory2__namespace.createTypeReferenceNode(
-      factory2__namespace.createIdentifier(schemas.request.name),
+    properties["request"] = factory3.createTypeReferenceNode(
+      factory3.createIdentifier(schemas.request.name),
       void 0
     );
   }
   if (schemas.pathParams) {
-    properties["pathParams"] = factory2__namespace.createTypeReferenceNode(
-      factory2__namespace.createIdentifier(schemas.pathParams.name),
+    properties["pathParams"] = factory3.createTypeReferenceNode(
+      factory3.createIdentifier(schemas.pathParams.name),
       void 0
     );
   }
   if (schemas.queryParams) {
-    properties["queryParams"] = factory2__namespace.createTypeReferenceNode(
-      factory2__namespace.createIdentifier(schemas.queryParams.name),
+    properties["queryParams"] = factory3.createTypeReferenceNode(
+      factory3.createIdentifier(schemas.queryParams.name),
       void 0
     );
   }
   if (schemas.headerParams) {
-    properties["headerParams"] = factory2__namespace.createTypeReferenceNode(
-      factory2__namespace.createIdentifier(schemas.headerParams.name),
+    properties["headerParams"] = factory3.createTypeReferenceNode(
+      factory3.createIdentifier(schemas.headerParams.name),
       void 0
     );
   }
   if (schemas.errors) {
-    properties["errors"] = factory2__namespace.createUnionDeclaration({
+    properties["errors"] = factory3.createUnionDeclaration({
       nodes: schemas.errors.map((error) => {
-        return factory2__namespace.createTypeReferenceNode(
-          factory2__namespace.createIdentifier(error.name),
+        return factory3.createTypeReferenceNode(
+          factory3.createIdentifier(error.name),
           void 0
         );
       })
     });
   }
-  const namespaceNode = factory2__namespace.createTypeAliasDeclaration({
+  const namespaceNode = factory3.createTypeAliasDeclaration({
     name: operation.method === "get" ? `${name}Query` : `${name}Mutation`,
-    type: factory2__namespace.createTypeLiteralNode(
+    type: factory3.createTypeLiteralNode(
       Object.keys(properties).map((key) => {
         const type = properties[key];
         if (!type) {
           return void 0;
         }
-        return factory2__namespace.createPropertySignature(
+        return factory3.createPropertySignature(
           {
-            name: transformers2__default.default.pascalCase(key),
+            name: _transformers2.default.pascalCase(key),
             type
           }
         );
       }).filter(Boolean)
     ),
-    modifiers: [factory2__namespace.modifiers.export]
+    modifiers: [factory3.modifiers.export]
   });
-  return parser.print(namespaceNode);
+  return _parser.print.call(void 0, namespaceNode);
 }
 function Mutation({
   builder
 }) {
   const { source } = builder.build();
-  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: source });
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _jsxruntime.Fragment, { children: source });
 }
 Mutation.File = function({ mode }) {
-  const { options } = react.usePlugin();
-  const schemas = hooks.useSchemas();
-  const pluginManager = react.usePluginManager();
-  const oas = hooks.useOas();
-  const file = hooks.useOperationFile();
-  const factoryName = hooks.useOperationName({ type: "type" });
-  const operation = hooks.useOperation();
+  const { options } = _react.usePlugin.call(void 0, );
+  const schemas = _hooks.useSchemas.call(void 0, );
+  const pluginManager = _react.usePluginManager.call(void 0, );
+  const oas = _hooks.useOas.call(void 0, );
+  const file = _hooks.useOperationFile.call(void 0, );
+  const factoryName = _hooks.useOperationName.call(void 0, { type: "type" });
+  const operation = _hooks.useOperation.call(void 0, );
   const builder = new TypeBuilder(options, { oas, pluginManager }).add(schemas.pathParams).add(schemas.queryParams).add(schemas.headerParams).add(schemas.response).add(schemas.request).add(schemas.statusCodes);
   const { source, imports } = builder.build();
-  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: /* @__PURE__ */ jsxRuntime.jsxs(
-    react.File,
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _react.Editor, { language: "typescript", children: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, 
+    _react.File,
     {
       baseName: file.baseName,
       path: file.path,
       meta: file.meta,
       children: [
         mode === "directory" && imports.map((item, index) => {
-          return /* @__PURE__ */ jsxRuntime.jsx(react.File.Import, { root: file.path, ...item }, index);
+          return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _react.File.Import, { root: file.path, ...item }, index);
         }),
-        /* @__PURE__ */ jsxRuntime.jsxs(react.File.Source, { children: [
+        /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _react.File.Source, { children: [
           source,
           printCombinedSchema2(factoryName, operation, schemas)
         ] })
@@ -797,11 +811,12 @@ Mutation.File = function({ mode }) {
   ) });
 };
 
-exports.Mutation = Mutation;
-exports.Oas = Oas;
-exports.Query = Query;
-exports.definePlugin = definePlugin;
-exports.pluginKey = pluginKey;
-exports.pluginName = pluginName;
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-3QUKTW23.cjs.map
+
+
+
+
+
+
+
+exports.Mutation = Mutation; exports.Oas = Oas; exports.Query = Query; exports.pluginName = pluginName; exports.pluginKey = pluginKey; exports.definePlugin = definePlugin;
+//# sourceMappingURL=chunk-T5JLEKOF.cjs.map