api-sdk-gen 1.0.4 → 1.0.5

package/dist/index.js

@@ -3,17 +3,15 @@
 
 // src/generators/typescript/util.ts
 function pascalCase(str) {
-  return str.replace(/(^\w|-\w)/g, clearAndUpper).replace(/_/g, "");
-}
-function clearAndUpper(text) {
-  return text.replace(/-/, "").toUpperCase();
+  return str.replace(/(^|[-_])(\w)/g, (_, __, c) => c.toUpperCase());
 }
 function resolveSchema(ref) {
   const parts = ref.split("#/components/schemas/");
-  return pascalCase(parts[1]);
+  return pascalCase(parts[1] || parts[0]);
 }
 
 // src/generators/typescript/schema_to_ts.ts
+var import_ts_morph = require("ts-morph");
 function schemaToTypeLiteral(schema, doc, refPrefix) {
   return (writer) => {
     if ("$ref" in schema) {
@@ -22,34 +20,79 @@ function schemaToTypeLiteral(schema, doc, refPrefix) {
       writer.write(
         schema.enum.map((value) => JSON.stringify(value)).join(" | ")
       );
+    } else if (schema.allOf && schema.allOf.length > 0) {
+      const uniqueTypes = /* @__PURE__ */ new Set();
+      for (const subSchema of schema.allOf) {
+        const subWriter = new import_ts_morph.CodeBlockWriter();
+        schemaToTypeLiteral(subSchema, doc, refPrefix)(subWriter);
+        const str = subWriter.toString().trim();
+        if (str) uniqueTypes.add(str);
+      }
+      const typesArray = Array.from(uniqueTypes);
+      if (typesArray.length > 1) {
+        writer.write("(");
+        writer.write(typesArray.join(" & "));
+        writer.write(")");
+      } else if (typesArray.length === 1) {
+        writer.write(typesArray[0]);
+      } else {
+        writer.write("unknown");
+      }
     } else if (schema.anyOf || schema.oneOf) {
-      (schema.anyOf || schema.oneOf)?.forEach((subSchema, index) => {
-        if (index > 0) {
-          writer.write(" | ");
+      const items = schema.anyOf || schema.oneOf;
+      if (items && items.length > 0) {
+        const uniqueTypes = /* @__PURE__ */ new Set();
+        for (const subSchema of items) {
+          const subWriter = new import_ts_morph.CodeBlockWriter();
+          schemaToTypeLiteral(subSchema, doc, refPrefix)(subWriter);
+          const str = subWriter.toString().trim();
+          if (str) uniqueTypes.add(str);
         }
-        schemaToTypeLiteral(subSchema, doc, refPrefix)(writer);
-      });
+        const typesArray = Array.from(uniqueTypes);
+        if (typesArray.length > 1) {
+          writer.write("(");
+          writer.write(typesArray.join(" | "));
+          writer.write(")");
+        } else if (typesArray.length === 1) {
+          writer.write(typesArray[0]);
+        } else {
+          writer.write("unknown");
+        }
+      }
+    } else if (schema.type === "object" || !schema.type && schema.properties) {
+      const properties = schema.properties || {};
+      const propEntries = Object.entries(properties);
+      if (propEntries.length === 0) {
+        if (schema.additionalProperties && typeof schema.additionalProperties === "object" && Object.keys(schema.additionalProperties).length > 0) {
+          writer.write("Record<string, ");
+          schemaToTypeLiteral(schema.additionalProperties, doc, refPrefix)(writer);
+          writer.write(">");
+        } else {
+          writer.write("Record<string, unknown>");
+        }
+      } else {
+        const requiredProps = new Set(schema.required || []);
+        writer.write("{").newLine();
+        for (const [propName, propSchema] of propEntries) {
+          writer.indent(() => {
+            writer.write(propName);
+            if (!requiredProps.has(propName)) {
+              writer.write("?");
+            }
+            writer.write(": ");
+            schemaToTypeLiteral(propSchema, doc, refPrefix)(writer);
+            writer.write(";").newLine();
+          });
+        }
+        if (schema.additionalProperties) {
+          writer.indent(() => {
+            writer.write("[k: string]: unknown;").newLine();
+          });
+        }
+        writer.write("}");
+      }
     } else if (schema.type) {
       switch (schema.type) {
-        case "object": {
-          const requiredProps = new Set(schema.required || []);
-          writer.write("{").newLine();
-          for (const [propName, propSchema] of Object.entries(
-            schema.properties || {}
-          )) {
-            writer.indent(() => {
-              writer.write(propName);
-              if (!requiredProps.has(propName)) {
-                writer.write("?");
-              }
-              writer.write(": ");
-              schemaToTypeLiteral(propSchema, doc, refPrefix)(writer);
-              writer.write(";").newLine();
-            });
-          }
-          writer.write("}");
-          break;
-        }
         case "array":
           if (Array.isArray(schema.items)) {
             writer.write("[");
@@ -118,12 +161,33 @@ var jsonSchemaTags = [
   "format",
   "example"
 ];
+var standardFormatsWithRedundantPatterns = /* @__PURE__ */ new Set([
+  "date",
+  "date-time",
+  "uuid",
+  "email",
+  "ipv4",
+  "ipv6",
+  "uri",
+  "url"
+]);
+function shouldIgnorePattern(schema) {
+  const format = schema.format;
+  if (format && standardFormatsWithRedundantPatterns.has(format)) {
+    return true;
+  }
+  const subFormats = (schema.oneOf || schema.anyOf)?.map((s) => s?.format).filter(Boolean);
+  if (subFormats && subFormats.some((f) => standardFormatsWithRedundantPatterns.has(f))) {
+    return true;
+  }
+  return false;
+}
 function createInterfaceModel(doc, file, name, schema) {
   if (!schema.properties || Object.keys(schema.properties).length === 0) {
     file.addTypeAlias({
       name: pascalCase(name),
       isExported: true,
-      type: "{}"
+      type: schema.additionalProperties ? "Record<string, unknown>" : "{}"
     });
     return;
   }
@@ -162,12 +226,23 @@ function generateSchemaDocs(schema, doc) {
     });
   }
   for (const tagName of jsonSchemaTags) {
+    if (tagName === "pattern" && shouldIgnorePattern(schema)) {
+      continue;
+    }
     const value = schema[tagName];
     if (value !== void 0) {
       jsdoc.tags?.push({
         tagName,
         text: String(value)
       });
+    } else if (tagName === "format") {
+      const subFormats = (schema.oneOf || schema.anyOf)?.map((sub) => sub?.format).filter(Boolean);
+      if (subFormats && subFormats.length > 0) {
+        jsdoc.tags?.push({
+          tagName: "format",
+          text: Array.from(new Set(subFormats)).join(" | ")
+        });
+      }
     }
   }
   if (!jsdoc.tags?.length && !jsdoc.description) {
@@ -184,10 +259,7 @@ function generatePropertySignature(doc, propName, propSchema) {
   };
 }
 function createModel(doc, file, name, schema) {
-  if ("$ref" in schema) {
-    return;
-  }
-  if (schema.type === "object" && schema.properties) {
+  if (!("$ref" in schema) && (schema.type === "object" || !schema.type && schema.properties) && schema.properties) {
     createInterfaceModel(doc, file, name, schema);
     return;
   }
@@ -199,19 +271,49 @@ function createModel(doc, file, name, schema) {
     docs: jsdoc ? [jsdoc] : []
   });
 }
+function findReferencedSchemas(obj, refs = /* @__PURE__ */ new Set()) {
+  if (!obj || typeof obj !== "object") return refs;
+  for (const [k, v] of Object.entries(obj)) {
+    if (k === "$ref" && typeof v === "string") {
+      const parts = v.split("#/components/schemas/");
+      if (parts.length > 1 && parts[1]) {
+        refs.add(parts[1]);
+      }
+    } else {
+      findReferencedSchemas(v, refs);
+    }
+  }
+  return refs;
+}
 async function generateModels(file, config, doc) {
   const schemas = doc?.components?.schemas;
-  if (!schemas) {
-    return;
+  if (schemas) {
+    for (const [schemaName, schema] of Object.entries(schemas)) {
+      createModel(doc, file, schemaName, schema);
+    }
   }
-  for (const [schemaName, schema] of Object.entries(schemas)) {
-    createModel(doc, file, schemaName, schema);
+  const referencedSchemas = findReferencedSchemas(doc);
+  for (const refName of referencedSchemas) {
+    const pascalName = pascalCase(refName);
+    if (!file.getTypeAlias(pascalName) && !file.getInterface(pascalName)) {
+      file.addTypeAlias({
+        name: pascalName,
+        isExported: true,
+        type: "Record<string, unknown>",
+        docs: [
+          {
+            description: `Aviso: Este schema n\xE3o existe ou n\xE3o foi declarado na especifica\xE7\xE3o OpenAPI ('#/components/schemas/${refName}').
+Gerado automaticamente como fallback para evitar quebras de refer\xEAncia e erros de compila\xE7\xE3o.`
+          }
+        ]
+      });
+    }
   }
 }
 
 // src/index.ts
 var import_promises = require("fs/promises");
-var import_ts_morph = require("ts-morph");
+var import_ts_morph2 = require("ts-morph");
 var import_node_path = require("path");
 
 // src/generators/typescript/api_generator.ts
@@ -339,28 +441,50 @@ async function generateApiType(file, config, doc) {
 // src/index.ts
 var import_commander = require("commander");
 var program = new import_commander.Command();
-program.name("api-sdk-gen").description("Generate TypeScript SDK from OpenAPI specification").version("1.0.0").requiredOption("-u, --url <url>", "URL of the OpenAPI JSON specification").requiredOption("-b, --base <url>", "Base URL for the API calls").option("-o, --output <dir>", "Output directory", "./output").action(async (options) => {
+program.name("api-sdk-gen").description("Generate TypeScript SDK from OpenAPI specification").version("1.0.0").requiredOption("-u, --url <url>", "URL or file path of the OpenAPI JSON specification").option("-b, --base <url>", "Base URL for the API calls", "http://localhost").option("-o, --output <dir>", "Output directory", "./output").action(async (options) => {
   const config = {
     url: options.url,
     api_base: options.base,
     outputDir: options.output
   };
   try {
-    console.log(`Fetching OpenAPI spec from: ${config.url}...`);
-    const res = await fetch(config.url);
-    if (!res.ok) {
-      throw new Error(`Failed to fetch OpenAPI spec: ${res.statusText}`);
+    let openapi;
+    if (config.url.startsWith("http://") || config.url.startsWith("https://")) {
+      console.log(`Fetching OpenAPI spec from: ${config.url}...`);
+      const res = await fetch(config.url);
+      if (!res.ok) {
+        throw new Error(`Failed to fetch OpenAPI spec: ${res.statusText}`);
+      }
+      openapi = await res.json();
+    } else {
+      console.log(`Reading OpenAPI spec from file: ${config.url}...`);
+      const content = await (0, import_promises.readFile)(config.url, "utf-8");
+      openapi = JSON.parse(content);
     }
-    const openapi = await res.json();
     console.log(`Generating SDK to: ${config.outputDir}...`);
     await (0, import_promises.mkdir)(config.outputDir, { recursive: true });
-    const project = new import_ts_morph.Project();
+    const project = new import_ts_morph2.Project();
     const modelsFile = project.createSourceFile((0, import_node_path.join)(config.outputDir, "models.ts"), "", { overwrite: true });
     const apiFile = project.createSourceFile((0, import_node_path.join)(config.outputDir, "api.ts"), "", { overwrite: true });
-    const templatePath = (0, import_node_path.join)(__dirname, "../templates", "core.ts");
+    const templatePathCandidates = [
+      (0, import_node_path.join)(__dirname, "../templates", "core.ts"),
+      (0, import_node_path.join)(__dirname, "templates", "core.ts"),
+      (0, import_node_path.join)(process.cwd(), "templates", "core.ts")
+    ];
+    let templateContent = "";
+    for (const candidate of templatePathCandidates) {
+      try {
+        templateContent = await (0, import_promises.readFile)(candidate, "utf-8");
+        break;
+      } catch {
+      }
+    }
+    if (!templateContent) {
+      throw new Error("Template core.ts not found");
+    }
     const coreFile = project.createSourceFile(
       (0, import_node_path.join)(config.outputDir, "core.ts"),
-      await (0, import_promises.readFile)(templatePath, "utf-8"),
+      templateContent,
       { overwrite: true }
     );
     await generateModels(modelsFile, config, openapi);

package/dist/index.mjs

@@ -9,17 +9,15 @@ var __dirname = /* @__PURE__ */ getDirname();
 
 // src/generators/typescript/util.ts
 function pascalCase(str) {
-  return str.replace(/(^\w|-\w)/g, clearAndUpper).replace(/_/g, "");
-}
-function clearAndUpper(text) {
-  return text.replace(/-/, "").toUpperCase();
+  return str.replace(/(^|[-_])(\w)/g, (_, __, c) => c.toUpperCase());
 }
 function resolveSchema(ref) {
   const parts = ref.split("#/components/schemas/");
-  return pascalCase(parts[1]);
+  return pascalCase(parts[1] || parts[0]);
 }
 
 // src/generators/typescript/schema_to_ts.ts
+import { CodeBlockWriter } from "ts-morph";
 function schemaToTypeLiteral(schema, doc, refPrefix) {
   return (writer) => {
     if ("$ref" in schema) {
@@ -28,34 +26,79 @@ function schemaToTypeLiteral(schema, doc, refPrefix) {
       writer.write(
         schema.enum.map((value) => JSON.stringify(value)).join(" | ")
       );
+    } else if (schema.allOf && schema.allOf.length > 0) {
+      const uniqueTypes = /* @__PURE__ */ new Set();
+      for (const subSchema of schema.allOf) {
+        const subWriter = new CodeBlockWriter();
+        schemaToTypeLiteral(subSchema, doc, refPrefix)(subWriter);
+        const str = subWriter.toString().trim();
+        if (str) uniqueTypes.add(str);
+      }
+      const typesArray = Array.from(uniqueTypes);
+      if (typesArray.length > 1) {
+        writer.write("(");
+        writer.write(typesArray.join(" & "));
+        writer.write(")");
+      } else if (typesArray.length === 1) {
+        writer.write(typesArray[0]);
+      } else {
+        writer.write("unknown");
+      }
     } else if (schema.anyOf || schema.oneOf) {
-      (schema.anyOf || schema.oneOf)?.forEach((subSchema, index) => {
-        if (index > 0) {
-          writer.write(" | ");
+      const items = schema.anyOf || schema.oneOf;
+      if (items && items.length > 0) {
+        const uniqueTypes = /* @__PURE__ */ new Set();
+        for (const subSchema of items) {
+          const subWriter = new CodeBlockWriter();
+          schemaToTypeLiteral(subSchema, doc, refPrefix)(subWriter);
+          const str = subWriter.toString().trim();
+          if (str) uniqueTypes.add(str);
         }
-        schemaToTypeLiteral(subSchema, doc, refPrefix)(writer);
-      });
+        const typesArray = Array.from(uniqueTypes);
+        if (typesArray.length > 1) {
+          writer.write("(");
+          writer.write(typesArray.join(" | "));
+          writer.write(")");
+        } else if (typesArray.length === 1) {
+          writer.write(typesArray[0]);
+        } else {
+          writer.write("unknown");
+        }
+      }
+    } else if (schema.type === "object" || !schema.type && schema.properties) {
+      const properties = schema.properties || {};
+      const propEntries = Object.entries(properties);
+      if (propEntries.length === 0) {
+        if (schema.additionalProperties && typeof schema.additionalProperties === "object" && Object.keys(schema.additionalProperties).length > 0) {
+          writer.write("Record<string, ");
+          schemaToTypeLiteral(schema.additionalProperties, doc, refPrefix)(writer);
+          writer.write(">");
+        } else {
+          writer.write("Record<string, unknown>");
+        }
+      } else {
+        const requiredProps = new Set(schema.required || []);
+        writer.write("{").newLine();
+        for (const [propName, propSchema] of propEntries) {
+          writer.indent(() => {
+            writer.write(propName);
+            if (!requiredProps.has(propName)) {
+              writer.write("?");
+            }
+            writer.write(": ");
+            schemaToTypeLiteral(propSchema, doc, refPrefix)(writer);
+            writer.write(";").newLine();
+          });
+        }
+        if (schema.additionalProperties) {
+          writer.indent(() => {
+            writer.write("[k: string]: unknown;").newLine();
+          });
+        }
+        writer.write("}");
+      }
     } else if (schema.type) {
       switch (schema.type) {
-        case "object": {
-          const requiredProps = new Set(schema.required || []);
-          writer.write("{").newLine();
-          for (const [propName, propSchema] of Object.entries(
-            schema.properties || {}
-          )) {
-            writer.indent(() => {
-              writer.write(propName);
-              if (!requiredProps.has(propName)) {
-                writer.write("?");
-              }
-              writer.write(": ");
-              schemaToTypeLiteral(propSchema, doc, refPrefix)(writer);
-              writer.write(";").newLine();
-            });
-          }
-          writer.write("}");
-          break;
-        }
         case "array":
           if (Array.isArray(schema.items)) {
             writer.write("[");
@@ -124,12 +167,33 @@ var jsonSchemaTags = [
   "format",
   "example"
 ];
+var standardFormatsWithRedundantPatterns = /* @__PURE__ */ new Set([
+  "date",
+  "date-time",
+  "uuid",
+  "email",
+  "ipv4",
+  "ipv6",
+  "uri",
+  "url"
+]);
+function shouldIgnorePattern(schema) {
+  const format = schema.format;
+  if (format && standardFormatsWithRedundantPatterns.has(format)) {
+    return true;
+  }
+  const subFormats = (schema.oneOf || schema.anyOf)?.map((s) => s?.format).filter(Boolean);
+  if (subFormats && subFormats.some((f) => standardFormatsWithRedundantPatterns.has(f))) {
+    return true;
+  }
+  return false;
+}
 function createInterfaceModel(doc, file, name, schema) {
   if (!schema.properties || Object.keys(schema.properties).length === 0) {
     file.addTypeAlias({
       name: pascalCase(name),
       isExported: true,
-      type: "{}"
+      type: schema.additionalProperties ? "Record<string, unknown>" : "{}"
     });
     return;
   }
@@ -168,12 +232,23 @@ function generateSchemaDocs(schema, doc) {
     });
   }
   for (const tagName of jsonSchemaTags) {
+    if (tagName === "pattern" && shouldIgnorePattern(schema)) {
+      continue;
+    }
     const value = schema[tagName];
     if (value !== void 0) {
       jsdoc.tags?.push({
         tagName,
         text: String(value)
       });
+    } else if (tagName === "format") {
+      const subFormats = (schema.oneOf || schema.anyOf)?.map((sub) => sub?.format).filter(Boolean);
+      if (subFormats && subFormats.length > 0) {
+        jsdoc.tags?.push({
+          tagName: "format",
+          text: Array.from(new Set(subFormats)).join(" | ")
+        });
+      }
     }
   }
   if (!jsdoc.tags?.length && !jsdoc.description) {
@@ -190,10 +265,7 @@ function generatePropertySignature(doc, propName, propSchema) {
   };
 }
 function createModel(doc, file, name, schema) {
-  if ("$ref" in schema) {
-    return;
-  }
-  if (schema.type === "object" && schema.properties) {
+  if (!("$ref" in schema) && (schema.type === "object" || !schema.type && schema.properties) && schema.properties) {
     createInterfaceModel(doc, file, name, schema);
     return;
   }
@@ -205,13 +277,43 @@ function createModel(doc, file, name, schema) {
     docs: jsdoc ? [jsdoc] : []
   });
 }
+function findReferencedSchemas(obj, refs = /* @__PURE__ */ new Set()) {
+  if (!obj || typeof obj !== "object") return refs;
+  for (const [k, v] of Object.entries(obj)) {
+    if (k === "$ref" && typeof v === "string") {
+      const parts = v.split("#/components/schemas/");
+      if (parts.length > 1 && parts[1]) {
+        refs.add(parts[1]);
+      }
+    } else {
+      findReferencedSchemas(v, refs);
+    }
+  }
+  return refs;
+}
 async function generateModels(file, config, doc) {
   const schemas = doc?.components?.schemas;
-  if (!schemas) {
-    return;
+  if (schemas) {
+    for (const [schemaName, schema] of Object.entries(schemas)) {
+      createModel(doc, file, schemaName, schema);
+    }
   }
-  for (const [schemaName, schema] of Object.entries(schemas)) {
-    createModel(doc, file, schemaName, schema);
+  const referencedSchemas = findReferencedSchemas(doc);
+  for (const refName of referencedSchemas) {
+    const pascalName = pascalCase(refName);
+    if (!file.getTypeAlias(pascalName) && !file.getInterface(pascalName)) {
+      file.addTypeAlias({
+        name: pascalName,
+        isExported: true,
+        type: "Record<string, unknown>",
+        docs: [
+          {
+            description: `Aviso: Este schema n\xE3o existe ou n\xE3o foi declarado na especifica\xE7\xE3o OpenAPI ('#/components/schemas/${refName}').
+Gerado automaticamente como fallback para evitar quebras de refer\xEAncia e erros de compila\xE7\xE3o.`
+          }
+        ]
+      });
+    }
   }
 }
 
@@ -345,28 +447,50 @@ async function generateApiType(file, config, doc) {
 // src/index.ts
 import { Command } from "commander";
 var program = new Command();
-program.name("api-sdk-gen").description("Generate TypeScript SDK from OpenAPI specification").version("1.0.0").requiredOption("-u, --url <url>", "URL of the OpenAPI JSON specification").requiredOption("-b, --base <url>", "Base URL for the API calls").option("-o, --output <dir>", "Output directory", "./output").action(async (options) => {
+program.name("api-sdk-gen").description("Generate TypeScript SDK from OpenAPI specification").version("1.0.0").requiredOption("-u, --url <url>", "URL or file path of the OpenAPI JSON specification").option("-b, --base <url>", "Base URL for the API calls", "http://localhost").option("-o, --output <dir>", "Output directory", "./output").action(async (options) => {
   const config = {
     url: options.url,
     api_base: options.base,
     outputDir: options.output
   };
   try {
-    console.log(`Fetching OpenAPI spec from: ${config.url}...`);
-    const res = await fetch(config.url);
-    if (!res.ok) {
-      throw new Error(`Failed to fetch OpenAPI spec: ${res.statusText}`);
+    let openapi;
+    if (config.url.startsWith("http://") || config.url.startsWith("https://")) {
+      console.log(`Fetching OpenAPI spec from: ${config.url}...`);
+      const res = await fetch(config.url);
+      if (!res.ok) {
+        throw new Error(`Failed to fetch OpenAPI spec: ${res.statusText}`);
+      }
+      openapi = await res.json();
+    } else {
+      console.log(`Reading OpenAPI spec from file: ${config.url}...`);
+      const content = await readFile(config.url, "utf-8");
+      openapi = JSON.parse(content);
     }
-    const openapi = await res.json();
     console.log(`Generating SDK to: ${config.outputDir}...`);
     await mkdir(config.outputDir, { recursive: true });
     const project = new Project();
     const modelsFile = project.createSourceFile(join(config.outputDir, "models.ts"), "", { overwrite: true });
     const apiFile = project.createSourceFile(join(config.outputDir, "api.ts"), "", { overwrite: true });
-    const templatePath = join(__dirname, "../templates", "core.ts");
+    const templatePathCandidates = [
+      join(__dirname, "../templates", "core.ts"),
+      join(__dirname, "templates", "core.ts"),
+      join(process.cwd(), "templates", "core.ts")
+    ];
+    let templateContent = "";
+    for (const candidate of templatePathCandidates) {
+      try {
+        templateContent = await readFile(candidate, "utf-8");
+        break;
+      } catch {
+      }
+    }
+    if (!templateContent) {
+      throw new Error("Template core.ts not found");
+    }
     const coreFile = project.createSourceFile(
       join(config.outputDir, "core.ts"),
-      await readFile(templatePath, "utf-8"),
+      templateContent,
       { overwrite: true }
     );
     await generateModels(modelsFile, config, openapi);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "api-sdk-gen",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

package/templates/core.ts

@@ -27,5 +27,16 @@ type Pretty<T> = {
   [K in keyof T]: T[K];
 };
 
-export type QueryParams<Api extends ApiDoc, Path extends keyof Api, Method extends keyof Api[Path]> = Api[Path][Method] extends { parameters: infer P } ? P : never
-export type ResponseStatus<Api extends ApiDoc, Path extends keyof Api, Method extends keyof Api[Path], Status extends keyof Api[Path][Method]['responses']> = Api[Path][Method]['responses'][Status]
+export type QueryParams<Api extends ApiDoc, Path extends keyof Api, Method extends keyof Api[Path]> = Api[Path][Method] extends { parameters: infer P } ? P : never;
+export type ResponseStatus<
+  Api extends ApiDoc,
+  Path extends keyof Api,
+  Method extends keyof Api[Path],
+  Status extends Api[Path][Method] extends { responses: Record<string | number, any> }
+    ? keyof Api[Path][Method]['responses']
+    : never
+> = Api[Path][Method] extends { responses: infer R }
+  ? Status extends keyof R
+    ? R[Status]
+    : never
+  : never;