@kubb/plugin-ts 3.0.0-alpha.2 → 3.0.0-alpha.21

package/dist/chunk-PU22CLWV.js

@@ -1,608 +0,0 @@
-// src/plugin.ts
-import path from "path";
-import { FileManager, PluginManager, createPlugin } from "@kubb/core";
-import { camelCase, pascalCase } from "@kubb/core/transformers";
-import { renderTemplate } from "@kubb/core/utils";
-import { pluginOasName } from "@kubb/plugin-oas";
-
-// src/OperationGenerator.tsx
-import { OperationGenerator as Generator2 } from "@kubb/plugin-oas";
-import { Oas as Oas4 } from "@kubb/plugin-oas/components";
-import { App as App2, createRoot as createRoot2 } from "@kubb/react";
-
-// src/components/OasType.tsx
-import { Parser, File, Type, useApp } from "@kubb/react";
-import { useOas } from "@kubb/plugin-oas/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 {
-    pluginManager,
-    plugin: { key: pluginKey }
-  } = useApp();
-  const file = pluginManager.getFile({ name, extName: ".ts", pluginKey });
-  const Template2 = templates.default;
-  return /* @__PURE__ */ jsx(Parser, { language: "typescript", children: /* @__PURE__ */ jsxs(File, { baseName: file.baseName, path: file.path, meta: file.meta, children: [
-    /* @__PURE__ */ jsx(File.Import, { name: ["Infer"], path: "@kubb/oas", isTypeOnly: true }),
-    /* @__PURE__ */ jsx(File.Source, { children: /* @__PURE__ */ jsx(OasType, { Template: Template2, name, typeName }) })
-  ] }) });
-};
-OasType.templates = defaultTemplates;
-
-// src/components/OperationSchema.tsx
-import transformers3 from "@kubb/core/transformers";
-import { print as print2 } from "@kubb/parser-ts";
-import * as factory3 from "@kubb/parser-ts/factory";
-import { Oas as Oas3 } from "@kubb/plugin-oas/components";
-import { useOas as useOas2, useOperation, useOperationManager } from "@kubb/plugin-oas/hooks";
-import { File as File3, Parser as Parser2, useApp as useApp3 } from "@kubb/react";
-
-// src/SchemaGenerator.tsx
-import { SchemaGenerator as Generator } from "@kubb/plugin-oas";
-import { Oas as Oas2 } from "@kubb/plugin-oas/components";
-import { App, createRoot } from "@kubb/react";
-
-// src/components/Schema.tsx
-import { Oas } from "@kubb/plugin-oas/components";
-import { File as File2, useApp as useApp2 } from "@kubb/react";
-import transformers2 from "@kubb/core/transformers";
-import { print } from "@kubb/parser-ts";
-import * as factory2 from "@kubb/parser-ts/factory";
-import { SchemaGenerator, schemaKeywords as schemaKeywords2 } from "@kubb/plugin-oas";
-import { useSchema } from "@kubb/plugin-oas/hooks";
-
-// src/parser/index.ts
-import transformers from "@kubb/core/transformers";
-import * as factory from "@kubb/parser-ts/factory";
-import { isKeyword, schemaKeywords } from "@kubb/plugin-oas";
-var typeKeywordMapper = {
-  any: () => factory.keywordTypeNodes.any,
-  unknown: () => factory.keywordTypeNodes.unknown,
-  number: () => factory.keywordTypeNodes.number,
-  integer: () => factory.keywordTypeNodes.number,
-  object: (nodes) => {
-    if (!nodes || !nodes.length) {
-      return factory.keywordTypeNodes.object;
-    }
-    return factory.createTypeLiteralNode(nodes);
-  },
-  string: () => factory.keywordTypeNodes.string,
-  boolean: () => factory.keywordTypeNodes.boolean,
-  undefined: () => factory.keywordTypeNodes.undefined,
-  nullable: void 0,
-  null: () => factory.keywordTypeNodes.null,
-  nullish: void 0,
-  array: (nodes) => {
-    if (!nodes) {
-      return void 0;
-    }
-    return factory.createArrayDeclaration({ nodes });
-  },
-  tuple: (nodes) => {
-    if (!nodes) {
-      return void 0;
-    }
-    return factory.createTupleTypeNode(nodes);
-  },
-  enum: (name) => {
-    if (!name) {
-      return void 0;
-    }
-    return factory.createTypeReferenceNode(name, void 0);
-  },
-  union: (nodes) => {
-    if (!nodes) {
-      return void 0;
-    }
-    return factory.createUnionDeclaration({
-      withParentheses: true,
-      nodes
-    });
-  },
-  const: (name, format) => {
-    if (!name) {
-      return void 0;
-    }
-    if (format === "number") {
-      return factory.createLiteralTypeNode(factory.createNumericLiteral(name));
-    }
-    return factory.createLiteralTypeNode(factory.createStringLiteral(name.toString()));
-  },
-  datetime: () => factory.keywordTypeNodes.string,
-  date: (type = "string") => type === "string" ? factory.keywordTypeNodes.string : factory.createTypeReferenceNode(factory.createIdentifier("Date")),
-  time: (type = "string") => type === "string" ? factory.keywordTypeNodes.string : factory.createTypeReferenceNode(factory.createIdentifier("Date")),
-  uuid: void 0,
-  url: void 0,
-  strict: void 0,
-  default: void 0,
-  and: (nodes) => {
-    if (!nodes) {
-      return void 0;
-    }
-    return factory.createIntersectionDeclaration({
-      withParentheses: true,
-      nodes
-    });
-  },
-  describe: void 0,
-  min: void 0,
-  max: void 0,
-  optional: void 0,
-  matches: void 0,
-  email: void 0,
-  firstName: void 0,
-  lastName: void 0,
-  password: void 0,
-  phone: void 0,
-  readOnly: void 0,
-  ref: (propertyName) => {
-    if (!propertyName) {
-      return void 0;
-    }
-    return factory.createTypeReferenceNode(propertyName, void 0);
-  },
-  blob: () => factory.createTypeReferenceNode("Blob", []),
-  deprecated: void 0,
-  example: void 0,
-  schema: void 0,
-  catchall: void 0,
-  name: void 0
-};
-function parse(parent, current, options) {
-  const value = typeKeywordMapper[current.keyword];
-  if (!value) {
-    return void 0;
-  }
-  if (isKeyword(current, schemaKeywords.union)) {
-    return typeKeywordMapper.union(current.args.map((schema) => parse(current, schema, options)).filter(Boolean));
-  }
-  if (isKeyword(current, schemaKeywords.and)) {
-    return typeKeywordMapper.and(current.args.map((schema) => parse(current, schema, options)).filter(Boolean));
-  }
-  if (isKeyword(current, schemaKeywords.array)) {
-    return typeKeywordMapper.array(current.args.items.map((schema) => parse(current, schema, options)).filter(Boolean));
-  }
-  if (isKeyword(current, schemaKeywords.enum)) {
-    return typeKeywordMapper.enum(current.args.typeName);
-  }
-  if (isKeyword(current, schemaKeywords.ref)) {
-    return typeKeywordMapper.ref(current.args.name);
-  }
-  if (isKeyword(current, schemaKeywords.blob)) {
-    return value();
-  }
-  if (isKeyword(current, schemaKeywords.tuple)) {
-    return typeKeywordMapper.tuple(current.args.items.map((schema) => parse(current, schema, options)).filter(Boolean));
-  }
-  if (isKeyword(current, schemaKeywords.const)) {
-    return typeKeywordMapper.const(current.args.name, current.args.format);
-  }
-  if (isKeyword(current, schemaKeywords.object)) {
-    const properties = Object.entries(current.args?.properties || {}).filter((item) => {
-      const schemas = item[1];
-      return schemas && typeof schemas.map === "function";
-    }).map(([name, schemas]) => {
-      const nameSchema = schemas.find((schema) => schema.keyword === schemaKeywords.name);
-      const mappedName = nameSchema?.args || name;
-      if (options.mapper?.[mappedName]) {
-        return options.mapper?.[mappedName];
-      }
-      const isNullish = schemas.some((schema) => schema.keyword === schemaKeywords.nullish);
-      const isNullable = schemas.some((schema) => schema.keyword === schemaKeywords.nullable);
-      const isOptional = schemas.some((schema) => schema.keyword === schemaKeywords.optional);
-      const isReadonly = schemas.some((schema) => schema.keyword === schemaKeywords.readOnly);
-      const describeSchema = schemas.find((schema) => schema.keyword === schemaKeywords.describe);
-      const deprecatedSchema = schemas.find((schema) => schema.keyword === schemaKeywords.deprecated);
-      const defaultSchema = schemas.find((schema) => schema.keyword === schemaKeywords.default);
-      const exampleSchema = schemas.find((schema) => schema.keyword === schemaKeywords.example);
-      const schemaSchema = schemas.find((schema) => schema.keyword === schemaKeywords.schema);
-      let type = schemas.map((schema) => parse(current, schema, options)).filter(Boolean)[0];
-      if (isNullable) {
-        type = factory.createUnionDeclaration({
-          nodes: [type, factory.keywordTypeNodes.null]
-        });
-      }
-      if (isNullish && ["undefined", "questionTokenAndUndefined"].includes(options.optionalType)) {
-        type = factory.createUnionDeclaration({
-          nodes: [type, factory.keywordTypeNodes.undefined]
-        });
-      }
-      if (isOptional && ["undefined", "questionTokenAndUndefined"].includes(options.optionalType)) {
-        type = factory.createUnionDeclaration({
-          nodes: [type, factory.keywordTypeNodes.undefined]
-        });
-      }
-      const propertySignature = factory.createPropertySignature({
-        questionToken: isOptional || isNullish ? ["questionToken", "questionTokenAndUndefined"].includes(options.optionalType) : false,
-        name: mappedName,
-        type,
-        readOnly: isReadonly
-      });
-      return factory.appendJSDocToNode({
-        node: propertySignature,
-        comments: [
-          describeSchema ? `@description ${transformers.jsStringEscape(describeSchema.args)}` : void 0,
-          deprecatedSchema ? "@deprecated" : void 0,
-          defaultSchema ? `@default ${defaultSchema.args}` : void 0,
-          exampleSchema ? `@example ${exampleSchema.args}` : void 0,
-          schemaSchema?.args?.type || schemaSchema?.args?.format ? [`@type ${schemaSchema?.args?.type || "unknown"}${!isOptional ? "" : " | undefined"}`, schemaSchema?.args?.format].filter(Boolean).join(", ") : void 0
-        ].filter(Boolean)
-      });
-    });
-    const additionalProperties = current.args?.additionalProperties?.length ? factory.createIndexSignature(
-      current.args.additionalProperties.map((schema) => parse(current, schema, options)).filter(Boolean).at(0)
-    ) : void 0;
-    return typeKeywordMapper.object([...properties, additionalProperties].filter(Boolean));
-  }
-  if (isKeyword(current, schemaKeywords.datetime)) {
-    return typeKeywordMapper.datetime();
-  }
-  if (isKeyword(current, schemaKeywords.date)) {
-    return typeKeywordMapper.date(current.args.type);
-  }
-  if (isKeyword(current, schemaKeywords.time)) {
-    return typeKeywordMapper.time(current.args.type);
-  }
-  if (current.keyword in typeKeywordMapper) {
-    return value();
-  }
-  return void 0;
-}
-
-// src/components/Schema.tsx
-import { jsx as jsx2 } from "@kubb/react/jsx-runtime";
-function Schema(props) {
-  const { keysToOmit, description } = props;
-  const { tree, name } = useSchema();
-  const {
-    pluginManager,
-    plugin: {
-      options: { mapper, enumType, optionalType }
-    }
-  } = useApp2();
-  const resolvedName = pluginManager.resolveName({
-    name,
-    pluginKey: [pluginTsName],
-    type: "function"
-  });
-  const typeName = pluginManager.resolveName({
-    name,
-    pluginKey: [pluginTsName],
-    type: "type"
-  });
-  const nodes = [];
-  const extraNodes = [];
-  if (!tree.length) {
-    return "";
-  }
-  const isNullish = tree.some((item) => item.keyword === schemaKeywords2.nullish);
-  const isNullable = tree.some((item) => item.keyword === schemaKeywords2.nullable);
-  const isOptional = tree.some((item) => item.keyword === schemaKeywords2.optional);
-  let type = tree.map((schema) => parse(void 0, schema, { name: resolvedName, typeName, description, keysToOmit, optionalType, enumType, mapper })).filter(Boolean).at(0) || typeKeywordMapper.undefined();
-  if (isNullable) {
-    type = factory2.createUnionDeclaration({
-      nodes: [type, factory2.keywordTypeNodes.null]
-    });
-  }
-  if (isNullish && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) {
-    type = factory2.createUnionDeclaration({
-      nodes: [type, factory2.keywordTypeNodes.undefined]
-    });
-  }
-  if (isOptional && ["undefined", "questionTokenAndUndefined"].includes(optionalType)) {
-    type = factory2.createUnionDeclaration({
-      nodes: [type, factory2.keywordTypeNodes.undefined]
-    });
-  }
-  const node = factory2.createTypeAliasDeclaration({
-    modifiers: [factory2.modifiers.export],
-    name: resolvedName,
-    type: keysToOmit?.length ? factory2.createOmitDeclaration({
-      keys: keysToOmit,
-      type,
-      nonNullable: true
-    }) : type
-  });
-  const enumSchemas = SchemaGenerator.deepSearch(tree, schemaKeywords2.enum);
-  if (enumSchemas) {
-    enumSchemas.forEach((enumSchema) => {
-      extraNodes.push(
-        ...factory2.createEnumDeclaration({
-          name: transformers2.camelCase(enumSchema.args.name),
-          typeName: enumSchema.args.typeName,
-          enums: enumSchema.args.items.map((item) => item.value === void 0 ? void 0 : [transformers2.trimQuotes(item.name?.toString()), item.value]).filter(Boolean),
-          type: enumType
-        })
-      );
-    });
-  }
-  nodes.push(
-    factory2.appendJSDocToNode({
-      node,
-      comments: [description ? `@description ${transformers2.jsStringEscape(description)}` : void 0].filter(Boolean)
-    })
-  );
-  const filterdNodes = nodes.filter(
-    (node2) => !extraNodes.some(
-      (extraNode) => extraNode?.name?.escapedText === node2?.name?.escapedText
-    )
-  );
-  return print([...extraNodes, ...filterdNodes]);
-}
-Schema.File = function({}) {
-  const { pluginManager } = useApp2();
-  const { schema } = useSchema();
-  return /* @__PURE__ */ jsx2(Oas.Schema.File, { output: pluginManager.config.output.path, children: /* @__PURE__ */ jsx2(File2.Source, { children: /* @__PURE__ */ jsx2(Schema, { description: schema?.description }) }) });
-};
-
-// src/SchemaGenerator.tsx
-import { jsx as jsx3 } from "@kubb/react/jsx-runtime";
-var SchemaGenerator2 = class extends Generator {
-  async schema(name, schema, options) {
-    const { oas, pluginManager, plugin, mode, output } = this.context;
-    const root = createRoot({
-      logger: pluginManager.logger
-    });
-    const tree = this.parse({ schema, name });
-    root.render(
-      /* @__PURE__ */ jsx3(App, { pluginManager, plugin: { ...plugin, options }, mode, children: /* @__PURE__ */ jsx3(Oas2, { oas, children: /* @__PURE__ */ jsx3(Oas2.Schema, { name, value: schema, tree, children: /* @__PURE__ */ jsx3(Schema.File, {}) }) }) })
-    );
-    return root.files;
-  }
-};
-
-// src/components/OperationSchema.tsx
-import { jsx as jsx4, jsxs as jsxs2 } from "@kubb/react/jsx-runtime";
-function printCombinedSchema({
-  name,
-  operation,
-  schemas,
-  pluginManager
-}) {
-  const properties = {};
-  if (schemas.response) {
-    const identifier = pluginManager.resolveName({
-      name: schemas.response.name,
-      pluginKey: [pluginTsName],
-      type: "function"
-    });
-    properties["response"] = factory3.createTypeReferenceNode(factory3.createIdentifier(identifier), void 0);
-  }
-  if (schemas.request) {
-    const identifier = pluginManager.resolveName({
-      name: schemas.request.name,
-      pluginKey: [pluginTsName],
-      type: "function"
-    });
-    properties["request"] = factory3.createTypeReferenceNode(factory3.createIdentifier(identifier), void 0);
-  }
-  if (schemas.pathParams) {
-    const identifier = pluginManager.resolveName({
-      name: schemas.pathParams.name,
-      pluginKey: [pluginTsName],
-      type: "function"
-    });
-    properties["pathParams"] = factory3.createTypeReferenceNode(factory3.createIdentifier(identifier), void 0);
-  }
-  if (schemas.queryParams) {
-    const identifier = pluginManager.resolveName({
-      name: schemas.queryParams.name,
-      pluginKey: [pluginTsName],
-      type: "function"
-    });
-    properties["queryParams"] = factory3.createTypeReferenceNode(factory3.createIdentifier(identifier), void 0);
-  }
-  if (schemas.headerParams) {
-    const identifier = pluginManager.resolveName({
-      name: schemas.headerParams.name,
-      pluginKey: [pluginTsName],
-      type: "function"
-    });
-    properties["headerParams"] = factory3.createTypeReferenceNode(factory3.createIdentifier(identifier), void 0);
-  }
-  if (schemas.errors) {
-    properties["errors"] = factory3.createUnionDeclaration({
-      nodes: schemas.errors.map((error) => {
-        const identifier = pluginManager.resolveName({
-          name: error.name,
-          pluginKey: [pluginTsName],
-          type: "function"
-        });
-        return factory3.createTypeReferenceNode(factory3.createIdentifier(identifier), 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: transformers3.pascalCase(key),
-          type
-        });
-      }).filter(Boolean)
-    ),
-    modifiers: [factory3.modifiers.export]
-  });
-  return print2(namespaceNode);
-}
-function OperationSchema({ keysToOmit, description }) {
-  return /* @__PURE__ */ jsx4(Schema, { keysToOmit, description });
-}
-OperationSchema.File = function({}) {
-  const { pluginManager, plugin, mode, fileManager } = useApp3();
-  const oas = useOas2();
-  const { getSchemas, getFile, getName } = useOperationManager();
-  const operation = useOperation();
-  const file = getFile(operation);
-  const schemas = getSchemas(operation);
-  const factoryName = getName(operation, { type: "type" });
-  const generator = new SchemaGenerator2(plugin.options, {
-    oas,
-    plugin,
-    pluginManager,
-    mode,
-    override: plugin.options.override
-  });
-  const items = [schemas.pathParams, schemas.queryParams, schemas.headerParams, schemas.statusCodes, schemas.request, schemas.response].flat().filter(Boolean);
-  const mapItem = ({ name, schema, description, keysToOmit, ...options }, i) => {
-    const tree = generator.parse({ schema, name });
-    return /* @__PURE__ */ jsxs2(Oas3.Schema, { name, value: schema, tree, children: [
-      mode === "split" && /* @__PURE__ */ jsx4(Oas3.Schema.Imports, { extName: plugin.options.extName, isTypeOnly: true }),
-      /* @__PURE__ */ jsx4(File3.Source, { children: /* @__PURE__ */ jsx4(OperationSchema, { description, keysToOmit }) })
-    ] }, i);
-  };
-  return /* @__PURE__ */ jsx4(Parser2, { language: "typescript", children: /* @__PURE__ */ jsxs2(File3, { baseName: file.baseName, path: file.path, meta: file.meta, children: [
-    items.map(mapItem),
-    /* @__PURE__ */ jsx4(File3.Source, { children: printCombinedSchema({ name: factoryName, operation, schemas, pluginManager }) })
-  ] }) });
-};
-
-// src/OperationGenerator.tsx
-import { jsx as jsx5 } from "@kubb/react/jsx-runtime";
-var OperationGenerator = class extends Generator2 {
-  async all(operations) {
-    const { oas, pluginManager, plugin, mode } = this.context;
-    const root = createRoot2({
-      logger: pluginManager.logger
-    });
-    root.render(
-      /* @__PURE__ */ jsx5(App2, { pluginManager, plugin, mode, children: /* @__PURE__ */ jsx5(Oas4, { oas, operations, generator: this, children: plugin.options.oasType && /* @__PURE__ */ jsx5(OasType.File, { name: "oas", typeName: "Oas" }) }) })
-    );
-    return root.files;
-  }
-  async operation(operation, options) {
-    const { oas, pluginManager, plugin, mode } = this.context;
-    const root = createRoot2({
-      logger: pluginManager.logger
-    });
-    root.render(
-      /* @__PURE__ */ jsx5(App2, { pluginManager, plugin: { ...plugin, options }, mode, children: /* @__PURE__ */ jsx5(Oas4, { oas, operations: [operation], generator: this, children: /* @__PURE__ */ jsx5(Oas4.Operation, { operation, children: /* @__PURE__ */ jsx5(OperationSchema.File, {}) }) }) })
-    );
-    return root.files;
-  }
-};
-
-// src/plugin.ts
-var pluginTsName = "plugin-ts";
-var pluginTs = createPlugin((options) => {
-  const {
-    output = { path: "types" },
-    group,
-    exclude = [],
-    include,
-    override = [],
-    enumType = "asConst",
-    enumSuffix = "",
-    dateType = "string",
-    unknownType = "any",
-    optionalType = "questionToken",
-    transformers: transformers4 = {},
-    oasType = false,
-    mapper = {}
-  } = options;
-  const template = group?.output ? group.output : `${output.path}/{{tag}}Controller`;
-  return {
-    name: pluginTsName,
-    options: {
-      extName: output.extName,
-      transformers: transformers4,
-      dateType,
-      optionalType,
-      oasType,
-      enumType,
-      enumSuffix,
-      // keep the used enumnames between SchemaGenerator and OperationGenerator per plugin(pluginKey)
-      usedEnumNames: {},
-      unknownType,
-      override,
-      mapper
-    },
-    pre: [pluginOasName],
-    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 === "single") {
-        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 transformers4?.name?.(resolvedName, type) || resolvedName;
-      }
-      return resolvedName;
-    },
-    async buildStart() {
-      const [swaggerPlugin] = PluginManager.getDependedPlugins(this.plugins, [pluginOasName]);
-      const oas = await swaggerPlugin.context.getOas();
-      const root = path.resolve(this.config.root, this.config.output.path);
-      const mode = FileManager.getMode(path.resolve(root, output.path));
-      const schemaGenerator = new SchemaGenerator2(this.plugin.options, {
-        oas,
-        pluginManager: this.pluginManager,
-        plugin: this.plugin,
-        contentType: swaggerPlugin.context.contentType,
-        include: void 0,
-        override,
-        mode,
-        output: output.path
-      });
-      const schemaFiles = await schemaGenerator.build();
-      await this.addFile(...schemaFiles);
-      const operationGenerator = new OperationGenerator(this.plugin.options, {
-        oas,
-        pluginManager: this.pluginManager,
-        plugin: this.plugin,
-        contentType: swaggerPlugin.context.contentType,
-        exclude,
-        include,
-        override,
-        mode
-      });
-      const operationFiles = await operationGenerator.build();
-      await this.addFile(...operationFiles);
-    },
-    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 },
-        logger: this.logger
-      });
-    }
-  };
-});
-
-export {
-  OasType,
-  Schema,
-  OperationSchema,
-  pluginTsName,
-  pluginTs
-};
-//# sourceMappingURL=chunk-PU22CLWV.js.map