@kubb/swagger-ts 2.9.1 → 2.11.0

package/dist/chunk-75HLNTZM.cjs

@@ -1,823 +0,0 @@
-"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 _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 __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-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
-
-
-var _components = require('@kubb/swagger/components');
-
-// src/components/OasType.tsx
-
-
-
-var _jsxruntime = require('@kubb/react/jsx-runtime');
-function Template({
-  name,
-  typeName,
-  api
-}) {
-  return /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _jsxruntime.Fragment, { children: [
-    `export const ${name} = ${JSON.stringify(api, void 0, 2)} as const`,
-    /* @__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 };
-function OasType({
-  name,
-  typeName,
-  Template: Template2 = defaultTemplates.default
-}) {
-  const oas = _hooks.useOas.call(void 0, );
-  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Template2, { name, typeName, api: oas.api });
-}
-OasType.File = function({ name, typeName, templates = defaultTemplates }) {
-  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.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.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, OasType, { Template: Template2, name, typeName }) })
-      ]
-    }
-  ) });
-};
-OasType.templates = defaultTemplates;
-
-// src/components/Query.tsx
-
-
-
-
-
-
-function printCombinedSchema(name, operation, schemas) {
-  const properties = {
-    "response": factory.createTypeReferenceNode(
-      factory.createIdentifier(schemas.response.name),
-      void 0
-    )
-  };
-  if (schemas.request) {
-    properties["request"] = factory.createTypeReferenceNode(
-      factory.createIdentifier(schemas.request.name),
-      void 0
-    );
-  }
-  if (schemas.pathParams) {
-    properties["pathParams"] = factory.createTypeReferenceNode(
-      factory.createIdentifier(schemas.pathParams.name),
-      void 0
-    );
-  }
-  if (schemas.queryParams) {
-    properties["queryParams"] = factory.createTypeReferenceNode(
-      factory.createIdentifier(schemas.queryParams.name),
-      void 0
-    );
-  }
-  if (schemas.headerParams) {
-    properties["headerParams"] = factory.createTypeReferenceNode(
-      factory.createIdentifier(schemas.headerParams.name),
-      void 0
-    );
-  }
-  if (schemas.errors) {
-    properties["errors"] = factory.createUnionDeclaration({
-      nodes: schemas.errors.map((error) => {
-        return factory.createTypeReferenceNode(
-          factory.createIdentifier(error.name),
-          void 0
-        );
-      })
-    });
-  }
-  const namespaceNode = factory.createTypeAliasDeclaration({
-    name: operation.method === "get" ? `${name}Query` : `${name}Mutation`,
-    type: factory.createTypeLiteralNode(
-      Object.keys(properties).map((key) => {
-        const type = properties[key];
-        if (!type) {
-          return void 0;
-        }
-        return factory.createPropertySignature(
-          {
-            name: _transformers2.default.pascalCase(key),
-            type
-          }
-        );
-      }).filter(Boolean)
-    ),
-    modifiers: [factory.modifiers.export]
-  });
-  return _parser.print.call(void 0, namespaceNode);
-}
-function Query({
-  builder
-}) {
-  const { source } = builder.build();
-  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _jsxruntime.Fragment, { children: source });
-}
-Query.File = function({ mode }) {
-  const plugin = _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(plugin.options, { oas, plugin, 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.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.call(void 0, _react.File.Import, { root: file.path, ...item }, index);
-        }),
-        /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _react.File.Source, { children: [
-          source,
-          printCombinedSchema(factoryName, operation, schemas)
-        ] })
-      ]
-    }
-  ) });
-};
-
-// src/OperationGenerator.tsx
-
-var OperationGenerator = class extends _swagger.OperationGenerator {
-  async all(operations) {
-    const { oas, pluginManager, plugin } = this.context;
-    const root = _react.createRoot.call(void 0, { logger: pluginManager.logger });
-    root.render(
-      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _components.Oas, { oas, operations, getSchemas: (...props) => this.getSchemas(...props), children: plugin.options.oasType && /* @__PURE__ */ _jsxruntime.jsx.call(void 0, OasType.File, { name: "oas", typeName: "Oas" }) }),
-      { meta: { pluginManager, plugin } }
-    );
-    return root.files;
-  }
-  async get(operation, options) {
-    const { oas, pluginManager, plugin, mode = "directory" } = this.context;
-    const root = _react.createRoot.call(void 0, { logger: pluginManager.logger });
-    root.render(
-      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _components.Oas, { oas, operations: [operation], getSchemas: (...props) => this.getSchemas(...props), children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _components.Oas.Operation, { operation, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Query.File, { mode }) }) }),
-      { meta: { pluginManager, plugin: { ...plugin, options } } }
-    );
-    return root.files;
-  }
-  async post(operation, options) {
-    const { oas, pluginManager, plugin, mode = "directory" } = this.context;
-    const root = _react.createRoot.call(void 0, { logger: pluginManager.logger });
-    root.render(
-      /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _components.Oas, { oas, operations: [operation], getSchemas: (...props) => this.getSchemas(...props), children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _components.Oas.Operation, { operation, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, Mutation.File, { mode }) }) }),
-      { meta: { pluginManager, plugin: { ...plugin, options } } }
-    );
-    return root.files;
-  }
-  async put(operation, options) {
-    return this.post(operation, options);
-  }
-  async patch(operation, options) {
-    return this.post(operation, options);
-  }
-  async delete(operation, options) {
-    return this.post(operation, options);
-  }
-};
-
-// src/plugin.ts
-var pluginName = "swagger-ts";
-var pluginKey = [pluginName];
-var definePlugin = _core.createPlugin.call(void 0, (options) => {
-  const {
-    output = { path: "types" },
-    group,
-    exclude = [],
-    include,
-    override = [],
-    enumType = "asConst",
-    enumSuffix = "",
-    dateType = "string",
-    unknownType = "any",
-    optionalType = "questionToken",
-    transformers: transformers5 = {},
-    oasType = false
-  } = options;
-  const template = _optionalChain([group, 'optionalAccess', _ => _.output]) ? group.output : `${output.path}/{{tag}}Controller`;
-  return {
-    name: pluginName,
-    options: {
-      transformers: transformers5,
-      dateType,
-      enumType,
-      enumSuffix,
-      optionalType,
-      oasType,
-      // keep the used enumnames between TypeBuilder and OperationGenerator per plugin(pluginKey)
-      usedEnumNames: {},
-      unknownType
-    },
-    pre: [_swagger.pluginName],
-    resolvePath(baseName, pathMode, options2) {
-      const root = _path2.default.resolve(this.config.root, this.config.output.path);
-      const mode = _nullishCoalesce(pathMode, () => ( _core.FileManager.getMode(_path2.default.resolve(root, output.path))));
-      if (mode === "file") {
-        return _path2.default.resolve(root, output.path);
-      }
-      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 _path2.default.resolve(root, output.path, baseName);
-    },
-    resolveName(name, type) {
-      const resolvedName = _transformers.pascalCase.call(void 0, name, { isFile: type === "file" });
-      if (type) {
-        return _optionalChain([transformers5, 'optionalAccess', _4 => _4.name, 'optionalCall', _5 => _5(resolvedName, type)]) || resolvedName;
-      }
-      return resolvedName;
-    },
-    async writeFile(source, writePath) {
-      if (!writePath.endsWith(".ts") || !source) {
-        return;
-      }
-      return this.fileManager.write(source, writePath, { sanity: false });
-    },
-    async buildStart() {
-      const [swaggerPlugin] = _core.PluginManager.getDependedPlugins(this.plugins, [_swagger.pluginName]);
-      const oas = await swaggerPlugin.api.getOas();
-      const schemas = await swaggerPlugin.api.getSchemas();
-      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, plugin: this.plugin, pluginManager: this.pluginManager });
-      builder.add(
-        Object.entries(schemas).map(([name, schema]) => ({ name, schema }))
-      );
-      if (mode === "directory") {
-        const mapFolderSchema = async ([name]) => {
-          const baseName = `${this.resolveName({ name, pluginKey: this.plugin.key, type: "file" })}.ts`;
-          const resolvedPath = this.resolvePath({ baseName, pluginKey: this.plugin.key });
-          const { source, imports } = builder.build(name);
-          if (!resolvedPath) {
-            return null;
-          }
-          return this.addFile({
-            path: resolvedPath,
-            baseName,
-            source,
-            imports: imports.map((item) => ({ ...item, root: resolvedPath })),
-            meta: {
-              pluginKey: this.plugin.key
-            }
-          });
-        };
-        const promises = Object.entries(schemas).map(mapFolderSchema);
-        await Promise.all(promises);
-      }
-      if (mode === "file") {
-        const resolvedPath = this.resolvePath({ baseName: "", pluginKey: this.plugin.key });
-        const { source } = builder.build();
-        if (!resolvedPath) {
-          return;
-        }
-        await this.addFile({
-          path: resolvedPath,
-          baseName: output.path,
-          source,
-          imports: [],
-          meta: {
-            pluginKey: this.plugin.key
-          }
-        });
-      }
-      const operationGenerator = new OperationGenerator(
-        this.plugin.options,
-        {
-          oas,
-          pluginManager: this.pluginManager,
-          plugin: this.plugin,
-          contentType: swaggerPlugin.api.contentType,
-          exclude,
-          include,
-          override,
-          mode
-        }
-      );
-      const files = await operationGenerator.build();
-      await this.addFile(...files);
-    },
-    async buildEnd() {
-      if (this.config.output.write === false) {
-        return;
-      }
-      const root = _path2.default.resolve(this.config.root, this.config.output.path);
-      await this.fileManager.addIndexes({
-        root,
-        output,
-        meta: { pluginKey: this.plugin.key }
-      });
-    }
-  };
-});
-
-// 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 {
-  constructor() {
-    super(...arguments);
-    /**
-     * Recursively creates a type literal with the given props.
-     */
-    __privateAdd(this, _getTypeFromProperties);
-    /**
-     * Create a type alias for the schema referenced by the given ReferenceObject
-     */
-    __privateAdd(this, _getRefAlias);
-    __privateAdd(this, _getParsedSchema);
-    /**
-     * This is the very core of the OpenAPI to TS conversion - it takes a
-     * schema and returns the appropriate type.
-     */
-    __privateAdd(this, _getBaseTypeFromSchema);
-    __privateAdd(this, _unknownReturn);
-    this.refs = {};
-    this.imports = [];
-    this.extraNodes = [];
-    this.aliases = [];
-    // Keep track of already used type aliases
-    __privateAdd(this, _usedAliasNames, {});
-  }
-  build({
-    schema,
-    optional,
-    baseName,
-    description,
-    keysToOmit
-  }) {
-    const nodes = [];
-    let type = this.getTypeFromSchema(schema, baseName);
-    if (!type) {
-      return this.extraNodes;
-    }
-    if (optional) {
-      type = factory2.createUnionDeclaration({ nodes: [type, factory2.keywordTypeNodes.undefined] });
-    }
-    const node = factory2.createTypeAliasDeclaration({
-      modifiers: [factory2.modifiers.export],
-      name: this.context.pluginManager.resolveName({ name: baseName, pluginKey, type: "type" }),
-      type: _optionalChain([keysToOmit, 'optionalAccess', _6 => _6.length]) ? factory2.createOmitDeclaration({ keys: keysToOmit, type, nonNullable: true }) : type
-    });
-    if (description) {
-      nodes.push(
-        factory2.appendJSDocToNode({
-          node,
-          comments: [`@description ${_transformers2.default.trim(description)}`]
-        })
-      );
-    } else {
-      nodes.push(node);
-    }
-    const filterdNodes = nodes.filter(
-      (node2) => !this.extraNodes.some(
-        (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];
-  }
-  /**
-   * Creates a type node from a given schema.
-   * Delegates to getBaseTypeFromSchema internally and
-   * optionally adds a union with null.
-   */
-  getTypeFromSchema(schema, name) {
-    const type = __privateMethod(this, _getBaseTypeFromSchema, getBaseTypeFromSchema_fn).call(this, schema, name);
-    if (!type) {
-      return null;
-    }
-    const nullable = _nullishCoalesce(_nullishCoalesce(_optionalChain([schema, 'optionalAccess', _11 => _11.nullable]), () => ( _optionalChain([schema, 'optionalAccess', _12 => _12["x-nullable"]]))), () => ( false));
-    if (nullable) {
-      return factory2.createUnionDeclaration({ nodes: [type, factory2.keywordTypeNodes.null] });
-    }
-    return type;
-  }
-};
-_usedAliasNames = new WeakMap();
-_getTypeFromProperties = new WeakSet();
-getTypeFromProperties_fn = function(baseSchema, baseName) {
-  const { optionalType } = this.options;
-  const properties = _optionalChain([baseSchema, 'optionalAccess', _13 => _13.properties]) || {};
-  const required = _optionalChain([baseSchema, 'optionalAccess', _14 => _14.required]);
-  const additionalProperties = _optionalChain([baseSchema, 'optionalAccess', _15 => _15.additionalProperties]);
-  const members = Object.keys(properties).map((name) => {
-    const schema = properties[name];
-    const isRequired = Array.isArray(required) ? required.includes(name) : !!required;
-    let type = this.getTypeFromSchema(schema, this.context.pluginManager.resolveName({ name: `${baseName || ""} ${name}`, pluginKey, type: "type" }));
-    if (!type) {
-      return null;
-    }
-    if (!isRequired && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) {
-      type = factory2.createUnionDeclaration({ nodes: [type, factory2.keywordTypeNodes.undefined] });
-    }
-    const propertySignature = factory2.createPropertySignature({
-      questionToken: ["questionToken", "questionTokenAndUndefined"].includes(optionalType) && !isRequired,
-      name,
-      type,
-      readOnly: schema.readOnly
-    });
-    return factory2.appendJSDocToNode({
-      node: propertySignature,
-      comments: [
-        schema.description ? `@description ${schema.description}` : void 0,
-        schema.type ? `@type ${_optionalChain([schema, 'access', _16 => _16.type, 'optionalAccess', _17 => _17.toString, 'call', _18 => _18()])}${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,
-        schema.default !== void 0 && typeof schema.default !== "string" ? `@default ${schema.default}` : void 0
-      ].filter(Boolean)
-    });
-  });
-  if (additionalProperties) {
-    const type = additionalProperties === true ? __privateGet(this, _unknownReturn, unknownReturn_get) : this.getTypeFromSchema(additionalProperties);
-    if (type) {
-      members.push(factory2.createIndexSignature(type));
-    }
-  }
-  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.createTypeReferenceNode(ref.propertyName, void 0);
-  }
-  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,
-    originalName
-  };
-  const fileName = this.context.pluginManager.resolveName({ name: originalName, pluginKey, type: "file" });
-  const path2 = this.context.pluginManager.resolvePath({ baseName: fileName, pluginKey });
-  this.imports.push({
-    ref,
-    path: path2 || "",
-    isTypeOnly: true
-  });
-  return factory2.createTypeReferenceNode(ref.propertyName, void 0);
-};
-_getParsedSchema = new WeakSet();
-getParsedSchema_fn = function(schema) {
-  const parsedSchema = _utils.getSchemaFactory.call(void 0, this.context.oas)(schema);
-  return parsedSchema;
-};
-_getBaseTypeFromSchema = new WeakSet();
-getBaseTypeFromSchema_fn = function(_schema, baseName) {
-  const { schema, version } = __privateMethod(this, _getParsedSchema, getParsedSchema_fn).call(this, _schema);
-  if (!schema) {
-    return __privateGet(this, _unknownReturn, unknownReturn_get);
-  }
-  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.createUnionDeclaration({
-      withParentheses: true,
-      nodes: schema.oneOf.map((item) => {
-        return item && this.getTypeFromSchema(item);
-      }).filter((item) => {
-        return item && item !== __privateGet(this, _unknownReturn, unknownReturn_get);
-      })
-    });
-    if (schemaWithoutOneOf.properties) {
-      return factory2.createIntersectionDeclaration({
-        nodes: [this.getTypeFromSchema(schemaWithoutOneOf, baseName), union].filter(Boolean)
-      });
-    }
-    return union;
-  }
-  if (schema.anyOf) {
-    const schemaWithoutAnyOf = { ...schema, anyOf: void 0 };
-    const union = factory2.createUnionDeclaration({
-      withParentheses: true,
-      nodes: schema.anyOf.map((item) => {
-        return item && this.getTypeFromSchema(item);
-      }).filter((item) => {
-        return item && item !== __privateGet(this, _unknownReturn, unknownReturn_get);
-      })
-    });
-    if (schemaWithoutAnyOf.properties) {
-      return factory2.createIntersectionDeclaration({
-        nodes: [this.getTypeFromSchema(schemaWithoutAnyOf, baseName), union].filter(Boolean)
-      });
-    }
-    return union;
-  }
-  if (schema.allOf) {
-    const schemaWithoutAllOf = { ...schema, allOf: void 0 };
-    const and = factory2.createIntersectionDeclaration({
-      withParentheses: true,
-      nodes: schema.allOf.map((item) => {
-        return item && this.getTypeFromSchema(item);
-      }).filter((item) => {
-        return item && item !== __privateGet(this, _unknownReturn, unknownReturn_get);
-      })
-    });
-    if (schemaWithoutAllOf.properties) {
-      return factory2.createIntersectionDeclaration({
-        nodes: [this.getTypeFromSchema(schemaWithoutAllOf, baseName), and].filter(Boolean)
-      });
-    }
-    return and;
-  }
-  if (schema.enum && baseName) {
-    const enumName = _utils3.getUniqueName.call(void 0, _transformers.pascalCase.call(void 0, [baseName, this.options.enumSuffix].join(" ")), 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, _optionalChain([schema, 'access', _19 => _19.enum, 'optionalAccess', _20 => _20[index]])])
-    );
-    if (extensionEnums.length > 0 && extensionEnums[0]) {
-      enums = extensionEnums[0];
-    }
-    this.extraNodes.push(
-      ...factory2.createEnumDeclaration({
-        name: _transformers2.default.camelCase(enumName),
-        typeName: this.context.pluginManager.resolveName({ name: enumName, pluginKey, type: "type" }),
-        enums,
-        type: this.options.enumType
-      })
-    );
-    return factory2.createTypeReferenceNode(this.context.pluginManager.resolveName({ name: enumName, pluginKey, type: "type" }), void 0);
-  }
-  if (schema.enum) {
-    return factory2.createUnionDeclaration({
-      nodes: schema.enum.map((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.createArrayTypeNode(node);
-    }
-  }
-  if ("prefixItems" in schema) {
-    const prefixItems = schema.prefixItems;
-    return factory2.createTupleDeclaration({
-      nodes: prefixItems.map((item) => {
-        return this.getTypeFromSchema(item, void 0);
-      })
-    });
-  }
-  if (schema.properties || schema.additionalProperties) {
-    return __privateMethod(this, _getTypeFromProperties, getTypeFromProperties_fn).call(this, schema, baseName);
-  }
-  if (version === "3.1" && "const" in schema) {
-    if (schema["const"]) {
-      if (typeof schema["const"] === "string") {
-        return factory2.createLiteralTypeNode(factory2.createStringLiteral(schema["const"]));
-      } else if (typeof schema["const"] === "number") {
-        return factory2.createLiteralTypeNode(factory2.createNumericLiteral(schema["const"]));
-      }
-    } else {
-      return _factory.keywordTypeNodes.null;
-    }
-  }
-  if (schema.type) {
-    if (Array.isArray(schema.type)) {
-      const [type, nullable] = schema.type;
-      return factory2.createUnionDeclaration({
-        nodes: [
-          this.getTypeFromSchema(
-            {
-              ...schema,
-              type
-            },
-            baseName
-          ),
-          nullable ? factory2.createLiteralTypeNode(factory2.createNull()) : void 0
-        ].filter(Boolean)
-      });
-    }
-    if (this.options.dateType === "date" && ["date", "date-time"].some((item) => item === schema.format)) {
-      return factory2.createTypeReferenceNode(factory2.createIdentifier("Date"));
-    }
-    if (schema.type in factory2.keywordTypeNodes) {
-      return factory2.keywordTypeNodes[schema.type];
-    }
-  }
-  if (schema.format === "binary") {
-    return factory2.createTypeReferenceNode("Blob", []);
-  }
-  return __privateGet(this, _unknownReturn, unknownReturn_get);
-};
-_unknownReturn = new WeakSet();
-unknownReturn_get = function() {
-  if (this.options.unknownType === "any") {
-    return factory2.keywordTypeNodes.any;
-  }
-  return factory2.keywordTypeNodes.unknown;
-};
-
-// src/TypeBuilder.ts
-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.nameSorter).map((operationSchema) => {
-      const generator = new TypeGenerator(this.options, this.context);
-      const required = Array.isArray(_optionalChain([operationSchema, 'access', _21 => _21.schema, 'optionalAccess', _22 => _22.required])) ? !!operationSchema.schema.required.length : !!_optionalChain([operationSchema, 'access', _23 => _23.schema, 'optionalAccess', _24 => _24.required]);
-      const sources = generator.build({
-        schema: operationSchema.schema,
-        baseName: operationSchema.name,
-        description: operationSchema.description,
-        keysToOmit: operationSchema.keysToOmit,
-        optional: !required && !!operationSchema.name.includes("Params")
-      });
-      importMeta.push(...generator.imports);
-      return {
-        import: {
-          refs: generator.refs,
-          name: operationSchema.name
-        },
-        sources
-      };
-    }).sort(_utils.refsSorter);
-    generated.forEach((item) => {
-      codes.push(_parser.print.call(void 0, item.sources));
-    });
-    const imports = importMeta.map((item) => {
-      return {
-        name: [item.ref.propertyName],
-        path: item.path,
-        isTypeOnly: item.isTypeOnly
-      };
-    });
-    return {
-      imports,
-      source: _transformers2.default.combineCodes(codes)
-    };
-  }
-};
-
-// src/components/Mutation.tsx
-
-function printCombinedSchema2(name, operation, schemas) {
-  const properties = {
-    "response": factory3.createTypeReferenceNode(
-      factory3.createIdentifier(schemas.response.name),
-      void 0
-    )
-  };
-  if (schemas.request) {
-    properties["request"] = factory3.createTypeReferenceNode(
-      factory3.createIdentifier(schemas.request.name),
-      void 0
-    );
-  }
-  if (schemas.pathParams) {
-    properties["pathParams"] = factory3.createTypeReferenceNode(
-      factory3.createIdentifier(schemas.pathParams.name),
-      void 0
-    );
-  }
-  if (schemas.queryParams) {
-    properties["queryParams"] = factory3.createTypeReferenceNode(
-      factory3.createIdentifier(schemas.queryParams.name),
-      void 0
-    );
-  }
-  if (schemas.headerParams) {
-    properties["headerParams"] = factory3.createTypeReferenceNode(
-      factory3.createIdentifier(schemas.headerParams.name),
-      void 0
-    );
-  }
-  if (schemas.errors) {
-    properties["errors"] = factory3.createUnionDeclaration({
-      nodes: schemas.errors.map((error) => {
-        return factory3.createTypeReferenceNode(
-          factory3.createIdentifier(error.name),
-          void 0
-        );
-      })
-    });
-  }
-  const namespaceNode = factory3.createTypeAliasDeclaration({
-    name: operation.method === "get" ? `${name}Query` : `${name}Mutation`,
-    type: factory3.createTypeLiteralNode(
-      Object.keys(properties).map((key) => {
-        const type = properties[key];
-        if (!type) {
-          return void 0;
-        }
-        return factory3.createPropertySignature(
-          {
-            name: _transformers2.default.pascalCase(key),
-            type
-          }
-        );
-      }).filter(Boolean)
-    ),
-    modifiers: [factory3.modifiers.export]
-  });
-  return _parser.print.call(void 0, namespaceNode);
-}
-function Mutation({
-  builder
-}) {
-  const { source } = builder.build();
-  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _jsxruntime.Fragment, { children: source });
-}
-Mutation.File = function({ mode }) {
-  const plugin = _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(plugin.options, { plugin, 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.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.call(void 0, _react.File.Import, { root: file.path, ...item }, index);
-        }),
-        /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, _react.File.Source, { children: [
-          source,
-          printCombinedSchema2(factoryName, operation, schemas)
-        ] })
-      ]
-    }
-  ) });
-};
-
-
-
-
-
-
-
-
-exports.Mutation = Mutation; exports.OasType = OasType; exports.Query = Query; exports.pluginName = pluginName; exports.pluginKey = pluginKey; exports.definePlugin = definePlugin;
-//# sourceMappingURL=chunk-75HLNTZM.cjs.map