@sdk-it/typescript 0.12.6 → 0.12.7

package/dist/index.js

@@ -14,8 +14,11 @@ async function exist(file) {
   return stat(file).then(() => true).catch(() => false);
 }
 async function writeFiles(dir, contents) {
-  return Promise.all(
+  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") {
@@ -25,15 +28,20 @@ async function writeFiles(dir, contents) {
           if (!await exist(filePath)) {
             await writeFile(filePath, content.content, "utf-8");
           }
+        } else {
+          await writeFile(filePath, content.content, "utf-8");
         }
       }
     })
   );
 }
-async function getFolderExports(folder, extensions = ["ts"]) {
+async function getFolderExports(folder, 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()) {
       exports.push(`export * from './${file.name}/index.ts';`);
     } else if (file.name !== "index.ts" && extensions.includes(getExt(file.name))) {
@@ -75,13 +83,13 @@ function toLitObject(obj, accessor = (value) => value) {
 
 // packages/typescript/src/lib/generator.ts
 import { get as get2, merge } from "lodash-es";
-import { camelcase as camelcase2, pascalcase as pascalcase2, spinalcase as spinalcase2 } from "stringcase";
+import { camelcase as camelcase2, pascalcase, spinalcase as spinalcase2 } from "stringcase";
 
 // packages/typescript/src/lib/utils.ts
 import { get } from "lodash-es";
 
 // packages/typescript/src/lib/sdk.ts
-import { camelcase, pascalcase, spinalcase } from "stringcase";
+import { camelcase, spinalcase } from "stringcase";
 
 // packages/typescript/src/lib/client.ts
 var client_default = (spec) => {
@@ -122,8 +130,10 @@ ${spec.servers.length ? `export type Servers = typeof servers[number];` : ""}
 type ${spec.name}Options = z.infer<typeof optionsSchema>;
 
 export class ${spec.name} {
-
-  constructor(public options: ${spec.name}Options) {}
+  public options: ${spec.name}Options
+  constructor(options: ${spec.name}Options) {
+    this.options = options;
+  }
 
   async request<E extends keyof Endpoints>(
     endpoint: E,
@@ -200,37 +210,63 @@ ${this.endpoints.join("\n")}
 }`;
   }
 };
-var StreamEmitter = class extends Emitter {
-  complete() {
-    return `${this.imports.join("\n")}
-export interface StreamEndpoints {
-${this.endpoints.join("\n")}
-}`;
+function generateInputs(operationsSet, commonZod) {
+  const commonImports = commonZod.keys().toArray();
+  const inputs = {};
+  for (const [name, operations] of Object.entries(operationsSet)) {
+    const output = [];
+    const imports = /* @__PURE__ */ new Set(['import { z } from "zod";']);
+    for (const operation of operations) {
+      const schemaName = camelcase(`${operation.name} schema`);
+      const schema = `export const ${schemaName} = ${Object.keys(operation.schemas).length === 1 ? Object.values(operation.schemas)[0] : toLitObject(operation.schemas)};`;
+      const inputContent = schema;
+      for (const schema2 of commonImports) {
+        if (inputContent.includes(schema2)) {
+          imports.add(
+            `import { ${schema2} } from './schemas/${spinalcase(schema2)}.ts';`
+          );
+        }
+      }
+      output.push(inputContent);
+    }
+    inputs[`inputs/${spinalcase(name)}.ts`] = [...imports, ...output].join("\n") + "\n";
   }
-};
-function generateClientSdk(spec) {
+  const schemas = commonZod.entries().reduce((acc, [name, schema]) => {
+    const output = [`import { z } from 'zod';`];
+    const content = `export const ${name} = ${schema};`;
+    for (const schema2 of commonImports) {
+      const preciseMatch = new RegExp(`\\b${schema2}\\b`);
+      if (preciseMatch.test(content) && schema2 !== name) {
+        output.push(
+          `import { ${schema2} } from './${spinalcase(schema2)}.ts';`
+        );
+      }
+    }
+    output.push(content);
+    return [
+      [`inputs/schemas/${spinalcase(name)}.ts`, output.join("\n")],
+      ...acc
+    ];
+  }, []);
+  return {
+    ...Object.fromEntries(schemas),
+    ...inputs
+  };
+}
+function generateSDK(spec) {
   const emitter = new Emitter();
-  const streamEmitter = new StreamEmitter();
-  const schemas = {};
   const schemaEndpoint = new SchemaEndpoint();
   const errors = [];
   for (const [name, operations] of Object.entries(spec.operations)) {
-    const featureSchemaFileName = camelcase(name);
-    schemas[featureSchemaFileName] = [`import z from 'zod';`];
     emitter.addImport(
-      `import * as ${featureSchemaFileName} from './inputs/${featureSchemaFileName}.ts';`
-    );
-    streamEmitter.addImport(
-      `import * as ${featureSchemaFileName} from './inputs/${featureSchemaFileName}.ts';`
+      `import * as ${camelcase(name)} from './inputs/${spinalcase(name)}.ts';`
     );
     schemaEndpoint.addImport(
-      `import * as ${featureSchemaFileName} from './inputs/${featureSchemaFileName}.ts';`
+      `import * as ${camelcase(name)} from './inputs/${spinalcase(name)}.ts';`
     );
     for (const operation of operations) {
       const schemaName = camelcase(`${operation.name} schema`);
-      const schema = `export const ${schemaName} = ${Object.keys(operation.schemas).length === 1 ? Object.values(operation.schemas)[0] : toLitObject(operation.schemas)};`;
-      schemas[featureSchemaFileName].push(schema);
-      const schemaRef = `${featureSchemaFileName}.${schemaName}`;
+      const schemaRef = `${camelcase(name)}.${schemaName}`;
       const output = operation.formatOutput();
       const inputHeaders = [];
       const inputQuery = [];
@@ -255,51 +291,25 @@ function generateClientSdk(spec) {
           );
         }
       }
-      if (operation.type === "sse") {
-        const input = `z.infer<typeof ${schemaRef}>`;
-        const endpoint = `${operation.trigger.method.toUpperCase()} ${operation.trigger.path}`;
-        streamEmitter.addImport(
-          `import type {${pascalcase(operation.name)}} from './outputs/${spinalcase(operation.name)}.ts';`
-        );
-        streamEmitter.addEndpoint(
+      emitter.addImport(
+        `import type {${output.import}} from './outputs/${spinalcase(operation.name)}.ts';`
+      );
+      errors.push(...operation.errors ?? []);
+      const addTypeParser = Object.keys(operation.schemas).length > 1;
+      for (const type in operation.schemas ?? {}) {
+        let typePrefix = "";
+        if (addTypeParser && type !== "json") {
+          typePrefix = `${type} `;
+        }
+        const input = `typeof ${schemaRef}${addTypeParser ? `.${type}` : ""}`;
+        const endpoint = `${typePrefix}${operation.trigger.method.toUpperCase()} ${operation.trigger.path}`;
+        emitter.addEndpoint(
           endpoint,
-          `{input: ${input}, output: ${output.use}}`
+          `{input: z.infer<${input}>; output: ${output.use}; error: ${(operation.errors ?? ["ServerError"]).concat(`ParseError<${input}>`).join("|")}}`
         );
         schemaEndpoint.addEndpoint(
           endpoint,
           `{
-        schema: ${schemaRef},
-        toRequest(input: StreamEndpoints['${endpoint}']['input']) {
-          const endpoint = '${endpoint}';
-            return toRequest(endpoint, json(input, {
-            inputHeaders: [${inputHeaders}],
-            inputQuery: [${inputQuery}],
-            inputBody: [${inputBody}],
-            inputParams: [${inputParams}],
-          }));
-          },
-        }`
-        );
-      } else {
-        emitter.addImport(
-          `import type {${output.import}} from './outputs/${spinalcase(operation.name)}.ts';`
-        );
-        errors.push(...operation.errors ?? []);
-        const addTypeParser = Object.keys(operation.schemas).length > 1;
-        for (const type in operation.schemas ?? {}) {
-          let typePrefix = "";
-          if (addTypeParser && type !== "json") {
-            typePrefix = `${type} `;
-          }
-          const input = `typeof ${schemaRef}${addTypeParser ? `.${type}` : ""}`;
-          const endpoint = `${typePrefix}${operation.trigger.method.toUpperCase()} ${operation.trigger.path}`;
-          emitter.addEndpoint(
-            endpoint,
-            `{input: z.infer<${input}>; output: ${output.use}; error: ${(operation.errors ?? ["ServerError"]).concat(`ParseError<${input}>`).join("|")}}`
-          );
-          schemaEndpoint.addEndpoint(
-            endpoint,
-            `{
           schema: ${schemaRef}${addTypeParser ? `.${type}` : ""},
           toRequest(input: Endpoints['${endpoint}']['input']) {
             const endpoint = '${endpoint}';
@@ -311,8 +321,7 @@ function generateClientSdk(spec) {
               }));
             },
           }`
-          );
-        }
+        );
       }
     }
   }
@@ -320,19 +329,6 @@ function generateClientSdk(spec) {
     `import type { ${removeDuplicates(errors, (it) => it).join(", ")} } from './http/response.ts';`
   );
   return {
-    ...Object.fromEntries(
-      Object.entries(schemas).map(([key, value]) => [
-        `inputs/${key}.ts`,
-        [
-          // schemasImports.length
-          //   ? `import {${removeDuplicates(schemasImports, (it) => it)}} from '../zod';`
-          //   : '',
-          spec.commonZod ? 'import * as commonZod from "../zod.ts";' : "",
-          ...value
-        ].map((it) => it.trim()).filter(Boolean).join("\n") + "\n"
-        // add a newline at the end
-      ])
-    ),
     "client.ts": client_default(spec),
     "schemas.ts": schemaEndpoint.complete(),
     "endpoints.ts": emitter.complete()
@@ -421,6 +417,25 @@ function importsToString(...imports) {
     throw new Error(`Invalid import ${JSON.stringify(it)}`);
   });
 }
+function exclude2(list, exclude3) {
+  return list.filter((it) => !exclude3.includes(it));
+}
+function useImports(content, imports) {
+  const output = [];
+  for (const it of mergeImports(imports)) {
+    const singleImport = it.defaultImport ?? it.namespaceImport;
+    if (singleImport && content.includes(singleImport)) {
+      output.push(importsToString(it).join("\n"));
+    } else if (it.namedImports.length) {
+      for (const namedImport of it.namedImports) {
+        if (content.includes(namedImport.name)) {
+          output.push(importsToString(it).join("\n"));
+        }
+      }
+    }
+  }
+  return output;
+}
 
 // packages/typescript/src/lib/emitters/interface.ts
 var TypeScriptDeserialzer = class {
@@ -431,6 +446,70 @@ var TypeScriptDeserialzer = class {
     this.#spec = spec;
     this.#onRef = onRef;
   }
+  #stringifyKey = (key) => {
+    const reservedWords = [
+      "constructor",
+      "prototype",
+      "break",
+      "case",
+      "catch",
+      "class",
+      "const",
+      "continue",
+      "debugger",
+      "default",
+      "delete",
+      "do",
+      "else",
+      "export",
+      "extends",
+      "false",
+      "finally",
+      "for",
+      "function",
+      "if",
+      "import",
+      "in",
+      "instanceof",
+      "new",
+      "null",
+      "return",
+      "super",
+      "switch",
+      "this",
+      "throw",
+      "true",
+      "try",
+      "typeof",
+      "var",
+      "void",
+      "while",
+      "with",
+      "yield"
+    ];
+    if (reservedWords.includes(key)) {
+      return `'${key}'`;
+    }
+    if (key.trim() === "") {
+      return `'${key}'`;
+    }
+    const firstChar = key.charAt(0);
+    const validFirstChar = firstChar >= "a" && firstChar <= "z" || firstChar >= "A" && firstChar <= "Z" || firstChar === "_" || firstChar === "$";
+    if (!validFirstChar) {
+      return `'${key.replace(/'/g, "\\'")}'`;
+    }
+    for (let i = 1; i < key.length; i++) {
+      const char = key.charAt(i);
+      const validChar = char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char >= "0" && char <= "9" || char === "_" || char === "$";
+      if (!validChar) {
+        return `'${key.replace(/'/g, "\\'")}'`;
+      }
+    }
+    return key;
+  };
+  #stringifyKeyV2 = (value) => {
+    return `'${value}'`;
+  };
   /**
    * Handle objects (properties)
    */
@@ -439,7 +518,7 @@ var TypeScriptDeserialzer = class {
     const propEntries = Object.entries(properties).map(([key, propSchema]) => {
       const isRequired = (schema.required ?? []).includes(key);
       const tsType = this.handle(propSchema, isRequired);
-      return `${key}: ${tsType}`;
+      return `${this.#stringifyKeyV2(key)}: ${tsType}`;
     });
     if (schema.additionalProperties) {
       if (typeof schema.additionalProperties === "object") {
@@ -689,10 +768,16 @@ var ZodDeserialzer = class {
   }
   allOf(schemas) {
     const allOfSchemas = schemas.map((sub) => this.handle(sub, true));
+    if (allOfSchemas.length === 1) {
+      return allOfSchemas[0];
+    }
     return allOfSchemas.length ? `z.intersection(${allOfSchemas.join(", ")})` : allOfSchemas[0];
   }
   anyOf(schemas, required) {
     const anyOfSchemas = schemas.map((sub) => this.handle(sub, false));
+    if (anyOfSchemas.length === 1) {
+      return anyOfSchemas[0];
+    }
     return anyOfSchemas.length > 1 ? `z.union([${anyOfSchemas.join(", ")}])${appendOptional2(required)}` : (
       // Handle an invalid anyOf with one schema
       anyOfSchemas[0]
@@ -708,6 +793,9 @@ var ZodDeserialzer = class {
       }
       return this.handle(sub, false);
     });
+    if (oneOfSchemas.length === 1) {
+      return oneOfSchemas[0];
+    }
     return oneOfSchemas.length > 1 ? `z.union([${oneOfSchemas.join(", ")}])${appendOptional2(required)}` : (
       // Handle an invalid oneOf with one schema
       oneOfSchemas[0]
@@ -869,7 +957,18 @@ var defaults = {
 };
 function generateCode(config) {
   const commonSchemas = {};
-  const zodDeserialzer = new ZodDeserialzer(config.spec);
+  const commonZod = /* @__PURE__ */ new Map();
+  const commonZodImports = [];
+  const zodDeserialzer = new ZodDeserialzer(config.spec, (model, schema) => {
+    commonZod.set(model, schema);
+    commonZodImports.push({
+      defaultImport: void 0,
+      isTypeOnly: true,
+      moduleSpecifier: `./${model}.ts`,
+      namedImports: [{ isTypeOnly: true, name: model }],
+      namespaceImport: void 0
+    });
+  });
   const groups = {};
   const outputs = {};
   for (const [path, methods2] of Object.entries(config.spec.paths ?? {})) {
@@ -1003,26 +1102,15 @@ function generateCode(config) {
             responseContent["application/json"].schema,
             true
           ) : "ReadableStream";
-          for (const it of mergeImports(imports)) {
-            const singleImport = it.defaultImport ?? it.namespaceImport;
-            if (singleImport && responseSchema.includes(singleImport)) {
-              output.push(importsToString(it).join("\n"));
-            } else if (it.namedImports.length) {
-              for (const namedImport of it.namedImports) {
-                if (responseSchema.includes(namedImport.name)) {
-                  output.push(importsToString(it).join("\n"));
-                }
-              }
-            }
-          }
+          output.push(...useImports(responseSchema, imports));
           output.push(
-            `export type ${pascalcase2(operationName + " output")} = ${responseSchema}`
+            `export type ${pascalcase(operationName + " output")} = ${responseSchema}`
           );
         }
       }
       if (!foundResponse) {
         output.push(
-          `export type ${pascalcase2(operationName + " output")} = void`
+          `export type ${pascalcase(operationName + " output")} = void`
         );
       }
       outputs[`${spinalcase2(operationName)}.ts`] = output.join("\n");
@@ -1034,8 +1122,8 @@ function generateCode(config) {
         contentType,
         schemas: types,
         formatOutput: () => ({
-          import: pascalcase2(operationName + " output"),
-          use: pascalcase2(operationName + " output")
+          import: pascalcase(operationName + " output"),
+          use: pascalcase(operationName + " output")
         }),
         trigger: {
           path,
@@ -1044,7 +1132,7 @@ function generateCode(config) {
       });
     }
   }
-  return { groups, commonSchemas, outputs };
+  return { groups, commonSchemas, commonZod, outputs };
 }
 
 // packages/typescript/src/lib/http/interceptors.txt
@@ -1057,7 +1145,7 @@ var parse_response_default = "import { parse } from 'fast-content-type-parse';\n
 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";
 
 // packages/typescript/src/lib/http/request.txt
-var request_default = "export type Method = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';\nexport type ContentType = 'xml' | 'json' | 'urlencoded' | 'multipart';\nexport type Endpoint =\n  | `${ContentType} ${Method} ${string}`\n  | `${Method} ${string}`;\n\nexport type BodyInit =\n  | ArrayBuffer\n  | Blob\n  | FormData\n  | URLSearchParams\n  | null\n  | string;\n\nexport function createUrl(path: string, query: URLSearchParams) {\n  const url = new URL(path, `local://`);\n  url.search = query.toString();\n  return url;\n}\n\nfunction template(\n  templateString: string,\n  templateVariables: Record<string, any>,\n): string {\n  const nargs = /{([0-9a-zA-Z_]+)}/g;\n  return templateString.replace(nargs, (match, key: string, index: number) => {\n    // Handle escaped double braces\n    if (\n      templateString[index - 1] === '{' &&\n      templateString[index + match.length] === '}'\n    ) {\n      return key;\n    }\n\n    const result = key in templateVariables ? templateVariables[key] : null;\n    return result === null || result === undefined ? '' : String(result);\n  });\n}\n\ntype Input = Record<string, any>;\ntype Props = {\n  inputHeaders: string[];\n  inputQuery: string[];\n  inputBody: string[];\n  inputParams: string[];\n};\n\nabstract class Serializer {\n  constructor(\n    protected input: Input,\n    protected props: Props,\n  ) {}\n  abstract getBody(): BodyInit | null;\n  abstract getHeaders(): Record<string, string>;\n  serialize(): Serialized {\n    const headers = new Headers({});\n    for (const header of this.props.inputHeaders) {\n      headers.set(header, this.input[header]);\n    }\n\n    const query = new URLSearchParams();\n    for (const key of this.props.inputQuery) {\n      const value = this.input[key];\n      if (value !== undefined) {\n        query.set(key, String(value));\n      }\n    }\n\n    const params = this.props.inputParams.reduce<Record<string, any>>(\n      (acc, key) => {\n        acc[key] = this.input[key];\n        return acc;\n      },\n      {},\n    );\n\n    return {\n      body: this.getBody(),\n      query,\n      params,\n      headers: this.getHeaders(),\n    };\n  }\n}\n\ninterface Serialized {\n  body: BodyInit | null;\n  query: URLSearchParams;\n  params: Record<string, any>;\n  headers: Record<string, string>;\n}\n\nclass JsonSerializer extends Serializer {\n  getBody(): BodyInit | null {\n    const body: Record<string, any> = {};\n    for (const prop of this.props.inputBody) {\n      body[prop] = this.input[prop];\n    }\n    return JSON.stringify(body);\n  }\n  getHeaders(): Record<string, string> {\n    return {\n      'Content-Type': 'application/json',\n      Accept: 'application/json',\n    };\n  }\n}\n\nclass UrlencodedSerializer extends Serializer {\n  getBody(): BodyInit | null {\n    const body = new URLSearchParams();\n    for (const prop of this.props.inputBody) {\n      body.set(prop, this.input[prop]);\n    }\n    return body;\n  }\n  getHeaders(): Record<string, string> {\n    return {};\n  }\n}\n\nclass NoBodySerializer extends Serializer {\n  getBody(): BodyInit | null {\n    return null;\n  }\n  getHeaders(): Record<string, string> {\n    return {};\n  }\n}\n\nclass FormDataSerializer extends Serializer {\n  getBody(): BodyInit | null {\n    const body = new FormData();\n    for (const prop of this.props.inputBody) {\n      body.append(prop, this.input[prop]);\n    }\n    return body;\n  }\n  getHeaders(): Record<string, string> {\n    return {};\n  }\n}\n\nexport function json(input: Input, props: Props) {\n  return new JsonSerializer(input, props).serialize();\n}\nexport function urlencoded(input: Input, props: Props) {\n  return new UrlencodedSerializer(input, props).serialize();\n}\nexport function nobody(input: Input, props: Props) {\n  return new NoBodySerializer(input, props).serialize();\n}\nexport function formdata(input: Input, props: Props) {\n  return new FormDataSerializer(input, props).serialize();\n}\n\nexport function toRequest<T extends Endpoint>(\n  endpoint: T,\n  input: Serialized,\n): Request {\n  const [method, path] = endpoint.split(' ');\n  const pathVariable = template(path, input.params);\n\n  const url = createUrl(pathVariable, input.query);\n  return new Request(url, {\n    method: method,\n    headers: input.headers,\n    body: method === 'GET' ? undefined : input.body,\n  });\n}\n";
+var request_default = "export type Method = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';\nexport type ContentType = 'xml' | 'json' | 'urlencoded' | 'multipart';\nexport type Endpoint =\n  | `${ContentType} ${Method} ${string}`\n  | `${Method} ${string}`;\n\nexport type BodyInit =\n  | ArrayBuffer\n  | Blob\n  | FormData\n  | URLSearchParams\n  | null\n  | string;\n\nexport function createUrl(path: string, query: URLSearchParams) {\n  const url = new URL(path, `local://`);\n  url.search = query.toString();\n  return url;\n}\n\nfunction template(\n  templateString: string,\n  templateVariables: Record<string, any>,\n): string {\n  const nargs = /{([0-9a-zA-Z_]+)}/g;\n  return templateString.replace(nargs, (match, key: string, index: number) => {\n    // Handle escaped double braces\n    if (\n      templateString[index - 1] === '{' &&\n      templateString[index + match.length] === '}'\n    ) {\n      return key;\n    }\n\n    const result = key in templateVariables ? templateVariables[key] : null;\n    return result === null || result === undefined ? '' : String(result);\n  });\n}\n\ntype Input = Record<string, any>;\ntype Props = {\n  inputHeaders: string[];\n  inputQuery: string[];\n  inputBody: string[];\n  inputParams: string[];\n};\n\nabstract class Serializer {\n  protected input: Input;\n  protected props: Props;\n\n  constructor(\n    input: Input,\n    props: Props,\n  ) {\n    this.input = input;\n    this.props = props;\n  }\n\n  abstract getBody(): BodyInit | null;\n  abstract getHeaders(): Record<string, string>;\n  serialize(): Serialized {\n    const headers = new Headers({});\n    for (const header of this.props.inputHeaders) {\n      headers.set(header, this.input[header]);\n    }\n\n    const query = new URLSearchParams();\n    for (const key of this.props.inputQuery) {\n      const value = this.input[key];\n      if (value !== undefined) {\n        query.set(key, String(value));\n      }\n    }\n\n    const params = this.props.inputParams.reduce<Record<string, any>>(\n      (acc, key) => {\n        acc[key] = this.input[key];\n        return acc;\n      },\n      {},\n    );\n\n    return {\n      body: this.getBody(),\n      query,\n      params,\n      headers: this.getHeaders(),\n    };\n  }\n}\n\ninterface Serialized {\n  body: BodyInit | null;\n  query: URLSearchParams;\n  params: Record<string, any>;\n  headers: Record<string, string>;\n}\n\nclass JsonSerializer extends Serializer {\n  getBody(): BodyInit | null {\n    const body: Record<string, any> = {};\n    for (const prop of this.props.inputBody) {\n      body[prop] = this.input[prop];\n    }\n    return JSON.stringify(body);\n  }\n  getHeaders(): Record<string, string> {\n    return {\n      'Content-Type': 'application/json',\n      Accept: 'application/json',\n    };\n  }\n}\n\nclass UrlencodedSerializer extends Serializer {\n  getBody(): BodyInit | null {\n    const body = new URLSearchParams();\n    for (const prop of this.props.inputBody) {\n      body.set(prop, this.input[prop]);\n    }\n    return body;\n  }\n  getHeaders(): Record<string, string> {\n    return {};\n  }\n}\n\nclass NoBodySerializer extends Serializer {\n  getBody(): BodyInit | null {\n    return null;\n  }\n  getHeaders(): Record<string, string> {\n    return {};\n  }\n}\n\nclass FormDataSerializer extends Serializer {\n  getBody(): BodyInit | null {\n    const body = new FormData();\n    for (const prop of this.props.inputBody) {\n      body.append(prop, this.input[prop]);\n    }\n    return body;\n  }\n  getHeaders(): Record<string, string> {\n    return {};\n  }\n}\n\nexport function json(input: Input, props: Props) {\n  return new JsonSerializer(input, props).serialize();\n}\nexport function urlencoded(input: Input, props: Props) {\n  return new UrlencodedSerializer(input, props).serialize();\n}\nexport function nobody(input: Input, props: Props) {\n  return new NoBodySerializer(input, props).serialize();\n}\nexport function formdata(input: Input, props: Props) {\n  return new FormDataSerializer(input, props).serialize();\n}\n\nexport function toRequest<T extends Endpoint>(\n  endpoint: T,\n  input: Serialized,\n): Request {\n  const [method, path] = endpoint.split(' ');\n  const pathVariable = template(path, input.params);\n\n  const url = createUrl(pathVariable, input.query);\n  return new Request(url, {\n    method: method,\n    headers: input.headers,\n    body: method === 'GET' ? undefined : input.body,\n  });\n}\n";
 
 // packages/typescript/src/lib/http/response.txt
 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";
@@ -1087,23 +1175,24 @@ function security(spec) {
   return options;
 }
 async function generate(spec, settings) {
-  const { commonSchemas, groups, outputs } = generateCode({
+  const { commonSchemas, groups, outputs, commonZod } = generateCode({
     spec,
     style: "github",
     target: "javascript"
   });
   const output = settings.mode === "full" ? join2(settings.output, "src") : settings.output;
   const options = security(spec);
-  const clientFiles = generateClientSdk({
+  const clientFiles = generateSDK({
     name: settings.name || "Client",
     operations: groups,
     servers: spec.servers?.map((server) => server.url) || [],
     options
   });
+  const inputFiles = generateInputs(groups, commonZod);
   await writeFiles(output, {
-    "outputs/index.ts": "",
-    "inputs/index.ts": ""
-    // 'models/index.ts': '',
+    "outputs/.gitkeep": "",
+    "inputs/.gitkeep": "",
+    "models/.getkeep": ""
     // 'README.md': readme,
   });
   await writeFiles(join2(output, "http"), {
@@ -1115,15 +1204,16 @@ async function generate(spec, settings) {
     "request.ts": request_default
   });
   await writeFiles(join2(output, "outputs"), outputs);
-  const imports = Object.entries(commonSchemas).map(([name]) => name);
+  const modelsImports = Object.entries(commonSchemas).map(([name]) => name);
   await writeFiles(output, {
     ...clientFiles,
+    ...inputFiles,
     ...Object.fromEntries(
       Object.entries(commonSchemas).map(([name, schema]) => [
         `models/${name}.ts`,
         [
           `import { z } from 'zod';`,
-          ...exclude(imports, [name]).map(
+          ...exclude2(modelsImports, [name]).map(
             (it) => `import type { ${it} } from './${it}.ts';`
           ),
           `export type ${name} = ${schema};`
@@ -1134,25 +1224,58 @@ async function generate(spec, settings) {
   const folders = [
     getFolderExports(output),
     getFolderExports(join2(output, "outputs")),
-    getFolderExports(join2(output, "inputs")),
+    getFolderExports(
+      join2(output, "inputs"),
+      ["ts"],
+      (dirent) => dirent.isDirectory() && dirent.name === "schemas"
+    ),
     getFolderExports(join2(output, "http"))
   ];
-  if (imports.length) {
+  if (modelsImports.length) {
     folders.push(getFolderExports(join2(output, "models")));
   }
   const [index, outputIndex, inputsIndex, httpIndex, modelsIndex] = await Promise.all(folders);
   await writeFiles(output, {
     "index.ts": index,
     "outputs/index.ts": outputIndex,
-    "inputs/index.ts": inputsIndex,
+    "inputs/index.ts": inputsIndex || null,
     "http/index.ts": httpIndex,
-    ...imports.length ? { "models/index.ts": modelsIndex } : {}
+    ...modelsImports.length ? { "models/index.ts": modelsIndex } : {}
   });
   if (settings.mode === "full") {
     await writeFiles(settings.output, {
       "package.json": {
         ignoreIfExists: true,
-        content: `{"type":"module","main":"./src/index.ts","dependencies":{"fast-content-type-parse":"^3.0.0"}}`
+        content: JSON.stringify(
+          {
+            type: "module",
+            main: "./src/index.ts",
+            dependencies: { "fast-content-type-parse": "^3.0.0" }
+          },
+          null,
+          2
+        )
+      },
+      "tsconfig.json": {
+        ignoreIfExists: false,
+        content: JSON.stringify(
+          {
+            compilerOptions: {
+              skipLibCheck: true,
+              skipDefaultLibCheck: true,
+              target: "ESNext",
+              module: "ESNext",
+              noEmit: true,
+              allowImportingTsExtensions: true,
+              verbatimModuleSyntax: true,
+              baseUrl: ".",
+              moduleResolution: "bundler"
+            },
+            include: ["**/*.ts"]
+          },
+          null,
+          2
+        )
       }
     });
   }
@@ -1161,9 +1284,6 @@ async function generate(spec, settings) {
     env: npmRunPathEnv()
   });
 }
-function exclude(list, exclude2) {
-  return list.filter((it) => !exclude2.includes(it));
-}
 
 // packages/typescript/src/lib/watcher.ts
 import { watch as nodeWatch } from "node:fs/promises";