@kubb/swagger-ts 2.10.0 → 2.11.0

package/dist/chunk-EX53MIMI.js

@@ -1,823 +0,0 @@
-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
-import transformers4 from "@kubb/core/transformers";
-import { print as print3 } from "@kubb/parser";
-import * as factory3 from "@kubb/parser/factory";
-import { Editor as Editor3, File as File3, usePlugin as usePlugin3, usePluginManager as usePluginManager2 } from "@kubb/react";
-import { useOas as useOas3, useOperation as useOperation2, useOperationFile as useOperationFile2, useOperationName as useOperationName2, useSchemas as useSchemas2 } from "@kubb/swagger/hooks";
-
-// src/TypeBuilder.ts
-import transformers3 from "@kubb/core/transformers";
-import { print as print2 } from "@kubb/parser";
-import { OasBuilder } from "@kubb/swagger";
-import { refsSorter } from "@kubb/swagger/utils";
-
-// src/TypeGenerator.ts
-import { Generator as Generator2 } from "@kubb/core";
-import transformers2, { pascalCase as pascalCase2 } from "@kubb/core/transformers";
-import { getUniqueName } from "@kubb/core/utils";
-import * as factory2 from "@kubb/parser/factory";
-import { keywordTypeNodes as keywordTypeNodes2 } from "@kubb/parser/factory";
-import { getSchemaFactory, isReference } from "@kubb/swagger/utils";
-
-// src/plugin.ts
-import path from "path";
-import { createPlugin, FileManager, PluginManager } from "@kubb/core";
-import { camelCase, pascalCase } from "@kubb/core/transformers";
-import { renderTemplate } from "@kubb/core/utils";
-import { pluginName as swaggerPluginName } from "@kubb/swagger";
-
-// src/OperationGenerator.tsx
-import { createRoot } from "@kubb/react";
-import { OperationGenerator as Generator } from "@kubb/swagger";
-import { Oas } from "@kubb/swagger/components";
-
-// src/components/OasType.tsx
-import { Editor, File, Type, usePlugin } from "@kubb/react";
-import { useFile } from "@kubb/react";
-import { useOas } from "@kubb/swagger/hooks";
-import { Fragment, jsx, jsxs } from "@kubb/react/jsx-runtime";
-function Template({
-  name,
-  typeName,
-  api
-}) {
-  return /* @__PURE__ */ jsxs(Fragment, { children: [
-    `export const ${name} = ${JSON.stringify(api, void 0, 2)} as const`,
-    /* @__PURE__ */ jsx("br", {}),
-    /* @__PURE__ */ jsx(Type, { name: typeName, export: true, children: `Infer<typeof ${name}>` })
-  ] });
-}
-var defaultTemplates = { default: Template };
-function OasType({
-  name,
-  typeName,
-  Template: Template2 = defaultTemplates.default
-}) {
-  const oas = useOas();
-  return /* @__PURE__ */ jsx(Template2, { name, typeName, api: oas.api });
-}
-OasType.File = function({ name, typeName, templates = defaultTemplates }) {
-  const { key: pluginKey2 } = usePlugin();
-  const file = useFile({ name, extName: ".ts", pluginKey: pluginKey2 });
-  const Template2 = templates.default;
-  return /* @__PURE__ */ jsx(Editor, { language: "typescript", children: /* @__PURE__ */ jsxs(
-    File,
-    {
-      baseName: file.baseName,
-      path: file.path,
-      meta: file.meta,
-      children: [
-        /* @__PURE__ */ jsx(File.Import, { name: ["Infer"], path: "@kubb/swagger-ts/oas", isTypeOnly: true }),
-        /* @__PURE__ */ jsx(File.Source, { children: /* @__PURE__ */ jsx(OasType, { Template: Template2, name, typeName }) })
-      ]
-    }
-  ) });
-};
-OasType.templates = defaultTemplates;
-
-// src/components/Query.tsx
-import transformers from "@kubb/core/transformers";
-import { print } from "@kubb/parser";
-import * as factory from "@kubb/parser/factory";
-import { Editor as Editor2, File as File2, usePlugin as usePlugin2, usePluginManager } from "@kubb/react";
-import { useOas as useOas2, useOperation, useOperationFile, useOperationName, useSchemas } from "@kubb/swagger/hooks";
-import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "@kubb/react/jsx-runtime";
-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: transformers.pascalCase(key),
-            type
-          }
-        );
-      }).filter(Boolean)
-    ),
-    modifiers: [factory.modifiers.export]
-  });
-  return print(namespaceNode);
-}
-function Query({
-  builder
-}) {
-  const { source } = builder.build();
-  return /* @__PURE__ */ jsx2(Fragment2, { children: source });
-}
-Query.File = function({ mode }) {
-  const plugin = usePlugin2();
-  const schemas = useSchemas();
-  const pluginManager = usePluginManager();
-  const oas = useOas2();
-  const file = useOperationFile();
-  const factoryName = useOperationName({ type: "type" });
-  const operation = useOperation();
-  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__ */ jsx2(Editor2, { language: "typescript", children: /* @__PURE__ */ jsxs2(
-    File2,
-    {
-      baseName: file.baseName,
-      path: file.path,
-      meta: file.meta,
-      children: [
-        mode === "directory" && imports.map((item, index) => {
-          return /* @__PURE__ */ jsx2(File2.Import, { root: file.path, ...item }, index);
-        }),
-        /* @__PURE__ */ jsxs2(File2.Source, { children: [
-          source,
-          printCombinedSchema(factoryName, operation, schemas)
-        ] })
-      ]
-    }
-  ) });
-};
-
-// src/OperationGenerator.tsx
-import { jsx as jsx3 } from "@kubb/react/jsx-runtime";
-var OperationGenerator = class extends Generator {
-  async all(operations) {
-    const { oas, pluginManager, plugin } = this.context;
-    const root = createRoot({ logger: pluginManager.logger });
-    root.render(
-      /* @__PURE__ */ jsx3(Oas, { oas, operations, getSchemas: (...props) => this.getSchemas(...props), children: plugin.options.oasType && /* @__PURE__ */ jsx3(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 = createRoot({ logger: pluginManager.logger });
-    root.render(
-      /* @__PURE__ */ jsx3(Oas, { oas, operations: [operation], getSchemas: (...props) => this.getSchemas(...props), children: /* @__PURE__ */ jsx3(Oas.Operation, { operation, children: /* @__PURE__ */ jsx3(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 = createRoot({ logger: pluginManager.logger });
-    root.render(
-      /* @__PURE__ */ jsx3(Oas, { oas, operations: [operation], getSchemas: (...props) => this.getSchemas(...props), children: /* @__PURE__ */ jsx3(Oas.Operation, { operation, children: /* @__PURE__ */ jsx3(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 = createPlugin((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 = group?.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: [swaggerPluginName],
-    resolvePath(baseName, pathMode, options2) {
-      const root = path.resolve(this.config.root, this.config.output.path);
-      const mode = pathMode ?? FileManager.getMode(path.resolve(root, output.path));
-      if (mode === "file") {
-        return path.resolve(root, output.path);
-      }
-      if (options2?.tag && group?.type === "tag") {
-        const tag = camelCase(options2.tag);
-        return path.resolve(root, renderTemplate(template, { tag }), baseName);
-      }
-      return path.resolve(root, output.path, baseName);
-    },
-    resolveName(name, type) {
-      const resolvedName = pascalCase(name, { isFile: type === "file" });
-      if (type) {
-        return transformers5?.name?.(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] = PluginManager.getDependedPlugins(this.plugins, [swaggerPluginName]);
-      const oas = await swaggerPlugin.api.getOas();
-      const schemas = await swaggerPlugin.api.getSchemas();
-      const root = path.resolve(this.config.root, this.config.output.path);
-      const mode = FileManager.getMode(path.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 = path.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 Generator2 {
-  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: keysToOmit?.length ? factory2.createOmitDeclaration({ keys: keysToOmit, type, nonNullable: true }) : type
-    });
-    if (description) {
-      nodes.push(
-        factory2.appendJSDocToNode({
-          node,
-          comments: [`@description ${transformers2.trim(description)}`]
-        })
-      );
-    } else {
-      nodes.push(node);
-    }
-    const filterdNodes = nodes.filter(
-      (node2) => !this.extraNodes.some(
-        (extraNode) => extraNode?.name?.escapedText === node2?.name?.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 = schema?.nullable ?? schema?.["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 = baseSchema?.properties || {};
-  const required = baseSchema?.required;
-  const additionalProperties = baseSchema?.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 ${schema.type?.toString()}${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 = getUniqueName($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 = getSchemaFactory(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 (isReference(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 = getUniqueName(pascalCase2([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, schema.enum?.[index]])
-    );
-    if (extensionEnums.length > 0 && extensionEnums[0]) {
-      enums = extensionEnums[0];
-    }
-    this.extraNodes.push(
-      ...factory2.createEnumDeclaration({
-        name: transformers2.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 keywordTypeNodes2.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 OasBuilder {
-  build(name) {
-    const importMeta = [];
-    const codes = [];
-    const generated = this.items.filter((operationSchema) => name ? operationSchema.name === name : true).sort(transformers3.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 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(refsSorter);
-    generated.forEach((item) => {
-      codes.push(print2(item.sources));
-    });
-    const imports = importMeta.map((item) => {
-      return {
-        name: [item.ref.propertyName],
-        path: item.path,
-        isTypeOnly: item.isTypeOnly
-      };
-    });
-    return {
-      imports,
-      source: transformers3.combineCodes(codes)
-    };
-  }
-};
-
-// src/components/Mutation.tsx
-import { Fragment as Fragment3, jsx as jsx4, jsxs as jsxs3 } from "@kubb/react/jsx-runtime";
-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: transformers4.pascalCase(key),
-            type
-          }
-        );
-      }).filter(Boolean)
-    ),
-    modifiers: [factory3.modifiers.export]
-  });
-  return print3(namespaceNode);
-}
-function Mutation({
-  builder
-}) {
-  const { source } = builder.build();
-  return /* @__PURE__ */ jsx4(Fragment3, { children: source });
-}
-Mutation.File = function({ mode }) {
-  const plugin = usePlugin3();
-  const schemas = useSchemas2();
-  const pluginManager = usePluginManager2();
-  const oas = useOas3();
-  const file = useOperationFile2();
-  const factoryName = useOperationName2({ type: "type" });
-  const operation = useOperation2();
-  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__ */ jsx4(Editor3, { language: "typescript", children: /* @__PURE__ */ jsxs3(
-    File3,
-    {
-      baseName: file.baseName,
-      path: file.path,
-      meta: file.meta,
-      children: [
-        mode === "directory" && imports.map((item, index) => {
-          return /* @__PURE__ */ jsx4(File3.Import, { root: file.path, ...item }, index);
-        }),
-        /* @__PURE__ */ jsxs3(File3.Source, { children: [
-          source,
-          printCombinedSchema2(factoryName, operation, schemas)
-        ] })
-      ]
-    }
-  ) });
-};
-
-export {
-  Mutation,
-  OasType,
-  Query,
-  pluginName,
-  pluginKey,
-  definePlugin
-};
-//# sourceMappingURL=chunk-EX53MIMI.js.map