api-core-lib 12.0.65 → 12.0.67

package/dist/cli.cjs

@@ -69,76 +69,114 @@ var import_path2 = __toESM(require("path"), 1);
 // src/generator/index.ts
 var import_fs = __toESM(require("fs"), 1);
 var import_path = __toESM(require("path"), 1);
+var import_util = __toESM(require("util"), 1);
 var import_chalk = __toESM(require("chalk"), 1);
 var import_dotenv = __toESM(require("dotenv"), 1);
 var import_swagger_parser = __toESM(require("@apidevtools/swagger-parser"), 1);
 var import_openapi_types = __toESM(require_dist(), 1);
 var import_json_schema_to_typescript = require("json-schema-to-typescript");
+var DEBUG_MODE = process.env.DEBUG === "true";
+var debugLog = (title, data) => {
+  if (DEBUG_MODE) {
+    console.log(import_chalk.default.yellow(`
+[DEBUG: ${title}]`));
+    console.log(import_util.default.inspect(data, { depth: null, colors: true }));
+  }
+};
+var toPascalCase = (str) => str.replace(/[^a-zA-Z0-9_]/g, " ").replace(/(?:^\w|[A-Z]|\b\w)/g, (w) => w.toUpperCase()).replace(/\s+/g, "");
+var getModuleNameFromOpId = (opId) => `${opId.split("_")[0].replace(/Controller$/, "")}Api`;
+var getActionNameFromOpId = (opId) => (opId.split("_")[1] || opId).replace(/^\w/, (c) => c.toLowerCase());
+var findCommonBasePath = (paths) => {
+  if (!paths || paths.length === 0) return "/";
+  const sorted = [...paths].sort();
+  const first = sorted[0];
+  const last = sorted[sorted.length - 1];
+  let i = 0;
+  while (i < first.length && first.charAt(i) === last.charAt(i)) i++;
+  const prefix = first.substring(0, i);
+  return prefix.substring(0, prefix.lastIndexOf("/") + 1) || "/";
+};
 function parseSpecToModules(spec) {
-  const modules = {};
-  if (!spec.components) spec.components = {};
-  if (!spec.components.schemas) spec.components.schemas = {};
+  const modules = /* @__PURE__ */ new Map();
+  const allSchemas = /* @__PURE__ */ new Map();
+  const modulePaths = /* @__PURE__ */ new Map();
+  if (spec.components?.schemas) {
+    for (const schemaName in spec.components.schemas) {
+      allSchemas.set(schemaName, { name: schemaName, schema: spec.components.schemas[schemaName] });
+    }
+  }
   for (const apiPath in spec.paths) {
     const pathItem = spec.paths[apiPath];
     if (!pathItem) continue;
     for (const method in pathItem) {
       if (!Object.values(import_openapi_types.OpenAPIV3.HttpMethods).includes(method)) continue;
       const endpoint = pathItem[method];
-      if (!endpoint.tags || endpoint.tags.length === 0) continue;
-      const tagName = endpoint.tags[0];
-      const moduleName = _sanitizeTagName(tagName) + "Api";
-      if (!modules[moduleName]) {
-        modules[moduleName] = { baseEndpoint: _findCommonBasePath(spec, tagName), actions: {}, types: /* @__PURE__ */ new Set() };
+      if (!endpoint.operationId) continue;
+      const moduleName = getModuleNameFromOpId(endpoint.operationId);
+      if (!modules.has(moduleName)) {
+        modules.set(moduleName, { moduleName, baseEndpoint: "", actions: {}, schemas: /* @__PURE__ */ new Set() });
+        modulePaths.set(moduleName, []);
       }
-      const currentModule = modules[moduleName];
-      const { inputType, outputType } = _extractInputOutputTypes(endpoint, spec.components.schemas);
+      const currentModule = modules.get(moduleName);
+      modulePaths.get(moduleName).push(apiPath);
+      const { inputType, outputType } = _extractAndRegisterTypes(endpoint, allSchemas);
       [inputType, outputType].forEach((t) => {
-        if (t && !["unknown", "undefined", "void", "any", "QueryOptions", "Promise"].includes(t)) {
-          currentModule.types.add(t.replace("[]", ""));
+        const cleanType = t.replace("[]", "");
+        if (cleanType && !["unknown", "undefined", "void", "any", "QueryOptions", "Promise"].includes(cleanType)) {
+          currentModule.schemas.add(cleanType);
         }
       });
-      const actionName = _sanitizeActionName(endpoint.operationId, method, apiPath);
-      const relativePath = apiPath.replace(currentModule.baseEndpoint, "").replace(/^\//, "");
+      const actionName = getActionNameFromOpId(endpoint.operationId);
       currentModule.actions[actionName] = {
         method: method.toUpperCase(),
-        path: relativePath === "" ? "/" : relativePath,
+        path: apiPath,
         description: endpoint.summary || "",
         hasQuery: (endpoint.parameters || []).some((p) => p.in === "query"),
         autoFetch: method.toUpperCase() === "GET" && !apiPath.includes("{"),
-        invalidates: [],
+        requiresAuth: !!endpoint.security && endpoint.security.length > 0,
         _inputType: inputType,
         _outputType: outputType
       };
+      debugLog("Parsed Action", { moduleName, actionName, ...currentModule.actions[actionName] });
     }
   }
-  return modules;
+  modules.forEach((mod, name) => {
+    const basePath = findCommonBasePath(modulePaths.get(name));
+    mod.baseEndpoint = basePath;
+    Object.values(mod.actions).forEach((action) => {
+      const relativePath = action.path.replace(basePath, "").replace(/^\//, "");
+      action.path = relativePath === "" ? "/" : relativePath;
+    });
+  });
+  return { modules, allSchemas };
 }
-function _extractInputOutputTypes(endpoint, schemas) {
-  const operationId = endpoint.operationId || "UnnamedOperation";
-  const successResponseKey = Object.keys(endpoint.responses).find((code) => code.startsWith("2"));
-  const successResponse = successResponseKey ? endpoint.responses[successResponseKey] : void 0;
-  const responseSchema = successResponse?.content?.["application/json"]?.schema;
-  const outputType = successResponseKey === "204" ? "void" : _schemaToTypeName(responseSchema, `${operationId}Response`, schemas);
-  const requestBody = endpoint.requestBody;
-  const requestSchema = requestBody?.content?.["application/json"]?.schema;
+function _extractAndRegisterTypes(endpoint, allSchemas) {
+  const opId = endpoint.operationId || "Unnamed";
+  const successKey = Object.keys(endpoint.responses).find((c) => c.startsWith("2"));
+  const successRes = successKey ? endpoint.responses[successKey] : void 0;
+  const resSchema = successRes?.content?.["application/json"]?.schema;
+  const outputType = successKey === "204" ? "void" : _schemaToTypeName(resSchema, `${opId}Response`, allSchemas);
+  const reqBody = endpoint.requestBody;
+  const reqSchema = reqBody?.content?.["application/json"]?.schema;
   let inputType = "undefined";
-  if (requestSchema) {
-    inputType = _schemaToTypeName(requestSchema, `${operationId}Request`, schemas);
+  if (reqSchema) {
+    inputType = _schemaToTypeName(reqSchema, `${opId}Request`, allSchemas);
   } else if ((endpoint.parameters || []).some((p) => p.in === "query")) {
     inputType = "QueryOptions";
   }
   return { inputType, outputType };
 }
-function _schemaToTypeName(schema, name, schemas) {
+function _schemaToTypeName(schema, name, allSchemas) {
   if (!schema) return "unknown";
   if (schema.type === "array" && schema.items) {
-    const itemTypeName = _schemaToTypeName(schema.items, `${name}Item`, schemas);
+    const itemTypeName = _schemaToTypeName(schema.items, `${name}Item`, allSchemas);
     return `${itemTypeName}[]`;
   }
-  if (schema.type === "object" || schema.properties || schema.allOf) {
-    const typeName = _toPascalCase(name) + "Dto";
-    if (!schemas[typeName]) {
-      schemas[typeName] = schema;
+  if (schema.type === "object" || schema.properties || schema.allOf || !schema.type) {
+    const typeName = toPascalCase(name);
+    if (!allSchemas.has(typeName)) {
+      debugLog("Registering new inline schema", { assignedName: typeName, originalSchema: schema });
+      allSchemas.set(typeName, { name: typeName, schema });
     }
     return typeName;
   }
@@ -147,155 +185,190 @@ function _schemaToTypeName(schema, name, schemas) {
   }
   return "unknown";
 }
-async function generateModuleFiles(moduleName, moduleData, allSchemas, outputDir) {
-  console.log(import_chalk.default.gray(`  Generating files for module: ${import_chalk.default.bold(moduleName)}...`));
-  const moduleFolderPath = import_path.default.join(outputDir, moduleName);
-  if (!import_fs.default.existsSync(moduleFolderPath)) import_fs.default.mkdirSync(moduleFolderPath, { recursive: true });
-  await _generateTypesFile(moduleFolderPath, moduleName, moduleData.types, allSchemas);
-  await _generateConfigFile(moduleFolderPath, moduleName, moduleData);
-}
-async function _generateTypesFile(moduleFolderPath, moduleName, typeNames, allSchemas) {
-  if (typeNames.size === 0) {
-    console.log(import_chalk.default.yellow(`    - No types found for module "${moduleName}". Skipping types.ts generation.`));
-    return;
-  }
-  console.log(import_chalk.default.gray(`    - Generating types.ts with ${typeNames.size} types...`));
-  let typesContent = `// This file is auto-generated by the API generator. Do not edit.
+async function generateModuleFiles(module2, allSchemas, outputDir) {
+  const moduleName = module2.moduleName;
+  const moduleOutputPath = import_path.default.join(outputDir, moduleName);
+  if (!import_fs.default.existsSync(moduleOutputPath)) import_fs.default.mkdirSync(moduleOutputPath, { recursive: true });
+  console.log(import_chalk.default.cyan(`
+  Generating module: ${import_chalk.default.bold(moduleName)}`));
+  const typesToImport = [...module2.schemas].sort();
+  let configContent = `/* eslint-disable */
+// This file is auto-generated.
 
+import type { ApiModuleConfig, ActionConfigModule, QueryOptions } from 'api-core-lib';
 `;
-  const compilationOptions = {
-    bannerComment: "",
-    style: { bracketSpacing: true, printWidth: 120, semi: true, singleQuote: true, tabWidth: 2, trailingComma: "es5", useTabs: false },
-    additionalProperties: false
-  };
-  for (const typeName of Array.from(typeNames).sort()) {
-    const schema = allSchemas[typeName];
-    if (schema) {
+  if (typesToImport.length > 0) configContent += `import type { ${typesToImport.join(", ")} } from './types';
+`;
+  const actionsType = Object.values(module2.actions).map((a) => `  ${getActionNameFromOpId(a.path)}: ActionConfigModule<${a._inputType}, ${a._outputType}>;`).join("\n");
+  const actionsValue = Object.values(module2.actions).map((a) => {
+    const { _inputType, _outputType, ...config } = a;
+    return `    ${getActionNameFromOpId(a.path)}: ${JSON.stringify(config, null, 2).replace(/\n/g, "\n    ")}`;
+  }).join(",\n");
+  configContent += `
+export const ${moduleName}Module: ApiModuleConfig<{
+${actionsType}
+}> = {
+  baseEndpoint: '${module2.baseEndpoint}',
+  actions: {
+${actionsValue}
+  },
+};
+`;
+  import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "config.ts"), configContent.trim(), { encoding: "utf-8" });
+  console.log(import_chalk.default.gray(`    \u2713 config.ts`));
+  if (typesToImport.length === 0) return;
+  let typesContent = `// This file is auto-generated.
+
+`;
+  const tsOptions = { bannerComment: "", style: { bracketSpacing: true, printWidth: 120, semi: true, singleQuote: true, tabWidth: 2 }, additionalProperties: false };
+  for (const typeName of typesToImport) {
+    const parsedSchema = allSchemas.get(typeName);
+    if (parsedSchema) {
       try {
-        const tsType = await (0, import_json_schema_to_typescript.compile)(schema, typeName, compilationOptions);
+        const tsType = await (0, import_json_schema_to_typescript.compile)(parsedSchema.schema, typeName, tsOptions);
         typesContent += tsType + "\n";
-      } catch (compileError) {
-        console.error(import_chalk.default.red(`    - Error compiling type "${typeName}": ${compileError.message}`));
+      } catch (e) {
+        console.error(import_chalk.default.red(`    - Error compiling type "${typeName}": ${e.message}`));
       }
-    } else {
-      console.log(import_chalk.default.yellow(`    - Warning: Schema for type "${typeName}" not found, skipping.`));
     }
   }
-  const typesFilePath = import_path.default.join(moduleFolderPath, "types.ts");
-  import_fs.default.writeFileSync(typesFilePath, typesContent, { encoding: "utf-8" });
-}
-async function _generateConfigFile(moduleFolderPath, moduleName, moduleData) {
-  const actionsCount = Object.keys(moduleData.actions).length;
-  console.log(import_chalk.default.gray(`    - Generating config.ts with ${actionsCount} actions...`));
-  const typeNamesArray = [...moduleData.types].sort();
-  const typesImportStatement = typeNamesArray.length > 0 ? `import type { ${typeNamesArray.join(", ")} } from './types';` : ``;
-  const actionsTypeParts = Object.entries(moduleData.actions).map(
-    ([actionName, actionData]) => `  ${actionName}: ActionConfigModule<${actionData._inputType}, ${actionData._outputType}>;`
-  );
-  const actionsTypeDefinition = `{
-${actionsTypeParts.join("\n")}
-}`;
-  const actionsValueParts = Object.entries(moduleData.actions).map(([actionName, actionData]) => {
-    const { _inputType, _outputType, ...config } = actionData;
-    return `    ${actionName}: ${JSON.stringify(config, null, 2).replace(/\n/g, "\n    ")}`;
-  });
-  const actionsValueDefinition = `{
-${actionsValueParts.join(",\n")}
-  }`;
-  const configContent = `/* eslint-disable */
-// This file is auto-generated...
+  import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "types.ts"), typesContent, { encoding: "utf-8" });
+  console.log(import_chalk.default.gray(`    \u2713 types.ts`));
+  let validationContent = `// This file is auto-generated.
+import { z } from 'zod';
 
-import type { ApiModuleConfig, ActionConfigModule, QueryOptions } from 'api-core-lib';
-${typesImportStatement}
+`;
+  for (const typeName of typesToImport) {
+    const parsedSchema = allSchemas.get(typeName);
+    if (parsedSchema?.schema.type === "object") {
+      validationContent += `export const ${typeName}Schema = ${_schemaToZod(parsedSchema.schema)};
 
-export const ${moduleName}Module: ApiModuleConfig<${actionsTypeDefinition}> = {
-  baseEndpoint: '${moduleData.baseEndpoint}',
-  actions: ${actionsValueDefinition},
-};
 `;
-  const configFilePath = import_path.default.join(moduleFolderPath, "config.ts");
-  import_fs.default.writeFileSync(configFilePath, configContent.trim(), { encoding: "utf-8" });
-}
-function _toPascalCase(str) {
-  return str.replace(/[^a-zA-Z0-9]/g, " ").replace(/(?:^\w|[A-Z]|\b\w)/g, (w) => w.toUpperCase()).replace(/\s+/g, "");
+    }
+  }
+  import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "validation.ts"), validationContent, { encoding: "utf-8" });
+  console.log(import_chalk.default.gray(`    \u2713 validation.ts`));
+  let mocksContent = `// This file is auto-generated.
+import type { ${typesToImport.join(", ")} } from './types';
+
+`;
+  for (const typeName of typesToImport) {
+    const parsedSchema = allSchemas.get(typeName);
+    if (parsedSchema) {
+      mocksContent += `export const mock${typeName}: ${typeName} = ${JSON.stringify(_schemaToMock(parsedSchema.schema), null, 2)};
+
+`;
+    }
+  }
+  import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "mocks.ts"), mocksContent, { encoding: "utf-8" });
+  console.log(import_chalk.default.gray(`    \u2713 mocks.ts`));
+  let indexContent = `// This file is auto-generated.
+
+export * from './config';
+export * from './types';
+export * from './validation';
+export * from './mocks';
+`;
+  import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "index.ts"), indexContent, { encoding: "utf-8" });
+  console.log(import_chalk.default.gray(`    \u2713 index.ts`));
 }
-function _sanitizeTagName(tagName) {
-  return tagName.replace(/[^a-zA-Z0-9]/g, "").replace(/Central|Tenant/g, "");
+function _schemaToZod(schema) {
+  const shape = [];
+  if (schema.properties) {
+    for (const [key, prop] of Object.entries(schema.properties)) {
+      shape.push(`  ${key}: ${_propToZod(prop, (schema.required || []).includes(key))}`);
+    }
+  }
+  return `z.object({
+${shape.join(",\n")}
+})`;
 }
-function _sanitizeActionName(operationId, method, path3) {
-  if (operationId) {
-    const name = operationId.split("_").slice(1).join("_");
-    const sanitized = name.charAt(0).toLowerCase() + name.slice(1).replace(/_v\d+$/, "");
-    return sanitized || "action";
+function _propToZod(prop, isRequired) {
+  let zodString = "z.any()";
+  switch (prop.type) {
+    case "string":
+      zodString = "z.string()";
+      if (prop.format === "email") zodString += ".email()";
+      if (prop.format === "uuid") zodString += ".uuid()";
+      if (prop.enum) zodString = `z.enum(${JSON.stringify(prop.enum)})`;
+      break;
+    case "integer":
+    case "number":
+      zodString = "z.number()";
+      if (prop.minimum !== void 0) zodString += `.min(${prop.minimum})`;
+      if (prop.maximum !== void 0) zodString += `.max(${prop.maximum})`;
+      break;
+    case "boolean":
+      zodString = "z.boolean()";
+      break;
+    case "array":
+      zodString = `z.array(${prop.items ? _propToZod(prop.items, true) : "z.any()"})`;
+      break;
+    case "object":
+      zodString = _schemaToZod(prop);
+      break;
   }
-  const pathPart = path3.replace(/[\/{}]/g, "_").replace(/^_|_$/g, "");
-  return `${method.toLowerCase()}_${pathPart}`;
+  return isRequired ? zodString : `${zodString}.optional().nullable()`;
 }
-function _findCommonBasePath(spec, tagName) {
-  const paths = Object.keys(spec.paths).filter((p) => {
-    const pathItem = spec.paths[p];
-    if (!pathItem) return false;
-    for (const method in pathItem) {
-      const endpoint = pathItem[method];
-      if (endpoint.tags?.includes(tagName)) return true;
-    }
-    return false;
-  });
-  if (paths.length === 0) return "/";
-  let commonPrefix = paths[0];
-  for (let i = 1; i < paths.length; i++) {
-    while (paths[i].indexOf(commonPrefix) !== 0) {
-      commonPrefix = commonPrefix.substring(0, commonPrefix.length - 1);
-    }
+function _schemaToMock(schema) {
+  if (schema.example) return schema.example;
+  switch (schema.type) {
+    case "string":
+      if (schema.format === "email") return "test@example.com";
+      if (schema.format === "uuid") return "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11";
+      if (schema.enum) return schema.enum[0];
+      return "Mock String";
+    case "integer":
+    case "number":
+      return 1;
+    case "boolean":
+      return true;
+    case "array":
+      return schema.items ? [_schemaToMock(schema.items)] : [];
+    case "object":
+      const mock = {};
+      if (schema.properties) {
+        for (const [key, prop] of Object.entries(schema.properties)) {
+          mock[key] = _schemaToMock(prop);
+        }
+      }
+      return mock;
+    default:
+      return null;
   }
-  return commonPrefix.substring(0, commonPrefix.lastIndexOf("/") + 1) || "/";
 }
-async function runGenerator(options) {
-  console.log(import_chalk.default.cyan.bold("\u{1F680} Starting API Core Lib Code Generator..."));
+async function runGenerator() {
+  const options = {
+    output: "src/lib/api",
+    envPath: ".env"
+  };
+  console.log(import_chalk.default.cyan.bold("\u{1F680} Starting API Development Platform Generator..."));
   import_dotenv.default.config({ path: options.envPath });
-  const specUrl = getSpecUrl();
+  const specUrl = process.env.OPENAPI_SPEC_URL || "./swagger.json";
   console.log(import_chalk.default.blue("\u2713 Step 1: Environment variables loaded."));
   try {
     console.log(import_chalk.default.blue(`
 \u23F3 Step 2: Fetching and fully dereferencing spec from ${specUrl}...`));
-    const dereferencedSpec = await import_swagger_parser.default.dereference(specUrl);
+    const spec = await import_swagger_parser.default.dereference(specUrl);
     console.log(import_chalk.default.green("\u2713 Spec fetched and fully dereferenced successfully."));
-    console.log(import_chalk.default.blue("\n\u23F3 Step 3: Parsing spec and generating API modules structure..."));
-    const modules = parseSpecToModules(dereferencedSpec);
-    const modulesCount = Object.keys(modules).length;
-    console.log(import_chalk.default.green(`\u2713 Found ${modulesCount} modules to generate.`));
-    if (modulesCount === 0) {
-      console.log(import_chalk.default.yellow("Warning: No modules were found in the spec."));
+    debugLog("Dereferenced Spec", spec);
+    console.log(import_chalk.default.blue("\n\u23F3 Step 3: Parsing spec using intelligent grouping..."));
+    const { modules, allSchemas } = parseSpecToModules(spec);
+    console.log(import_chalk.default.green(`\u2713 Found and grouped ${modules.size} logical modules.`));
+    debugLog("Parsed Modules", Object.fromEntries(modules));
+    console.log(import_chalk.default.blue("\n\u23F3 Step 4: Generating all module files..."));
+    for (const module2 of modules.values()) {
+      await generateModuleFiles(module2, allSchemas, options.output);
     }
-    console.log(import_chalk.default.blue("\n\u23F3 Step 4: Generating module files..."));
-    const modulesOutputPath = import_path.default.join(options.output, "modules");
-    const allSchemas = dereferencedSpec.components?.schemas || {};
-    for (const moduleName in modules) {
-      const moduleData = modules[moduleName];
-      await generateModuleFiles(moduleName, moduleData, allSchemas, modulesOutputPath);
-    }
-    console.log(import_chalk.default.green("\u2713 All module files generated."));
+    console.log(import_chalk.default.green("\n\u2713 All module files generated successfully."));
     console.log(import_chalk.default.bold.green("\n\u{1F389} API generation complete!"));
     console.log(import_chalk.default.bold.cyan(`   Output directory: ${options.output}`));
   } catch (error) {
-    handleGenerationError(error);
-  }
-}
-function getSpecUrl() {
-  const specUrl = process.env.OPENAPI_SPEC_URL || "./swagger.json";
-  if (!specUrl) {
-    console.error(import_chalk.default.red.bold("\n\u274C Error: API specification URL not found."));
+    console.error(import_chalk.default.red.bold("\n\u274C An error occurred during generation:"));
+    console.error(import_chalk.default.red(`Error Message: ${error.message}`));
+    if (error.stack && DEBUG_MODE) console.error(import_chalk.default.gray(error.stack));
     process.exit(1);
   }
-  return specUrl;
-}
-function handleGenerationError(error) {
-  console.error(import_chalk.default.red.bold("\n\u274C An error occurred during generation:"));
-  console.error(import_chalk.default.red(`Error Message: ${error.message}`));
-  if (error.stack) {
-    console.error(import_chalk.default.gray(error.stack));
-  }
-  process.exit(1);
 }
 
 // src/cli.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "api-core-lib",
-  "version": "12.0.65",
+  "version": "12.0.67",
   "description": "A flexible and powerful API client library for modern web applications.",
   "type": "module",
   "exports": {
@@ -42,24 +42,27 @@
     "chalk": "^4.1.2",
     "colorette": "^2.0.20",
     "commander": "^9.4.1",
-    "dotenv": "^16.0.3",
+    "dotenv": "^16.6.1",
     "fast-deep-equal": "^3.1.3",
     "fs-extra": "^11.3.1",
     "json-schema-to-typescript": "^15.0.4",
     "openapi-typescript": "^6.2.4",
     "openapi-typescript-codegen": "^0.29.0",
     "path": "^0.12.7",
-    "uuid": "^9.0.1"
+    "swagger-parser": "^10.0.3",
+    "uuid": "^9.0.1",
+    "zod": "^4.1.5"
   },
   "devDependencies": {
     "@openapitools/openapi-generator-cli": "^2.23.1",
     "@types/fs-extra": "^11.0.4",
     "@types/jest": "^30.0.0",
-    "@types/node": "^24.2.1",
+    "@types/node": "^24.3.0",
     "@types/react": "^18.3.2",
     "@types/uuid": "^9.0.8",
     "javascript-obfuscator": "^4.1.1",
     "jest": "^30.0.5",
+    "openapi-types": "^12.1.3",
     "react": "19.1.0",
     "react-dom": "19.1.0",
     "ts-jest": "^29.4.1",