@sdk-it/typescript 0.12.10 → 0.13.0

package/dist/index.js

@@ -39,14 +39,14 @@ var client_default = (spec) => {
     }
   };
   return `
-import { fetchType, sendRequest } from './http/send-request.ts';
+import { fetchType, sendRequest } from './http/${spec.makeImport("send-request")}';
 import z from 'zod';
-import type { Endpoints } from './endpoints.ts';
-import schemas from './schemas.ts';
+import type { Endpoints } from './${spec.makeImport("endpoints")}';
+import schemas from './${spec.makeImport("schemas")}';
 import {
   createBaseUrlInterceptor,
   createDefaultHeadersInterceptor,
-} from './http/interceptors.ts';
+} from './http/${spec.makeImport("interceptors")}';
 
 ${spec.servers.length ? `export const servers = ${JSON.stringify(spec.servers, null, 2)} as const` : ""}
 const optionsSchema = z.object(${toLitObject(specOptions, (x) => x.schema)});
@@ -57,7 +57,7 @@ type ${spec.name}Options = z.infer<typeof optionsSchema>;
 export class ${spec.name} {
   public options: ${spec.name}Options
   constructor(options: ${spec.name}Options) {
-    this.options = options;
+    this.options = optionsSchema.parse(options);
   }
 
   async request<E extends keyof Endpoints>(
@@ -96,12 +96,18 @@ export class ${spec.name} {
 
 // packages/typescript/src/lib/sdk.ts
 var SchemaEndpoint = class {
-  #imports = [
-    `import z from 'zod';`,
-    'import type { Endpoints } from "./endpoints.ts";',
-    `import { toRequest, json, urlencoded, nobody, formdata, createUrl } from './http/request.ts';`,
-    `import type { ParseError } from './http/parser.ts';`
-  ];
+  #makeImport;
+  #imports = [];
+  constructor(makeImport) {
+    this.#makeImport = makeImport;
+    this.#imports = [
+      `import z from 'zod';`,
+      `import type { Endpoints } from '${this.#makeImport("./endpoints")}';`,
+      `import { toRequest, json, urlencoded, nobody, formdata, createUrl } from '${this.#makeImport("./http/request")}';`,
+      `import type { ParseError } from '${this.#makeImport("./http/parser")}';`,
+      `import { chunked, buffered } from "${this.#makeImport("./http/parse-response")}";`
+    ];
+  }
   #endpoints = [];
   addEndpoint(endpoint, operation) {
     this.#endpoints.push(`  "${endpoint}": ${operation},`);
@@ -117,10 +123,15 @@ ${this.#endpoints.join("\n")}
   }
 };
 var Emitter = class {
-  imports = [
-    `import z from 'zod';`,
-    `import type { ParseError } from './http/parser.ts';`
-  ];
+  #makeImport;
+  imports = [];
+  constructor(makeImport) {
+    this.#makeImport = makeImport;
+    this.imports = [
+      `import type z from 'zod';`,
+      `import type { ParseError } from '${this.#makeImport("./http/parser")}';`
+    ];
+  }
   endpoints = [];
   addEndpoint(endpoint, operation) {
     this.endpoints.push(`  "${endpoint}": ${operation};`);
@@ -135,7 +146,7 @@ ${this.endpoints.join("\n")}
 }`;
   }
 };
-function generateInputs(operationsSet, commonZod) {
+function generateInputs(operationsSet, commonZod, makeImport) {
   const commonImports = commonZod.keys().toArray();
   const inputs = {};
   for (const [name, operations] of Object.entries(operationsSet)) {
@@ -148,7 +159,7 @@ function generateInputs(operationsSet, commonZod) {
       for (const schema2 of commonImports) {
         if (inputContent.includes(schema2)) {
           imports.add(
-            `import { ${schema2} } from './schemas/${spinalcase(schema2)}.ts';`
+            `import { ${schema2} } from './schemas/${makeImport(spinalcase(schema2))}';`
           );
         }
       }
@@ -163,7 +174,7 @@ function generateInputs(operationsSet, commonZod) {
       const preciseMatch = new RegExp(`\\b${schema2}\\b`);
       if (preciseMatch.test(content) && schema2 !== name) {
         output.push(
-          `import { ${schema2} } from './${spinalcase(schema2)}.ts';`
+          `import { ${schema2} } from './${makeImport(spinalcase(schema2))}';`
         );
       }
     }
@@ -179,15 +190,15 @@ function generateInputs(operationsSet, commonZod) {
   };
 }
 function generateSDK(spec) {
-  const emitter = new Emitter();
-  const schemaEndpoint = new SchemaEndpoint();
+  const emitter = new Emitter(spec.makeImport);
+  const schemaEndpoint = new SchemaEndpoint(spec.makeImport);
   const errors = [];
   for (const [name, operations] of Object.entries(spec.operations)) {
     emitter.addImport(
-      `import * as ${camelcase(name)} from './inputs/${spinalcase(name)}.ts';`
+      `import type * as ${camelcase(name)} from './inputs/${spec.makeImport(spinalcase(name))}';`
     );
     schemaEndpoint.addImport(
-      `import * as ${camelcase(name)} from './inputs/${spinalcase(name)}.ts';`
+      `import * as ${camelcase(name)} from './inputs/${spec.makeImport(spinalcase(name))}';`
     );
     for (const operation of operations) {
       const schemaName = camelcase(`${operation.name} schema`);
@@ -217,7 +228,7 @@ function generateSDK(spec) {
         }
       }
       emitter.addImport(
-        `import type {${output.import}} from './outputs/${spinalcase(operation.name)}.ts';`
+        `import type {${output.import}} from './outputs/${spec.makeImport(spinalcase(operation.name))}';`
       );
       errors.push(...operation.errors ?? []);
       const addTypeParser = Object.keys(operation.schemas).length > 1;
@@ -236,9 +247,10 @@ function generateSDK(spec) {
           endpoint,
           `{
           schema: ${schemaRef}${addTypeParser ? `.${type}` : ""},
+          deserializer: ${operation.parser === "chunked" ? "chunked" : "buffered"},
           toRequest(input: Endpoints['${endpoint}']['input']) {
             const endpoint = '${endpoint}';
-                return toRequest(endpoint, ${operation.contentType || "nobody"}(input, {
+                return toRequest(endpoint, ${operation.outgoingContentType || "nobody"}(input, {
                 inputHeaders: [${inputHeaders}],
                 inputQuery: [${inputQuery}],
                 inputBody: [${inputBody}],
@@ -251,7 +263,7 @@ function generateSDK(spec) {
     }
   }
   emitter.addImport(
-    `import type { ${removeDuplicates(errors, (it) => it).join(", ")} } from './http/response.ts';`
+    `import type { ${removeDuplicates(errors, (it) => it).join(", ")} } from '${spec.makeImport("./http/response")}';`
   );
   return {
     "client.ts": client_default(spec),
@@ -342,8 +354,8 @@ function importsToString(...imports) {
     throw new Error(`Invalid import ${JSON.stringify(it)}`);
   });
 }
-function exclude2(list, exclude3) {
-  return list.filter((it) => !exclude3.includes(it));
+function exclude(list, exclude2) {
+  return list.filter((it) => !exclude2.includes(it));
 }
 function useImports(content, imports) {
   const output = [];
@@ -580,6 +592,9 @@ var TypeScriptDeserialzer = class {
     }
     const types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
     if (!types.length) {
+      if ("properties" in schema) {
+        return this.object(schema, required);
+      }
       return appendOptional("any", required);
     }
     if (types.length > 1) {
@@ -655,19 +670,24 @@ var ZodDeserialzer = class {
   }
   // oneOf() {}
   // enum() {}
+  #suffixes = (defaultValue, required, nullable) => {
+    return `${nullable ? ".nullable()" : ""}${appendDefault(defaultValue)}${appendOptional2(required)}`;
+  };
   /**
    * Convert a basic type (string | number | boolean | object | array, etc.) to Zod.
    * We'll also handle .optional() if needed.
    */
-  normal(type, schema, required = false) {
+  normal(type, schema, required = false, nullable = false) {
     switch (type) {
       case "string":
-        return this.string(schema, required);
+        return `${this.string(schema)}${this.#suffixes(schema.default, required, nullable)}`;
       case "number":
-      case "integer":
-        return this.number(schema, required);
+      case "integer": {
+        const { base, defaultValue } = this.number(schema);
+        return `${base}${this.#suffixes(defaultValue, required, nullable)}`;
+      }
       case "boolean":
-        return `z.boolean()${appendDefault(schema.default)}${appendOptional2(required)}`;
+        return `z.boolean()${this.#suffixes(schema.default, required, nullable)}`;
       case "object":
         return this.object(schema, required);
       case "array":
@@ -693,10 +713,20 @@ var ZodDeserialzer = class {
   }
   allOf(schemas) {
     const allOfSchemas = schemas.map((sub) => this.handle(sub, true));
+    if (allOfSchemas.length === 0) {
+      return `z.unknown()`;
+    }
     if (allOfSchemas.length === 1) {
       return allOfSchemas[0];
     }
-    return allOfSchemas.length ? `z.intersection(${allOfSchemas.join(", ")})` : allOfSchemas[0];
+    return this.#toIntersection(allOfSchemas);
+  }
+  #toIntersection(schemas) {
+    const [left, ...right] = schemas;
+    if (!right.length) {
+      return left;
+    }
+    return `z.intersection(${left}, ${this.#toIntersection(right)})`;
   }
   anyOf(schemas, required) {
     const anyOfSchemas = schemas.map((sub) => this.handle(sub, false));
@@ -733,7 +763,7 @@ var ZodDeserialzer = class {
   /**
    * Handle a `string` schema with possible format keywords (JSON Schema).
    */
-  string(schema, required) {
+  string(schema) {
     let base = "z.string()";
     switch (schema.format) {
       case "date-time":
@@ -775,20 +805,20 @@ var ZodDeserialzer = class {
       default:
         break;
     }
-    return `${base}${appendDefault(schema.default)}${appendOptional2(required)}`;
+    return base;
   }
   /**
    * Handle number/integer constraints from OpenAPI/JSON Schema.
    * In 3.1, exclusiveMinimum/Maximum hold the actual numeric threshold,
    * rather than a boolean toggling `minimum`/`maximum`.
    */
-  number(schema, required) {
-    let defaultValue = schema.default !== void 0 ? `.default(${schema.default})` : ``;
+  number(schema) {
+    let defaultValue = schema.default;
     let base = "z.number()";
     if (schema.format === "int64") {
       base = "z.bigint()";
       if (schema.default !== void 0) {
-        defaultValue = `.default(BigInt(${schema.default}))`;
+        defaultValue = `BigInt(${schema.default})`;
       }
     }
     if (schema.format === "int32") {
@@ -809,7 +839,7 @@ var ZodDeserialzer = class {
     if (typeof schema.multipleOf === "number") {
       base += `.refine((val) => Number.isInteger(val / ${schema.multipleOf}), "Must be a multiple of ${schema.multipleOf}")`;
     }
-    return `${base}${defaultValue}${appendOptional2(required)}`;
+    return { base, defaultValue };
   }
   handle(schema, required) {
     if (isRef(schema)) {
@@ -831,16 +861,18 @@ var ZodDeserialzer = class {
     if (!types.length) {
       return `z.unknown()${appendOptional2(required)}`;
     }
+    if ("nullable" in schema && schema.nullable) {
+      types.push("null");
+    }
     if (types.length > 1) {
       const realTypes = types.filter((t) => t !== "null");
       if (realTypes.length === 1 && types.includes("null")) {
-        const typeZod = this.normal(realTypes[0], schema, false);
-        return `${typeZod}.nullable()${appendOptional2(required)}`;
+        return this.normal(realTypes[0], schema, false, true);
       }
       const subSchemas = types.map((t) => this.normal(t, schema, false));
       return `z.union([${subSchemas.join(", ")}])${appendOptional2(required)}`;
     }
-    return this.normal(types[0], schema, required);
+    return this.normal(types[0], schema, required, false);
   }
 };
 function appendOptional2(isRequired) {
@@ -889,7 +921,7 @@ function generateCode(config) {
     commonZodImports.push({
       defaultImport: void 0,
       isTypeOnly: true,
-      moduleSpecifier: `./${model}.ts`,
+      moduleSpecifier: `./${config.makeImport(model)}`,
       namedImports: [{ isTypeOnly: true, name: model }],
       namespaceImport: void 0
     });
@@ -901,7 +933,7 @@ function generateCode(config) {
       const formatOperationId = config.operationId ?? defaults.operationId;
       const operationName = formatOperationId(operation, path, method);
       console.log(`Processing ${method} ${path}`);
-      const groupName = (operation.tags ?? ["unknown"])[0];
+      const [groupName] = Array.isArray(operation.tags) ? operation.tags : ["unknown"];
       groups[groupName] ??= [];
       const inputs = {};
       const additionalProperties = [];
@@ -942,7 +974,7 @@ function generateCode(config) {
         "application/xml": "xml",
         "text/plain": "text"
       };
-      let contentType;
+      let outgoingContentType;
       if (operation.requestBody && Object.keys(operation.requestBody).length) {
         const content = isRef(operation.requestBody) ? get2(followRef(config.spec, operation.requestBody.$ref), ["content"]) : operation.requestBody.content;
         for (const type in content) {
@@ -961,22 +993,17 @@ function generateCode(config) {
               {}
             )
           });
-          for (const [name] of Object.entries(ctSchema.properties ?? {})) {
-            inputs[name] = {
-              in: "body",
-              schema: ""
-            };
-          }
+          Object.assign(inputs, bodyInputs(config, ctSchema));
           types[shortContenTypeMap[type]] = zodDeserialzer.handle(schema, true);
         }
         if (content["application/json"]) {
-          contentType = "json";
+          outgoingContentType = "json";
         } else if (content["application/x-www-form-urlencoded"]) {
-          contentType = "urlencoded";
+          outgoingContentType = "urlencoded";
         } else if (content["multipart/form-data"]) {
-          contentType = "formdata";
+          outgoingContentType = "formdata";
         } else {
-          contentType = "json";
+          outgoingContentType = "json";
         }
       } else {
         const properties = additionalProperties.reduce(
@@ -999,8 +1026,14 @@ function generateCode(config) {
       operation.responses ??= {};
       let foundResponse = false;
       const output = [`import z from 'zod';`];
+      let parser = "buffered";
       for (const status in operation.responses) {
-        const response = operation.responses[status];
+        const response = isRef(
+          operation.responses[status]
+        ) ? followRef(
+          config.spec,
+          operation.responses[status].$ref
+        ) : operation.responses[status];
         const statusCode = +status;
         if (statusCode >= 400) {
           errors.push(responses[status] ?? "ProblematicResponse");
@@ -1009,6 +1042,9 @@ function generateCode(config) {
           foundResponse = true;
           const responseContent = get2(response, ["content"]);
           const isJson = responseContent && responseContent["application/json"];
+          if ((response.headers ?? {})["Transfer-Encoding"]) {
+            parser = "chunked";
+          }
           const imports = [];
           const typeScriptDeserialzer = new TypeScriptDeserialzer(
             config.spec,
@@ -1017,7 +1053,7 @@ function generateCode(config) {
               imports.push({
                 defaultImport: void 0,
                 isTypeOnly: true,
-                moduleSpecifier: `../models/${schemaName}.ts`,
+                moduleSpecifier: `../models/${config.makeImport(schemaName)}`,
                 namedImports: [{ isTypeOnly: true, name: schemaName }],
                 namespaceImport: void 0
               });
@@ -1044,8 +1080,9 @@ function generateCode(config) {
         type: "http",
         inputs,
         errors: errors.length ? errors : ["ServerError"],
-        contentType,
+        outgoingContentType,
         schemas: types,
+        parser,
         formatOutput: () => ({
           import: pascalcase(operationName + " output"),
           use: pascalcase(operationName + " output")
@@ -1059,12 +1096,42 @@ function generateCode(config) {
   }
   return { groups, commonSchemas, commonZod, outputs };
 }
+function toProps(spec, schemaOrRef, aggregator = []) {
+  if (isRef(schemaOrRef)) {
+    const schema = followRef(spec, schemaOrRef.$ref);
+    return toProps(spec, schema, aggregator);
+  } else if (schemaOrRef.type === "object") {
+    for (const [name] of Object.entries(schemaOrRef.properties ?? {})) {
+      aggregator.push(name);
+    }
+    return void 0;
+  } else if (schemaOrRef.allOf) {
+    for (const it of schemaOrRef.allOf) {
+      toProps(spec, it, aggregator);
+    }
+    return void 0;
+  }
+}
+function bodyInputs(config, ctSchema) {
+  const props = [];
+  toProps(config.spec, ctSchema, props);
+  return props.reduce(
+    (acc, prop) => ({
+      ...acc,
+      [prop]: {
+        in: "body",
+        schema: ""
+      }
+    }),
+    {}
+  );
+}
 
 // packages/typescript/src/lib/http/interceptors.txt
-var interceptors_default = "export interface Interceptor {\n  before?: (request: Request) => Promise<Request> | Request;\n  after?: (response: Response) => Promise<Response> | Response;\n}\n\nexport const createDefaultHeadersInterceptor = (\n  getHeaders: () => Record<string, string | undefined>,\n) => {\n  return {\n    before(request: Request) {\n      const headers = getHeaders();\n\n      for (const [key, value] of Object.entries(headers)) {\n        // Only set the header if it doesn't already exist and has a value\n        if (value !== undefined && !request.headers.has(key)) {\n          request.headers.set(key, value);\n        }\n      }\n\n      return request;\n    },\n  };\n};\n\nexport const createBaseUrlInterceptor = (getBaseUrl: () => string) => {\n  return {\n    before(request: Request) {\n      const baseUrl = getBaseUrl();\n      if (request.url.startsWith('local://')) {\n        return new Request(request.url.replace('local://', baseUrl), request);\n      }\n      return request;\n    },\n  };\n};\n\nexport const logInterceptor = {\n  before(request: Request) {\n    console.log('Request', request);\n    return request;\n  },\n  after(response: Response) {\n    console.log('Response', response);\n    return response;\n  },\n};\n";
+var interceptors_default = "export interface Interceptor {\n  before?: (request: Request) => Promise<Request> | Request;\n  after?: (response: Response) => Promise<Response> | Response;\n}\n\nexport const createDefaultHeadersInterceptor = (\n  getHeaders: () => Record<string, string | undefined>,\n) => {\n  return {\n    before(request: Request) {\n      const headers = getHeaders();\n\n      for (const [key, value] of Object.entries(headers)) {\n        // Only set the header if it doesn't already exist and has a value\n        if (value !== undefined && !request.headers.has(key)) {\n          request.headers.set(key, value);\n        }\n      }\n\n      return request;\n    },\n  };\n};\n\nexport const createBaseUrlInterceptor = (getBaseUrl: () => string) => {\n  return {\n    before(request: Request) {\n      const baseUrl = getBaseUrl();\n      if (request.url.startsWith('local://')) {\n        return new Request(request.url.replace('local://', baseUrl), request);\n      }\n      return request;\n    },\n  };\n};\n\nexport const logInterceptor = {\n  before(request: Request) {\n    console.log('Request', request);\n    return request;\n  },\n  after(response: Response) {\n    console.log('Response', response);\n    return response;\n  },\n};\n\n/**\n * Creates an interceptor that logs detailed information about requests and responses.\n * @param options Configuration options for the logger\n * @returns An interceptor object with before and after handlers\n */\nexport const createDetailedLogInterceptor = (options?: {\n  logLevel?: 'debug' | 'info' | 'warn' | 'error';\n  includeRequestBody?: boolean;\n  includeResponseBody?: boolean;\n}) => {\n  const logLevel = options?.logLevel || 'info';\n  const includeRequestBody = options?.includeRequestBody || false;\n  const includeResponseBody = options?.includeResponseBody || false;\n\n  return {\n    async before(request: Request) {\n      const logData = {\n        url: request.url,\n        method: request.method,\n        contentType: request.headers.get('Content-Type'),\n        headers: Object.fromEntries([...request.headers.entries()]),\n      };\n\n      console[logLevel]('\u{1F680} Outgoing Request:', logData);\n\n      if (includeRequestBody) {\n        try {\n          // Clone the request to avoid consuming the body stream\n          const clonedRequest = request.clone();\n          if (clonedRequest.headers.get('Content-Type')?.includes('application/json')) {\n            const body = await clonedRequest.json().catch(() => null);\n            console[logLevel]('Request Body:', body);\n          } else {\n            const body = await clonedRequest.text().catch(() => null);\n            console[logLevel]('Request Body:', body);\n          }\n        } catch (error) {\n          console.error('Could not log request body:', error);\n        }\n      }\n\n      return request;\n    },\n\n    async after(response: Response) {\n      const logData = {\n        status: response.status,\n        statusText: response.statusText,\n        url: response.url,\n        headers: Object.fromEntries([...response.headers.entries()]),\n      };\n\n      console[logLevel]('\u{1F4E5} Incoming Response:', logData);\n\n      if (includeResponseBody && response.body) {\n        try {\n          // Clone the response to avoid consuming the body stream\n          const clonedResponse = response.clone();\n          if (clonedResponse.headers.get('Content-Type')?.includes('application/json')) {\n            const body = await clonedResponse.json().catch(() => null);\n            console[logLevel]('Response Body:', body);\n          } else {\n            const body = await clonedResponse.text().catch(() => null);\n            if (body) {\n              console[logLevel]('Response Body:', body.substring(0, 500) + (body.length > 500 ? '...' : ''));\n            } else {\n              console[logLevel]('No response body');\n            }\n          }\n        } catch (error) {\n          console.error('Could not log response body:', error);\n        }\n      }\n\n      return response;\n    },\n  };\n};\n";
 
 // packages/typescript/src/lib/http/parse-response.txt
-var parse_response_default = "import { parse } from 'fast-content-type-parse';\n\nexport async function handleError(response: Response) {\n  try {\n    if (response.status >= 400 && response.status < 500) {\n      const body = (await response.json()) as Record<string, any>;\n      return {\n        status: response.status,\n        body: body,\n      };\n    }\n    return new Error(\n      `An error occurred while fetching the data. Status: ${response.status}`,\n    );\n  } catch (error) {\n    return error as any;\n  }\n}\n\nasync function handleChunkedResponse(response: Response, contentType: string) {\n  const { type } = parse(contentType);\n\n  switch (type) {\n    case 'application/json': {\n      let buffer = '';\n      const reader = response.body!.getReader();\n      const decoder = new TextDecoder();\n      while (true) {\n        const { value, done } = await reader.read();\n        if (done) break;\n        buffer += decoder.decode(value);\n      }\n      return JSON.parse(buffer);\n    }\n    case 'text/html':\n    case 'text/plain': {\n      let buffer = '';\n      const reader = response.body!.getReader();\n      const decoder = new TextDecoder();\n      while (true) {\n        const { value, done } = await reader.read();\n        if (done) break;\n        buffer += decoder.decode(value);\n      }\n      return buffer;\n    }\n    default:\n      return response.body;\n  }\n}\n\nexport async function parseResponse(response: Response) {\n  const contentType = response.headers.get('Content-Type');\n  if (!contentType) {\n    throw new Error('Content-Type header is missing');\n  }\n\n  if (response.status === 204) {\n    return null;\n  }\n  const isChunked = response.headers.get('Transfer-Encoding') === 'chunked';\n  if (isChunked) {\n    return response.body!;\n    // return handleChunkedResponse(response, contentType);\n  }\n\n  const { type } = parse(contentType);\n  switch (type) {\n    case 'application/json':\n      return response.json();\n    case 'text/plain':\n      return response.text();\n    case 'text/html':\n      return response.text();\n    case 'text/xml':\n    case 'application/xml':\n      return response.text();\n    case 'application/x-www-form-urlencoded': {\n      const text = await response.text();\n      return Object.fromEntries(new URLSearchParams(text));\n    }\n    case 'multipart/form-data':\n      return response.formData();\n    default:\n      throw new Error(`Unsupported content type: ${contentType}`);\n  }\n}\n";
+var parse_response_default = 'import { parse } from "fast-content-type-parse";\n\nexport async function handleError(response: Response) {\n	try {\n		if (response.status >= 400 && response.status < 500) {\n			const body = (await response.json()) as Record<string, any>;\n			return {\n				status: response.status,\n				body: body,\n			};\n		}\n		return new Error(\n			`An error occurred while fetching the data. Status: ${response.status}`,\n		);\n	} catch (error) {\n		return error as any;\n	}\n}\n\nasync function handleChunkedResponse(response: Response, contentType: string) {\n	const { type } = parse(contentType);\n\n	switch (type) {\n		case "application/json": {\n			let buffer = "";\n			const reader = response.body!.getReader();\n			const decoder = new TextDecoder();\n			while (true) {\n				const { value, done } = await reader.read();\n				if (done) break;\n				buffer += decoder.decode(value);\n			}\n			return JSON.parse(buffer);\n		}\n		case "text/html":\n		case "text/plain": {\n			let buffer = "";\n			const reader = response.body!.getReader();\n			const decoder = new TextDecoder();\n			while (true) {\n				const { value, done } = await reader.read();\n				if (done) break;\n				buffer += decoder.decode(value);\n			}\n			return buffer;\n		}\n		default:\n			return response.body;\n	}\n}\n\nexport function chunked(response: Response) {\n	return response.body;\n}\n\nexport async function buffered(response: Response) {\n	const contentType = response.headers.get("Content-Type");\n	if (!contentType) {\n		throw new Error("Content-Type header is missing");\n	}\n\n	if (response.status === 204) {\n		return null;\n	}\n\n	const { type } = parse(contentType);\n	switch (type) {\n		case "application/json":\n			return response.json();\n		case "text/plain":\n			return response.text();\n		case "text/html":\n			return response.text();\n		case "text/xml":\n		case "application/xml":\n			return response.text();\n		case "application/x-www-form-urlencoded": {\n			const text = await response.text();\n			return Object.fromEntries(new URLSearchParams(text));\n		}\n		case "multipart/form-data":\n			return response.formData();\n		default:\n			throw new Error(`Unsupported content type: ${contentType}`);\n	}\n}\n';
 
 // packages/typescript/src/lib/http/parser.txt
 var parser_default = "import { z } from 'zod';\n\nexport type ParseError<T extends z.ZodType<any, any, any>> = {\n  kind: 'parse';\n} & z.inferFlattenedErrors<T>;\n\nexport function parse<T extends z.ZodType>(\n  schema: T,\n  input: unknown,\n) {\n  const result = schema.safeParse(input);\n  if (!result.success) {\n    const errors = result.error.flatten((issue) => issue);\n    return [null, errors];\n  }\n  return [result.data as z.infer<T>, null];\n}\n";
@@ -1076,7 +1143,7 @@ var request_default = "export type Method = 'GET' | 'POST' | 'PUT' | 'PATCH' | '
 var response_default = "export interface ApiResponse<Status extends number, Body extends unknown> {\n  kind: 'response';\n  status: Status;\n  body: Body;\n}\n\n// 4xx Client Errors\nexport type BadRequest = ApiResponse<400, { message: string }>;\nexport type Unauthorized = ApiResponse<401, { message: string }>;\nexport type PaymentRequired = ApiResponse<402, { message: string }>;\nexport type Forbidden = ApiResponse<403, { message: string }>;\nexport type NotFound = ApiResponse<404, { message: string }>;\nexport type MethodNotAllowed = ApiResponse<405, { message: string }>;\nexport type NotAcceptable = ApiResponse<406, { message: string }>;\nexport type Conflict = ApiResponse<409, { message: string }>;\nexport type Gone = ApiResponse<410, { message: string }>;\nexport type UnprocessableEntity = ApiResponse<422, { message: string; errors?: Record<string, string[]> }>;\nexport type TooManyRequests = ApiResponse<429, { message: string; retryAfter?: string }>;\nexport type PayloadTooLarge = ApiResponse<413, { message: string; }>;\nexport type UnsupportedMediaType = ApiResponse<415, { message: string; }>;\n\n// 5xx Server Errors\nexport type InternalServerError = ApiResponse<500, { message: string }>;\nexport type NotImplemented = ApiResponse<501, { message: string }>;\nexport type BadGateway = ApiResponse<502, { message: string }>;\nexport type ServiceUnavailable = ApiResponse<503, { message: string; retryAfter?: string }>;\nexport type GatewayTimeout = ApiResponse<504, { message: string }>;\n\nexport type ClientError =\n  | BadRequest\n  | Unauthorized\n  | PaymentRequired\n  | Forbidden\n  | NotFound\n  | MethodNotAllowed\n  | NotAcceptable\n  | Conflict\n  | Gone\n  | UnprocessableEntity\n  | TooManyRequests;\n\nexport type ServerError =\n  | InternalServerError\n  | NotImplemented\n  | BadGateway\n  | ServiceUnavailable\n  | GatewayTimeout;\n\nexport type ProblematicResponse = ClientError | ServerError;\n";
 
 // packages/typescript/src/lib/http/send-request.txt
-var send_request_default = "import z from 'zod';\n\nimport type { Interceptor } from './interceptors.ts';\nimport { handleError, parseResponse } from './parse-response.ts';\nimport { parse } from './parser.ts';\n\nexport interface RequestSchema {\n  schema: z.ZodType;\n  toRequest: (input: any) => Request;\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 sendRequest(\n  input: any,\n  route: RequestSchema,\n  options: {\n    fetch?: z.infer<typeof fetchType>;\n    interceptors?: Interceptor[];\n  },\n) {\n  const { interceptors = [] } = options;\n  const [parsedInput, parseError] = parse(route.schema, input);\n  if (parseError) {\n    return [null as never, { ...parseError, kind: 'parse' } as never] as const;\n  }\n\n  let request = route.toRequest(parsedInput as never);\n  for (const interceptor of interceptors) {\n    if (interceptor.before) {\n      request = await interceptor.before(request);\n    }\n  }\n\n  let response = await (options.fetch ?? fetch)(request);\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\n  if (response.ok) {\n    const data = await parseResponse(response);\n    return [data as never, null] as const;\n  }\n  const error = await handleError(response);\n  return [null as never, { ...error, kind: 'response' }] as const;\n}\n";
+var send_request_default = "\nexport interface RequestSchema {\n  schema: z.ZodType;\n  toRequest: (input: any) => Request;\n  deserializer: (response: Response) => Promise<unknown> | unknown;\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 sendRequest(\n  input: unknown,\n  route: RequestSchema,\n  options: {\n    fetch?: z.infer<typeof fetchType>;\n    interceptors?: Interceptor[];\n  },\n) {\n  const { interceptors = [] } = options;\n  const [parsedInput, parseError] = parse(route.schema, input);\n  if (parseError) {\n    return [null as never, { ...parseError, kind: 'parse' } as never] as const;\n  }\n\n  let request = route.toRequest(parsedInput as never);\n  for (const interceptor of interceptors) {\n    if (interceptor.before) {\n      request = await interceptor.before(request);\n    }\n  }\n\n  let response = await (options.fetch ?? fetch)(request);\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\n  if (response.ok) {\n    const data = await route.deserializer(response);\n    return [data as never, null] as const;\n  }\n  const error = await handleError(response);\n  return [null as never, { ...error, kind: 'response' }] as const;\n}\n";
 
 // packages/typescript/src/lib/generate.ts
 function security(spec) {
@@ -1100,10 +1167,15 @@ function security(spec) {
   return options;
 }
 async function generate(spec, settings) {
+  settings.useTsExtension ??= true;
+  const makeImport = (moduleSpecifier) => {
+    return settings.useTsExtension ? `${moduleSpecifier}.ts` : moduleSpecifier;
+  };
   const { commonSchemas, groups, outputs, commonZod } = generateCode({
     spec,
     style: "github",
-    target: "javascript"
+    target: "javascript",
+    makeImport
   });
   const output = settings.mode === "full" ? join(settings.output, "src") : settings.output;
   const options = security(spec);
@@ -1111,9 +1183,10 @@ async function generate(spec, settings) {
     name: settings.name || "Client",
     operations: groups,
     servers: spec.servers?.map((server) => server.url) || [],
-    options
+    options,
+    makeImport
   });
-  const inputFiles = generateInputs(groups, commonZod);
+  const inputFiles = generateInputs(groups, commonZod, makeImport);
   await writeFiles(output, {
     "outputs/.gitkeep": "",
     "inputs/.gitkeep": "",
@@ -1123,7 +1196,11 @@ async function generate(spec, settings) {
   await writeFiles(join(output, "http"), {
     "interceptors.ts": interceptors_default,
     "parse-response.ts": parse_response_default,
-    "send-request.ts": send_request_default,
+    "send-request.ts": `import z from 'zod';
+import type { Interceptor } from './${makeImport("interceptors")}';
+import { handleError } from './${makeImport("parse-response")}';
+import { parse } from './${makeImport("parser")}';
+${send_request_default}`,
     "response.ts": response_default,
     "parser.ts": parser_default,
     "request.ts": request_default
@@ -1138,7 +1215,7 @@ async function generate(spec, settings) {
         `models/${name}.ts`,
         [
           `import { z } from 'zod';`,
-          ...exclude2(modelsImports, [name]).map(
+          ...exclude(modelsImports, [name]).map(
             (it) => `import type { ${it} } from './${it}.ts';`
           ),
           `export type ${name} = ${schema};`
@@ -1147,17 +1224,20 @@ async function generate(spec, settings) {
     )
   });
   const folders = [
-    getFolderExports(output),
-    getFolderExports(join(output, "outputs")),
+    getFolderExports(output, settings.useTsExtension),
+    getFolderExports(join(output, "outputs"), settings.useTsExtension),
     getFolderExports(
       join(output, "inputs"),
+      settings.useTsExtension,
       ["ts"],
       (dirent) => dirent.isDirectory() && dirent.name === "schemas"
     ),
-    getFolderExports(join(output, "http"))
+    getFolderExports(join(output, "http"), settings.useTsExtension)
   ];
   if (modelsImports.length) {
-    folders.push(getFolderExports(join(output, "models")));
+    folders.push(
+      getFolderExports(join(output, "models"), settings.useTsExtension)
+    );
   }
   const [index, outputIndex, inputsIndex, httpIndex, modelsIndex] = await Promise.all(folders);
   await writeFiles(output, {
@@ -1173,6 +1253,7 @@ async function generate(spec, settings) {
         ignoreIfExists: true,
         content: JSON.stringify(
           {
+            name: "sdk",
             type: "module",
             main: "./src/index.ts",
             dependencies: {
@@ -1185,7 +1266,7 @@ async function generate(spec, settings) {
         )
       },
       "tsconfig.json": {
-        ignoreIfExists: false,
+        ignoreIfExists: true,
         content: JSON.stringify(
           {
             compilerOptions: {
@@ -1194,6 +1275,7 @@ async function generate(spec, settings) {
               target: "ESNext",
               module: "ESNext",
               noEmit: true,
+              strict: true,
               allowImportingTsExtensions: true,
               verbatimModuleSyntax: true,
               baseUrl: ".",