swagger2api-v3 1.0.6 → 1.0.8

package/README.md

@@ -1,6 +1,6 @@
 # Swagger2API-v3
 
-一个强大的命令行工具，用于从 Swagger/OpenAPI 文档自动生成 TypeScript 接口代码。
+一个强大的命令行工具，用于从 Swagger(OAS3.0) 文档自动生成 TypeScript 接口代码。
 
 ## ✨ 特性
 
@@ -26,7 +26,7 @@ npm install swagger2api-v3
 ### 1. 初始化配置文件
 
 ```bash
-swagger2api-v3 init
+npx swagger2api-v3 init
 ```
 
 ### 2. 配置文件说明
@@ -64,7 +64,7 @@ export default config;
 ### 3. 生成接口代码
 
 ```bash
-swagger2api-v3 generate
+npx swagger2api-v3 generate
 ```
 
 ## ⚙️ 配置选项
@@ -128,18 +128,20 @@ export interface UserInfo {
 ### 生成的 API 接口
 
 ```typescript
-// auth/index.ts
+// authController/index.ts
 import { request } from '@/utils/request';
-import type { LoginDto, UserInfo } from '../types';
+import type { LoginDto, LoginRespDto } from '../types';
 
 /**
- * 用户登录
+ * 登录
  * @param data 登录参数
+ * @param config 可选的请求配置
  */
-export const login = (data: LoginDto) => {
-  return request.post<UserInfo>({
-    url: '/auth/login',
-    data
+export const authControllerLoginPost = (data: LoginDto, config?: any) => {
+  return request.post<LoginRespDto>({
+    url: '/admin/auth/login',
+    data,
+    ...config
   });
 };
 ```
@@ -148,16 +150,16 @@ export const login = (data: LoginDto) => {
 
 ```bash
 # 初始化配置文件
-swagger2api-v3 init [--force]
+npx swagger2api-v3 init [--force]
 
 # 生成接口代码
-swagger2api-v3 generate [--config <path>]
+npx swagger2api-v3 generate [--config <path>]
 
 # 验证配置文件
-swagger2api-v3 validate [--config <path>]
+npx swagger2api-v3 validate [--config <path>]
 
 # 查看帮助
-swagger2api-v3 --help
+npx swagger2api-v3 --help
 ```
 
 ## 📝 NPM 脚本
@@ -168,7 +170,8 @@ swagger2api-v3 --help
 {
   "scripts": {
     "api:generate": "swagger2api-v3 generate",
-    "api:init": "swagger2api-v3 init"
+    "api:init": "swagger2api-v3 init",
+    "api:validate": "swagger2api-v3 validate"
   }
 }
 ```

package/dist/cli/index.js

@@ -109,43 +109,43 @@ program
             console.warn('⚠️ 无法读取package.json，使用默认CommonJS格式');
         }
     }
-    const configContent = `/**
- * Swagger2API 配置文件
- * 用于配置从 Swagger JSON 生成前端接口的参数
- */
-const config = {
-  // Swagger JSON 文件路径或 URL
-  input: 'http://localhost:3000/admin/docs/json',
-  
-  // 输出目录
-  output: './src/api',
-  
-  // request 导入路径模板
-  importTemplate: "import { request } from '@/utils/request';",
-  
-  // 生成器类型
-  generator: 'typescript',
-  
-  // 按标签分组生成文件
-  groupByTags: true,
-  
-  // 是否覆盖更新，默认为true。为true时会先删除输出目录下的所有文件
-  overwrite: true,
-  
-  // 接口路径公共前缀，默认为空字符串
-  prefix: '',
-  
-  // 代码格式化命令（可选）
-  lint: 'prettier --write',
-  
-  // 生成选项
-  options: {
-    // 是否添加注释
-    addComments: true
-  }
-};
-
-${isESModule ? 'export default config;' : 'module.exports = config;'}
+    const configContent = `/**
+ * Swagger2API 配置文件
+ * 用于配置从 Swagger JSON 生成前端接口的参数
+ */
+const config = {
+  // Swagger JSON 文件路径或 URL
+  input: 'http://localhost:3000/admin/docs/json',
+  
+  // 输出目录
+  output: './src/api',
+  
+  // request 导入路径模板
+  importTemplate: "import { request } from '@/utils/request';",
+  
+  // 生成器类型
+  generator: 'typescript',
+  
+  // 按标签分组生成文件
+  groupByTags: true,
+  
+  // 是否覆盖更新，默认为true。为true时会先删除输出目录下的所有文件
+  overwrite: true,
+  
+  // 接口路径公共前缀，默认为空字符串
+  prefix: '',
+  
+  // 代码格式化命令（可选）
+  lint: 'prettier --write',
+  
+  // 生成选项
+  options: {
+    // 是否添加注释
+    addComments: true
+  }
+};
+
+${isESModule ? 'export default config;' : 'module.exports = config;'}
 `;
     try {
         fs.writeFileSync(configPath, configContent, 'utf-8');

package/dist/core/generator.d.ts

@@ -67,12 +67,25 @@ export declare class CodeGenerator {
      * @returns 使用的类型名称数组
      */
     private collectUsedTypes;
+    /**
+     * 从类型字符串中提取所有类型名称（包括泛型参数）
+     * @param typeStr 类型字符串，如 "ResOp<UserListRespDto>"
+     * @returns 类型名称数组，如 ["ResOp", "UserListRespDto"]
+     */
+    private extractTypeNames;
     /**
      * 判断是否为基础类型
      * @param type 类型名称
      * @returns 是否为基础类型
      */
     private isPrimitiveType;
+    /**
+     * 检测是否为通用响应容器类型
+     * @param type 类型信息
+     * @param definition 类型定义
+     * @returns 是否为通用响应容器类型
+     */
+    private isGenericResponseContainer;
     /**
      * 生成请求配置
      * @param api API接口信息

package/dist/core/generator.js

@@ -102,11 +102,19 @@ class CodeGenerator {
             ''
         ].join('\n');
         const typeDefinitions = types
-            .map(type => {
+            .map((type) => {
             const comment = type.description
                 ? `/**\n * ${type.description}\n */\n`
                 : '';
-            return `${comment}${type.definition}`;
+            // 通用处理：检测通用响应容器类型并转换为泛型接口
+            let definition = type.definition;
+            if (this.isGenericResponseContainer(type, definition)) {
+                const typeName = type.name;
+                definition = definition
+                    .replace(`export interface ${typeName} {`, `export interface ${typeName}<T = Record<string, any>> {`)
+                    .replace('data: Record<string, any>;', 'data: T;');
+            }
+            return `${comment}${definition}`;
         })
             .join('\n\n');
         return `${header}${typeDefinitions}\n`;
@@ -163,7 +171,9 @@ class CodeGenerator {
             header.push(`import type { ${typeNames} } from '${typesPath}';`);
         }
         header.push('');
-        const apiImplementations = apis.map(api => this.generateApiFunction(api)).join('\n\n');
+        const apiImplementations = apis
+            .map((api) => this.generateApiFunction(api))
+            .join('\n\n');
         return `${header.join('\n')}${apiImplementations}\n`;
     }
     /**
@@ -175,7 +185,7 @@ class CodeGenerator {
         const parts = [];
         // 生成注释
         if (this.config.options?.addComments !== false) {
-            const swaggerParams = api.parameters.map(p => ({
+            const swaggerParams = api.parameters.map((p) => ({
                 name: p.name,
                 in: p.in,
                 required: p.required,
@@ -186,7 +196,7 @@ class CodeGenerator {
             parts.push(comment);
         }
         // 生成函数签名
-        const swaggerParameters = api.parameters.map(p => ({
+        const swaggerParameters = api.parameters.map((p) => ({
             name: p.name,
             in: p.in,
             required: p.required,
@@ -211,34 +221,36 @@ class CodeGenerator {
      */
     generateDirectParameters(parameters) {
         const params = [];
-        const queryParams = parameters.filter(p => p.in === 'query');
-        const pathParams = parameters.filter(p => p.in === 'path');
-        const bodyParams = parameters.filter(p => p.in === 'body');
-        const formParams = parameters.filter(p => p.in === 'formData');
+        const queryParams = parameters.filter((p) => p.in === 'query');
+        const pathParams = parameters.filter((p) => p.in === 'path');
+        const bodyParams = parameters.filter((p) => p.in === 'body');
+        const formParams = parameters.filter((p) => p.in === 'formData');
         // 合并路径参数和查询参数为一个params对象
         const allParams = [...pathParams, ...queryParams];
         if (allParams.length > 0) {
             const paramType = allParams
-                .map(p => {
+                .map((p) => {
                 const optional = p.required ? '' : '?';
                 return `${p.name}${optional}: ${p.type}`;
             })
                 .join(', ');
             // 检查是否所有参数都是可选的
-            const allOptional = allParams.every(p => !p.required);
+            const allOptional = allParams.every((p) => !p.required);
             const optionalModifier = allOptional ? '?' : '';
             params.push(`params${optionalModifier}: { ${paramType} }`);
         }
         // 请求体参数
         if (bodyParams.length > 0) {
             const bodyParam = bodyParams[0];
-            const bodyType = bodyParam.schema ? this.getTypeFromSchema(bodyParam.schema) : bodyParam.type;
+            const bodyType = bodyParam.schema
+                ? this.getTypeFromSchema(bodyParam.schema)
+                : bodyParam.type;
             params.push(`data: ${bodyType}`);
         }
         // 表单参数
         if (formParams.length > 0) {
             const formType = formParams
-                .map(p => {
+                .map((p) => {
                 const optional = p.required ? '' : '?';
                 return `${p.name}${optional}: ${p.type}`;
             })
@@ -267,17 +279,22 @@ class CodeGenerator {
      */
     collectUsedTypes(apis) {
         const usedTypes = new Set();
-        apis.forEach(api => {
+        apis.forEach((api) => {
             // 收集响应类型
             if (api.responseType && api.responseType !== 'any') {
-                usedTypes.add(api.responseType);
+                // 提取泛型类型中的所有类型名称
+                this.extractTypeNames(api.responseType).forEach((typeName) => {
+                    usedTypes.add(typeName);
+                });
             }
             // 收集参数类型
-            api.parameters.forEach(param => {
+            api.parameters.forEach((param) => {
                 if (param.schema) {
                     const type = this.getTypeFromSchema(param.schema);
                     if (type && type !== 'any' && !this.isPrimitiveType(type)) {
-                        usedTypes.add(type);
+                        this.extractTypeNames(type).forEach((typeName) => {
+                            usedTypes.add(typeName);
+                        });
                     }
                 }
                 else if (param.type && !this.isPrimitiveType(param.type)) {
@@ -287,15 +304,60 @@ class CodeGenerator {
         });
         return Array.from(usedTypes).sort();
     }
+    /**
+     * 从类型字符串中提取所有类型名称（包括泛型参数）
+     * @param typeStr 类型字符串，如 "ResOp<UserListRespDto>"
+     * @returns 类型名称数组，如 ["ResOp", "UserListRespDto"]
+     */
+    extractTypeNames(typeStr) {
+        const typeNames = new Set();
+        // 匹配所有标识符（类型名称）
+        const matches = typeStr.match(/[A-Za-z_][A-Za-z0-9_]*/g);
+        if (matches) {
+            matches.forEach((match) => {
+                if (!this.isPrimitiveType(match)) {
+                    typeNames.add(match);
+                }
+            });
+        }
+        return Array.from(typeNames);
+    }
     /**
      * 判断是否为基础类型
      * @param type 类型名称
      * @returns 是否为基础类型
      */
     isPrimitiveType(type) {
-        const primitiveTypes = ['string', 'number', 'boolean', 'object', 'array', 'any', 'void', 'null', 'undefined'];
+        const primitiveTypes = [
+            'string',
+            'number',
+            'boolean',
+            'object',
+            'array',
+            'any',
+            'void',
+            'null',
+            'undefined'
+        ];
         return primitiveTypes.includes(type.toLowerCase());
     }
+    /**
+     * 检测是否为通用响应容器类型
+     * @param type 类型信息
+     * @param definition 类型定义
+     * @returns 是否为通用响应容器类型
+     */
+    isGenericResponseContainer(type, definition) {
+        // 检查是否为接口定义
+        if (!definition.includes(`export interface ${type.name} {`)) {
+            return false;
+        }
+        // 检查是否包含 data 字段且类型为 Record<string, any>
+        const hasDataField = definition.includes('data: Record<string, any>;');
+        // 检查是否包含其他常见的响应容器字段
+        const hasCommonFields = ['code', 'message', 'success', 'status'].some((field) => definition.includes(`${field}:`));
+        return hasDataField && hasCommonFields;
+    }
     /**
      * 生成请求配置
      * @param api API接口信息
@@ -309,11 +371,11 @@ class CodeGenerator {
         if (this.config.prefix) {
             url = this.config.prefix + url;
         }
-        const pathParams = api.parameters.filter(p => p.in === 'path');
-        const queryParams = api.parameters.filter(p => p.in === 'query');
+        const pathParams = api.parameters.filter((p) => p.in === 'path');
+        const queryParams = api.parameters.filter((p) => p.in === 'query');
         if (pathParams.length > 0) {
             // 替换路径参数，从params对象中获取
-            pathParams.forEach(param => {
+            pathParams.forEach((param) => {
                 url = url.replace(`{${param.name}}`, `\${params.${param.name}}`);
             });
             config.push(`url: \`${url}\``);
@@ -327,8 +389,8 @@ class CodeGenerator {
             config.push('params');
         }
         // 请求体数据
-        const bodyParams = api.parameters.filter(p => p.in === 'body');
-        const formParams = api.parameters.filter(p => p.in === 'formData');
+        const bodyParams = api.parameters.filter((p) => p.in === 'body');
+        const formParams = api.parameters.filter((p) => p.in === 'formData');
         if (bodyParams.length > 0) {
             config.push('data');
         }

package/dist/core/parser.js

@@ -161,7 +161,22 @@ class SwaggerParser {
         else if (schema.enum) {
             // 枚举类型
             const enumValues = schema.enum
-                .map((value) => `  ${value.toUpperCase()} = '${value}'`)
+                .map((value, index) => {
+                let key = value;
+                // 优先使用 x-enum-varnames 或 x-enumNames 扩展字段
+                if ((schema['x-enum-varnames'] && schema['x-enum-varnames'][index]) ||
+                    (schema['x-enumNames'] && schema['x-enumNames'][index])) {
+                    key = schema['x-enum-varnames']?.[index] || schema['x-enumNames']?.[index];
+                }
+                else if (/^\d+$/.test(value)) {
+                    // 对于数字枚举，使用 VALUE_ 前缀
+                    key = `VALUE_${value}`;
+                }
+                else {
+                    key = value.toUpperCase();
+                }
+                return `  ${key} = '${value}'`;
+            })
                 .join(',\n');
             definition = `export enum ${typeName} {\n${enumValues}\n}`;
         }

package/dist/utils/index.js

@@ -120,32 +120,65 @@ function swaggerTypeToTsType(schema) {
     if (!schema) {
         return 'any';
     }
+    let baseType;
     // 处理 allOf 类型组合
     if (schema.allOf && schema.allOf.length > 0) {
-        // 对于 allOf，通常第一个元素是引用类型
+        // 检查是否为泛型模式：第一个是引用类型，第二个定义了扩展属性
         const firstSchema = schema.allOf[0];
-        if (firstSchema.$ref) {
+        if (firstSchema.$ref && schema.allOf.length > 1) {
             const refName = firstSchema.$ref.split('/').pop();
-            return refName || 'any';
+            const secondSchema = schema.allOf[1];
+            // 检查第二个 schema 是否定义了对象属性（可能没有 type 字段）
+            if (secondSchema.properties) {
+                // 获取所有扩展属性的类型
+                const propertyTypes = [];
+                for (const [propName, propSchema] of Object.entries(secondSchema.properties)) {
+                    const propType = swaggerTypeToTsType(propSchema);
+                    propertyTypes.push(propType);
+                }
+                // 如果只有一个属性，直接作为泛型参数
+                if (propertyTypes.length === 1) {
+                    baseType = `${refName}<${propertyTypes[0]}>`;
+                }
+                // 如果有多个属性，组合成联合类型或对象类型
+                else if (propertyTypes.length > 1) {
+                    const combinedType = `{ ${Object.entries(secondSchema.properties)
+                        .map(([key, value]) => {
+                        const optional = secondSchema.required?.includes(key) ? '' : '?';
+                        const type = swaggerTypeToTsType(value);
+                        return `${key}${optional}: ${type}`;
+                    })
+                        .join('; ')} }`;
+                    baseType = `${refName}<${combinedType}>`;
+                }
+                else {
+                    baseType = refName || 'any';
+                }
+            }
+            else {
+                baseType = refName || 'any';
+            }
+        }
+        else {
+            // 如果不是引用，尝试合并所有类型
+            const types = schema.allOf
+                .map((s) => swaggerTypeToTsType(s))
+                .filter((t) => t !== 'any');
+            baseType = types.length > 0 ? types[0] : 'any';
         }
-        // 如果不是引用，尝试合并所有类型
-        const types = schema.allOf
-            .map((s) => swaggerTypeToTsType(s))
-            .filter((t) => t !== 'any');
-        return types.length > 0 ? types[0] : 'any';
     }
     // 处理引用类型
-    if (schema.$ref) {
+    else if (schema.$ref) {
         const refName = schema.$ref.split('/').pop();
-        return refName || 'any';
+        baseType = refName || 'any';
     }
     // 处理数组类型
-    if (schema.type === 'array') {
+    else if (schema.type === 'array') {
         const itemType = swaggerTypeToTsType(schema.items);
-        return `${itemType}[]`;
+        baseType = `${itemType}[]`;
     }
     // 处理对象类型
-    if (schema.type === 'object') {
+    else if (schema.type === 'object') {
         if (schema.properties) {
             const properties = Object.entries(schema.properties)
                 .map(([key, value]) => {
@@ -154,27 +187,43 @@ function swaggerTypeToTsType(schema) {
                 return `  ${key}${optional}: ${type};`;
             })
                 .join('\n');
-            return `{\n${properties}\n}`;
+            baseType = `{\n${properties}\n}`;
+        }
+        else {
+            baseType = 'Record<string, any>';
         }
-        return 'Record<string, any>';
     }
     // 处理基本类型
-    switch (schema.type) {
-        case 'integer':
-        case 'number':
-            return 'number';
-        case 'string':
-            if (schema.enum) {
-                return schema.enum.map((value) => `'${value}'`).join(' | ');
-            }
-            return 'string';
-        case 'boolean':
-            return 'boolean';
-        case 'file':
-            return 'File';
-        default:
-            return 'any';
+    else {
+        switch (schema.type) {
+            case 'integer':
+            case 'number':
+                baseType = 'number';
+                break;
+            case 'string':
+                if (schema.enum) {
+                    baseType = schema.enum.map((value) => `'${value}'`).join(' | ');
+                }
+                else {
+                    baseType = 'string';
+                }
+                break;
+            case 'boolean':
+                baseType = 'boolean';
+                break;
+            case 'file':
+                baseType = 'File';
+                break;
+            default:
+                baseType = 'any';
+                break;
+        }
+    }
+    // 处理 nullable 属性
+    if (schema.nullable === true) {
+        return `${baseType} | null`;
     }
+    return baseType;
 }
 /**
  * 从Swagger参数生成TypeScript参数类型
@@ -290,11 +339,33 @@ function generateApiComment(operation, parameters) {
         comments.push(` * ${operation.description}`);
     }
     if (parameters && parameters.length > 0) {
-        comments.push(' *');
-        parameters.forEach((param) => {
-            const description = param.description || '';
-            comments.push(` * @param ${param.name} ${description}`);
-        });
+        // 收集不同类型的参数
+        const queryParams = parameters.filter((p) => p.in === 'query');
+        const pathParams = parameters.filter((p) => p.in === 'path');
+        const bodyParams = parameters.filter((p) => p.in === 'body');
+        const formParams = parameters.filter((p) => p.in === 'formData');
+        const hasParams = queryParams.length > 0 || pathParams.length > 0;
+        const hasData = bodyParams.length > 0 || formParams.length > 0;
+        if (hasParams || hasData) {
+            comments.push(' *');
+            // 如果有查询参数或路径参数，添加params注释
+            if (hasParams) {
+                const paramDescriptions = [...pathParams, ...queryParams]
+                    .map(p => p.description || '')
+                    .filter(desc => desc)
+                    .join(', ');
+                const description = paramDescriptions || '请求参数';
+                comments.push(` * @param params ${description}`);
+            }
+            // 如果有请求体参数，添加data注释
+            if (hasData) {
+                const dataParam = bodyParams[0] || formParams[0];
+                const description = dataParam?.description || '请求数据';
+                comments.push(` * @param data ${description}`);
+            }
+            // 添加config参数注释
+            comments.push(` * @param config 可选的请求配置`);
+        }
     }
     if (operation.deprecated) {
         comments.push(' * @deprecated');

package/package.json

@@ -1,68 +1,68 @@
-{
-  "name": "swagger2api-v3",
-  "version": "1.0.6",
-  "description": "从 Swagger/OpenAPI 文档生成 TypeScript API 接口的命令行工具",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "type": "commonjs",
-  "bin": {
-    "swagger2api-v3": "dist/cli/index.js"
-  },
-  "files": [
-    "dist",
-    "README.md",
-    "package.json"
-  ],
-  "scripts": {
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage",
-    "test:ci": "jest --ci --coverage --watchAll=false",
-    "build": "tsc",
-    "clean": "rimraf dist",
-    "prebuild": "npm run clean",
-    "start": "node dist/cli/index.js",
-    "dev": "npm run build && npm start",
-    "lint": "prettier --write",
-    "generate": "npm run build && node dist/cli/index.js generate",
-    "init": "npm run build && node dist/cli/index.js init",
-    "validate": "npm run build && node dist/cli/index.js validate",
-    "swagger:generate": "npm run generate",
-    "swagger:run": "npm run generate",
-    "swagger:init": "npm run init",
-    "swagger:validate": "npm run validate"
-  },
-  "keywords": [
-    "swagger",
-    "openapi",
-    "typescript",
-    "api",
-    "generator",
-    "cli",
-    "code-generation"
-  ],
-  "author": "xiaoyang",
-  "license": "MIT",
-  "homepage": "https://github.com/xiaoyang33/swagger2api-v3#readme",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/xiaoyang33/swagger2api-v3.git"
-  },
-  "bugs": {
-    "url": "https://github.com/xiaoyang33/swagger2api-v3/issues"
-  },
-  "packageManager": "pnpm@10.11.0",
-  "devDependencies": {
-    "@types/jest": "^29.5.0",
-    "@types/node": "^24.3.1",
-    "jest": "^29.5.0",
-    "prettier": "^3.6.2",
-    "rimraf": "^6.0.1",
-    "ts-jest": "^29.1.0",
-    "typescript": "^5.9.2"
-  },
-  "dependencies": {
-    "axios": "^1.11.0",
-    "commander": "^12.0.0"
-  }
-}
+{
+  "name": "swagger2api-v3",
+  "version": "1.0.8",
+  "description": "从 Swagger/OpenAPI 文档生成 TypeScript API 接口的命令行工具",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "commonjs",
+  "bin": {
+    "swagger2api-v3": "dist/cli/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "package.json"
+  ],
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "test:ci": "jest --ci --coverage --watchAll=false",
+    "build": "tsc",
+    "clean": "rimraf dist",
+    "prebuild": "npm run clean",
+    "start": "node dist/cli/index.js",
+    "dev": "npm run build && npm start",
+    "lint": "prettier --write",
+    "generate": "npm run build && node dist/cli/index.js generate",
+    "init": "npm run build && node dist/cli/index.js init",
+    "validate": "npm run build && node dist/cli/index.js validate",
+    "swagger:generate": "npm run generate",
+    "swagger:run": "npm run generate",
+    "swagger:init": "npm run init",
+    "swagger:validate": "npm run validate"
+  },
+  "keywords": [
+    "swagger",
+    "openapi",
+    "typescript",
+    "api",
+    "generator",
+    "cli",
+    "code-generation"
+  ],
+  "author": "xiaoyang",
+  "license": "MIT",
+  "homepage": "https://github.com/xiaoyang33/swagger2api-v3#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/xiaoyang33/swagger2api-v3.git"
+  },
+  "bugs": {
+    "url": "https://github.com/xiaoyang33/swagger2api-v3/issues"
+  },
+  "packageManager": "pnpm@10.11.0",
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@types/node": "^24.3.1",
+    "jest": "^29.5.0",
+    "prettier": "^3.6.2",
+    "rimraf": "^6.0.1",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.9.2"
+  },
+  "dependencies": {
+    "axios": "^1.11.0",
+    "commander": "^12.0.0"
+  }
+}