@bitstack/ng-query-codegen-openapi 0.0.30

package/lib/index.mjs

@@ -0,0 +1,1376 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/tsup/assets/esm_shims.js
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/utils/http.ts
+var http_exports = {};
+__export(http_exports, {
+  argumentMatches: () => argumentMatches,
+  defaultIsDataResponse: () => defaultIsDataResponse,
+  getOperationName: () => getOperationName,
+  getOverrides: () => getOverrides,
+  getTags: () => getTags,
+  operationMatches: () => operationMatches
+});
+import {
+  getOperationName as _getOperationName
+} from "oazapfts/generate";
+function defaultIsDataResponse(code, includeDefault) {
+  if (includeDefault && code === "default") {
+    return true;
+  }
+  const parsedCode = Number(code);
+  return !Number.isNaN(parsedCode) && parsedCode >= 200 && parsedCode < 300;
+}
+function getOperationName({ verb, path: path5 }) {
+  return _getOperationName(verb, path5, void 0);
+}
+function getTags({ verb, pathItem }) {
+  return verb ? pathItem[verb]?.tags || [] : [];
+}
+function patternMatches(pattern) {
+  const filters = Array.isArray(pattern) ? pattern : [pattern];
+  return function matcher(operationName) {
+    if (!pattern) return true;
+    return filters.some(
+      (filter) => typeof filter === "string" ? filter === operationName : filter?.test(operationName)
+    );
+  };
+}
+function operationMatches(pattern) {
+  const checkMatch = typeof pattern === "function" ? pattern : patternMatches(pattern);
+  return function matcher(operationDefinition) {
+    if (!pattern) return true;
+    const operationName = getOperationName(operationDefinition);
+    return checkMatch(operationName, operationDefinition);
+  };
+}
+function argumentMatches(pattern) {
+  const checkMatch = typeof pattern === "function" ? pattern : patternMatches(pattern);
+  return function matcher(argumentDefinition) {
+    if (!pattern || argumentDefinition.in === "path") return true;
+    const argumentName = argumentDefinition.name;
+    return checkMatch(argumentName, argumentDefinition);
+  };
+}
+function getOverrides(operation, endpointOverrides) {
+  return endpointOverrides?.find((override) => operationMatches(override.pattern)(operation));
+}
+var init_http = __esm({
+  "src/utils/http.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/index.ts
+init_esm_shims();
+
+// src/services/unified-code-generator.ts
+init_esm_shims();
+import path4 from "node:path";
+import ts3 from "typescript";
+
+// src/services/openapi-service.ts
+init_esm_shims();
+
+// src/utils/capitalize.ts
+init_esm_shims();
+function capitalize(str) {
+  return str.replace(str[0], str[0].toUpperCase());
+}
+
+// src/utils/downloadSchema.ts
+init_esm_shims();
+import fs from "node:fs";
+import path from "node:path";
+
+// src/utils/isValidUrl.ts
+init_esm_shims();
+function isValidUrl(string) {
+  try {
+    new URL(string);
+  } catch (_) {
+    return false;
+  }
+  return true;
+}
+
+// src/utils/downloadSchema.ts
+async function downloadSchemaFile(remoteFile, targetPath) {
+  if (!isValidUrl(remoteFile)) {
+    throw new Error(`remoteFile must be a valid URL: ${remoteFile}`);
+  }
+  try {
+    const dir = path.dirname(targetPath);
+    if (!fs.existsSync(dir)) {
+      await fs.promises.mkdir(dir, { recursive: true });
+    }
+    const response = await fetch(remoteFile);
+    if (!response.ok) {
+      throw new Error(`Failed to download schema from ${remoteFile}: ${response.statusText}`);
+    }
+    const content = await response.text();
+    await fs.promises.writeFile(targetPath, content, "utf-8");
+    console.log(`Schema downloaded from ${remoteFile} to ${targetPath}`);
+    return targetPath;
+  } catch (error) {
+    console.error(`Error downloading schema from ${remoteFile}:`, error);
+    throw error;
+  }
+}
+
+// src/utils/getOperationDefinitions.ts
+init_esm_shims();
+
+// src/types.ts
+init_esm_shims();
+var operationKeys = ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
+
+// src/utils/getOperationDefinitions.ts
+function getOperationDefinitions(v3Doc) {
+  return Object.entries(v3Doc.paths).flatMap(
+    ([path5, pathItem]) => !pathItem ? [] : Object.entries(pathItem).filter(
+      (arg) => operationKeys.includes(arg[0])
+    ).map(([verb, operation]) => ({
+      path: path5,
+      verb,
+      pathItem,
+      operation
+    }))
+  );
+}
+
+// src/utils/getV3Doc.ts
+init_esm_shims();
+import SwaggerParser from "@apidevtools/swagger-parser";
+import converter from "swagger2openapi";
+async function getV3Doc(spec, httpResolverOptions) {
+  const doc = await SwaggerParser.bundle(spec, {
+    resolve: {
+      http: httpResolverOptions
+    }
+  });
+  const isOpenApiV3 = "openapi" in doc && doc.openapi.startsWith("3");
+  if (isOpenApiV3) {
+    return doc;
+  } else {
+    const result = await converter.convertObj(doc, {});
+    return result.openapi;
+  }
+}
+
+// src/utils/isQuery.ts
+init_esm_shims();
+function isQuery(verb, path5, overrides, queryMatch) {
+  if (queryMatch) {
+    return queryMatch(verb, path5);
+  }
+  if (overrides?.type) {
+    return overrides.type === "query";
+  }
+  return verb === "get";
+}
+
+// src/services/openapi-service.ts
+var OpenApiService = class {
+  docCache = {};
+  /**
+   * 獲取 OpenAPI 文檔
+   * @param schemaLocation - Schema 位置 (URL 或本地路徑)
+   * @param httpResolverOptions - HTTP 解析選項
+   */
+  async getDocument(schemaLocation, httpResolverOptions) {
+    if (this.docCache[schemaLocation]) {
+      return this.docCache[schemaLocation];
+    }
+    const doc = await getV3Doc(schemaLocation, httpResolverOptions);
+    this.docCache[schemaLocation] = doc;
+    return doc;
+  }
+  /**
+   * 下載遠程 Schema 文件
+   * @param remoteUrl - 遠程 URL
+   * @param localPath - 本地儲存路徑
+   */
+  async downloadSchema(remoteUrl, localPath) {
+    return downloadSchemaFile(remoteUrl, localPath);
+  }
+  /**
+   * 獲取所有 API 路徑
+   * @param doc - OpenAPI 文檔
+   */
+  getPaths(doc) {
+    return Object.keys(doc.paths || {});
+  }
+  /**
+   * 清除快取
+   */
+  clearCache() {
+    this.docCache = {};
+  }
+};
+
+// src/services/group-service.ts
+init_esm_shims();
+import camelCase from "lodash.camelcase";
+var GroupService = class {
+  /**
+   * 根據配置對路徑進行分組
+   * @param paths - API 路徑陣列
+   * @param config - 群組配置
+   */
+  groupPaths(paths, config) {
+    const { groupKeyMatch, outputDir } = config;
+    const groupedPaths = paths.reduce((acc, path5) => {
+      const rawGroupKey = groupKeyMatch(path5);
+      const groupKey = rawGroupKey ? camelCase(rawGroupKey) : "_common";
+      if (!acc[groupKey]) {
+        acc[groupKey] = [];
+      }
+      acc[groupKey].push(path5);
+      return acc;
+    }, {});
+    const result = {};
+    for (const [groupKey, paths2] of Object.entries(groupedPaths)) {
+      result[groupKey] = {
+        groupKey,
+        paths: paths2,
+        outputPath: `${outputDir}/${groupKey}/query.service.ts`
+      };
+    }
+    return result;
+  }
+  /**
+   * 為特定群組建立篩選函數
+   * @param groupKey - 群組鍵
+   * @param config - 群組配置
+   */
+  createGroupFilter(groupKey, config) {
+    return (operationName, operationDefinition) => {
+      const path5 = operationDefinition.path;
+      const pathGroupKey = camelCase(config.groupKeyMatch(path5) || "");
+      if (pathGroupKey !== groupKey && (pathGroupKey || "_common") !== groupKey) {
+        return false;
+      }
+      if (config.filterEndpoint) {
+        return config.filterEndpoint(operationName, path5, groupKey);
+      }
+      return true;
+    };
+  }
+};
+
+// src/services/file-writer-service.ts
+init_esm_shims();
+import fs3 from "node:fs";
+import path3 from "node:path";
+
+// src/utils/directory.ts
+init_esm_shims();
+import path2 from "node:path";
+import fs2 from "node:fs";
+async function ensureDirectoryExists(filePath) {
+  const dirname = path2.dirname(filePath);
+  if (!fs2.existsSync(dirname)) {
+    await fs2.promises.mkdir(dirname, { recursive: true });
+  }
+}
+
+// src/services/file-writer-service.ts
+var FileWriterService = class {
+  /**
+   * 寫入單一檔案
+   * @param filePath - 檔案路徑
+   * @param content - 檔案內容
+   */
+  async writeFile(filePath, content) {
+    try {
+      const resolvedPath = path3.resolve(process.cwd(), filePath);
+      await ensureDirectoryExists(resolvedPath);
+      fs3.writeFileSync(resolvedPath, content);
+      return {
+        path: resolvedPath,
+        success: true
+      };
+    } catch (error) {
+      return {
+        path: filePath,
+        success: false,
+        error
+      };
+    }
+  }
+  /**
+   * 批次寫入多個檔案
+   * @param files - 檔案路徑與內容的對應表
+   */
+  async writeFiles(files) {
+    const results = [];
+    for (const [filePath, content] of Object.entries(files)) {
+      const result = await this.writeFile(filePath, content);
+      results.push(result);
+    }
+    return results;
+  }
+  /**
+   * 為群組寫入標準檔案結構
+   * @param groupOutputDir - 群組輸出目錄
+   * @param files - 檔案內容
+   */
+  async writeGroupFiles(groupOutputDir, files) {
+    const filesToWrite = {};
+    if (files.types) {
+      filesToWrite[path3.join(groupOutputDir, "types.ts")] = files.types;
+    }
+    if (files.apiService) {
+      filesToWrite[path3.join(groupOutputDir, "api.service.ts")] = files.apiService;
+    }
+    if (files.queryService) {
+      filesToWrite[path3.join(groupOutputDir, "query.service.ts")] = files.queryService;
+    }
+    if (files.index) {
+      filesToWrite[path3.join(groupOutputDir, "index.ts")] = files.index;
+    }
+    return this.writeFiles(filesToWrite);
+  }
+  /**
+   * 寫入共享檔案
+   * @param outputDir - 輸出目錄
+   * @param sharedFiles - 共享檔案內容
+   */
+  async writeSharedFiles(outputDir, sharedFiles) {
+    const filesToWrite = {};
+    if (sharedFiles.commonTypes) {
+      filesToWrite[path3.join(outputDir, "common-types.ts")] = sharedFiles.commonTypes;
+    }
+    if (sharedFiles.cacheKeys) {
+      filesToWrite[path3.join(outputDir, "cache-keys.ts")] = sharedFiles.cacheKeys;
+    }
+    if (sharedFiles.doNotModify) {
+      filesToWrite[path3.join(outputDir, "DO_NOT_MODIFY.md")] = sharedFiles.doNotModify;
+    }
+    if (sharedFiles.utils) {
+      filesToWrite[path3.join(outputDir, "utils.ts")] = sharedFiles.utils;
+    }
+    return this.writeFiles(filesToWrite);
+  }
+  /**
+   * 寫入共享檔案
+   * @param outputDir - 輸出目錄
+   * @param schema
+   */
+  async writeSchemaFile(outputDir, schema) {
+    const filesToWrite = {};
+    filesToWrite[path3.join(outputDir, "schema.ts")] = schema;
+    return this.writeFiles(filesToWrite);
+  }
+};
+
+// src/services/openapi-parser-service.ts
+init_esm_shims();
+import ApiGenerator from "oazapfts/generate";
+var OpenApiParserService = class {
+  constructor(v3Doc, options) {
+    this.v3Doc = v3Doc;
+    this.apiGen = new ApiGenerator(v3Doc, {
+      unionUndefined: options.unionUndefined,
+      useEnumType: options.useEnumType,
+      mergeReadWriteOnly: options.mergeReadWriteOnly
+    });
+  }
+  apiGen;
+  /**
+   * 初始化 - 預處理組件
+   */
+  initialize() {
+    if (this.apiGen.spec.components?.schemas) {
+      this.apiGen.preprocessComponents(this.apiGen.spec.components.schemas);
+      Object.keys(this.apiGen.spec.components.schemas).forEach((schemaName) => {
+        try {
+          this.apiGen.getRefAlias({ $ref: `#/components/schemas/${schemaName}` });
+        } catch (error) {
+        }
+      });
+    }
+  }
+  /**
+   * 獲取操作定義列表
+   * @param filterEndpoints - 端點過濾函數
+   */
+  getOperationDefinitions(filterEndpoints) {
+    const { operationMatches: operationMatches2 } = (init_http(), __toCommonJS(http_exports));
+    return getOperationDefinitions(this.v3Doc).filter(operationMatches2(filterEndpoints));
+  }
+  /**
+   * 獲取 API 生成器實例
+   */
+  getApiGenerator() {
+    return this.apiGen;
+  }
+  /**
+   * 獲取 OpenAPI 文檔
+   */
+  getDocument() {
+    return this.v3Doc;
+  }
+  /**
+   * 獲取所有 schema 類型名稱
+   */
+  getSchemaTypeNames() {
+    const schemeTypeNames = /* @__PURE__ */ new Set();
+    return schemeTypeNames;
+  }
+};
+
+// src/generators/cache-keys-generator.ts
+init_esm_shims();
+
+// src/generators/utils-generator.ts
+init_esm_shims();
+function generateUtilsFile() {
+  return `/* eslint-disable */
+// [Warning] Generated automatically - do not edit manually 
+    
+/**
+* Clear undefined in object
+*/
+export function withoutUndefined(obj?: Record<string, any>) {
+  if(typeof obj === 'undefined') return;
+  return Object.fromEntries(
+      Object.entries(obj).filter(([_, v]) => v !== undefined && v !== null)
+  );
+}
+
+`;
+}
+function toCamelCase(str) {
+  return str.toLowerCase().replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+
+// src/generators/cache-keys-generator.ts
+function generateCacheKeysFile(allEndpointInfos) {
+  const groupedKeys = allEndpointInfos.reduce((acc, info) => {
+    if (!acc[info.groupKey]) {
+      acc[info.groupKey] = [];
+    }
+    acc[info.groupKey].push({
+      operationName: info.operationName,
+      queryKeyName: info.queryKeyName
+    });
+    return acc;
+  }, {});
+  const enumEntries = Object.entries(groupedKeys).map(([groupKey, keys]) => {
+    const groupComment = `  // ${groupKey.charAt(0).toUpperCase() + groupKey.slice(1)} related cache keys`;
+    const keyEntries = keys.map(
+      (key) => `  ${key.queryKeyName} = '${toCamelCase(key.queryKeyName)}',`
+    ).join("\n");
+    return `${groupComment}
+${keyEntries}`;
+  }).join("\n\n");
+  return `// [Warning] Generated automatically - do not edit manually 
+  
+/**
+ * Cache keys enum for all API queries
+ */
+export enum ECacheKeys {
+${enumEntries}
+}
+
+export default ECacheKeys;
+`;
+}
+
+// src/generators/common-types-generator.ts
+init_esm_shims();
+function generateCommonTypesFile() {
+  return `/* eslint-disable */
+// [Warning] Generated automatically - do not edit manually
+ 
+export interface RequestOptions {
+  headers?: Record<string, string>;
+  observe?: 'body' | 'events' | 'response';
+  responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
+  reportProgress?: boolean;
+  withCredentials?: boolean;
+  timeout?: number;
+}
+
+export interface QueryConfig {
+    refetchOnMountOrArgChange?: boolean|number,
+    keepUnusedDataFor?: number,
+}
+
+export type IRestFulEndpointsQueryReturn<TVariables> = TVariables extends void ? 
+  void | {fetchOptions?: RequestOptions;config?: QueryConfig;}: 
+  {
+      variables: TVariables;
+      fetchOptions?: RequestOptions;
+      config?: QueryConfig;
+  };
+`;
+}
+
+// src/generators/component-schema-generator.ts
+init_esm_shims();
+import ts from "typescript";
+function generateComponentSchemaFile(interfaces) {
+  const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+  const resultFile = ts.createSourceFile(
+    "component-schema.ts",
+    "",
+    ts.ScriptTarget.Latest,
+    false,
+    ts.ScriptKind.TS
+  );
+  return `/* eslint-disable */
+// [Warning] Generated automatically - do not edit manually 
+    
+${Object.values(interfaces).map((i) => printer.printNode(ts.EmitHint.Unspecified, i, resultFile)).join("\n")}
+`;
+}
+
+// src/generators/do-not-modify-generator.ts
+init_esm_shims();
+function generateDoNotModifyFile() {
+  return `# \u8ACB\u52FF\u4FEE\u6539\u6B64\u8CC7\u6599\u593E
+
+\u26A0\uFE0F **\u91CD\u8981\u63D0\u9192\uFF1A\u8ACB\u52FF\u4FEE\u6539\u6B64\u8CC7\u6599\u593E\u4E2D\u7684\u4EFB\u4F55\u6A94\u6848**
+
+\u6B64\u8CC7\u6599\u593E\u4E2D\u7684\u6240\u6709\u6A94\u6848\u90FD\u662F\u900F\u904E\u7A0B\u5F0F\u78BC\u7522\u751F\u5668\u81EA\u52D5\u7522\u751F\u7684\u3002\u4EFB\u4F55\u624B\u52D5\u4FEE\u6539\u7684\u5167\u5BB9\u5728\u4E0B\u6B21\u91CD\u65B0\u7522\u751F\u6642\u90FD\u5C07\u6703\u88AB\u8986\u84CB\u3002
+
+## \u5982\u4F55\u4FEE\u6539\u9019\u4E9B\u6A94\u6848\uFF1F
+
+\u5982\u679C\u60A8\u9700\u8981\u4FEE\u6539\u9019\u4E9B\u6A94\u6848\u7684\u5167\u5BB9\uFF0C\u8ACB\uFF1A
+
+1. \u4FEE\u6539\u76F8\u5C0D\u61C9\u7684\u8A2D\u5B9A\u6A94\u6848\u6216\u6A21\u677F
+2. \u91CD\u65B0\u57F7\u884C\u7A0B\u5F0F\u78BC\u7522\u751F\u5668
+3. \u8B93\u7522\u751F\u5668\u81EA\u52D5\u66F4\u65B0\u9019\u4E9B\u6A94\u6848
+
+## \u7522\u751F\u5668\u76F8\u95DC\u8CC7\u8A0A
+
+\u9019\u4E9B\u6A94\u6848\u662F\u7531 @bitstack/ng-query-codegen-openapi \u7522\u751F\u5668\u6240\u5EFA\u7ACB\u3002
+
+\u5982\u6709\u7591\u554F\uFF0C\u8ACB\u53C3\u8003\u5C08\u6848\u6587\u4EF6\u6216\u806F\u7E6B\u958B\u767C\u5718\u968A\u3002
+`;
+}
+
+// src/services/api-code-generator.ts
+init_esm_shims();
+import ts2 from "typescript";
+
+// src/services/endpoint-info-extractor.ts
+init_esm_shims();
+init_http();
+import { supportDeepObjects } from "oazapfts/generate";
+var EndpointInfoExtractor = class {
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * 從操作定義列表提取端點資訊
+   * @param operationDefinitions - 操作定義列表
+   */
+  extractEndpointInfos(operationDefinitions) {
+    return operationDefinitions.map((operationDefinition) => {
+      return this.extractSingleEndpointInfo(operationDefinition);
+    });
+  }
+  /**
+   * 從單一操作定義提取端點資訊
+   * @param operationDefinition - 操作定義
+   */
+  extractSingleEndpointInfo(operationDefinition) {
+    const { verb, path: path5, operation } = operationDefinition;
+    const { operationNameSuffix = "", argSuffix = "Req", responseSuffix = "Res", queryMatch, endpointOverrides } = this.options;
+    const operationName = getOperationName({ verb, path: path5 });
+    const finalOperationName = operationNameSuffix ? capitalize(operationName + operationNameSuffix) : operationName;
+    const argTypeName = capitalize(operationName + operationNameSuffix + argSuffix);
+    const responseTypeName = capitalize(operationName + operationNameSuffix + responseSuffix);
+    const isQuery2 = isQuery(verb, path5, getOverrides(operationDefinition, endpointOverrides), queryMatch);
+    const queryKeyName = `${operationName.replace(/([A-Z])/g, "_$1").toUpperCase()}`;
+    const summary = operation.summary || `${verb.toUpperCase()} ${path5}`;
+    const { queryParams, pathParams, isVoidArg } = this.extractParameters(operationDefinition);
+    return {
+      operationName: finalOperationName,
+      argTypeName,
+      responseTypeName,
+      isQuery: isQuery2,
+      verb: verb.toUpperCase(),
+      path: path5,
+      queryKeyName,
+      queryParams,
+      pathParams,
+      isVoidArg,
+      summary
+    };
+  }
+  /**
+   * 提取操作的參數資訊
+   * @param operationDefinition - 操作定義
+   */
+  extractParameters(operationDefinition) {
+    const { operation, pathItem } = operationDefinition;
+    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 queryParams = allParameters.filter((param) => param.in === "query");
+    const pathParams = allParameters.filter((param) => param.in === "path");
+    const isVoidArg = queryParams.length === 0 && pathParams.length === 0 && !operation.requestBody;
+    return {
+      queryParams,
+      pathParams,
+      isVoidArg
+    };
+  }
+  /**
+   * 解析參數陣列 (模擬 apiGen.resolveArray)
+   */
+  resolveArray(parameters) {
+    if (!parameters) return [];
+    return Array.isArray(parameters) ? parameters : [parameters];
+  }
+};
+
+// src/generators/types-generator.ts
+init_esm_shims();
+function generateTypesFile(endpointInfos, _options, schemaInterfaces, operationDefinitions) {
+  let importStatement = `/* eslint-disable */
+// [Warning] Generated automatically - do not edit manually 
+  
+`;
+  const hasSchemaTypes = schemaInterfaces && Object.keys(schemaInterfaces).length > 0;
+  if (hasSchemaTypes) {
+    importStatement += `import * as Schema from "../schema";
+`;
+  }
+  importStatement += "\n";
+  const typeDefinitions = [];
+  const endpointTypes = [];
+  endpointInfos.forEach((endpoint) => {
+    const reqTypeName = endpoint.argTypeName;
+    const resTypeName = endpoint.responseTypeName;
+    if (reqTypeName) {
+      const requestTypeContent = generateRequestTypeContent(endpoint, operationDefinitions);
+      if (requestTypeContent.trim() === "" || requestTypeContent.includes("TODO") || requestTypeContent.includes("[key: string]: any")) {
+        endpointTypes.push(
+          `export type ${reqTypeName} = void;`,
+          ``
+        );
+      } else {
+        endpointTypes.push(
+          `export type ${reqTypeName} = {`,
+          requestTypeContent,
+          `};`,
+          ``
+        );
+      }
+    }
+    if (resTypeName) {
+      const responseTypeContent = generateResponseTypeContent(endpoint, operationDefinitions);
+      if (responseTypeContent.trim() === "" || responseTypeContent.includes("TODO") || responseTypeContent.includes("[key: string]: any")) {
+        endpointTypes.push(
+          `export type ${resTypeName} = void;`,
+          ``
+        );
+      } else {
+        endpointTypes.push(
+          `export type ${resTypeName} = {`,
+          responseTypeContent,
+          `};`,
+          ``
+        );
+      }
+    }
+  });
+  if (endpointTypes.length > 0) {
+    typeDefinitions.push(endpointTypes.join("\n"));
+  }
+  if (typeDefinitions.length === 0) {
+    typeDefinitions.push(
+      `// \u6B64\u6A94\u6848\u7528\u65BC\u5B9A\u7FA9 API \u76F8\u95DC\u7684\u985E\u578B`,
+      `// \u985E\u578B\u5B9A\u7FA9\u6703\u6839\u64DA OpenAPI Schema \u81EA\u52D5\u751F\u6210`,
+      ``
+    );
+  }
+  return importStatement + typeDefinitions.join("\n\n");
+}
+function generateRequestTypeContent(endpoint, operationDefinitions) {
+  const properties = [];
+  if (endpoint.queryParams && endpoint.queryParams.length > 0) {
+    endpoint.queryParams.forEach((param) => {
+      const optional = param.required ? "" : "?";
+      const paramType = getTypeFromParameter(param);
+      properties.push(`  ${param.name}${optional}: ${paramType};`);
+    });
+  }
+  if (endpoint.pathParams && endpoint.pathParams.length > 0) {
+    endpoint.pathParams.forEach((param) => {
+      const optional = param.required ? "" : "?";
+      const paramType = getTypeFromParameter(param);
+      properties.push(`  ${param.name}${optional}: ${paramType};`);
+    });
+  }
+  const operationDef = operationDefinitions?.find((op) => {
+    return op.operation?.operationId === endpoint.operationName || op.operation?.operationId === endpoint.operationName.toLowerCase() || // 也嘗試匹配 verb + path 組合
+    op.verb === endpoint.verb.toLowerCase() && op.path === endpoint.path;
+  });
+  if (operationDef?.operation?.requestBody) {
+    const requestBody = operationDef.operation.requestBody;
+    const content = requestBody.content;
+    const jsonContent = content["application/json"];
+    const formContent = content["multipart/form-data"] || content["application/x-www-form-urlencoded"];
+    if (jsonContent?.schema) {
+      const bodyType = getTypeFromSchema(jsonContent.schema);
+      properties.push(`  body: ${bodyType};`);
+    } else if (formContent?.schema) {
+      const bodyType = getTypeFromSchema(formContent.schema);
+      properties.push(`  body: ${bodyType};`);
+    } else {
+      properties.push(`  body?: any; // Request body from OpenAPI`);
+    }
+  }
+  if (properties.length === 0) {
+    return "";
+  }
+  return properties.join("\n");
+}
+function generateResponseTypeContent(endpoint, operationDefinitions) {
+  const properties = [];
+  const operationDef = operationDefinitions?.find((op) => {
+    return op.operation?.operationId === endpoint.operationName || op.operation?.operationId === endpoint.operationName.toLowerCase() || // 也嘗試匹配 verb + path 組合
+    op.verb === endpoint.verb.toLowerCase() && op.path === endpoint.path;
+  });
+  if (operationDef?.operation?.responses) {
+    const successResponse = operationDef.operation.responses["200"] || operationDef.operation.responses["201"];
+    if (successResponse?.content) {
+      const jsonContent = successResponse.content["application/json"];
+      if (jsonContent?.schema) {
+        const responseProps = parseSchemaProperties(jsonContent.schema);
+        properties.push(...responseProps);
+      } else {
+        properties.push(`  // Success response from OpenAPI`);
+        properties.push(`  data?: any;`);
+      }
+    }
+  }
+  if (properties.length === 0) {
+    return "";
+  }
+  return properties.join("\n");
+}
+function parseSchemaProperties(schema) {
+  const properties = [];
+  if (schema.type === "object" && schema.properties) {
+    const required = schema.required || [];
+    Object.entries(schema.properties).forEach(([propName, propSchema]) => {
+      const isRequired = required.includes(propName);
+      const optional = isRequired ? "" : "?";
+      const propType = getTypeFromSchema(propSchema);
+      const description = propSchema.description ? ` // ${propSchema.description}` : "";
+      properties.push(`  ${propName}${optional}: ${propType};${description}`);
+    });
+  }
+  return properties;
+}
+function getTypeFromSchema(schema) {
+  if (!schema) return "any";
+  if (schema.$ref) {
+    const refPath = schema.$ref;
+    if (refPath.startsWith("#/components/schemas/")) {
+      const typeName = refPath.replace("#/components/schemas/", "");
+      return `Schema.${typeName}`;
+    }
+  }
+  switch (schema.type) {
+    case "string":
+      if (schema.enum) {
+        return schema.enum.map((val) => `"${val}"`).join(" | ");
+      }
+      return "string";
+    case "number":
+    case "integer":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "array":
+      const itemType = schema.items ? getTypeFromSchema(schema.items) : "any";
+      return `${itemType}[]`;
+    case "object":
+      if (schema.properties) {
+        const props = Object.entries(schema.properties).map(([key, propSchema]) => {
+          const required = schema.required || [];
+          const optional = required.includes(key) ? "" : "?";
+          const type = getTypeFromSchema(propSchema);
+          return `${key}${optional}: ${type}`;
+        }).join("; ");
+        return `{ ${props} }`;
+      }
+      return "any";
+    default:
+      return "any";
+  }
+}
+function getTypeFromParameter(param) {
+  if (!param.schema) return "any";
+  return getTypeFromSchema(param.schema);
+}
+
+// src/generators/index-generator.ts
+init_esm_shims();
+function generateIndexFile(groupKey, options) {
+  const { groupKey: optionsGroupKey } = options;
+  return `export * from './types';
+export * from './api.service';
+export * from './query.service';
+`;
+}
+
+// src/services/query-code-generator.ts
+init_esm_shims();
+
+// src/generators/query-service-generator.ts
+init_esm_shims();
+function generateQueryServiceFile(endpointInfos, options) {
+  const { groupKey, refetchOnMountOrArgChange = 60 } = options;
+  const queryServiceName = groupKey ? `${groupKey.charAt(0).toUpperCase() + groupKey.slice(1)}QueryService` : "QueryService";
+  const apiServiceName = groupKey ? `${groupKey.charAt(0).toUpperCase() + groupKey.slice(1)}ApiService` : "ApiService";
+  const queryMethods = endpointInfos.filter((info) => info.isQuery).map((info) => `
+  /**
+   * ${info.summary}
+   */
+  ${info.operationName}Query(${info.argTypeName !== "VoidApiArg" ? `args: IRestFulEndpointsQueryReturn<${info.argTypeName}>` : ""}): Observable<QueryState<${info.responseTypeName}>> {
+    return this.ntkQuery.query<${info.responseTypeName}, ${info.argTypeName !== "VoidApiArg" ? `IRestFulEndpointsQueryReturn<${info.argTypeName}>` : "void"}>({
+      queryKey: [ECacheKeys.${info.queryKeyName}${info.argTypeName !== "VoidApiArg" ? ", args.variables" : ""}],
+      queryFn: () => {
+        return this.apiService.${info.operationName}(${info.argTypeName !== "VoidApiArg" ? "args" : ""});
+      },
+      fetchOptions: args?.fetchOptions,
+      config: args?.config,
+    })${info.argTypeName !== "VoidApiArg" ? "(args)" : "()"};
+  }`).join("");
+  const mutationMethods = endpointInfos.filter((info) => !info.isQuery).map((info) => `
+  /**
+   * ${info.summary}
+   */
+  ${info.operationName}Mutation(): MutationResponse<${info.responseTypeName}, {
+    variables: ${info.argTypeName !== "VoidApiArg" ? info.argTypeName : "void"};
+    fetchOptions?: RequestOptions;
+  }, HttpErrorResponse> {
+    return this.ntkQuery.mutation<${info.responseTypeName}, ${info.argTypeName !== "VoidApiArg" ? `IRestFulEndpointsQueryReturn<${info.argTypeName}>` : "void"}, HttpErrorResponse>({
+      endpointName: '${info.operationName}',
+      mutationFn: (${info.argTypeName !== "VoidApiArg" ? "args" : ""}) => {
+        return this.apiService.${info.operationName}(${info.argTypeName !== "VoidApiArg" ? "args" : ""});
+      },
+    });
+  }`).join("");
+  const lazyQueryMethods = endpointInfos.filter((info) => info.isQuery).map((info) => `
+  /**
+   * ${info.summary}
+   */
+  ${info.operationName}LazyQuery(): {
+    trigger: (${info.argTypeName !== "VoidApiArg" ? `args: IRestFulEndpointsQueryReturn<${info.argTypeName}>, ` : ""}options?: { skipCache?: boolean }) => Observable<${info.responseTypeName}>
+  } {
+    return {
+      trigger: (${info.argTypeName !== "VoidApiArg" ? "args, " : ""}options = {}) => {
+        const { skipCache = true } = options;
+        if (!skipCache) {
+          const cachedResult = this.ntkQuery.getQueryCache<${info.responseTypeName}>([ECacheKeys.${info.queryKeyName}${info.argTypeName !== "VoidApiArg" ? ", args.variables" : ""}]);
+          if (cachedResult) {
+            return cachedResult;
+          }
+        }
+        return this.apiService.${info.operationName}(${info.argTypeName !== "VoidApiArg" ? "args" : ""});
+      }
+    };
+  }`).join("");
+  return `/* eslint-disable */
+// [Warning] Generated automatically - do not edit manually 
+  
+import {Injectable, inject} from '@angular/core';
+import {Observable} from 'rxjs';
+import {HttpErrorResponse} from '@angular/common/http';
+import {NtkQueryService, MutationState, QueryState, MutationResponse} from '@core/ntk-query';
+import {ECacheKeys} from '../cache-keys';
+import {${apiServiceName}} from './api.service';
+import {IRestFulEndpointsQueryReturn, RequestOptions} from '../common-types';
+import {${endpointInfos.map((info) => ` ${info.argTypeName}, ${info.responseTypeName}`).join(",")}} from './types';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class ${queryServiceName} {
+  private apiService = inject(${apiServiceName});
+  private ntkQuery = inject(NtkQueryService);
+${queryMethods}${mutationMethods}${lazyQueryMethods}
+}
+`;
+}
+
+// src/services/query-code-generator.ts
+var QueryCodeGenerator = class {
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * 生成 Query Service 檔案內容
+   */
+  generateQueryService(endpointInfos) {
+    const generatorOptions = {
+      ...this.options,
+      apiConfiguration: this.options.apiConfiguration || {
+        file: "@/store/webapi",
+        importName: "WebApiConfiguration"
+      }
+    };
+    return generateQueryServiceFile(endpointInfos, generatorOptions);
+  }
+};
+
+// src/services/api-service-generator.ts
+init_esm_shims();
+
+// src/generators/api-service-generator.ts
+init_esm_shims();
+function generateApiServiceFile(endpointInfos, options) {
+  const { apiConfiguration, httpClient, groupKey } = options;
+  const apiServiceClassName = groupKey ? `${groupKey.charAt(0).toUpperCase() + groupKey.slice(1)}ApiService` : "ApiService";
+  return `/* eslint-disable */
+// [Warning] Generated automatically - do not edit manually 
+  
+import { ${httpClient.importName} } from '${httpClient.file}';
+import { Injectable, inject } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ${apiConfiguration.importName} } from '${apiConfiguration.file}';
+import { RequestOptions, IRestFulEndpointsQueryReturn } from '../common-types';
+import { withoutUndefined } from '../utils';
+import {${endpointInfos.map((info) => ` ${info.argTypeName}, ${info.responseTypeName}`).join(",")} } from './types';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class ${apiServiceClassName} {
+  private config = inject(${apiConfiguration.importName});
+  private http = inject(${httpClient.importName});
+
+${endpointInfos.map((info) => {
+    const isGet = info.verb.toUpperCase() === "GET";
+    const hasArgs = info.argTypeName !== "VoidApiArg";
+    const generateUrlTemplate = (path5) => {
+      const hasPathParams = path5.includes("{");
+      if (hasPathParams && hasArgs) {
+        const urlTemplate = path5.replace(/\{([^}]+)\}/g, "${args.variables.$1}");
+        return `\`\${this.config.rootUrl}${urlTemplate}\``;
+      } else {
+        return `\`\${this.config.rootUrl}${path5}\``;
+      }
+    };
+    const hasQueryParams = info.queryParams.length > 0;
+    const hasBody = !isGet && hasArgs && !info.isVoidArg;
+    const generateRequestOptions = () => {
+      const options2 = [
+        "...args.fetchOptions"
+      ];
+      if (hasBody || !isGet) {
+        options2.push(`headers: { 'Content-Type': 'application/json', ...args.fetchOptions?.headers }`);
+      }
+      if (hasQueryParams && hasArgs) {
+        options2.push(generateQueryParams(info.queryParams));
+      }
+      if (hasBody) {
+        options2.push("body: args.variables.body");
+      }
+      return options2.length > 0 ? `{ ${options2.join(", ")} }` : "{}";
+    };
+    return `
+  /**
+   * ${info.summary}
+   */
+  ${info.operationName}(
+    ${hasArgs ? `args: IRestFulEndpointsQueryReturn<${info.argTypeName}>, ` : ""}
+  ): Observable<${info.responseTypeName}> {
+    const url = ${generateUrlTemplate(info.path)};
+    return this.http.request('${info.verb.toLowerCase()}', url, ${generateRequestOptions()});
+  }`;
+  }).join("")}
+}
+`;
+}
+function generateQueryParams(queryParams) {
+  const paramEntries = queryParams.map(
+    (param) => `${param.name}: args.variables.${param.name}`
+  ).join(", ");
+  return `params: withoutUndefined({ ${paramEntries} })`;
+}
+
+// src/services/api-service-generator.ts
+var ApiServiceGenerator = class {
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * 生成 API Service 檔案內容
+   */
+  generateApiService(endpointInfos) {
+    const generatorOptions = {
+      ...this.options,
+      apiConfiguration: this.options.apiConfiguration || {
+        file: "@/store/webapi",
+        importName: "WebApiConfiguration"
+      }
+    };
+    return generateApiServiceFile(endpointInfos, generatorOptions);
+  }
+};
+
+// src/services/api-code-generator.ts
+var ApiCodeGenerator = class {
+  constructor(parserService, options) {
+    this.parserService = parserService;
+    this.options = options;
+    this.infoExtractor = new EndpointInfoExtractor(options);
+    this.queryGenerator = new QueryCodeGenerator(options);
+    this.apiServiceGenerator = new ApiServiceGenerator(options);
+  }
+  infoExtractor;
+  queryGenerator;
+  apiServiceGenerator;
+  /**
+   * 生成完整的 API 程式碼
+   */
+  async generate() {
+    const operationDefinitions = this.parserService.getOperationDefinitions(this.options.filterEndpoints);
+    const endpointInfos = this.infoExtractor.extractEndpointInfos(operationDefinitions);
+    const typesContent = this.generateTypes(endpointInfos);
+    const apiServiceContent = this.generateApiService(endpointInfos);
+    const queryServiceContent = this.generateQueryService(endpointInfos);
+    const indexContent = this.generateIndex();
+    const allEndpointCacheKeys = endpointInfos.filter((info) => info.isQuery).map((info) => ({
+      operationName: info.operationName,
+      queryKeyName: info.queryKeyName,
+      groupKey: this.options.groupKey || "_common"
+    }));
+    const operationNames = endpointInfos.map((info) => info.operationName);
+    return {
+      operationNames,
+      files: {
+        types: typesContent,
+        apiService: apiServiceContent,
+        queryService: queryServiceContent,
+        index: indexContent,
+        allEndpointCacheKeys
+      }
+    };
+  }
+  /**
+   * 生成 Types 檔案內容
+   */
+  generateTypes(endpointInfos) {
+    const generatorOptions = {
+      ...this.options,
+      apiConfiguration: this.options.apiConfiguration || {
+        file: "@/store/webapi",
+        importName: "WebApiConfiguration"
+      }
+    };
+    const apiGen = this.parserService.getApiGenerator();
+    const schemaInterfaces = apiGen.aliases.reduce((curr, alias) => {
+      if (ts2.isInterfaceDeclaration(alias) || ts2.isTypeAliasDeclaration(alias)) {
+        const name = alias.name.text;
+        return {
+          ...curr,
+          [name]: alias
+        };
+      }
+      return curr;
+    }, {});
+    const operationDefinitions = this.parserService.getOperationDefinitions(this.options.filterEndpoints);
+    return generateTypesFile(endpointInfos, generatorOptions, schemaInterfaces, operationDefinitions);
+  }
+  /**
+   * 生成 API Service 檔案內容
+   */
+  generateApiService(endpointInfos) {
+    return this.apiServiceGenerator.generateApiService(endpointInfos);
+  }
+  /**
+   * 生成 Query Service 檔案內容
+   */
+  generateQueryService(endpointInfos) {
+    return this.queryGenerator.generateQueryService(endpointInfos);
+  }
+  /**
+   * 生成 Index 檔案內容
+   */
+  generateIndex() {
+    const generatorOptions = {
+      ...this.options,
+      apiConfiguration: this.options.apiConfiguration || {
+        file: "@/store/webapi",
+        importName: "WebApiConfiguration"
+      }
+    };
+    return generateIndexFile(this.options.groupKey || "", generatorOptions);
+  }
+  // /**
+  //  * 獲取已解析的 parser service（供外部使用）
+  //  */
+  // getParserService(): OpenApiParserService {
+  //   return this.parserService;
+  // }
+  //
+  // /**
+  //  * 獲取端點資訊提取器（供外部使用）
+  //  */
+  // getInfoExtractor(): EndpointInfoExtractor {
+  //   return this.infoExtractor;
+  // }
+};
+
+// src/services/unified-code-generator.ts
+var UnifiedCodeGenerator = class {
+  _options;
+  openApiService = new OpenApiService();
+  groupService = new GroupService();
+  fileWriterService = new FileWriterService();
+  // 內部狀態存儲
+  openApiDoc = null;
+  parserService = null;
+  schemaInterfaces = {};
+  allEndpointCacheKeys = [];
+  actualSchemaFile = "";
+  // 生成內容存儲
+  generatedContent = {
+    groups: [],
+    cacheKeys: null,
+    commonTypes: "",
+    componentSchema: "",
+    doNotModify: "",
+    utils: ""
+  };
+  constructor(options) {
+    this._options = options;
+  }
+  /**
+   * 一次性生成（整合所有階段）
+   */
+  async generateAll() {
+    await this.prepare();
+    await this.generateApi();
+    this.generateCacheKeysContent();
+    this.generateCommonTypesContent();
+    this.generateSchemaContent();
+    this.generateUtilsContent();
+    this.generateDoNotModifyContent();
+    return await this.release();
+  }
+  /**
+   * 準備階段：解析 schema 並初始化所有服務
+   */
+  async prepare() {
+    this.actualSchemaFile = this._options.schemaFile;
+    if (this._options.remoteFile) {
+      this.actualSchemaFile = await this.openApiService.downloadSchema(
+        this._options.remoteFile,
+        this._options.schemaFile
+      );
+    }
+    this.openApiDoc = await this.openApiService.getDocument(
+      this.actualSchemaFile,
+      this._options.httpResolverOptions
+    );
+    this.parserService = new OpenApiParserService(this.openApiDoc, this._options);
+    this.parserService.initialize();
+    const apiGen = this.parserService.getApiGenerator();
+    this.schemaInterfaces = apiGen.aliases.reduce((curr, alias) => {
+      if (ts3.isInterfaceDeclaration(alias) || ts3.isTypeAliasDeclaration(alias)) {
+        const name = alias.name.text;
+        return {
+          ...curr,
+          [name]: alias
+        };
+      }
+      return curr;
+    }, {});
+  }
+  /**
+   * 生成階段：產生所有內容但不寫檔
+   */
+  async generateApi() {
+    if (!this.openApiDoc || !this.parserService) {
+      throw new Error("\u8ACB\u5148\u8ABF\u7528 prepare() \u65B9\u6CD5");
+    }
+    const paths = this.openApiService.getPaths(this.openApiDoc);
+    const groupInfos = this.groupService.groupPaths(paths, this._options.outputFiles);
+    for (const groupInfo of Object.values(groupInfos)) {
+      try {
+        const groupContent = await this.generateApiGroupContent(
+          this._options,
+          groupInfo
+        );
+        if (groupContent.operationNames.length > 0) {
+          this.generatedContent.groups.push({
+            groupKey: groupInfo.groupKey,
+            outputPath: groupInfo.outputPath,
+            content: groupContent
+          });
+        }
+      } catch (error) {
+        throw new Error(`\u7FA4\u7D44 ${groupInfo.groupKey} \u751F\u6210\u5931\u6557: ${error}`);
+      }
+    }
+  }
+  /**
+   * 生成 cache keys
+   */
+  async generateCacheKeysContent() {
+    this.generatedContent.cacheKeys = generateCacheKeysFile(this.allEndpointCacheKeys);
+  }
+  /**
+   * 生成 common types
+   */
+  async generateCommonTypesContent() {
+    this.generatedContent.commonTypes = generateCommonTypesFile();
+  }
+  /**
+   * 生成Schema
+   */
+  async generateSchemaContent() {
+    this.generatedContent.componentSchema = generateComponentSchemaFile(this.schemaInterfaces);
+  }
+  /**
+   * 生成 DO_NOT_MODIFY.md
+   */
+  async generateDoNotModifyContent() {
+    this.generatedContent.doNotModify = generateDoNotModifyFile();
+  }
+  /**
+   * 生成 Utils Function
+   */
+  async generateUtilsContent() {
+    this.generatedContent.utils = generateUtilsFile();
+  }
+  /**
+   * 發佈階段：統一寫入所有檔案
+   */
+  async release() {
+    const results = [];
+    const errors = [];
+    const generatedGroups = [];
+    try {
+      for (const group of this.generatedContent.groups) {
+        try {
+          if (group.content?.files) {
+            const groupOutputDir = path4.dirname(group.outputPath);
+            const groupResults = await this.fileWriterService.writeGroupFiles(
+              groupOutputDir,
+              {
+                types: group.content.files.types,
+                apiService: group.content.files.apiService,
+                queryService: group.content.files.queryService,
+                index: group.content.files.index
+              }
+            );
+            results.push(...groupResults);
+            generatedGroups.push(group.groupKey);
+          }
+        } catch (error) {
+          errors.push(new Error(`\u5BEB\u5165\u7FA4\u7D44 ${group.groupKey} \u5931\u6557: ${error}`));
+        }
+      }
+      const outputDir = this.generatedContent.groups[0] ? path4.dirname(path4.dirname(this.generatedContent.groups[0].outputPath)) : "./generated";
+      if (this.generatedContent.cacheKeys || this.generatedContent.commonTypes || this.generatedContent.doNotModify || this.generatedContent.utils) {
+        const sharedResults = await this.fileWriterService.writeSharedFiles(
+          outputDir,
+          {
+            cacheKeys: this.generatedContent.cacheKeys || void 0,
+            commonTypes: this.generatedContent.commonTypes || void 0,
+            doNotModify: this.generatedContent.doNotModify || void 0,
+            utils: this.generatedContent.utils || void 0
+          }
+        );
+        results.push(...sharedResults);
+      }
+      if (this.generatedContent.componentSchema) {
+        const schemaResults = await this.fileWriterService.writeSchemaFile(
+          outputDir,
+          this.generatedContent.componentSchema
+        );
+        results.push(...schemaResults);
+      }
+    } catch (error) {
+      errors.push(error);
+    }
+    return {
+      success: errors.length === 0,
+      writtenFiles: results,
+      errors,
+      generatedGroups
+    };
+  }
+  /**
+   * 為單一群組生成內容
+   */
+  async generateApiGroupContent(options, groupInfo) {
+    const { outputFiles, ...commonConfig } = options;
+    const groupOptions = {
+      ...commonConfig,
+      schemaFile: this.actualSchemaFile,
+      outputFile: groupInfo.outputPath,
+      sharedTypesFile: `${outputFiles.outputDir}/common-types.ts`,
+      filterEndpoints: this.groupService.createGroupFilter(groupInfo.groupKey, outputFiles),
+      queryMatch: outputFiles.queryMatch,
+      groupKey: groupInfo.groupKey
+    };
+    if (!this.openApiDoc || !this.parserService) {
+      throw new Error("OpenAPI \u6587\u6A94\u672A\u521D\u59CB\u5316\uFF0C\u8ACB\u5148\u8ABF\u7528 prepare()");
+    }
+    const apiGenerator = new ApiCodeGenerator(this.parserService, groupOptions);
+    const result = await apiGenerator.generate();
+    if (result.files && "allEndpointCacheKeys" in result.files) {
+      const cacheKeys = result.files.allEndpointCacheKeys;
+      this.allEndpointCacheKeys.push(...cacheKeys);
+    }
+    return result;
+  }
+};
+
+// src/index.ts
+async function generateEndpoints(options) {
+  const generator = new UnifiedCodeGenerator(options);
+  const result = await generator.generateAll();
+  if (!result.success) {
+    if (result.errors.length > 0) {
+      throw result.errors[0];
+    }
+  }
+  return;
+}
+export {
+  generateEndpoints
+};
+//# sourceMappingURL=index.mjs.map