@sdk-it/typescript 0.19.0 → 0.20.0

package/dist/index.js

@@ -1,137 +1,16 @@
 // packages/typescript/src/lib/generate.ts
 import { template as template2 } from "lodash-es";
-import { join as join3 } from "node:path";
+import { join as join2 } from "node:path";
 import { npmRunPathEnv } from "npm-run-path";
 import { spinalcase as spinalcase3 } from "stringcase";
-
-// packages/core/dist/index.js
+import { methods, pascalcase as pascalcase3 } from "@sdk-it/core";
 import {
-  pascalcase as _pascalcase,
-  snakecase as _snakecase,
-  spinalcase as _spinalcase
-} from "stringcase";
-import ts, { TypeFlags, symbolName } from "typescript";
-import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
-import { dirname, extname, isAbsolute, join } from "node:path";
-import debug from "debug";
-import ts2 from "typescript";
-import { get } from "lodash-es";
-var deriveSymbol = Symbol.for("serialize");
-var $types = Symbol.for("types");
-async function exist(file) {
-  return stat(file).then(() => true).catch(() => false);
-}
-async function writeFiles(dir, contents) {
-  await Promise.all(
-    Object.entries(contents).map(async ([file, content]) => {
-      if (content === null) {
-        return;
-      }
-      const filePath = isAbsolute(file) ? file : join(dir, file);
-      await mkdir(dirname(filePath), { recursive: true });
-      if (typeof content === "string") {
-        await writeFile(filePath, content, "utf-8");
-      } else {
-        if (content.ignoreIfExists) {
-          if (!await exist(filePath)) {
-            await writeFile(filePath, content.content, "utf-8");
-          }
-        } else {
-          await writeFile(filePath, content.content, "utf-8");
-        }
-      }
-    })
-  );
-}
-async function getFolderExports(folder, includeExtension = true, extensions = ["ts"], ignore = () => false) {
-  const files = await readdir(folder, { withFileTypes: true });
-  const exports = [];
-  for (const file of files) {
-    if (ignore(file)) {
-      continue;
-    }
-    if (file.isDirectory()) {
-      if (await exist(`${file.parentPath}/${file.name}/index.ts`)) {
-        exports.push(
-          `export * from './${file.name}/index${includeExtension ? ".ts" : ""}';`
-        );
-      }
-    } else if (file.name !== "index.ts" && extensions.includes(getExt(file.name))) {
-      exports.push(
-        `export * from './${includeExtension ? file.name : file.name.replace(extname(file.name), "")}';`
-      );
-    }
-  }
-  return exports.join("\n");
-}
-var getExt = (fileName) => {
-  if (!fileName) {
-    return "";
-  }
-  const lastDot = fileName.lastIndexOf(".");
-  if (lastDot === -1) {
-    return "";
-  }
-  const ext = fileName.slice(lastDot + 1).split("/").filter(Boolean).join("");
-  if (ext === fileName) {
-    return "";
-  }
-  return ext || "txt";
-};
-var methods = [
-  "get",
-  "post",
-  "put",
-  "patch",
-  "delete",
-  "trace",
-  "head"
-];
-var logger = debug("january:client");
-function isRef(obj) {
-  return obj && "$ref" in obj;
-}
-function cleanRef(ref) {
-  return ref.replace(/^#\//, "");
-}
-function parseRef(ref) {
-  const parts = ref.split("/");
-  const [model] = parts.splice(-1);
-  const [namespace] = parts.splice(-1);
-  return {
-    model,
-    namespace,
-    path: cleanRef(parts.join("/"))
-  };
-}
-function followRef(spec, ref) {
-  const pathParts = cleanRef(ref).split("/");
-  const entry = get(spec, pathParts);
-  if (entry && "$ref" in entry) {
-    return followRef(spec, entry.$ref);
-  }
-  return entry;
-}
-function removeDuplicates(data, accessor = (item) => item) {
-  return [...new Map(data.map((x) => [accessor(x), x])).values()];
-}
-function toLitObject(obj, accessor = (value) => value) {
-  return `{${Object.keys(obj).map((key) => `${key}: ${accessor(obj[key])}`).join(", ")}}`;
-}
-function isEmpty(value) {
-  if (value === null || value === void 0 || value === "") {
-    return true;
-  }
-  if (Array.isArray(value) && value.length === 0) {
-    return true;
-  }
-  if (typeof value === "object" && Object.keys(value).length === 0) {
-    return true;
-  }
-  return false;
-}
+  getFolderExports,
+  writeFiles
+} from "@sdk-it/core/file-system.js";
 
 // packages/typescript/src/lib/client.ts
+import { toLitObject } from "@sdk-it/core";
 var client_default = (spec, style) => {
   const optionsEntries = Object.entries(spec.options).map(
     ([key, value]) => [`'${key}'`, value]
@@ -255,11 +134,13 @@ export class ${spec.name} {
 
 // packages/typescript/src/lib/generator.ts
 import { merge, template } from "lodash-es";
-import { join as join2 } from "node:path";
+import { join } from "node:path";
 import { camelcase as camelcase3, pascalcase as pascalcase2, spinalcase as spinalcase2 } from "stringcase";
+import { followRef as followRef5, isEmpty, isRef as isRef6 } from "@sdk-it/core";
 
 // packages/spec/dist/lib/operation.js
 import { camelcase } from "stringcase";
+import { followRef, isRef } from "@sdk-it/core";
 var defaults = {
   operationId: (operation, path, method) => {
     if (operation.operationId) {
@@ -274,9 +155,18 @@ var defaults = {
     );
   },
   tag: (operation, path) => {
-    return operation.tags?.[0] || determineGenericTag(path, operation);
+    return operation.tags?.[0] ? sanitizeTag(operation.tags?.[0]) : determineGenericTag(path, operation);
   }
 };
+function resolveResponses(spec, operation) {
+  const responses = operation.responses ?? {};
+  const resolved = {};
+  for (const status in responses) {
+    const response = isRef(responses[status]) ? followRef(spec, responses[status].$ref) : responses[status];
+    resolved[status] = response;
+  }
+  return resolved;
+}
 function forEachOperation(config, callback) {
   const result = [];
   for (const [path, pathItem] of Object.entries(config.spec.paths ?? {})) {
@@ -300,7 +190,8 @@ function forEachOperation(config, callback) {
           {
             ...operation,
             parameters: [...parameters, ...operation.parameters ?? []],
-            operationId: operationName
+            operationId: operationName,
+            responses: resolveResponses(config.spec, operation)
           }
         )
       );
@@ -309,15 +200,11 @@ function forEachOperation(config, callback) {
   return result;
 }
 var reservedKeywords = /* @__PURE__ */ new Set([
-  "abstract",
-  "arguments",
   "await",
-  "boolean",
+  // Reserved in async functions
   "break",
-  "byte",
   "case",
   "catch",
-  "char",
   "class",
   "const",
   "continue",
@@ -325,85 +212,59 @@ var reservedKeywords = /* @__PURE__ */ new Set([
   "default",
   "delete",
   "do",
-  "double",
   "else",
   "enum",
-  "eval",
   "export",
   "extends",
   "false",
-  "final",
   "finally",
-  "float",
   "for",
   "function",
-  "goto",
   "if",
   "implements",
+  // Strict mode
   "import",
   "in",
   "instanceof",
-  "int",
   "interface",
+  // Strict mode
   "let",
-  "long",
-  "native",
+  // Strict mode
   "new",
   "null",
   "package",
+  // Strict mode
   "private",
+  // Strict mode
   "protected",
+  // Strict mode
   "public",
+  // Strict mode
   "return",
-  "short",
   "static",
+  // Strict mode
   "super",
   "switch",
-  "synchronized",
   "this",
   "throw",
-  "throws",
-  "transient",
   "true",
   "try",
   "typeof",
   "var",
   "void",
-  "volatile",
   "while",
   "with",
   "yield",
-  // Potentially problematic identifiers / Common Verbs used as tags
-  "object",
-  "string",
-  "number",
-  "any",
-  "unknown",
-  "never",
-  "get",
-  "list",
-  "create",
-  "update",
-  "delete",
-  "post",
-  "put",
-  "patch",
-  "do",
-  "send",
-  "add",
-  "remove",
-  "set",
-  "find",
-  "search",
-  "check",
-  "make"
-  // Added make, check
+  // Strict mode / Generator functions
+  // 'arguments' is not technically a reserved word, but it's a special identifier within functions
+  // and assigning to it or declaring it can cause issues or unexpected behavior.
+  "arguments"
 ]);
 function sanitizeTag(camelCasedTag) {
   if (/^\d/.test(camelCasedTag)) {
     return `_${camelCasedTag}`;
   }
-  return reservedKeywords.has(camelCasedTag) ? `${camelCasedTag}_` : camelCasedTag;
+  return reservedKeywords.has(camelcase(camelCasedTag)) ? `${camelCasedTag}_` : camelCasedTag;
 }
 function determineGenericTag(pathString, operation) {
   const operationId = operation.operationId || "";
@@ -427,7 +288,6 @@ function determineGenericTag(pathString, operation) {
     "search",
     "check",
     "make"
-    // Added make
   ]);
   const segments = pathString.split("/").filter(Boolean);
   const potentialCandidates = segments.filter(
@@ -521,8 +381,9 @@ function determineGenericTag(pathString, operation) {
 }
 
 // packages/typescript/src/lib/emitters/zod.ts
+import { cleanRef, followRef as followRef2, isRef as isRef2 } from "@sdk-it/core";
 var ZodDeserialzer = class {
-  circularRefTracker = /* @__PURE__ */ new Set();
+  generatedRefs = /* @__PURE__ */ new Set();
   #spec;
   #onRef;
   constructor(spec, onRef) {
@@ -596,15 +457,14 @@ var ZodDeserialzer = class {
   }
   ref($ref, required) {
     const schemaName = cleanRef($ref).split("/").pop();
-    if (this.circularRefTracker.has(schemaName)) {
+    if (this.generatedRefs.has(schemaName)) {
       return schemaName;
     }
-    this.circularRefTracker.add(schemaName);
+    this.generatedRefs.add(schemaName);
     this.#onRef?.(
       schemaName,
-      this.handle(followRef(this.#spec, $ref), required)
+      this.handle(followRef2(this.#spec, $ref), required)
     );
-    this.circularRefTracker.delete(schemaName);
     return schemaName;
   }
   allOf(schemas, required) {
@@ -632,15 +492,7 @@ var ZodDeserialzer = class {
     return `z.union([${anyOfSchemas.join(", ")}])${appendOptional(required)}`;
   }
   oneOf(schemas, required) {
-    const oneOfSchemas = schemas.map((sub) => {
-      if (isRef(sub)) {
-        const { model } = parseRef(sub.$ref);
-        if (this.circularRefTracker.has(model)) {
-          return `${model}${appendOptional(required)}`;
-        }
-      }
-      return this.handle(sub, true);
-    });
+    const oneOfSchemas = schemas.map((sub) => this.handle(sub, true));
     if (oneOfSchemas.length === 1) {
       return `${oneOfSchemas[0]}${appendOptional(required)}`;
     }
@@ -660,6 +512,10 @@ var ZodDeserialzer = class {
    */
   string(schema) {
     let base = "z.string()";
+    if (schema.contentEncoding === "binary") {
+      base = "z.instanceof(Blob)";
+      return base;
+    }
     switch (schema.format) {
       case "date-time":
       case "datetime":
@@ -737,7 +593,7 @@ var ZodDeserialzer = class {
     return { base, defaultValue };
   }
   handle(schema, required) {
-    if (isRef(schema)) {
+    if (isRef2(schema)) {
       return `${this.ref(schema.$ref, true)}${appendOptional(required)}`;
     }
     if (schema.allOf && Array.isArray(schema.allOf)) {
@@ -782,12 +638,14 @@ function appendDefault(defaultValue) {
 }
 
 // packages/typescript/src/lib/sdk.ts
-import { get as get2 } from "lodash-es";
+import { get } from "lodash-es";
 import { camelcase as camelcase2, pascalcase, spinalcase } from "stringcase";
+import { followRef as followRef4, isRef as isRef5, toLitObject as toLitObject2 } from "@sdk-it/core";
 
 // packages/typescript/src/lib/emitters/interface.ts
+import { cleanRef as cleanRef2, followRef as followRef3, isRef as isRef3 } from "@sdk-it/core";
 var TypeScriptDeserialzer = class {
-  circularRefTracker = /* @__PURE__ */ new Set();
+  generatedRefs = /* @__PURE__ */ new Set();
   #spec;
   #onRef;
   constructor(spec, onRef) {
@@ -798,7 +656,7 @@ var TypeScriptDeserialzer = class {
     return `'${value}'`;
   };
   #isInternal = (schema) => {
-    return isRef(schema) ? false : !!schema["x-internal"];
+    return isRef3(schema) ? false : !!schema["x-internal"];
   };
   /**
    * Handle objects (properties)
@@ -859,16 +717,15 @@ var TypeScriptDeserialzer = class {
     }
   }
   ref($ref, required) {
-    const schemaName = cleanRef($ref).split("/").pop();
-    if (this.circularRefTracker.has(schemaName)) {
+    const schemaName = cleanRef2($ref).split("/").pop();
+    if (this.generatedRefs.has(schemaName)) {
       return schemaName;
     }
-    this.circularRefTracker.add(schemaName);
+    this.generatedRefs.add(schemaName);
     this.#onRef?.(
       schemaName,
-      this.handle(followRef(this.#spec, $ref), required)
+      this.handle(followRef3(this.#spec, $ref), required)
     );
-    this.circularRefTracker.delete(schemaName);
     return appendOptional2(schemaName, required);
   }
   allOf(schemas) {
@@ -884,12 +741,6 @@ var TypeScriptDeserialzer = class {
   }
   oneOf(schemas, required) {
     const oneOfTypes = schemas.map((sub) => {
-      if (isRef(sub)) {
-        const { model } = parseRef(sub.$ref);
-        if (this.circularRefTracker.has(model)) {
-          return model;
-        }
-      }
       return this.handle(sub, false);
     });
     return appendOptional2(
@@ -906,6 +757,9 @@ var TypeScriptDeserialzer = class {
    */
   string(schema, required) {
     let type;
+    if (schema.contentEncoding === "binary") {
+      return appendOptional2("Blob", required);
+    }
     switch (schema.format) {
       case "date-time":
       case "datetime":
@@ -932,7 +786,7 @@ var TypeScriptDeserialzer = class {
     return appendOptional2(type, required);
   }
   handle(schema, required) {
-    if (isRef(schema)) {
+    if (isRef3(schema)) {
       return this.ref(schema.$ref, required);
     }
     if (schema.allOf && Array.isArray(schema.allOf)) {
@@ -977,6 +831,7 @@ function appendOptional2(type, isRequired) {
 }
 
 // packages/typescript/src/lib/utils.ts
+import { isRef as isRef4, removeDuplicates } from "@sdk-it/core";
 function securityToOptions(security2, securitySchemes, staticIn) {
   securitySchemes ??= {};
   const options = {};
@@ -986,7 +841,7 @@ function securityToOptions(security2, securitySchemes, staticIn) {
       continue;
     }
     const schema = securitySchemes[name];
-    if (isRef(schema)) {
+    if (isRef4(schema)) {
       throw new Error(`Ref security schemas are not supported`);
     }
     if (schema.type === "http") {
@@ -1075,7 +930,7 @@ function generateInputs(operationsSet, commonZod, makeImport) {
     const imports = /* @__PURE__ */ new Set(['import { z } from "zod";']);
     for (const operation of operations) {
       const schemaName = camelcase2(`${operation.name} schema`);
-      const schema = `export const ${schemaName} = ${Object.keys(operation.schemas).length === 1 ? Object.values(operation.schemas)[0] : toLitObject(operation.schemas)};`;
+      const schema = `export const ${schemaName} = ${Object.keys(operation.schemas).length === 1 ? Object.values(operation.schemas)[0] : toLitObject2(operation.schemas)};`;
       const inputContent = schema;
       for (const schema2 of commonImports) {
         if (inputContent.includes(schema2)) {
@@ -1145,7 +1000,7 @@ function toEndpoint(groupName, spec, specOperation, operation, utils) {
     return statusCode >= 200 && statusCode < 300;
   }).length > 1;
   for (const status in specOperation.responses) {
-    const response = isRef(specOperation.responses[status]) ? followRef(spec, specOperation.responses[status].$ref) : specOperation.responses[status];
+    const response = isRef5(specOperation.responses[status]) ? followRef4(spec, specOperation.responses[status].$ref) : specOperation.responses[status];
     const handled = handleResponse(
       spec,
       operation.name,
@@ -1250,12 +1105,12 @@ function handleResponse(spec, operationName, status, response, utils, numbered)
       );
     }
   }
-  const responseContent = get2(response, ["content"]);
+  const responseContent = get(response, ["content"]);
   const isJson = responseContent && responseContent["application/json"];
   let responseSchema = parser === "chunked" ? "ReadableStream" : "void";
   if (isJson) {
     const schema = responseContent["application/json"].schema;
-    const isObject = !isRef(schema) && schema.type === "object";
+    const isObject = !isRef5(schema) && schema.type === "object";
     if (isObject && schema.properties) {
       schema.properties["[http.KIND]"] = {
         "x-internal": true,
@@ -1263,7 +1118,7 @@ function handleResponse(spec, operationName, status, response, utils, numbered)
         type: "string"
       };
       schema.required ??= [];
-      schema.required.push("[KIND]");
+      schema.required.push("[http.KIND]");
     }
     responseSchema = typeScriptDeserialzer.handle(schema, true);
   }
@@ -1320,9 +1175,9 @@ function generateCode(config) {
     groups[entry.groupName] ??= [];
     endpoints[entry.groupName] ??= [];
     const inputs = {};
-    const additionalProperties = [];
+    const additionalProperties = {};
     for (const param of operation.parameters ?? []) {
-      if (isRef(param)) {
+      if (isRef6(param)) {
         throw new Error(`Found reference in parameter ${param.$ref}`);
       }
       if (!param.schema) {
@@ -1332,24 +1187,22 @@ function generateCode(config) {
         in: param.in,
         schema: ""
       };
-      additionalProperties.push(param);
+      additionalProperties[param.name] = param;
     }
     const security2 = operation.security ?? [];
     const securitySchemes = config.spec.components?.securitySchemes ?? {};
     const securityOptions = securityToOptions(security2, securitySchemes);
     Object.assign(inputs, securityOptions);
-    additionalProperties.push(
-      ...Object.entries(securityOptions).map(
-        ([name, value]) => ({
-          name,
-          required: false,
-          schema: {
-            type: "string"
-          },
-          in: value.in
-        })
-      )
-    );
+    Object.entries(securityOptions).forEach(([name, value]) => {
+      additionalProperties[name] = {
+        name,
+        required: false,
+        schema: {
+          type: "string"
+        },
+        in: value.in
+      };
+    });
     const schemas = {};
     const shortContenTypeMap = {
       "application/json": "json",
@@ -1364,9 +1217,9 @@ function generateCode(config) {
     };
     let outgoingContentType;
     if (!isEmpty(operation.requestBody)) {
-      const requestBody = isRef(operation.requestBody) ? followRef(config.spec, operation.requestBody.$ref) : operation.requestBody;
+      const requestBody = isRef6(operation.requestBody) ? followRef5(config.spec, operation.requestBody.$ref) : operation.requestBody;
       for (const type in requestBody.content) {
-        const ctSchema = isRef(requestBody.content[type].schema) ? followRef(config.spec, requestBody.content[type].schema.$ref) : requestBody.content[type].schema;
+        const ctSchema = isRef6(requestBody.content[type].schema) ? followRef5(config.spec, requestBody.content[type].schema.$ref) : requestBody.content[type].schema;
         if (!ctSchema) {
           console.warn(
             `Schema not found for ${type} in ${entry.method} ${entry.path}`
@@ -1384,9 +1237,9 @@ function generateCode(config) {
           };
         }
         const schema = merge({}, objectSchema, {
-          required: additionalProperties.filter((p) => p.required).map((p) => p.name),
-          properties: additionalProperties.reduce(
-            (acc, p) => ({
+          required: Object.values(additionalProperties).filter((p) => p.required).map((p) => p.name),
+          properties: Object.entries(additionalProperties).reduce(
+            (acc, [, p]) => ({
               ...acc,
               [p.name]: p.schema
             }),
@@ -1406,8 +1259,8 @@ function generateCode(config) {
         outgoingContentType = "json";
       }
     } else {
-      const properties = additionalProperties.reduce(
-        (acc, p) => ({
+      const properties = Object.entries(additionalProperties).reduce(
+        (acc, [, p]) => ({
           ...acc,
           [p.name]: p.schema
         }),
@@ -1416,7 +1269,7 @@ function generateCode(config) {
       schemas[shortContenTypeMap["application/json"]] = zodDeserialzer.handle(
         {
           type: "object",
-          required: additionalProperties.filter((p) => p.required).map((p) => p.name),
+          required: Object.values(additionalProperties).filter((p) => p.required).map((p) => p.name),
           properties
         },
         true
@@ -1503,7 +1356,7 @@ function generateCode(config) {
     commonZod,
     outputs,
     endpoints: {
-      [join2("api", "endpoints.ts")]: `
+      [join("api", "endpoints.ts")]: `
 
 
 import type z from 'zod';
@@ -1518,7 +1371,7 @@ import type { OutputType, Parser, Type } from '${config.makeImport(
 import schemas from '${config.makeImport("./schemas")}';
 
       ${template(endpoints_default)({ outputType: config.style?.outputType })}`,
-      [`${join2("api", "schemas.ts")}`]: `${allSchemas.map((it) => it.import).join("\n")}
+      [`${join("api", "schemas.ts")}`]: `${allSchemas.map((it) => it.import).join("\n")}
 import { KIND } from "${config.makeImport("../http/index")}";
 export default {
 ${allSchemas.map((it) => it.use).join(",\n")}
@@ -1538,10 +1391,9 @@ ${allSchemas.map((it) => it.use).join(",\n")}
           );
           return [
             [
-              join2("api", `${spinalcase2(name)}.ts`),
+              join("api", `${spinalcase2(name)}.ts`),
               `${[
                 ...imps,
-                // ...imports,
                 `import z from 'zod';`,
                 `import * as http from '${config.makeImport("../http/response")}';`,
                 `import { toRequest, json, urlencoded, nobody, formdata, createUrl } from '${config.makeImport("../http/request")}';`,
@@ -1561,8 +1413,8 @@ ${endpoint.flatMap((it) => it.schemas).join(",\n")}
   };
 }
 function toProps(spec, schemaOrRef, aggregator = []) {
-  if (isRef(schemaOrRef)) {
-    const schema = followRef(spec, schemaOrRef.$ref);
+  if (isRef6(schemaOrRef)) {
+    const schema = followRef5(spec, schemaOrRef.$ref);
     return toProps(spec, schema, aggregator);
   } else if (schemaOrRef.type === "object") {
     for (const [name] of Object.entries(schemaOrRef.properties ?? {})) {
@@ -2032,6 +1884,311 @@ export type SuccessfulResponse =
 // packages/typescript/src/lib/http/send-request.txt
 var send_request_default = "export interface Type<T> {\n  new (...args: any[]): T;\n}\nexport type Parser = (\n  response: Response,\n) => Promise<unknown> | ReadableStream<any>;\nexport type OutputType =\n  | Type<APIResponse>\n  | { parser: Parser; type: Type<APIResponse> };\n\nexport interface RequestSchema {\n  schema: z.ZodType;\n  toRequest: (input: any) => RequestConfig;\n  output: OutputType[];\n}\n\nexport const fetchType = z\n  .function()\n  .args(z.instanceof(Request))\n  .returns(z.promise(z.instanceof(Response)))\n  .optional();\n\nexport async function dispatch(\n  input: unknown,\n  route: RequestSchema,\n  options: {\n    fetch?: z.infer<typeof fetchType>;\n    interceptors?: Interceptor[];\n    signal?: AbortSignal;\n  },\n) {\n  const { interceptors = [] } = options;\n  const [parsedInput, parseError] = parseInput(route.schema, input);\n  if (parseError) {\n    <% if(throwError) { %>\n      throw parseError;\n    <% } else { %>\n      return [null as never, parseError as never] as const;\n    <% } %>\n  }\n\n  let config = route.toRequest(parsedInput as never);\n  for (const interceptor of interceptors) {\n    if (interceptor.before) {\n      config = await interceptor.before(config);\n    }\n  }\n\n  let response = await (options.fetch ?? fetch)(\n    new Request(config.url, config.init),\n    {\n      ...config.init,\n      signal: options.signal,\n    },\n  );\n\n  for (let i = interceptors.length - 1; i >= 0; i--) {\n    const interceptor = interceptors[i];\n    if (interceptor.after) {\n      response = await interceptor.after(response.clone());\n    }\n  }\n  return await parse(route, response);\n}\n\nexport async function parse(route: RequestSchema, response: Response) {\n  let output: typeof APIResponse | null = null;\n  let parser: Parser = buffered;\n  for (const outputType of route.output) {\n    if ('parser' in outputType) {\n      parser = outputType.parser;\n      if (isTypeOf(outputType.type, APIResponse)) {\n        if (response.status === outputType.type.status) {\n          output = outputType.type;\n          break;\n        }\n      }\n    } else if (isTypeOf(outputType, APIResponse)) {\n      if (response.status === outputType.status) {\n        output = outputType;\n        break;\n      }\n    }\n  }\n\n  if (response.ok) {\n    const apiresponse = (output || APIResponse).create(\n      response.status,\n      await parser(response),\n    );\n    <% if(throwError) { %>\n      return <% if (outputType === 'default') { %>apiresponse.data<% } else { %>apiresponse<% } %>;\n    <% } else { %>\n      return [<% if (outputType === 'default') { %>apiresponse.data<% } else { %>apiresponse<% } %> , null] as const;\n    <% } %>\n  }\n<% if(throwError) { %>\n  throw (output || APIError).create(\n    response.status,\n    await parser(response),\n  );\n<% } else { %>\n  const data = (output || APIError).create(\n    response.status,\n    await parser(response),\n  );\n  return [null as never, data as never] as const;\n<% } %>\n}\n\nexport function isTypeOf<T extends Type<APIResponse>>(\n  instance: any,\n  baseType: T,\n): instance is T {\n  if (instance === baseType) {\n    return true;\n  }\n  const prototype = Object.getPrototypeOf(instance);\n  if (prototype === null) {\n    return false;\n  }\n  return isTypeOf(prototype, baseType);\n}\n";
 
+// packages/typescript/src/lib/readme.ts
+import { followRef as followRef6, isRef as isRef7 } from "@sdk-it/core";
+var PropEmitter = class {
+  #spec;
+  constructor(spec) {
+    this.#spec = spec;
+  }
+  /**
+   * Handle objects (properties)
+   */
+  #object(schema) {
+    const lines = [];
+    const properties = schema.properties || {};
+    if (Object.keys(properties).length > 0) {
+      lines.push(`**Properties:**`);
+      for (const [propName, propSchema] of Object.entries(properties)) {
+        const isRequired = (schema.required ?? []).includes(propName);
+        lines.push(...this.#property(propName, propSchema, isRequired));
+      }
+    }
+    if (schema.additionalProperties) {
+      lines.push(`**Additional Properties:**`);
+      if (typeof schema.additionalProperties === "boolean") {
+        lines.push(`- Allowed: ${schema.additionalProperties}`);
+      } else {
+        lines.push(
+          ...this.handle(schema.additionalProperties).map((l) => `  ${l}`)
+        );
+      }
+    }
+    return lines;
+  }
+  /**
+   * Format a property with its type and description
+   */
+  #property(name, schema, required) {
+    const requiredMark = required ? " (required)" : "";
+    const propNameLine = `- \`${name}\`${requiredMark}:`;
+    const lines = [propNameLine];
+    const schemaDocs = this.handle(schema);
+    lines.push(...schemaDocs.map((line) => `  ${line}`));
+    return lines;
+  }
+  /**
+   * Handle array schemas
+   */
+  #array(schema) {
+    const lines = [];
+    lines.push(`**Array items:**`);
+    if (schema.items) {
+      const itemDocs = this.handle(schema.items);
+      lines.push(...itemDocs.map((line) => `  ${line}`));
+    } else {
+      lines.push(`  **Type:** \`unknown\``);
+    }
+    if (schema.minItems !== void 0)
+      lines.push(`- Minimum items: ${schema.minItems}`);
+    if (schema.maxItems !== void 0)
+      lines.push(`- Maximum items: ${schema.maxItems}`);
+    if (schema.uniqueItems)
+      lines.push(`- Items must be unique.`);
+    return lines;
+  }
+  #ref($ref) {
+    const schemaName = $ref.split("/").pop() || "object";
+    const resolved = followRef6(this.#spec, $ref);
+    const lines = [
+      `**Type:** [\`${schemaName}\`](#${schemaName.toLowerCase()})`
+    ];
+    if (resolved.description) {
+      lines.push(resolved.description);
+    }
+    return lines;
+  }
+  #allOf(schemas) {
+    const lines = ["**All of (Intersection):**"];
+    schemas.forEach((subSchema, index) => {
+      lines.push(`- **Constraint ${index + 1}:**`);
+      const subLines = this.handle(subSchema);
+      lines.push(...subLines.map((l) => `  ${l}`));
+    });
+    return lines;
+  }
+  #anyOf(schemas) {
+    const lines = ["**Any of (Union):**"];
+    schemas.forEach((subSchema, index) => {
+      lines.push(`- **Option ${index + 1}:**`);
+      const subLines = this.handle(subSchema);
+      lines.push(...subLines.map((l) => `  ${l}`));
+    });
+    return lines;
+  }
+  #oneOf(schemas) {
+    const lines = ["**One of (Exclusive Union):**"];
+    schemas.forEach((subSchema, index) => {
+      lines.push(`- **Option ${index + 1}:**`);
+      const subLines = this.handle(subSchema);
+      lines.push(...subLines.map((l) => `  ${l}`));
+    });
+    return lines;
+  }
+  #enum(schema) {
+    const lines = [`**Type:** \`${schema.type || "unknown"}\` (enum)`];
+    if (schema.description)
+      lines.push(schema.description);
+    lines.push("**Allowed values:**");
+    lines.push(
+      ...(schema.enum || []).map((val) => `- \`${JSON.stringify(val)}\``)
+    );
+    if (schema.default !== void 0) {
+      lines.push(`**Default:** \`${JSON.stringify(schema.default)}\``);
+    }
+    return lines;
+  }
+  #normal(type, schema, nullable) {
+    const lines = [];
+    const nullableSuffix = nullable ? " (nullable)" : "";
+    const description = schema.description ? [schema.description] : [];
+    switch (type) {
+      case "string":
+        lines.push(
+          `**Type:** \`string\`${schema.format ? ` (format: ${schema.format})` : ""}${nullableSuffix}`
+        );
+        lines.push(...description);
+        if (schema.minLength !== void 0)
+          lines.push(`- Minimum length: ${schema.minLength}`);
+        if (schema.maxLength !== void 0)
+          lines.push(`- Maximum length: ${schema.maxLength}`);
+        if (schema.pattern !== void 0)
+          lines.push(`- Pattern: \`${schema.pattern}\``);
+        break;
+      case "number":
+      case "integer":
+        lines.push(
+          `**Type:** \`${type}\`${schema.format ? ` (format: ${schema.format})` : ""}${nullableSuffix}`
+        );
+        lines.push(...description);
+        if (schema.minimum !== void 0) {
+          const exclusiveMin = typeof schema.exclusiveMinimum === "number";
+          lines.push(
+            `- Minimum: ${schema.minimum}${exclusiveMin ? " (exclusive)" : ""}`
+          );
+          if (exclusiveMin) {
+            lines.push(
+              `- Must be strictly greater than: ${schema.exclusiveMinimum}`
+            );
+          }
+        } else if (typeof schema.exclusiveMinimum === "number") {
+          lines.push(
+            `- Must be strictly greater than: ${schema.exclusiveMinimum}`
+          );
+        }
+        if (schema.maximum !== void 0) {
+          const exclusiveMax = typeof schema.exclusiveMaximum === "number";
+          lines.push(
+            `- Maximum: ${schema.maximum}${exclusiveMax ? " (exclusive)" : ""}`
+          );
+          if (exclusiveMax) {
+            lines.push(
+              `- Must be strictly less than: ${schema.exclusiveMaximum}`
+            );
+          }
+        } else if (typeof schema.exclusiveMaximum === "number") {
+          lines.push(
+            `- Must be strictly less than: ${schema.exclusiveMaximum}`
+          );
+        }
+        if (schema.multipleOf !== void 0)
+          lines.push(`- Must be a multiple of: ${schema.multipleOf}`);
+        break;
+      case "boolean":
+        lines.push(`**Type:** \`boolean\`${nullableSuffix}`);
+        lines.push(...description);
+        break;
+      case "object":
+        lines.push(`**Type:** \`object\`${nullableSuffix}`);
+        lines.push(...description);
+        lines.push(...this.#object(schema));
+        break;
+      case "array":
+        lines.push(`**Type:** \`array\`${nullableSuffix}`);
+        lines.push(...description);
+        lines.push(...this.#array(schema));
+        break;
+      case "null":
+        lines.push(`**Type:** \`null\``);
+        lines.push(...description);
+        break;
+      default:
+        lines.push(`**Type:** \`${type}\`${nullableSuffix}`);
+        lines.push(...description);
+    }
+    if (schema.default !== void 0) {
+      lines.push(`**Default:** \`${JSON.stringify(schema.default)}\``);
+    }
+    return lines.filter((l) => l);
+  }
+  /**
+   * Handle schemas by resolving references and delegating to appropriate handler
+   */
+  handle(schemaOrRef) {
+    if (isRef7(schemaOrRef)) {
+      return this.#ref(schemaOrRef.$ref);
+    }
+    const schema = schemaOrRef;
+    if (schema.allOf && Array.isArray(schema.allOf)) {
+      return this.#allOf(schema.allOf);
+    }
+    if (schema.anyOf && Array.isArray(schema.anyOf)) {
+      return this.#anyOf(schema.anyOf);
+    }
+    if (schema.oneOf && Array.isArray(schema.oneOf)) {
+      return this.#oneOf(schema.oneOf);
+    }
+    if (schema.enum && Array.isArray(schema.enum)) {
+      return this.#enum(schema);
+    }
+    let types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
+    let nullable = false;
+    if (types.includes("null")) {
+      nullable = true;
+      types = types.filter((t) => t !== "null");
+    }
+    if (types.length === 0) {
+      if (schema.properties || schema.additionalProperties) {
+        types = ["object"];
+      } else if (schema.items) {
+        types = ["array"];
+      }
+    }
+    if (types.length === 0) {
+      const lines2 = ["**Type:** `unknown`"];
+      if (schema.description)
+        lines2.push(schema.description);
+      if (schema.default !== void 0)
+        lines2.push(`**Default:** \`${JSON.stringify(schema.default)}\``);
+      return lines2;
+    }
+    if (types.length === 1) {
+      return this.#normal(types[0], schema, nullable);
+    }
+    const typeString = types.join(" | ");
+    const nullableSuffix = nullable ? " (nullable)" : "";
+    const lines = [`**Type:** \`${typeString}\`${nullableSuffix}`];
+    if (schema.description)
+      lines.push(schema.description);
+    if (schema.default !== void 0)
+      lines.push(`**Default:** \`${JSON.stringify(schema.default)}\``);
+    return lines;
+  }
+  /**
+   * Process a request body and return markdown documentation
+   */
+  requestBody(requestBody) {
+    if (!requestBody)
+      return [];
+    const resolvedBody = isRef7(requestBody) ? followRef6(this.#spec, requestBody.$ref) : requestBody;
+    const lines = [];
+    lines.push(`##### Request Body`);
+    if (resolvedBody.description) {
+      lines.push(resolvedBody.description);
+    }
+    if (resolvedBody.required) {
+      lines.push(`*This request body is required.*`);
+    }
+    if (resolvedBody.content) {
+      for (const [contentType, mediaType] of Object.entries(
+        resolvedBody.content
+      )) {
+        lines.push(`**Content Type:** \`${contentType}\``);
+        if (mediaType.schema) {
+          const schemaDocs = this.handle(mediaType.schema);
+          lines.push(...schemaDocs);
+        }
+      }
+    }
+    return lines;
+  }
+};
+function toReadme(spec) {
+  const markdown = [];
+  const propEmitter = new PropEmitter(spec);
+  forEachOperation({ spec }, ({ method, path, name }, operation) => {
+    spec.components ??= {};
+    spec.components.schemas ??= {};
+    const statuses = [];
+    markdown.push(
+      `#### ${name || operation.operationId} | ${`_${method.toUpperCase()} ${path}_`}`
+    );
+    markdown.push(operation.summary || "");
+    const requestBodyContent = propEmitter.requestBody(operation.requestBody);
+    if (requestBodyContent.length > 1) {
+      markdown.push(requestBodyContent.join("\n\n"));
+    }
+    markdown.push(`##### Responses`);
+    for (const status in operation.responses) {
+      const response = operation.responses[status];
+      const resolvedResponse = isRef7(response) ? followRef6(spec, response.$ref) : response;
+      statuses.push(`**${status}**	_${resolvedResponse.description}_`);
+    }
+    markdown.push(`<small>${statuses.join("\n\n")}</small>`);
+  });
+  return markdown.join("\n\n");
+}
+
 // packages/typescript/src/lib/generate.ts
 function security(spec) {
   const security2 = spec.security || [];
@@ -2074,17 +2231,18 @@ async function generate(spec, settings) {
       makeImport
     }
   );
-  const output = settings.mode === "full" ? join3(settings.output, "src") : settings.output;
+  const output = settings.mode === "full" ? join2(settings.output, "src") : settings.output;
   const options = security(spec);
-  const clientName = settings.name || "Client";
+  const clientName = settings.name?.trim() ? pascalcase3(settings.name) : "Client";
+  const readme = settings.readme ? toReadme(spec) : "";
   const inputFiles = generateInputs(groups, commonZod, makeImport);
+  console.log("Writing to", output);
   await writeFiles(output, {
     "outputs/.gitkeep": "",
     "inputs/.gitkeep": "",
     "models/.getkeep": ""
-    // 'README.md': readme,
   });
-  await writeFiles(join3(output, "http"), {
+  await writeFiles(join2(output, "http"), {
     "interceptors.ts": `
     import type { RequestConfig, HeadersInit } from './${makeImport("request")}';
     ${interceptors_default}`,
@@ -2101,7 +2259,7 @@ ${template2(send_request_default, {})({ throwError: !style.errorAsValue, outputT
     "parser.ts": parser_default,
     "request.ts": request_default
   });
-  await writeFiles(join3(output, "outputs"), outputs);
+  await writeFiles(join2(output, "outputs"), outputs);
   const modelsImports = Object.entries(commonSchemas).map(([name]) => name);
   await writeFiles(output, {
     "client.ts": client_default(
@@ -2129,16 +2287,16 @@ ${template2(send_request_default, {})({ throwError: !style.errorAsValue, outputT
     )
   });
   const folders = [
-    getFolderExports(join3(output, "outputs"), settings.useTsExtension),
+    getFolderExports(join2(output, "outputs"), settings.useTsExtension),
     getFolderExports(
-      join3(output, "inputs"),
+      join2(output, "inputs"),
       settings.useTsExtension,
       ["ts"],
       (dirent) => dirent.isDirectory() && ["schemas"].includes(dirent.name)
     ),
-    getFolderExports(join3(output, "api"), settings.useTsExtension),
+    getFolderExports(join2(output, "api"), settings.useTsExtension),
     getFolderExports(
-      join3(output, "http"),
+      join2(output, "http"),
       settings.useTsExtension,
       ["ts"],
       (dirent) => !["response.ts", "parser.ts"].includes(dirent.name)
@@ -2146,7 +2304,7 @@ ${template2(send_request_default, {})({ throwError: !style.errorAsValue, outputT
   ];
   if (modelsImports.length) {
     folders.push(
-      getFolderExports(join3(output, "models"), settings.useTsExtension)
+      getFolderExports(join2(output, "models"), settings.useTsExtension)
     );
   }
   const [outputIndex, inputsIndex, apiIndex, httpIndex, modelsIndex] = await Promise.all(folders);
@@ -2161,7 +2319,7 @@ ${template2(send_request_default, {})({ throwError: !style.errorAsValue, outputT
     "index.ts": await getFolderExports(output, settings.useTsExtension, ["ts"])
   });
   if (settings.mode === "full") {
-    await writeFiles(settings.output, {
+    const configFiles = {
       "package.json": {
         ignoreIfExists: true,
         content: JSON.stringify(
@@ -2200,7 +2358,14 @@ ${template2(send_request_default, {})({ throwError: !style.errorAsValue, outputT
           2
         )
       }
-    });
+    };
+    if (readme) {
+      configFiles["README.md"] = {
+        ignoreIfExists: true,
+        content: readme
+      };
+    }
+    await writeFiles(settings.output, configFiles);
   }
   await settings.formatCode?.({
     output,