@sdk-it/typescript 0.19.1 → 0.20.0

package/dist/index.js

@@ -3,7 +3,11 @@ import { template as template2 } from "lodash-es";
 import { join as join2 } from "node:path";
 import { npmRunPathEnv } from "npm-run-path";
 import { spinalcase as spinalcase3 } from "stringcase";
-import { getFolderExports, methods, writeFiles } from "@sdk-it/core";
+import { methods, pascalcase as pascalcase3 } from "@sdk-it/core";
+import {
+  getFolderExports,
+  writeFiles
+} from "@sdk-it/core/file-system.js";
 
 // packages/typescript/src/lib/client.ts
 import { toLitObject } from "@sdk-it/core";
@@ -132,10 +136,11 @@ export class ${spec.name} {
 import { merge, template } from "lodash-es";
 import { join } from "node:path";
 import { camelcase as camelcase3, pascalcase as pascalcase2, spinalcase as spinalcase2 } from "stringcase";
-import { followRef as followRef4, isEmpty, isRef as isRef5 } from "@sdk-it/core";
+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) {
@@ -150,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 ?? {})) {
@@ -176,7 +190,8 @@ function forEachOperation(config, callback) {
           {
             ...operation,
             parameters: [...parameters, ...operation.parameters ?? []],
-            operationId: operationName
+            operationId: operationName,
+            responses: resolveResponses(config.spec, operation)
           }
         )
       );
@@ -185,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",
@@ -201,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 || "";
@@ -303,7 +288,6 @@ function determineGenericTag(pathString, operation) {
     "search",
     "check",
     "make"
-    // Added make
   ]);
   const segments = pathString.split("/").filter(Boolean);
   const potentialCandidates = segments.filter(
@@ -397,9 +381,9 @@ function determineGenericTag(pathString, operation) {
 }
 
 // packages/typescript/src/lib/emitters/zod.ts
-import { cleanRef, followRef, isRef, parseRef } from "@sdk-it/core";
+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) {
@@ -473,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) {
@@ -509,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)}`;
     }
@@ -537,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":
@@ -614,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)) {
@@ -661,12 +640,12 @@ function appendDefault(defaultValue) {
 // packages/typescript/src/lib/sdk.ts
 import { get } from "lodash-es";
 import { camelcase as camelcase2, pascalcase, spinalcase } from "stringcase";
-import { followRef as followRef3, isRef as isRef4, toLitObject as toLitObject2 } from "@sdk-it/core";
+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 followRef2, isRef as isRef2, parseRef as parseRef2 } from "@sdk-it/core";
+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) {
@@ -677,7 +656,7 @@ var TypeScriptDeserialzer = class {
     return `'${value}'`;
   };
   #isInternal = (schema) => {
-    return isRef2(schema) ? false : !!schema["x-internal"];
+    return isRef3(schema) ? false : !!schema["x-internal"];
   };
   /**
    * Handle objects (properties)
@@ -739,15 +718,14 @@ var TypeScriptDeserialzer = class {
   }
   ref($ref, required) {
     const schemaName = cleanRef2($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(followRef2(this.#spec, $ref), required)
+      this.handle(followRef3(this.#spec, $ref), required)
     );
-    this.circularRefTracker.delete(schemaName);
     return appendOptional2(schemaName, required);
   }
   allOf(schemas) {
@@ -763,12 +741,6 @@ var TypeScriptDeserialzer = class {
   }
   oneOf(schemas, required) {
     const oneOfTypes = schemas.map((sub) => {
-      if (isRef2(sub)) {
-        const { model } = parseRef2(sub.$ref);
-        if (this.circularRefTracker.has(model)) {
-          return model;
-        }
-      }
       return this.handle(sub, false);
     });
     return appendOptional2(
@@ -785,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":
@@ -811,7 +786,7 @@ var TypeScriptDeserialzer = class {
     return appendOptional2(type, required);
   }
   handle(schema, required) {
-    if (isRef2(schema)) {
+    if (isRef3(schema)) {
       return this.ref(schema.$ref, required);
     }
     if (schema.allOf && Array.isArray(schema.allOf)) {
@@ -856,7 +831,7 @@ function appendOptional2(type, isRequired) {
 }
 
 // packages/typescript/src/lib/utils.ts
-import { isRef as isRef3, removeDuplicates } from "@sdk-it/core";
+import { isRef as isRef4, removeDuplicates } from "@sdk-it/core";
 function securityToOptions(security2, securitySchemes, staticIn) {
   securitySchemes ??= {};
   const options = {};
@@ -866,7 +841,7 @@ function securityToOptions(security2, securitySchemes, staticIn) {
       continue;
     }
     const schema = securitySchemes[name];
-    if (isRef3(schema)) {
+    if (isRef4(schema)) {
       throw new Error(`Ref security schemas are not supported`);
     }
     if (schema.type === "http") {
@@ -1025,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 = isRef4(specOperation.responses[status]) ? followRef3(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,
@@ -1135,7 +1110,7 @@ function handleResponse(spec, operationName, status, response, utils, numbered)
   let responseSchema = parser === "chunked" ? "ReadableStream" : "void";
   if (isJson) {
     const schema = responseContent["application/json"].schema;
-    const isObject = !isRef4(schema) && schema.type === "object";
+    const isObject = !isRef5(schema) && schema.type === "object";
     if (isObject && schema.properties) {
       schema.properties["[http.KIND]"] = {
         "x-internal": true,
@@ -1143,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);
   }
@@ -1200,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 (isRef5(param)) {
+      if (isRef6(param)) {
         throw new Error(`Found reference in parameter ${param.$ref}`);
       }
       if (!param.schema) {
@@ -1212,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",
@@ -1244,9 +1217,9 @@ function generateCode(config) {
     };
     let outgoingContentType;
     if (!isEmpty(operation.requestBody)) {
-      const requestBody = isRef5(operation.requestBody) ? followRef4(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 = isRef5(requestBody.content[type].schema) ? followRef4(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}`
@@ -1264,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
             }),
@@ -1286,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
         }),
@@ -1296,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
@@ -1421,7 +1394,6 @@ ${allSchemas.map((it) => it.use).join(",\n")}
               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")}';`,
@@ -1441,8 +1413,8 @@ ${endpoint.flatMap((it) => it.schemas).join(",\n")}
   };
 }
 function toProps(spec, schemaOrRef, aggregator = []) {
-  if (isRef5(schemaOrRef)) {
-    const schema = followRef4(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 ?? {})) {
@@ -1912,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 || [];
@@ -1956,13 +2233,14 @@ async function generate(spec, settings) {
   );
   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(join2(output, "http"), {
     "interceptors.ts": `
@@ -2041,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(
@@ -2080,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,