@bitstack/ng-query-codegen-openapi 0.0.30 → 0.0.31-alpha.0

package/src/services/api-code-generator.ts

@@ -3,81 +3,79 @@ import ts from 'typescript';
 import { OpenApiParserService } from './openapi-parser-service';
 import { EndpointInfoExtractor } from './endpoint-info-extractor';
 import { generateTypesFile } from '../generators/types-generator';
-import { generateIndexFile } from '../generators/index-generator';
-import { QueryCodeGenerator } from './query-code-generator';
-import { ApiServiceGenerator } from './api-service-generator';
+import { generateRtkQueryFile } from '../generators/rtk-query-generator';
+import { generateRtkEnhanceEndpointsFile } from '../generators/rtk-enhance-endpoints-generator';
 import type { GenerationOptions, GenerateApiResult } from '../types';
 
 /**
- * API 程式碼生成器 - 負責生成單一群組的 API 相關程式碼
- * 
+ * API 程式碼生成器 - 負責生成單一群組的 RTK Query 相關程式碼
+ *
  * 設計理念：
  * - 類別化管理：使用 class 封裝邏輯
- * - 分離關注點：將 Query 和 API 服務分開生成
+ * - RTK Query 專用：只生成 React/RTK Query 代碼
  * - 重用資源：接受外部已處理的 v3Doc，避免重複處理
  */
 export class ApiCodeGenerator {
   private infoExtractor: EndpointInfoExtractor;
-  private queryGenerator: QueryCodeGenerator;
-  private apiServiceGenerator: ApiServiceGenerator;
 
   constructor(
     private parserService: OpenApiParserService,
     private options: GenerationOptions
   ) {
-  
-    // // 初始化端點資訊提取器
+    // 初始化端點資訊提取器
     this.infoExtractor = new EndpointInfoExtractor(options);
-    //
-    // 初始化分離的生成器
-    this.queryGenerator = new QueryCodeGenerator(options);
-    this.apiServiceGenerator = new ApiServiceGenerator(options);
   }
 
   /**
-   * 生成完整的 API 程式碼
+   * 生成完整的 RTK Query 程式碼
    */
   async generate(): Promise<GenerateApiResult> {
-    // console.log('ApiCodeGenerator: 開始生成 API 程式碼...');
-
     // 步驟 1: 獲取操作定義
     const operationDefinitions = this.parserService.getOperationDefinitions(this.options.filterEndpoints);
 
     // 步驟 2: 提取端點資訊
     const endpointInfos = this.infoExtractor.extractEndpointInfos(operationDefinitions);
 
+    // 步驟 3: 生成 RTK Query 代碼
+    return this.generateRtkQueryCode(endpointInfos);
+  }
 
-    // 步驟 3: 生成各種內容
+  /**
+   * 生成 RTK Query 代碼
+   */
+  private generateRtkQueryCode(endpointInfos: Array<any>): GenerateApiResult {
+    // 步驟 1: 生成 types 檔案 (React 模式也需要)
     const typesContent = this.generateTypes(endpointInfos);
-    
 
-    const apiServiceContent = this.generateApiService(endpointInfos);
-    const queryServiceContent = this.generateQueryService(endpointInfos);
-    const indexContent = this.generateIndex();
+    // 步驟 2: 生成 RTK Query 檔案
+    const rtkQueryContent = generateRtkQueryFile(endpointInfos, this.options);
+
+    // 步驟 3: 生成 enhance endpoints 檔案
+    const enhanceEndpointsContent = generateRtkEnhanceEndpointsFile(endpointInfos, this.options);
 
-    // 步驟 4: 收集端點快取鍵資訊（只收集 Query 類型的端點）
-    const allEndpointCacheKeys = endpointInfos
-      .filter(info => info.isQuery) // 只收集查詢類型的端點
-      .map(info => ({
-        operationName: info.operationName,
-        queryKeyName: info.queryKeyName,
-        groupKey: this.options.groupKey || '_common'
-      }));
+    // 步驟 4: 生成 index 檔案
+    const indexContent = this.generateIndex();
 
-    // 步驟 5: 收集操作名稱
-    const operationNames = endpointInfos.map(info => info.operationName);
+    // 步驟 6: 收集操作名稱
+    const operationNames = endpointInfos.map((info) => info.operationName);
 
-    // console.log('ApiCodeGenerator: API 程式碼生成完成');
+    // 步驟 7: 收集所有 tags
+    const allTags = new Set<string>();
+    endpointInfos.forEach((info) => {
+      if (info.tags && Array.isArray(info.tags)) {
+        info.tags.forEach((tag: string) => allTags.add(tag));
+      }
+    });
 
     return {
       operationNames,
+      tags: Array.from(allTags),
       files: {
         types: typesContent,
-        apiService: apiServiceContent,
-        queryService: queryServiceContent,
+        queryService: rtkQueryContent, // RTK Query 檔案
         index: indexContent,
-        allEndpointCacheKeys: allEndpointCacheKeys
-      }
+        enhanceEndpoints: enhanceEndpointsContent, // 新增的 enhance endpoints 檔案
+      },
     };
   }
 
@@ -87,24 +85,27 @@ export class ApiCodeGenerator {
   private generateTypes(endpointInfos: Array<any>): string {
     const generatorOptions = {
       ...this.options,
-      apiConfiguration: this.options.apiConfiguration || { 
-        file: '@/store/webapi', 
-        importName: 'WebApiConfiguration' 
-      }
+      apiConfiguration: this.options.apiConfiguration || {
+        file: '@/store/webapi',
+        importName: 'WebApiConfiguration',
+      },
     };
 
     // 從 parser service 獲取 schema interfaces
     const apiGen = this.parserService.getApiGenerator();
-    const schemaInterfaces = apiGen.aliases.reduce<Record<string, ts.InterfaceDeclaration | ts.TypeAliasDeclaration>>((curr, alias) => {
-      if (ts.isInterfaceDeclaration(alias) || ts.isTypeAliasDeclaration(alias)) {
-        const name = alias.name.text;
-        return {
-          ...curr,
-          [name]: alias,
-        };
-      }
-      return curr;
-    }, {});
+    const schemaInterfaces = apiGen.aliases.reduce<Record<string, ts.InterfaceDeclaration | ts.TypeAliasDeclaration>>(
+      (curr, alias) => {
+        if (ts.isInterfaceDeclaration(alias) || ts.isTypeAliasDeclaration(alias)) {
+          const name = alias.name.text;
+          return {
+            ...curr,
+            [name]: alias,
+          };
+        }
+        return curr;
+      },
+      {}
+    );
 
     // 獲取操作定義以供類型生成使用
     const operationDefinitions = this.parserService.getOperationDefinitions(this.options.filterEndpoints);
@@ -112,33 +113,20 @@ export class ApiCodeGenerator {
     return generateTypesFile(endpointInfos, generatorOptions, schemaInterfaces, operationDefinitions);
   }
 
-  /**
-   * 生成 API Service 檔案內容
-   */
-  private generateApiService(endpointInfos: Array<any>): string {
-    return this.apiServiceGenerator.generateApiService(endpointInfos);
-  }
-
-  /**
-   * 生成 Query Service 檔案內容
-   */
-  private generateQueryService(endpointInfos: Array<any>): string {
-    return this.queryGenerator.generateQueryService(endpointInfos);
-  }
-
   /**
    * 生成 Index 檔案內容
    */
   private generateIndex(): string {
-    const generatorOptions = {
-      ...this.options,
-      apiConfiguration: this.options.apiConfiguration || { 
-        file: '@/store/webapi', 
-        importName: 'WebApiConfiguration' 
-      }
-    };
+    const groupKey = this.options.groupKey || '';
+    const exportName = groupKey ? `${groupKey.charAt(0).toLowerCase() + groupKey.slice(1)}Api` : 'api';
+
+    return `/* eslint-disable */
+// [Warning] Generated automatically - do not edit manually
 
-    return generateIndexFile(this.options.groupKey || '', generatorOptions);
+export { default as ${exportName} } from "./enhanceEndpoints";
+export * from "./query.generated";
+export * from "./types";
+`;
   }
 
   // /**
@@ -154,4 +142,4 @@ export class ApiCodeGenerator {
   // getInfoExtractor(): EndpointInfoExtractor {
   //   return this.infoExtractor;
   // }
-}
+}

package/src/services/endpoint-info-extractor.ts

@@ -18,6 +18,9 @@ export interface EndpointInfo {
   pathParams: any[];
   isVoidArg: boolean;
   summary: string;
+  contentType: string;
+  hasRequestBody: boolean;
+  tags: string[];
 }
 
 /**
@@ -25,7 +28,10 @@ export interface EndpointInfo {
  */
 export class EndpointInfoExtractor {
   constructor(
-    private options: Pick<GenerationOptions, 'operationNameSuffix' | 'argSuffix' | 'responseSuffix' | 'queryMatch' | 'endpointOverrides'>
+    private options: Pick<
+      GenerationOptions,
+      'operationNameSuffix' | 'argSuffix' | 'responseSuffix' | 'queryMatch' | 'endpointOverrides'
+    >
   ) {}
 
   /**
@@ -44,7 +50,13 @@ export class EndpointInfoExtractor {
    */
   private extractSingleEndpointInfo(operationDefinition: OperationDefinition): EndpointInfo {
     const { verb, path, operation } = operationDefinition;
-    const { operationNameSuffix = '', argSuffix = 'Req', responseSuffix = 'Res', queryMatch, endpointOverrides } = this.options;
+    const {
+      operationNameSuffix = '',
+      argSuffix = 'Req',
+      responseSuffix = 'Res',
+      queryMatch,
+      endpointOverrides,
+    } = this.options;
 
     // 獲取操作名稱
     const operationName = getOperationName({ verb, path });
@@ -56,7 +68,7 @@ export class EndpointInfoExtractor {
 
     // 判斷是否為查詢類型
     const isQuery = testIsQuery(verb, path, getOverrides(operationDefinition, endpointOverrides), queryMatch);
-    
+
     // 生成查詢鍵名稱
     const queryKeyName = `${operationName.replace(/([A-Z])/g, '_$1').toUpperCase()}`;
 
@@ -64,7 +76,13 @@ export class EndpointInfoExtractor {
     const summary = operation.summary || `${verb.toUpperCase()} ${path}`;
 
     // 解析參數
-    const { queryParams, pathParams, isVoidArg } = this.extractParameters(operationDefinition);
+    const { queryParams, pathParams, isVoidArg, hasRequestBody } = this.extractParameters(operationDefinition);
+
+    // 提取 content type
+    const contentType = this.extractContentType(operation);
+
+    // 提取 tags
+    const tags = Array.isArray(operation.tags) ? operation.tags : [];
 
     return {
       operationName: finalOperationName,
@@ -77,7 +95,10 @@ export class EndpointInfoExtractor {
       queryParams,
       pathParams,
       isVoidArg,
-      summary
+      summary,
+      contentType,
+      hasRequestBody,
+      tags,
     };
   }
 
@@ -90,14 +111,19 @@ export class EndpointInfoExtractor {
 
     // 解析參數
     const operationParameters = this.resolveArray(operation.parameters);
-    const pathItemParameters = this.resolveArray(pathItem.parameters)
-      .filter((pp) => !operationParameters.some((op) => op.name === pp.name && op.in === pp.in));
-    
-    const allParameters = supportDeepObjects([...pathItemParameters, ...operationParameters])
-      .filter((param) => param.in !== 'header');
+    const pathItemParameters = this.resolveArray(pathItem.parameters).filter(
+      (pp) => !operationParameters.some((op) => op.name === pp.name && op.in === pp.in)
+    );
 
-    const queryParams = allParameters.filter(param => param.in === 'query');
-    const pathParams = allParameters.filter(param => param.in === 'path');
+    const allParameters = supportDeepObjects([...pathItemParameters, ...operationParameters]).filter(
+      (param) => param.in !== 'header'
+    );
+
+    const queryParams = allParameters.filter((param) => param.in === 'query');
+    const pathParams = allParameters.filter((param) => param.in === 'path');
+
+    // 檢查是否有 request body
+    const hasRequestBody = !!operation.requestBody;
 
     // 檢查是否為 void 類型參數
     const isVoidArg = queryParams.length === 0 && pathParams.length === 0 && !operation.requestBody;
@@ -105,7 +131,8 @@ export class EndpointInfoExtractor {
     return {
       queryParams,
       pathParams,
-      isVoidArg
+      isVoidArg,
+      hasRequestBody,
     };
   }
 
@@ -116,4 +143,29 @@ export class EndpointInfoExtractor {
     if (!parameters) return [];
     return Array.isArray(parameters) ? parameters : [parameters];
   }
-}
+
+  /**
+   * 提取操作的 content type
+   * @param operation - 操作對象
+   */
+  private extractContentType(operation: any): string {
+    // 檢查 requestBody 是否存在
+    if (!operation.requestBody) {
+      return 'application/json';
+    }
+
+    // 從 requestBody.content 中獲取第一個 content type
+    const content = operation.requestBody.content;
+    if (!content || typeof content !== 'object') {
+      return 'application/json';
+    }
+
+    const contentTypes = Object.keys(content);
+    if (contentTypes.length === 0) {
+      return 'application/json';
+    }
+
+    // 返回第一個 content type
+    return contentTypes[0];
+  }
+}

package/src/services/file-writer-service.ts

@@ -23,10 +23,20 @@ export class FileWriterService {
   async writeFile(filePath: string, content: string): Promise<FileWriteResult> {
     try {
       const resolvedPath = path.resolve(process.cwd(), filePath);
+      const fileName = path.basename(resolvedPath);
+
+      // enhanceEndpoints.ts 如果已存在則跳過寫入
+      if (fileName === 'enhanceEndpoints.ts' && fs.existsSync(resolvedPath)) {
+        return {
+          path: resolvedPath,
+          success: true
+        };
+      }
+
       await ensureDirectoryExists(resolvedPath);
-      
+
       fs.writeFileSync(resolvedPath, content);
-      
+
       return {
         path: resolvedPath,
         success: true
@@ -46,27 +56,28 @@ export class FileWriterService {
    */
   async writeFiles(files: Record<string, string>): Promise<FileWriteResult[]> {
     const results: FileWriteResult[] = [];
-    
+
     for (const [filePath, content] of Object.entries(files)) {
       const result = await this.writeFile(filePath, content);
       results.push(result);
     }
-    
+
     return results;
   }
 
+
   /**
-   * 為群組寫入標準檔案結構
+   * 為群組寫入 RTK Query 檔案結構
    * @param groupOutputDir - 群組輸出目錄
    * @param files - 檔案內容
    */
   async writeGroupFiles(
     groupOutputDir: string,
     files: {
-      types?: string;
-      apiService?: string;
-      queryService?: string;
-      index?: string;
+      types?: string; // types.ts
+      queryService?: string; // query.generated.ts
+      enhanceEndpoints?: string; // enhanceEndpoints.ts
+      index?: string; // index.ts
     }
   ): Promise<FileWriteResult[]> {
     const filesToWrite: Record<string, string> = {};
@@ -74,15 +85,15 @@ export class FileWriterService {
     if (files.types) {
       filesToWrite[path.join(groupOutputDir, 'types.ts')] = files.types;
     }
-    
-    if (files.apiService) {
-      filesToWrite[path.join(groupOutputDir, 'api.service.ts')] = files.apiService;
-    }
-    
+
     if (files.queryService) {
-      filesToWrite[path.join(groupOutputDir, 'query.service.ts')] = files.queryService;
+      filesToWrite[path.join(groupOutputDir, 'query.generated.ts')] = files.queryService;
     }
-    
+
+    if (files.enhanceEndpoints) {
+      filesToWrite[path.join(groupOutputDir, 'enhanceEndpoints.ts')] = files.enhanceEndpoints;
+    }
+
     if (files.index) {
       filesToWrite[path.join(groupOutputDir, 'index.ts')] = files.index;
     }
@@ -99,7 +110,6 @@ export class FileWriterService {
     outputDir: string,
     sharedFiles: {
       commonTypes?: string;
-      cacheKeys?: string;
       doNotModify?: string;
       utils?: string;
     }
@@ -110,9 +120,6 @@ export class FileWriterService {
       filesToWrite[path.join(outputDir, 'common-types.ts')] = sharedFiles.commonTypes;
     }
     
-    if (sharedFiles.cacheKeys) {
-      filesToWrite[path.join(outputDir, 'cache-keys.ts')] = sharedFiles.cacheKeys;
-    }
 
     if (sharedFiles.doNotModify) {
       filesToWrite[path.join(outputDir, 'DO_NOT_MODIFY.md')] = sharedFiles.doNotModify;
@@ -125,9 +132,6 @@ export class FileWriterService {
     return this.writeFiles(filesToWrite);
   }
 
-
-
-
   /**
    * 寫入共享檔案
    * @param outputDir - 輸出目錄

package/src/services/openapi-parser-service.ts

@@ -15,7 +15,6 @@ export class OpenApiParserService {
   ) {
     this.apiGen = new ApiGenerator(v3Doc, {
       unionUndefined: options.unionUndefined,
-      useEnumType: options.useEnumType,
       mergeReadWriteOnly: options.mergeReadWriteOnly,
     });
   }
@@ -25,8 +24,17 @@ export class OpenApiParserService {
    */
   initialize(): void {
     if (this.apiGen.spec.components?.schemas) {
+      // 原因：oazapfts 會優先使用 schema.title 作為類型名稱，但應該使用 schema key
+      // 這只在記憶體中修改，不影響原始 OpenAPI 文件
+      Object.keys(this.apiGen.spec.components.schemas).forEach(schemaName => {
+        const schema = this.apiGen.spec.components!.schemas![schemaName];
+        if (schema && typeof schema === 'object' && 'title' in schema) {
+          delete schema.title;
+        }
+      });
+
       this.apiGen.preprocessComponents(this.apiGen.spec.components.schemas);
-      
+
       // 手動為每個 schema 生成 type alias
       Object.keys(this.apiGen.spec.components.schemas).forEach(schemaName => {
         try {

package/src/services/unified-code-generator.ts

@@ -4,19 +4,14 @@ import type { OpenAPIV3 } from 'openapi-types';
 import { OpenApiService } from './openapi-service';
 import { GroupService, type GroupConfig } from './group-service';
 import { FileWriterService, type FileWriteResult } from './file-writer-service';
-export interface EndpointCacheKey {
-  operationName: string;
-  queryKeyName: string;
-  groupKey: string;
-}
 import { OpenApiParserService } from './openapi-parser-service';
-import { generateCacheKeysFile } from '../generators/cache-keys-generator';
 import { generateCommonTypesFile } from '../generators/common-types-generator';
 import { generateComponentSchemaFile } from '../generators/component-schema-generator';
 import { generateDoNotModifyFile } from '../generators/do-not-modify-generator';
 import type { GenerationOptions, CommonOptions } from '../types';
 import { ApiCodeGenerator } from './api-code-generator';
 import { generateUtilsFile } from '../generators/utils-generator';
+import { generateTagTypesFile } from '../generators/tag-types-generator';
 
 /**
  * 統一代碼生成器選項
@@ -61,7 +56,6 @@ export class UnifiedCodeGenerator {
   private openApiDoc: OpenAPIV3.Document | null = null;
   private parserService: OpenApiParserService | null = null;
   private schemaInterfaces: Record<string, ts.InterfaceDeclaration | ts.TypeAliasDeclaration> = {};
-  private allEndpointCacheKeys: EndpointCacheKey[] = [];
   private actualSchemaFile: string = '';
   
   // 生成內容存儲
@@ -71,20 +65,23 @@ export class UnifiedCodeGenerator {
       outputPath: string;
       content: any;
     }>;
-    cacheKeys: string | null;
     commonTypes: string;
     componentSchema: string;
     doNotModify: string;
     utils: string;
+    tagTypes: string;
   } = {
     groups: [],
-    cacheKeys: null,
     commonTypes: '',
     componentSchema: '',
     doNotModify: '',
-    utils: ''
+    utils: '',
+    tagTypes: ''
   };
 
+  // 收集所有 tags
+  private allTags: Set<string> = new Set();
+
 
   constructor(options: UnifiedGenerationOptions) {
     this._options = options;
@@ -103,11 +100,11 @@ export class UnifiedCodeGenerator {
     // await this.generateQuery();
 
     // 生成共用
-    this.generateCacheKeysContent()
     this.generateCommonTypesContent()
     this.generateSchemaContent()
     this.generateUtilsContent()
     this.generateDoNotModifyContent()
+    this.generateTagTypesContent()
 
     return await this.release();
   }
@@ -186,6 +183,11 @@ export class UnifiedCodeGenerator {
             outputPath: groupInfo.outputPath,
             content: groupContent
           });
+
+          // 收集此群組的所有 tags
+          if (groupContent.tags && Array.isArray(groupContent.tags)) {
+            groupContent.tags.forEach((tag: string) => this.allTags.add(tag));
+          }
         }
         // 如果沒有任何 endpoint，則跳過此群組，不創建資料夾
       } catch (error) {
@@ -197,12 +199,6 @@ export class UnifiedCodeGenerator {
   }
 
 
-  /**
-   * 生成 cache keys
-   */
-  private async generateCacheKeysContent(): Promise<void> {
-    this.generatedContent.cacheKeys = generateCacheKeysFile(this.allEndpointCacheKeys);
-  }
 
   /**
    * 生成 common types
@@ -233,6 +229,14 @@ export class UnifiedCodeGenerator {
     this.generatedContent.utils = generateUtilsFile();
   }
 
+  /**
+   * 生成 Tag Types
+   */
+  private async generateTagTypesContent(): Promise<void> {
+    const tagsArray = Array.from(this.allTags);
+    this.generatedContent.tagTypes = generateTagTypesFile(tagsArray);
+  }
+
 
 
 
@@ -252,15 +256,17 @@ export class UnifiedCodeGenerator {
         try {
           if (group.content?.files) {
             const groupOutputDir = path.dirname(group.outputPath);
+            // RTK Query 模式 (唯一支援模式)
             const groupResults = await this.fileWriterService.writeGroupFiles(
               groupOutputDir,
               {
                 types: group.content.files.types,
-                apiService: group.content.files.apiService,
                 queryService: group.content.files.queryService,
+                enhanceEndpoints: group.content.files.enhanceEndpoints,
                 index: group.content.files.index
               }
             );
+
             results.push(...groupResults);
             generatedGroups.push(group.groupKey);
           }
@@ -275,11 +281,10 @@ export class UnifiedCodeGenerator {
         './generated';
 
       // 寫入共用檔案 (包含 DO_NOT_MODIFY.md)
-      if (this.generatedContent.cacheKeys || this.generatedContent.commonTypes || this.generatedContent.doNotModify || this.generatedContent.utils) {
+      if (this.generatedContent.commonTypes || this.generatedContent.doNotModify || this.generatedContent.utils) {
         const sharedResults = await this.fileWriterService.writeSharedFiles(
           outputDir,
-          { 
-            cacheKeys: this.generatedContent.cacheKeys || undefined,
+          {
             commonTypes: this.generatedContent.commonTypes || undefined,
             doNotModify: this.generatedContent.doNotModify || undefined,
             utils: this.generatedContent.utils || undefined
@@ -288,6 +293,15 @@ export class UnifiedCodeGenerator {
         results.push(...sharedResults);
       }
 
+      // 寫入 tagTypes.ts
+      if (this.generatedContent.tagTypes) {
+        const tagTypesResult = await this.fileWriterService.writeFile(
+          path.join(outputDir, 'tagTypes.ts'),
+          this.generatedContent.tagTypes
+        );
+        results.push(tagTypesResult);
+      }
+
       // 寫入 component schema
       if (this.generatedContent.componentSchema) {
         const schemaResults = await this.fileWriterService.writeSchemaFile(
@@ -297,6 +311,14 @@ export class UnifiedCodeGenerator {
         results.push(...schemaResults);
       }
 
+      // 生成主 index.ts 檔案
+      const mainIndexContent = this.generateMainIndex(generatedGroups);
+      const mainIndexResult = await this.fileWriterService.writeFile(
+        path.join(outputDir, 'index.ts'),
+        mainIndexContent
+      );
+      results.push(mainIndexResult);
+
     } catch (error) {
       errors.push(error as Error);
     }
@@ -340,14 +362,21 @@ export class UnifiedCodeGenerator {
     const apiGenerator = new ApiCodeGenerator(this.parserService, groupOptions);
     const result = await apiGenerator.generate();
 
-    // 提取並儲存快取鍵
-    if (result.files && 'allEndpointCacheKeys' in result.files) {
-      const cacheKeys = result.files.allEndpointCacheKeys as EndpointCacheKey[];
-      this.allEndpointCacheKeys.push(...cacheKeys);
-    }
 
     return result;
   }
 
+  /**
+   * 生成主 index.ts 檔案
+   */
+  private generateMainIndex(generatedGroups: string[]): string {
+    const exports = generatedGroups.map(groupKey => `export * from "./${groupKey}";`).join('\n');
+
+    return `/* eslint-disable */
+// [Warning] Generated automatically - do not edit manually
+
+${exports}
+`;
+  }
 
 }