@kubb/swagger-ts 2.0.0-canary.20231030T125204 → 2.0.1

package/dist/chunk-TCUL2H74.js

@@ -0,0 +1,757 @@
+import { createRequire } from 'module';
+import transformers2, { camelCase, pascalCase } from '@kubb/core/transformers';
+import { print } from '@kubb/parser';
+import * as factory2 from '@kubb/parser/factory';
+import { keywordTypeNodes } from '@kubb/parser/factory';
+import { usePlugin, useFile, File, usePluginManager, createRoot, Type } from '@kubb/react';
+import { useOas, useSchemas, useOperationFile, useOperationName, useOperation } from '@kubb/swagger/hooks';
+import { pluginName as pluginName$1, OasBuilder, OperationGenerator as OperationGenerator$1 } from '@kubb/swagger';
+import { refsSorter, isReference, getSchemaFactory } from '@kubb/swagger/utils';
+import { createPlugin, FileManager, PluginManager, Generator } from '@kubb/core';
+import { renderTemplate, getUniqueName } from '@kubb/core/utils';
+import path from 'path';
+import { jsx, jsxs, Fragment } from '@kubb/react/jsx-runtime';
+
+createRequire(import.meta.url);
+  
+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;
+};
+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 Oas({
+  name,
+  typeName,
+  Template: Template2 = defaultTemplates.default
+}) {
+  const oas = useOas();
+  return /* @__PURE__ */ jsx(Template2, { name, typeName, api: oas.api });
+}
+Oas.File = function({ name, typeName, templates = defaultTemplates }) {
+  const { key: pluginKey2 } = usePlugin();
+  const file = useFile({ name, pluginKey: pluginKey2 });
+  const Template2 = templates.default;
+  return /* @__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(Oas, { Template: Template2, name, typeName }) })
+      ]
+    }
+  );
+};
+Oas.templates = defaultTemplates;
+function printCombinedSchema(name, operation, schemas) {
+  const properties = {
+    "response": factory2.createTypeReferenceNode(
+      factory2.createIdentifier(schemas.response.name),
+      void 0
+    )
+  };
+  if (schemas.request) {
+    properties["request"] = factory2.createTypeReferenceNode(
+      factory2.createIdentifier(schemas.request.name),
+      void 0
+    );
+  }
+  if (schemas.pathParams) {
+    properties["pathParams"] = factory2.createTypeReferenceNode(
+      factory2.createIdentifier(schemas.pathParams.name),
+      void 0
+    );
+  }
+  if (schemas.queryParams) {
+    properties["queryParams"] = factory2.createTypeReferenceNode(
+      factory2.createIdentifier(schemas.queryParams.name),
+      void 0
+    );
+  }
+  if (schemas.headerParams) {
+    properties["headerParams"] = factory2.createTypeReferenceNode(
+      factory2.createIdentifier(schemas.headerParams.name),
+      void 0
+    );
+  }
+  if (schemas.errors) {
+    properties["errors"] = factory2.createUnionDeclaration({
+      nodes: schemas.errors.map((error) => {
+        return factory2.createTypeReferenceNode(
+          factory2.createIdentifier(error.name),
+          void 0
+        );
+      })
+    });
+  }
+  const namespaceNode = factory2.createNamespaceDeclaration({
+    name: operation.method === "get" ? `${name}Query` : `${name}Mutation`,
+    statements: Object.keys(properties).map((key) => {
+      const type = properties[key];
+      if (!type) {
+        return void 0;
+      }
+      return factory2.createTypeAliasDeclaration({
+        modifiers: [factory2.modifiers.export],
+        name: transformers2.pascalCase(key),
+        type
+      });
+    }).filter(Boolean)
+  });
+  return print(namespaceNode);
+}
+function Query({
+  builder
+}) {
+  const { source } = builder.build();
+  return /* @__PURE__ */ jsx(Fragment, { children: source });
+}
+Query.File = function({ mode }) {
+  const { options } = usePlugin();
+  const schemas = useSchemas();
+  const pluginManager = usePluginManager();
+  const oas = useOas();
+  const file = useOperationFile();
+  const factoryName = useOperationName({ type: "type" });
+  const operation = useOperation();
+  const builder = new TypeBuilder(options, { oas, pluginManager }).add(schemas.pathParams).add(schemas.queryParams).add(schemas.headerParams).add(schemas.response).add(schemas.errors);
+  const { source, imports } = builder.build();
+  return /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsxs(
+    File,
+    {
+      baseName: file.baseName,
+      path: file.path,
+      meta: file.meta,
+      children: [
+        mode === "directory" && imports.map((item, index) => {
+          return /* @__PURE__ */ jsx(File.Import, { root: file.path, ...item }, index);
+        }),
+        /* @__PURE__ */ jsxs(File.Source, { children: [
+          source,
+          printCombinedSchema(factoryName, operation, schemas)
+        ] })
+      ]
+    }
+  ) });
+};
+var OperationGenerator = class extends OperationGenerator$1 {
+  async all() {
+    const { oas, pluginManager, plugin } = this.context;
+    if (!plugin.options.oasType) {
+      return null;
+    }
+    const root = createRoot({ logger: pluginManager.logger });
+    root.render(
+      /* @__PURE__ */ jsx(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 = createRoot({ logger: pluginManager.logger });
+    root.render(
+      /* @__PURE__ */ jsx(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 = createRoot({ logger: pluginManager.logger });
+    root.render(
+      /* @__PURE__ */ jsx(Mutation.File, { mode }),
+      { meta: { oas, pluginManager, plugin: { ...plugin, options }, schemas, operation } }
+    );
+    return root.files;
+  }
+  async put(operation, schemas, options) {
+    return this.post(operation, schemas, options);
+  }
+  async patch(operation, schemas, options) {
+    return this.post(operation, schemas, options);
+  }
+  async delete(operation, schemas, options) {
+    return this.post(operation, schemas, 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",
+    dateType = "string",
+    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,
+      optionalType,
+      oasType,
+      // keep the used enumnames between TypeBuilder and OperationGenerator per plugin(pluginKey)
+      usedEnumNames: {}
+    },
+    pre: [pluginName$1],
+    resolvePath(baseName, directory, options2) {
+      const root = path.resolve(this.config.root, this.config.output.path);
+      const mode = 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);
+      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, [pluginName$1]);
+      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, 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);
+      const { exportType = "barrel" } = output;
+      if (exportType === "barrel") {
+        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;
+var TypeGenerator = class extends 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);
+    this.refs = {};
+    this.imports = [];
+    this.extraNodes = [];
+    this.aliases = [];
+    // Keep track of already used type aliases
+    __privateAdd(this, _usedAliasNames, {});
+  }
+  build({
+    schema,
+    baseName,
+    description,
+    keysToOmit
+  }) {
+    const nodes = [];
+    const type = this.getTypeFromSchema(schema, baseName);
+    if (!type) {
+      return this.extraNodes;
+    }
+    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;
+    }
+    if (schema && !schema.nullable) {
+      return type;
+    }
+    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 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 ? factory2.keywordTypeNodes.any : 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 path2 = this.context.pluginManager.resolvePath({ baseName: propertyName, 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 factory2.keywordTypeNodes.any;
+  }
+  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 !== factory2.keywordTypeNodes.any;
+      })
+    });
+    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 !== factory2.keywordTypeNodes.any;
+      })
+    });
+    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 !== factory2.keywordTypeNodes.any;
+      })
+    });
+    if (schemaWithoutAllOf.properties) {
+      return factory2.createIntersectionDeclaration({
+        nodes: [this.getTypeFromSchema(schemaWithoutAllOf, baseName), and].filter(Boolean)
+      });
+    }
+    return and;
+  }
+  if (schema.enum && baseName) {
+    const enumName = getUniqueName(baseName, this.options.usedEnumNames);
+    let enums = [...new Set(schema.enum)].map((key) => [key, key]);
+    if ("x-enumNames" in schema) {
+      enums = [...new Set(schema["x-enumNames"])].map((key, index) => {
+        return [key, schema.enum?.[index]];
+      });
+    }
+    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 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 factory2.keywordTypeNodes.any;
+};
+
+// 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(transformers2.nameSorter).map((operationSchema) => {
+      const generator = new TypeGenerator(this.options, this.context);
+      const sources = generator.build({
+        schema: operationSchema.schema,
+        baseName: operationSchema.name,
+        description: operationSchema.description,
+        keysToOmit: operationSchema.keysToOmit
+      });
+      importMeta.push(...generator.imports);
+      return {
+        import: {
+          refs: generator.refs,
+          name: operationSchema.name
+        },
+        sources
+      };
+    }).sort(refsSorter);
+    generated.forEach((item) => {
+      codes.push(print(item.sources));
+    });
+    const imports = importMeta.map((item) => {
+      return {
+        name: [item.ref.propertyName],
+        path: item.path,
+        isTypeOnly: item.isTypeOnly
+      };
+    });
+    return {
+      imports,
+      source: transformers2.combineCodes(codes)
+    };
+  }
+};
+function printCombinedSchema2(name, operation, schemas) {
+  const properties = {
+    "response": factory2.createTypeReferenceNode(
+      factory2.createIdentifier(schemas.response.name),
+      void 0
+    )
+  };
+  if (schemas.request) {
+    properties["request"] = factory2.createTypeReferenceNode(
+      factory2.createIdentifier(schemas.request.name),
+      void 0
+    );
+  }
+  if (schemas.pathParams) {
+    properties["pathParams"] = factory2.createTypeReferenceNode(
+      factory2.createIdentifier(schemas.pathParams.name),
+      void 0
+    );
+  }
+  if (schemas.queryParams) {
+    properties["queryParams"] = factory2.createTypeReferenceNode(
+      factory2.createIdentifier(schemas.queryParams.name),
+      void 0
+    );
+  }
+  if (schemas.headerParams) {
+    properties["headerParams"] = factory2.createTypeReferenceNode(
+      factory2.createIdentifier(schemas.headerParams.name),
+      void 0
+    );
+  }
+  if (schemas.errors) {
+    properties["errors"] = factory2.createUnionDeclaration({
+      nodes: schemas.errors.map((error) => {
+        return factory2.createTypeReferenceNode(
+          factory2.createIdentifier(error.name),
+          void 0
+        );
+      })
+    });
+  }
+  const namespaceNode = factory2.createNamespaceDeclaration({
+    name: operation.method === "get" ? `${name}Query` : `${name}Mutation`,
+    statements: Object.keys(properties).map((key) => {
+      const type = properties[key];
+      if (!type) {
+        return void 0;
+      }
+      return factory2.createTypeAliasDeclaration({
+        modifiers: [factory2.modifiers.export],
+        name: transformers2.pascalCase(key),
+        type
+      });
+    }).filter(Boolean)
+  });
+  return print(namespaceNode);
+}
+function Mutation({
+  builder
+}) {
+  const { source } = builder.build();
+  return /* @__PURE__ */ jsx(Fragment, { children: source });
+}
+Mutation.File = function({ mode }) {
+  const { options } = usePlugin();
+  const schemas = useSchemas();
+  const pluginManager = usePluginManager();
+  const oas = useOas();
+  const file = useOperationFile();
+  const factoryName = useOperationName({ type: "type" });
+  const operation = useOperation();
+  const builder = new TypeBuilder(options, { oas, pluginManager }).add(schemas.pathParams).add(schemas.queryParams).add(schemas.headerParams).add(schemas.response).add(schemas.request).add(schemas.errors);
+  const { source, imports } = builder.build();
+  return /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsxs(
+    File,
+    {
+      baseName: file.baseName,
+      path: file.path,
+      meta: file.meta,
+      children: [
+        mode === "directory" && imports.map((item, index) => {
+          return /* @__PURE__ */ jsx(File.Import, { root: file.path, ...item }, index);
+        }),
+        /* @__PURE__ */ jsxs(File.Source, { children: [
+          source,
+          printCombinedSchema2(factoryName, operation, schemas)
+        ] })
+      ]
+    }
+  ) });
+};
+
+export { Mutation, Oas, Query, definePlugin, pluginKey, pluginName };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=chunk-TCUL2H74.js.map