@sdk-it/typescript 0.20.0 → 0.22.0

package/dist/index.js

@@ -1,13 +1,22 @@
 // packages/typescript/src/lib/generate.ts
 import { template as template2 } from "lodash-es";
+import { readdir } from "node:fs/promises";
 import { join as join2 } from "node:path";
 import { npmRunPathEnv } from "npm-run-path";
-import { spinalcase as spinalcase3 } from "stringcase";
-import { methods, pascalcase as pascalcase3 } from "@sdk-it/core";
+import { camelcase as camelcase4, spinalcase as spinalcase3 } from "stringcase";
+import { methods, pascalcase as pascalcase5, toLitObject as toLitObject2 } from "@sdk-it/core";
 import {
+  createWriterProxy,
   getFolderExports,
   writeFiles
 } from "@sdk-it/core/file-system.js";
+import { toReadme } from "@sdk-it/readme";
+import {
+  augmentSpec,
+  cleanFiles,
+  readWriteMetadata,
+  sanitizeTag as sanitizeTag4
+} from "@sdk-it/spec";
 
 // packages/typescript/src/lib/client.ts
 import { toLitObject } from "@sdk-it/core";
@@ -32,11 +41,9 @@ var client_default = (spec, style) => {
       schema: spec.servers.length ? `z.enum(servers).default(servers[0])` : "z.string()"
     }
   };
-  return `
+  return `import z from 'zod';
 import type { HeadersInit, RequestConfig } from './http/${spec.makeImport("request")}';
-import { fetchType, dispatch, parse } from './http/${spec.makeImport("send-request")}';
-import z from 'zod';
-import type { Endpoints } from './api/${spec.makeImport("endpoints")}';
+import { fetchType, parse } from './http/${spec.makeImport("dispatcher")}';
 import schemas from './api/${spec.makeImport("schemas")}';
 import {
   createBaseUrlInterceptor,
@@ -57,13 +64,18 @@ export class ${spec.name} {
     this.options = optionsSchema.parse(options);
   }
 
-  async request<E extends keyof Endpoints>(
+  async request<const E extends keyof typeof schemas>(
     endpoint: E,
-    input: Endpoints[E]['input'],
+    input: z.infer<(typeof schemas)[E]['schema']>,
     options?: { signal?: AbortSignal, headers?: HeadersInit },
-  ) ${style.errorAsValue ? `: Promise<readonly [Endpoints[E]['output'], Endpoints[E]['error'] | null]>` : `: Promise<Endpoints[E]['output']>`} {
+  ) ${style.errorAsValue ? `: Promise<Awaited<ReturnType<(typeof schemas)[E]['dispatch']>>| [never, ParseError<(typeof schemas)[E]['schema']>]>` : `: Promise<Awaited<ReturnType<(typeof schemas)[E]['dispatch']>>>`} {
     const route = schemas[endpoint];
-    const result = await dispatch(Object.assign(this.#defaultInputs, input), route, {
+    const withDefaultInputs = Object.assign({}, this.#defaultInputs, input);
+    const [parsedInput, parseError] = parseInput(route.schema, withDefaultInputs);
+    if (parseError) {
+      ${style.errorAsValue ? "return [null as never, parseError as never] as const;" : "throw parseError;"}
+    }
+    const result = await route.dispatch(parsedInput as never, {
       fetch: this.options.fetch,
       interceptors: [
         createHeadersInterceptor(() => this.defaultHeaders, options?.headers ?? {}),
@@ -71,12 +83,12 @@ export class ${spec.name} {
       ],
       signal: options?.signal,
     });
-    return ${style.errorAsValue ? `result as [Endpoints[E]['output'], Endpoints[E]['error'] | null]` : `result as Endpoints[E]['output']`};
+    return result as Awaited<ReturnType<(typeof schemas)[E]['dispatch']>>;
   }
 
-  async prepare<E extends keyof Endpoints>(
+  async prepare<const E extends keyof typeof schemas>(
     endpoint: E,
-    input: Endpoints[E]['input'],
+    input: z.infer<(typeof schemas)[E]['schema']>,
     options?: { headers?: HeadersInit },
   ): ${style.errorAsValue ? `Promise<
     readonly [
@@ -108,8 +120,8 @@ export class ${spec.name} {
         config = await interceptor.before(config);
       }
     }
-    const prepared = { ...config, parse: (response: Response) => parse(route, response) };
-    return ${style.errorAsValue ? "[prepared, null as never] as const;" : "prepared"}
+    const prepared = { ...config, parse: (response: Response) => parse(route.output, response) as never };
+    return ${style.errorAsValue ? "[prepared, null as never] as const;" : "prepared as any"}
   }
 
   get defaultHeaders() {
@@ -132,258 +144,185 @@ export class ${spec.name} {
 }`;
 };
 
-// packages/typescript/src/lib/generator.ts
-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 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) {
-      return camelcase(operation.operationId);
-    }
-    const metadata = operation["x-oaiMeta"];
-    if (metadata && metadata.name) {
-      return camelcase(metadata.name);
-    }
-    return camelcase(
-      [method, ...path.replace(/[\\/\\{\\}]/g, " ").split(" ")].filter(Boolean).join(" ").trim()
-    );
-  },
-  tag: (operation, path) => {
-    return operation.tags?.[0] ? sanitizeTag(operation.tags?.[0]) : determineGenericTag(path, operation);
+// packages/typescript/src/lib/emitters/interface.ts
+import { followRef, isRef, parseRef, pascalcase } from "@sdk-it/core";
+import { isPrimitiveSchema, sanitizeTag } from "@sdk-it/spec";
+var TypeScriptEmitter = class {
+  #spec;
+  constructor(spec) {
+    this.#spec = spec;
   }
-};
-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 ?? {})) {
-    const { parameters = [], ...methods2 } = pathItem;
-    const fixedPath = path.replace(/:([^/]+)/g, "{$1}");
-    for (const [method, operation] of Object.entries(methods2)) {
-      const formatOperationId = config.operationId ?? defaults.operationId;
-      const formatTag = config.tag ?? defaults.tag;
-      const operationName = formatOperationId(operation, fixedPath, method);
-      const operationTag = formatTag(operation, fixedPath);
-      const metadata = operation["x-oaiMeta"] ?? {};
-      result.push(
-        callback(
-          {
-            name: metadata.name,
-            method,
-            path: fixedPath,
-            groupName: operationTag,
-            tag: operationTag
-          },
-          {
-            ...operation,
-            parameters: [...parameters, ...operation.parameters ?? []],
-            operationId: operationName,
-            responses: resolveResponses(config.spec, operation)
-          }
-        )
-      );
+  #stringifyKey = (value) => {
+    return `'${value}'`;
+  };
+  object(schema, required = false) {
+    const properties = schema.properties || {};
+    const propEntries = Object.entries(properties).map(([key, propSchema]) => {
+      const isRequired = (schema.required ?? []).includes(key);
+      const tsType = this.handle(propSchema, isRequired);
+      return `${this.#stringifyKey(key)}: ${tsType}`;
+    });
+    if (schema.additionalProperties) {
+      if (typeof schema.additionalProperties === "object") {
+        const indexType = this.handle(schema.additionalProperties, true);
+        propEntries.push(`[key: string]: ${indexType}`);
+      } else if (schema.additionalProperties === true) {
+        propEntries.push("[key: string]: any");
+      }
     }
+    return `${propEntries.length ? `{ ${propEntries.join("; ")} }` : "unknown"}`;
   }
-  return result;
-}
-var reservedKeywords = /* @__PURE__ */ new Set([
-  "await",
-  // Reserved in async functions
-  "break",
-  "case",
-  "catch",
-  "class",
-  "const",
-  "continue",
-  "debugger",
-  "default",
-  "delete",
-  "do",
-  "else",
-  "enum",
-  "export",
-  "extends",
-  "false",
-  "finally",
-  "for",
-  "function",
-  "if",
-  "implements",
-  // Strict mode
-  "import",
-  "in",
-  "instanceof",
-  "interface",
-  // Strict mode
-  "let",
-  // Strict mode
-  "new",
-  "null",
-  "package",
-  // Strict mode
-  "private",
-  // Strict mode
-  "protected",
-  // Strict mode
-  "public",
-  // Strict mode
-  "return",
-  "static",
-  // Strict mode
-  "super",
-  "switch",
-  "this",
-  "throw",
-  "true",
-  "try",
-  "typeof",
-  "var",
-  "void",
-  "while",
-  "with",
-  "yield",
-  // 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(camelcase(camelCasedTag)) ? `${camelCasedTag}_` : camelCasedTag;
-}
-function determineGenericTag(pathString, operation) {
-  const operationId = operation.operationId || "";
-  const VERSION_REGEX = /^[vV]\d+$/;
-  const commonVerbs = /* @__PURE__ */ new Set([
-    // Verbs to potentially strip from operationId prefix
-    "get",
-    "list",
-    "create",
-    "update",
-    "delete",
-    "post",
-    "put",
-    "patch",
-    "do",
-    "send",
-    "add",
-    "remove",
-    "set",
-    "find",
-    "search",
-    "check",
-    "make"
-  ]);
-  const segments = pathString.split("/").filter(Boolean);
-  const potentialCandidates = segments.filter(
-    (segment) => segment && !segment.startsWith("{") && !segment.endsWith("}") && !VERSION_REGEX.test(segment)
-  );
-  for (let i = potentialCandidates.length - 1; i >= 0; i--) {
-    const segment = potentialCandidates[i];
-    if (!segment.startsWith("@")) {
-      return sanitizeTag(camelcase(segment));
-    }
-  }
-  const canFallbackToPathSegment = potentialCandidates.length > 0;
-  if (operationId) {
-    const lowerOpId = operationId.toLowerCase();
-    const parts = operationId.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").replace(/([a-zA-Z])(\d)/g, "$1_$2").replace(/(\d)([a-zA-Z])/g, "$1_$2").toLowerCase().split(/[_-\s]+/);
-    const validParts = parts.filter(Boolean);
-    if (commonVerbs.has(lowerOpId) && validParts.length === 1 && canFallbackToPathSegment) {
-    } else if (validParts.length > 0) {
-      const firstPart = validParts[0];
-      const isFirstPartVerb = commonVerbs.has(firstPart);
-      if (isFirstPartVerb && validParts.length > 1) {
-        const verbPrefixLength = firstPart.length;
-        let nextPartStartIndex = -1;
-        if (operationId.length > verbPrefixLength) {
-          const charAfterPrefix = operationId[verbPrefixLength];
-          if (charAfterPrefix >= "A" && charAfterPrefix <= "Z") {
-            nextPartStartIndex = verbPrefixLength;
-          } else if (charAfterPrefix >= "0" && charAfterPrefix <= "9") {
-            nextPartStartIndex = verbPrefixLength;
-          } else if (["_", "-"].includes(charAfterPrefix)) {
-            nextPartStartIndex = verbPrefixLength + 1;
-          } else {
-            const match = operationId.substring(verbPrefixLength).match(/[A-Z0-9]/);
-            if (match && match.index !== void 0) {
-              nextPartStartIndex = verbPrefixLength + match.index;
-            }
-            if (nextPartStartIndex === -1 && operationId.length > verbPrefixLength) {
-              nextPartStartIndex = verbPrefixLength;
-            }
-          }
-        }
-        if (nextPartStartIndex !== -1 && nextPartStartIndex < operationId.length) {
-          const remainingOriginalSubstring = operationId.substring(nextPartStartIndex);
-          const potentialTag = camelcase(remainingOriginalSubstring);
-          if (potentialTag) {
-            return sanitizeTag(potentialTag);
-          }
-        }
-        const potentialTagJoined = camelcase(validParts.slice(1).join("_"));
-        if (potentialTagJoined) {
-          return sanitizeTag(potentialTagJoined);
-        }
-      }
-      const potentialTagFull = camelcase(operationId);
-      if (potentialTagFull) {
-        const isResultSingleVerb = validParts.length === 1 && isFirstPartVerb;
-        if (!(isResultSingleVerb && canFallbackToPathSegment)) {
-          if (potentialTagFull.length > 0) {
-            return sanitizeTag(potentialTagFull);
-          }
-        }
-      }
-      const firstPartCamel = camelcase(firstPart);
-      if (firstPartCamel) {
-        const isFirstPartCamelVerb = commonVerbs.has(firstPartCamel);
-        if (!isFirstPartCamelVerb || validParts.length === 1 || !canFallbackToPathSegment) {
-          return sanitizeTag(firstPartCamel);
-        }
-      }
-      if (isFirstPartVerb && validParts.length > 1 && validParts[1] && canFallbackToPathSegment) {
-        const secondPartCamel = camelcase(validParts[1]);
-        if (secondPartCamel) {
-          return sanitizeTag(secondPartCamel);
-        }
-      }
+  /**
+   * Handle arrays (items could be a single schema or a tuple)
+   */
+  #array(schema, required = false) {
+    const { items } = schema;
+    if (!items) {
+      return "any[]";
     }
+    if (Array.isArray(items)) {
+      const tupleItems = items.map((sub) => this.handle(sub, true));
+      return `[${tupleItems.join(", ")}]`;
+    }
+    const itemsType = this.handle(items, true);
+    return itemsType.length > 1 ? `(${itemsType})[]` : `${itemsType}[]`;
   }
-  if (potentialCandidates.length > 0) {
-    let firstCandidate = potentialCandidates[0];
-    if (firstCandidate.startsWith("@")) {
-      firstCandidate = firstCandidate.substring(1);
+  /**
+   * Convert a basic type (string | number | boolean | object | array, etc.) to TypeScript
+   */
+  normal(type, schema, required = false) {
+    switch (type) {
+      case "string":
+        return this.string(schema, required);
+      case "number":
+      case "integer":
+        return this.number(schema, required);
+      case "boolean":
+        return appendOptional("boolean", required);
+      case "object":
+        return this.object(schema, required);
+      case "array":
+        return this.#array(schema, required);
+      case "null":
+        return "null";
+      default:
+        console.warn(`Unknown type: ${type}`);
+        return appendOptional("any", required);
     }
-    if (firstCandidate) {
-      return sanitizeTag(camelcase(firstCandidate));
+  }
+  #ref($ref, required) {
+    const schemaName = pascalcase(sanitizeTag(parseRef($ref).model));
+    const schema = followRef(this.#spec, $ref);
+    if (isPrimitiveSchema(schema)) {
+      return this.handle(schema, required);
     }
+    return `models.${appendOptional(schemaName, required)}`;
   }
-  console.warn(
-    `Could not determine a suitable tag for path: ${pathString}, operationId: ${operationId}. Using 'unknown'.`
-  );
-  return "unknown";
+  allOf(schemas) {
+    const allOfTypes = schemas.map((sub) => this.handle(sub, true));
+    return allOfTypes.length > 1 ? `${allOfTypes.join(" & ")}` : allOfTypes[0];
+  }
+  oneOf(schemas, required) {
+    const oneOfTypes = schemas.map((sub) => this.handle(sub, true));
+    return appendOptional(
+      oneOfTypes.length > 1 ? `${oneOfTypes.join(" | ")}` : oneOfTypes[0],
+      required
+    );
+  }
+  anyOf(schemas, required) {
+    return this.oneOf(schemas, required);
+  }
+  enum(values, required) {
+    const enumValues = values.map((val) => typeof val === "string" ? `'${val}'` : `${val}`).join(" | ");
+    return appendOptional(enumValues, required);
+  }
+  /**
+   * Handle string type with formats
+   */
+  string(schema, required) {
+    let type;
+    if (schema.contentEncoding === "binary") {
+      return appendOptional("Blob", required);
+    }
+    switch (schema.format) {
+      case "date-time":
+      case "datetime":
+      case "date":
+        type = "Date";
+        break;
+      case "binary":
+      case "byte":
+        type = "Blob";
+        break;
+      case "int64":
+        type = "bigint";
+        break;
+      default:
+        type = "string";
+    }
+    return appendOptional(type, required);
+  }
+  /**
+   * Handle number/integer types with formats
+   */
+  number(schema, required) {
+    const type = schema.format === "int64" ? "bigint" : "number";
+    return appendOptional(type, required);
+  }
+  handle(schema, required) {
+    if (isRef(schema)) {
+      return this.#ref(schema.$ref, required);
+    }
+    if (schema.allOf && Array.isArray(schema.allOf)) {
+      return this.allOf(schema.allOf);
+    }
+    if (schema.anyOf && Array.isArray(schema.anyOf)) {
+      return this.anyOf(schema.anyOf, required);
+    }
+    if (schema.oneOf && Array.isArray(schema.oneOf)) {
+      return this.oneOf(schema.oneOf, required);
+    }
+    if (schema.enum && Array.isArray(schema.enum)) {
+      return this.enum(schema.enum, required);
+    }
+    if (schema.const) {
+      return this.enum([schema.const], true);
+    }
+    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) {
+      const realTypes = types.filter((t) => t !== "null");
+      if (realTypes.length === 1 && types.includes("null")) {
+        const tsType = this.normal(realTypes[0], schema, false);
+        return appendOptional(`${tsType} | null`, required);
+      }
+      const typeResults = types.map((t) => this.normal(t, schema, false));
+      return appendOptional(typeResults.join(" | "), required);
+    }
+    return this.normal(types[0], schema, required);
+  }
+};
+function appendOptional(type, isRequired) {
+  return isRequired ? type : `${type} | undefined`;
 }
 
+// packages/typescript/src/lib/generator.ts
+import { merge, template } from "lodash-es";
+import { join } from "node:path";
+import { camelcase as camelcase2, spinalcase } from "stringcase";
+import { followRef as followRef4, isEmpty as isEmpty2, isRef as isRef4, resolveRef } from "@sdk-it/core";
+import { forEachOperation } from "@sdk-it/spec";
+
 // packages/typescript/src/lib/emitters/zod.ts
-import { cleanRef, followRef as followRef2, isRef as isRef2 } from "@sdk-it/core";
-var ZodDeserialzer = class {
-  generatedRefs = /* @__PURE__ */ new Set();
+import { followRef as followRef2, isRef as isRef2, parseRef as parseRef2, pascalcase as pascalcase2 } from "@sdk-it/core";
+import { isPrimitiveSchema as isPrimitiveSchema2, sanitizeTag as sanitizeTag2 } from "@sdk-it/spec";
+var ZodEmitter = class {
+  #generatedRefs = /* @__PURE__ */ new Set();
   #spec;
   #onRef;
   constructor(spec, onRef) {
@@ -410,25 +349,21 @@ var ZodDeserialzer = class {
     }
     return `z.object({${propEntries.join(", ")}})${additionalProps}`;
   }
-  /**
-   * Handle arrays (items could be a single schema or a tuple (array of schemas)).
-   * In JSON Schema 2020-12, `items` can be an array → tuple style.
-   */
-  array(schema, required = false) {
+  #array(schema, required = false) {
     const { items } = schema;
     if (!items) {
-      return `z.array(z.unknown())${appendOptional(required)}`;
+      return `z.array(z.unknown())${appendOptional2(required)}`;
     }
     if (Array.isArray(items)) {
       const tupleItems = items.map((sub) => this.handle(sub, true));
       const base = `z.tuple([${tupleItems.join(", ")}])`;
-      return `${base}${appendOptional(required)}`;
+      return `${base}${appendOptional2(required)}`;
     }
     const itemsSchema = this.handle(items, true);
-    return `z.array(${itemsSchema})${appendOptional(required)}`;
+    return `z.array(${itemsSchema})${this.#suffixes(JSON.stringify(schema.default), required, false)}`;
   }
   #suffixes = (defaultValue, required, nullable) => {
-    return `${nullable ? ".nullable()" : ""}${appendDefault(defaultValue)}${appendOptional(required)}`;
+    return `${nullable ? ".nullable()" : ""}${appendDefault(defaultValue)}${appendOptional2(required)}`;
   };
   /**
    * Convert a basic type (string | number | boolean | object | array, etc.) to Zod.
@@ -448,55 +383,58 @@ var ZodDeserialzer = class {
       case "object":
         return `${this.object(schema)}${this.#suffixes(JSON.stringify(schema.default), required, nullable)}`;
       case "array":
-        return this.array(schema, required);
+        return this.#array(schema, required);
       case "null":
-        return `z.null()${appendOptional(required)}`;
+        return `z.null()${appendOptional2(required)}`;
       default:
-        return `z.unknown()${appendOptional(required)}`;
+        return `z.unknown()${appendOptional2(required)}`;
     }
   }
-  ref($ref, required) {
-    const schemaName = cleanRef($ref).split("/").pop();
-    if (this.generatedRefs.has(schemaName)) {
+  #ref($ref, required) {
+    const schemaName = pascalcase2(sanitizeTag2(parseRef2($ref).model));
+    const schema = followRef2(this.#spec, $ref);
+    if (isPrimitiveSchema2(schema)) {
+      const result = this.handle(schema, required);
+      this.#onRef?.(schemaName, result);
+      return result;
+    }
+    if (this.#generatedRefs.has(schemaName)) {
       return schemaName;
     }
-    this.generatedRefs.add(schemaName);
-    this.#onRef?.(
-      schemaName,
-      this.handle(followRef2(this.#spec, $ref), required)
-    );
+    this.#generatedRefs.add(schemaName);
+    this.#onRef?.(schemaName, this.handle(schema, required));
     return schemaName;
   }
+  #toIntersection(schemas) {
+    const [left, ...right] = schemas;
+    if (!right.length) {
+      return left;
+    }
+    return `z.intersection(${left}, ${this.#toIntersection(right)})`;
+  }
   allOf(schemas, required) {
     const allOfSchemas = schemas.map((sub) => this.handle(sub, true));
     if (allOfSchemas.length === 0) {
       return `z.unknown()`;
     }
     if (allOfSchemas.length === 1) {
-      return `${allOfSchemas[0]}${appendOptional(required)}`;
+      return `${allOfSchemas[0]}${appendOptional2(required)}`;
     }
-    return `${this.#toIntersection(allOfSchemas)}${appendOptional(required)}`;
-  }
-  #toIntersection(schemas) {
-    const [left, ...right] = schemas;
-    if (!right.length) {
-      return left;
-    }
-    return `z.intersection(${left}, ${this.#toIntersection(right)})`;
+    return `${this.#toIntersection(allOfSchemas)}${appendOptional2(required)}`;
   }
   anyOf(schemas, required) {
     const anyOfSchemas = schemas.map((sub) => this.handle(sub, true));
     if (anyOfSchemas.length === 1) {
-      return `${anyOfSchemas[0]}${appendOptional(required)}`;
+      return `${anyOfSchemas[0]}${appendOptional2(required)}`;
     }
-    return `z.union([${anyOfSchemas.join(", ")}])${appendOptional(required)}`;
+    return `z.union([${anyOfSchemas.join(", ")}])${appendOptional2(required)}`;
   }
   oneOf(schemas, required) {
     const oneOfSchemas = schemas.map((sub) => this.handle(sub, true));
     if (oneOfSchemas.length === 1) {
-      return `${oneOfSchemas[0]}${appendOptional(required)}`;
+      return `${oneOfSchemas[0]}${appendOptional2(required)}`;
     }
-    return `z.union([${oneOfSchemas.join(", ")}])${appendOptional(required)}`;
+    return `z.union([${oneOfSchemas.join(", ")}])${appendOptional2(required)}`;
   }
   enum(type, values) {
     if (values.length === 1) {
@@ -594,7 +532,7 @@ var ZodDeserialzer = class {
   }
   handle(schema, required) {
     if (isRef2(schema)) {
-      return `${this.ref(schema.$ref, true)}${appendOptional(required)}`;
+      return `${this.#ref(schema.$ref, true)}${appendOptional2(required)}`;
     }
     if (schema.allOf && Array.isArray(schema.allOf)) {
       return this.allOf(schema.allOf ?? [], required);
@@ -612,7 +550,7 @@ var ZodDeserialzer = class {
     }
     const types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
     if (!types.length) {
-      return `z.unknown()${appendOptional(required)}`;
+      return `z.unknown()${appendOptional2(required)}`;
     }
     if ("nullable" in schema && schema.nullable) {
       types.push("null");
@@ -625,12 +563,12 @@ var ZodDeserialzer = class {
         return this.normal(realTypes[0], schema, required, true);
       }
       const subSchemas = types.map((t) => this.normal(t, schema, false));
-      return `z.union([${subSchemas.join(", ")}])${appendOptional(required)}`;
+      return `z.union([${subSchemas.join(", ")}])${appendOptional2(required)}`;
     }
     return this.normal(types[0], schema, required, false);
   }
 };
-function appendOptional(isRequired) {
+function appendOptional2(isRequired) {
   return isRequired ? "" : ".optional()";
 }
 function appendDefault(defaultValue) {
@@ -638,201 +576,46 @@ 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 followRef4, isRef as isRef5, toLitObject as toLitObject2 } from "@sdk-it/core";
-
-// packages/typescript/src/lib/emitters/interface.ts
-import { cleanRef as cleanRef2, followRef as followRef3, isRef as isRef3 } from "@sdk-it/core";
-var TypeScriptDeserialzer = class {
-  generatedRefs = /* @__PURE__ */ new Set();
-  #spec;
-  #onRef;
-  constructor(spec, onRef) {
-    this.#spec = spec;
-    this.#onRef = onRef;
-  }
-  #stringifyKey = (value) => {
-    return `'${value}'`;
-  };
-  #isInternal = (schema) => {
-    return isRef3(schema) ? false : !!schema["x-internal"];
-  };
-  /**
-   * Handle objects (properties)
-   */
-  object(schema, required = false) {
-    const properties = schema.properties || {};
-    const propEntries = Object.entries(properties).map(([key, propSchema]) => {
-      const isRequired = (schema.required ?? []).includes(key);
-      const tsType = this.handle(propSchema, isRequired);
-      return `${this.#isInternal(propSchema) ? key : this.#stringifyKey(key)}: ${tsType}`;
-    });
-    if (schema.additionalProperties) {
-      if (typeof schema.additionalProperties === "object") {
-        const indexType = this.handle(schema.additionalProperties, true);
-        propEntries.push(`[key: string]: ${indexType}`);
-      } else if (schema.additionalProperties === true) {
-        propEntries.push("[key: string]: any");
-      }
-    }
-    return `{ ${propEntries.join("; ")} }`;
-  }
-  /**
-   * Handle arrays (items could be a single schema or a tuple)
-   */
-  array(schema, required = false) {
-    const { items } = schema;
-    if (!items) {
-      return "any[]";
-    }
-    if (Array.isArray(items)) {
-      const tupleItems = items.map((sub) => this.handle(sub, true));
-      return `[${tupleItems.join(", ")}]`;
-    }
-    const itemsType = this.handle(items, true);
-    return `${itemsType}[]`;
-  }
-  /**
-   * Convert a basic type (string | number | boolean | object | array, etc.) to TypeScript
-   */
-  normal(type, schema, required = false) {
-    switch (type) {
-      case "string":
-        return this.string(schema, required);
-      case "number":
-      case "integer":
-        return this.number(schema, required);
-      case "boolean":
-        return appendOptional2("boolean", required);
-      case "object":
-        return this.object(schema, required);
-      case "array":
-        return this.array(schema, required);
-      case "null":
-        return "null";
-      default:
-        console.warn(`Unknown type: ${type}`);
-        return appendOptional2("any", required);
-    }
-  }
-  ref($ref, required) {
-    const schemaName = cleanRef2($ref).split("/").pop();
-    if (this.generatedRefs.has(schemaName)) {
-      return schemaName;
-    }
-    this.generatedRefs.add(schemaName);
-    this.#onRef?.(
-      schemaName,
-      this.handle(followRef3(this.#spec, $ref), required)
-    );
-    return appendOptional2(schemaName, required);
-  }
-  allOf(schemas) {
-    const allOfTypes = schemas.map((sub) => this.handle(sub, true));
-    return allOfTypes.length > 1 ? `${allOfTypes.join(" & ")}` : allOfTypes[0];
-  }
-  anyOf(schemas, required) {
-    const anyOfTypes = schemas.map((sub) => this.handle(sub, true));
-    return appendOptional2(
-      anyOfTypes.length > 1 ? `${anyOfTypes.join(" | ")}` : anyOfTypes[0],
-      required
-    );
-  }
-  oneOf(schemas, required) {
-    const oneOfTypes = schemas.map((sub) => {
-      return this.handle(sub, false);
-    });
-    return appendOptional2(
-      oneOfTypes.length > 1 ? `${oneOfTypes.join(" | ")}` : oneOfTypes[0],
-      required
-    );
-  }
-  enum(values, required) {
-    const enumValues = values.map((val) => typeof val === "string" ? `'${val}'` : `${val}`).join(" | ");
-    return appendOptional2(enumValues, required);
-  }
-  /**
-   * Handle string type with formats
-   */
-  string(schema, required) {
-    let type;
-    if (schema.contentEncoding === "binary") {
-      return appendOptional2("Blob", required);
-    }
-    switch (schema.format) {
-      case "date-time":
-      case "datetime":
-      case "date":
-        type = "Date";
-        break;
-      case "binary":
-      case "byte":
-        type = "Blob";
-        break;
-      case "int64":
-        type = "bigint";
-        break;
-      default:
-        type = "string";
-    }
-    return appendOptional2(type, required);
-  }
-  /**
-   * Handle number/integer types with formats
-   */
-  number(schema, required) {
-    const type = schema.format === "int64" ? "bigint" : "number";
-    return appendOptional2(type, required);
-  }
-  handle(schema, required) {
-    if (isRef3(schema)) {
-      return this.ref(schema.$ref, required);
-    }
-    if (schema.allOf && Array.isArray(schema.allOf)) {
-      return this.allOf(schema.allOf);
-    }
-    if (schema.anyOf && Array.isArray(schema.anyOf)) {
-      return this.anyOf(schema.anyOf, required);
-    }
-    if (schema.oneOf && Array.isArray(schema.oneOf)) {
-      return this.oneOf(schema.oneOf, required);
-    }
-    if (schema.enum && Array.isArray(schema.enum)) {
-      return this.enum(schema.enum, required);
-    }
-    if (schema.const) {
-      if (schema["x-internal"]) {
-        return `${schema.const}`;
-      }
-      return this.enum([schema.const], required);
-    }
-    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 appendOptional2("any", required);
-    }
-    if (types.length > 1) {
-      const realTypes = types.filter((t) => t !== "null");
-      if (realTypes.length === 1 && types.includes("null")) {
-        const tsType = this.normal(realTypes[0], schema, false);
-        return appendOptional2(`${tsType} | null`, required);
-      }
-      const typeResults = types.map((t) => this.normal(t, schema, false));
-      return appendOptional2(typeResults.join(" | "), required);
-    }
-    return this.normal(types[0], schema, required);
-  }
+import { camelcase } from "stringcase";
+import { isEmpty, pascalcase as pascalcase3 } from "@sdk-it/core";
+import {
+  isErrorStatusCode,
+  isStreamingContentType,
+  isSuccessStatusCode,
+  isTextContentType,
+  parseJsonContentType,
+  sanitizeTag as sanitizeTag3
+} from "@sdk-it/spec";
+
+// packages/typescript/src/lib/status-map.ts
+var status_map_default = {
+  "200": "Ok",
+  "201": "Created",
+  "202": "Accepted",
+  "204": "NoContent",
+  "400": "BadRequest",
+  "401": "Unauthorized",
+  "402": "PaymentRequired",
+  "403": "Forbidden",
+  "404": "NotFound",
+  "405": "MethodNotAllowed",
+  "406": "NotAcceptable",
+  "409": "Conflict",
+  "412": "PreconditionFailed",
+  "413": "PayloadTooLarge",
+  "410": "Gone",
+  "422": "UnprocessableEntity",
+  "429": "TooManyRequests",
+  "500": "InternalServerError",
+  "501": "NotImplemented",
+  "502": "BadGateway",
+  "503": "ServiceUnavailable",
+  "504": "GatewayTimeout"
 };
-function appendOptional2(type, isRequired) {
-  return isRequired ? type : `${type} | undefined`;
-}
 
 // packages/typescript/src/lib/utils.ts
-import { isRef as isRef4, removeDuplicates } from "@sdk-it/core";
-function securityToOptions(security2, securitySchemes, staticIn) {
+import { followRef as followRef3, isRef as isRef3, removeDuplicates } from "@sdk-it/core";
+function securityToOptions(spec, security2, securitySchemes, staticIn) {
   securitySchemes ??= {};
   const options = {};
   for (const it of security2) {
@@ -840,10 +623,7 @@ function securityToOptions(security2, securitySchemes, staticIn) {
     if (!name) {
       continue;
     }
-    const schema = securitySchemes[name];
-    if (isRef4(schema)) {
-      throw new Error(`Ref security schemas are not supported`);
-    }
+    const schema = isRef3(securitySchemes[name]) ? followRef3(spec, securitySchemes[name].$ref) : securitySchemes[name];
     if (schema.type === "http") {
       options["authorization"] = {
         in: staticIn ?? "header",
@@ -901,73 +681,11 @@ function importsToString(...imports) {
     throw new Error(`Invalid import ${JSON.stringify(it)}`);
   });
 }
-function exclude(list, exclude2) {
-  return list.filter((it) => !exclude2.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/sdk.ts
-function generateInputs(operationsSet, commonZod, makeImport) {
-  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 = camelcase2(`${operation.name} schema`);
-      const schema = `export const ${schemaName} = ${Object.keys(operation.schemas).length === 1 ? Object.values(operation.schemas)[0] : toLitObject2(operation.schemas)};`;
-      const inputContent = schema;
-      for (const schema2 of commonImports) {
-        if (inputContent.includes(schema2)) {
-          imports.add(
-            `import { ${schema2} } from './schemas/${makeImport(spinalcase(schema2))}';`
-          );
-        }
-      }
-      output.push(inputContent);
-    }
-    inputs[`inputs/${spinalcase(name)}.ts`] = [...imports, ...output].join("\n") + "\n";
-  }
-  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 './${makeImport(spinalcase(schema2))}';`
-        );
-      }
-    }
-    output.push(content);
-    return [
-      [`inputs/schemas/${spinalcase(name)}.ts`, output.join("\n")],
-      ...acc
-    ];
-  }, []);
-  return {
-    ...Object.fromEntries(schemas),
-    ...inputs
-  };
-}
 function toEndpoint(groupName, spec, specOperation, operation, utils) {
-  const schemaName = camelcase2(`${operation.name} schema`);
-  const schemaRef = `${camelcase2(groupName)}.${schemaName}`;
+  const schemaName = camelcase(`${operation.name} schema`);
+  const schemaRef = `${camelcase(groupName)}.${schemaName}`;
   const inputHeaders = [];
   const inputQuery = [];
   const inputBody = [];
@@ -995,20 +713,13 @@ function toEndpoint(groupName, spec, specOperation, operation, utils) {
   }
   specOperation.responses ??= {};
   const outputs = [];
-  const statusesCount = Object.keys(specOperation.responses).filter((status) => {
-    const statusCode = +status;
-    return statusCode >= 200 && statusCode < 300;
-  }).length > 1;
   for (const status in specOperation.responses) {
-    const response = isRef5(specOperation.responses[status]) ? followRef4(spec, specOperation.responses[status].$ref) : specOperation.responses[status];
     const handled = handleResponse(
       spec,
       operation.name,
       status,
-      response,
-      utils,
-      true
-      // statusesCount,
+      specOperation.responses[status],
+      utils
     );
     responses.push(handled);
     outputs.push(...handled.outputs);
@@ -1019,49 +730,112 @@ function toEndpoint(groupName, spec, specOperation, operation, utils) {
     if (addTypeParser && type !== "json") {
       typePrefix = `${type} `;
     }
-    const endpoint = `${typePrefix}${operation.trigger.method.toUpperCase()} ${operation.trigger.path}`;
+    const endpoint = `${typePrefix}${operation.method.toUpperCase()} ${operation.path}`;
     schemas.push(
       `"${endpoint}": {
           schema: ${schemaRef}${addTypeParser ? `.${type}` : ""},
           output:[${outputs.join(",")}],
           toRequest(input: z.infer<typeof ${schemaRef}${addTypeParser ? `.${type}` : ""}>) {
-            const endpoint = '${endpoint}';
-                return toRequest(endpoint, ${operation.outgoingContentType || "nobody"}(input, {
-                inputHeaders: [${inputHeaders}],
-                inputQuery: [${inputQuery}],
-                inputBody: [${inputBody}],
-                inputParams: [${inputParams}],
-              }));
-            },
-          }`
+           return toRequest('${endpoint}', ${operation.outgoingContentType || "empty"}(input, {
+              inputHeaders: [${inputHeaders}],
+              inputQuery: [${inputQuery}],
+              inputBody: [${inputBody}],
+              inputParams: [${inputParams}],
+            }));},
+         async dispatch(input: z.infer<typeof ${schemaRef}${addTypeParser ? `.${type}` : ""}>,options: {
+            signal?: AbortSignal;
+            interceptors: Interceptor[];
+            fetch: z.infer<typeof fetchType>;
+          })${specOperation["x-pagination"] ? paginationOperation(specOperation, utils.style) : normalOperation(utils.style)}`
     );
   }
   return { responses, schemas };
 }
-var statusCodeToResponseMap = {
-  "200": "Ok",
-  "201": "Created",
-  "202": "Accepted",
-  "204": "NoContent",
-  "400": "BadRequest",
-  "401": "Unauthorized",
-  "402": "PaymentRequired",
-  "403": "Forbidden",
-  "404": "NotFound",
-  "405": "MethodNotAllowed",
-  "406": "NotAcceptable",
-  "409": "Conflict",
-  "413": "PayloadTooLarge",
-  "410": "Gone",
-  "422": "UnprocessableEntity",
-  "429": "TooManyRequests",
-  "500": "InternalServerError",
-  "501": "NotImplemented",
-  "502": "BadGateway",
-  "503": "ServiceUnavailable",
-  "504": "GatewayTimeout"
-};
-function handleResponse(spec, operationName, status, response, utils, numbered) {
+function normalOperation(style) {
+  return `{
+            const dispatcher = new Dispatcher(options.interceptors, options.fetch);
+            const result = await dispatcher.send(this.toRequest(input), this.output);
+            return ${style?.outputType === "status" ? "result" : style?.errorAsValue ? `result` : "result.data;"}
+            },
+          }`;
+}
+function paginationOperation(operation, style) {
+  const pagination = operation["x-pagination"];
+  const data = `${style?.errorAsValue ? `result[0]${style.outputType === "status" ? "" : ""}` : `${style?.outputType === "default" ? "result.data" : "result.data"}`}`;
+  const returnValue = `${style?.errorAsValue ? `[${style?.outputType === "status" ? "new http.Ok(pagination)" : "pagination"}, null]` : `${style?.outputType === "status" ? "new http.Ok(pagination);" : "pagination"}`}`;
+  if (pagination.type === "offset") {
+    const sameInputNames = pagination.limitParamName === "limit" && pagination.offsetParamName === "offset";
+    const initialParams = sameInputNames ? "input" : `{...input, limit: input.${pagination.limitParamName}, offset: input.${pagination.offsetParamName}}`;
+    const nextPageParams = sameInputNames ? "...nextPageParams" : `${pagination.offsetParamName}: nextPageParams.offset, ${pagination.limitParamName}: nextPageParams.limit`;
+    const logic = `const pagination = new OffsetPagination(${initialParams}, async (nextPageParams) => {
+        const dispatcher = new Dispatcher(options.interceptors, options.fetch);
+        const result = await dispatcher.send(
+          this.toRequest({...input, ${nextPageParams}}),
+          this.output,
+        );
+        return {
+          data: ${data}.${pagination.items},
+          meta: {
+            hasMore: Boolean(${data}.${pagination.hasMore}),
+          },
+        };
+      });
+      await pagination.getNextPage();
+      return ${returnValue}
+      `;
+    return style?.errorAsValue ? `{try {${logic}} catch (error) {return [null as never, error] as const;}}}` : `{${logic}}}`;
+  }
+  if (pagination.type === "cursor") {
+    const sameInputNames = pagination.cursorParamName === "cursor";
+    const initialParams = sameInputNames ? "input" : `{...input, cursor: input.${pagination.cursorParamName}}`;
+    const nextPageParams = sameInputNames ? "...nextPageParams" : `${pagination.cursorParamName}: nextPageParams.cursor`;
+    const logic = `
+      const pagination = new CursorPagination(${initialParams}, async (nextPageParams) => {
+        const dispatcher = new Dispatcher(options.interceptors, options.fetch);
+        const result = await dispatcher.send(
+          this.toRequest({...input, ${nextPageParams}}),
+          this.output,
+        );
+        ${style?.errorAsValue ? `if (result[1]) {throw result[1];}` : ""}
+        return {
+          data: ${data}.${pagination.items},
+          meta: {
+            hasMore: Boolean(${data}.${pagination.hasMore}),
+          },
+        };
+      });
+      await pagination.getNextPage();
+      return ${returnValue}
+      `;
+    return style?.errorAsValue ? `{try {${logic}} catch (error) {return [null as never, error] as const;}}}` : `{${logic}}}`;
+  }
+  if (pagination.type === "page") {
+    const sameInputNames = pagination.pageNumberParamName === "page" && pagination.pageSizeParamName === "pageSize";
+    const initialParams = sameInputNames ? "input" : `{...input, page: input.${pagination.pageNumberParamName}, pageSize: input.${pagination.pageSizeParamName}}`;
+    const nextPageParams = sameInputNames ? "...nextPageParams" : `${pagination.pageNumberParamName}: nextPageParams.page, ${pagination.pageSizeParamName}: nextPageParams.pageSize`;
+    const logic = `
+      const pagination = new Pagination(${initialParams}, async (nextPageParams) => {
+        const dispatcher = new Dispatcher(options.interceptors, options.fetch);
+        const result = await dispatcher.send(
+          this.toRequest({...input, ${nextPageParams}}),
+          this.output,
+        );
+        ${style?.errorAsValue ? `if (result[1]) {throw result[1];}` : ""}
+        return {
+          data: ${data}.${pagination.items},
+          meta: {
+            hasMore: Boolean(${data}.${pagination.hasMore}),
+          },
+        };
+      });
+      await pagination.getNextPage();
+      return ${returnValue}
+      `;
+    return style?.errorAsValue ? `{try {${logic}} catch (error) {return [null as never, error] as const;}}}` : `{${logic}}}`;
+  }
+  return normalOperation(style);
+}
+function handleResponse(spec, operationName, status, response, utils) {
   const schemas = {};
   const imports = {};
   const endpointImports = {
@@ -1075,89 +849,94 @@ function handleResponse(spec, operationName, status, response, utils, numbered)
   };
   const responses = [];
   const outputs = [];
-  const typeScriptDeserialzer = new TypeScriptDeserialzer(
-    spec,
-    (schemaName, zod) => {
-      schemas[schemaName] = zod;
-      imports[schemaName] = {
-        defaultImport: void 0,
-        isTypeOnly: true,
-        moduleSpecifier: `../models/${utils.makeImport(schemaName)}`,
-        namedImports: [{ isTypeOnly: true, name: schemaName }],
-        namespaceImport: void 0
+  const typeScriptDeserialzer = new TypeScriptEmitter(spec);
+  const statusCode = +status;
+  const statusName = `http.${status_map_default[status] || "APIResponse"}`;
+  const interfaceName = pascalcase3(sanitizeTag3(response["x-response-name"]));
+  let parser = "buffered";
+  if (isEmpty(response.content)) {
+    responses.push({
+      name: interfaceName,
+      schema: "void",
+      description: response.description
+    });
+  } else {
+    const contentTypeResult = fromContentType(
+      spec,
+      typeScriptDeserialzer,
+      response
+    );
+    if (!contentTypeResult) {
+      throw new Error(
+        `No recognizable content type for response ${status} in operation ${operationName}`
+      );
+    }
+    parser = contentTypeResult.parser;
+    const responseSchema = contentTypeResult.responseSchema;
+    responses.push({
+      name: interfaceName,
+      schema: responseSchema,
+      description: response.description
+    });
+    if (isErrorStatusCode(statusCode)) {
+      endpointImports[status_map_default[status] ?? "APIError"] = {
+        moduleSpecifier: utils.makeImport("../http/response"),
+        namedImports: [{ name: status_map_default[status] ?? "APIError" }]
       };
+    } else if (isSuccessStatusCode(statusCode)) {
     }
-  );
-  const statusCode = +status;
-  const parser = (response.headers ?? {})["Transfer-Encoding"] ? "chunked" : "buffered";
-  const statusName = `http.${statusCodeToResponseMap[status] || "APIResponse"}`;
-  const interfaceName = pascalcase(
-    operationName + ` output${numbered ? status : ""}`
-  );
+  }
   if (statusCode === 204) {
     outputs.push(statusName);
   } else {
     if (status.endsWith("XX")) {
-      outputs.push(`http.APIError<${interfaceName}>`);
+      outputs.push(`http.APIError<outputs.${interfaceName}>`);
     } else {
       outputs.push(
-        parser !== "buffered" ? `{type: ${statusName}<${interfaceName}>, parser: ${parser}}` : `${statusName}<${interfaceName}>`
+        parser !== "buffered" ? `{type: ${statusName}<outputs.${interfaceName}>, parser: ${parser}}` : `${statusName}<outputs.${interfaceName}>`
       );
     }
   }
-  const responseContent = get(response, ["content"]);
-  const isJson = responseContent && responseContent["application/json"];
-  let responseSchema = parser === "chunked" ? "ReadableStream" : "void";
-  if (isJson) {
-    const schema = responseContent["application/json"].schema;
-    const isObject = !isRef5(schema) && schema.type === "object";
-    if (isObject && schema.properties) {
-      schema.properties["[http.KIND]"] = {
-        "x-internal": true,
-        const: `typeof ${statusName}.kind`,
-        type: "string"
+  return { schemas, imports, endpointImports, responses, outputs };
+}
+function fromContentType(spec, typeScriptDeserialzer, response) {
+  if ((response.headers ?? {})["Transfer-Encoding"]) {
+    return streamedOutput();
+  }
+  for (const type in response.content) {
+    if (isStreamingContentType(type)) {
+      return streamedOutput();
+    }
+    if (parseJsonContentType(type)) {
+      return {
+        parser: "buffered",
+        responseSchema: response.content[type].schema ? typeScriptDeserialzer.handle(response.content[type].schema, true) : "void"
+      };
+    }
+    if (isTextContentType(type)) {
+      return {
+        parser: "buffered",
+        responseSchema: response.content[type].schema ? typeScriptDeserialzer.handle(response.content[type].schema, true) : "void"
       };
-      schema.required ??= [];
-      schema.required.push("[http.KIND]");
     }
-    responseSchema = typeScriptDeserialzer.handle(schema, true);
-  }
-  responses.push({
-    name: interfaceName,
-    schema: responseSchema,
-    description: response.description
-  });
-  const statusGroup = +status.slice(0, 1);
-  if (statusCode >= 400 || statusGroup >= 4) {
-    endpointImports[statusCodeToResponseMap[status] ?? "APIError"] = {
-      moduleSpecifier: utils.makeImport("../http/response"),
-      namedImports: [{ name: statusCodeToResponseMap[status] ?? "APIError" }]
-    };
-    endpointImports[interfaceName] = {
-      isTypeOnly: true,
-      moduleSpecifier: `../outputs/${utils.makeImport(spinalcase(operationName))}`,
-      namedImports: [{ isTypeOnly: true, name: interfaceName }]
-    };
-  } else if (statusCode >= 200 && statusCode < 300 || statusCode >= 2 || statusGroup <= 3) {
-    endpointImports[interfaceName] = {
-      defaultImport: void 0,
-      isTypeOnly: true,
-      moduleSpecifier: `../outputs/${utils.makeImport(spinalcase(operationName))}`,
-      namedImports: [{ isTypeOnly: true, name: interfaceName }],
-      namespaceImport: void 0
-    };
   }
-  return { schemas, imports, endpointImports, responses, outputs };
+  return streamedOutput();
+}
+function streamedOutput() {
+  return {
+    parser: "chunked",
+    responseSchema: "ReadableStream"
+  };
 }
 
 // packages/typescript/src/lib/styles/github/endpoints.txt
-var endpoints_default = "type Output<T extends OutputType> = T extends {\n  parser: Parser;\n  type: Type<unknown>;\n}\n  ? InstanceType<T['type']>\n  : T extends Type<unknown>\n    ? InstanceType<T>\n    : never;\n\ntype Unionize<T> = T extends [infer Single extends OutputType]\n  ? Output<Single>\n  : T extends readonly [...infer Tuple extends OutputType[]]\n    ? { [I in keyof Tuple]: Output<Tuple[I]> }[number]\n    : never;\n\ntype EndpointOutput<K extends keyof typeof schemas> = Extract<\n  Unionize<(typeof schemas)[K]['output']>,\n  SuccessfulResponse\n>;\n\ntype EndpointError<K extends keyof typeof schemas> = Extract<\n  Unionize<(typeof schemas)[K]['output']>,\n  ProblematicResponse\n>;\n\nexport type Endpoints = {\n  [K in keyof typeof schemas]: {\n    input: z.infer<(typeof schemas)[K]['schema']>;\n    output: <% if (outputType === 'default') { %>EndpointOutput<K>['data']<% } else { %>EndpointOutput<K><% } %>;\n    error: EndpointError<K> | ParseError<(typeof schemas)[K]['schema']>;\n  };\n};";
+var endpoints_default = "type EndpointOutput<K extends keyof typeof schemas> = Extract<\n  Unionize<(typeof schemas)[K]['output']>,\n  SuccessfulResponse\n>;\n\ntype EndpointError<K extends keyof typeof schemas> = Extract<\n  Unionize<(typeof schemas)[K]['output']>,\n  ProblematicResponse\n>;\n\nexport type Endpoints = {\n  [K in keyof typeof schemas]: {\n    input: z.infer<(typeof schemas)[K]['schema']>;\n    output: <% if (outputType === 'default') { %>EndpointOutput<K>['data']<% } else { %>EndpointOutput<K><% } %>;\n    error: EndpointError<K> | ParseError<(typeof schemas)[K]['schema']>;\n  };\n};";
 
 // packages/typescript/src/lib/generator.ts
 function generateCode(config) {
   const commonZod = /* @__PURE__ */ new Map();
   const commonZodImports = [];
-  const zodDeserialzer = new ZodDeserialzer(config.spec, (model, schema) => {
+  const zodDeserialzer = new ZodEmitter(config.spec, (model, schema) => {
     commonZod.set(model, schema);
     commonZodImports.push({
       defaultImport: void 0,
@@ -1168,20 +947,18 @@ function generateCode(config) {
     });
   });
   const groups = {};
-  const outputs = {};
   const endpoints = {};
-  forEachOperation(config, (entry, operation) => {
+  forEachOperation(config.spec, (entry, operation) => {
     console.log(`Processing ${entry.method} ${entry.path}`);
     groups[entry.groupName] ??= [];
     endpoints[entry.groupName] ??= [];
     const inputs = {};
     const additionalProperties = {};
-    for (const param of operation.parameters ?? []) {
-      if (isRef6(param)) {
-        throw new Error(`Found reference in parameter ${param.$ref}`);
-      }
+    for (const param of operation.parameters) {
       if (!param.schema) {
-        throw new Error(`Schema not found for parameter ${param.name}`);
+        param.schema = {
+          type: "string"
+        };
       }
       inputs[param.name] = {
         in: param.in,
@@ -1189,9 +966,12 @@ function generateCode(config) {
       };
       additionalProperties[param.name] = param;
     }
-    const security2 = operation.security ?? [];
     const securitySchemes = config.spec.components?.securitySchemes ?? {};
-    const securityOptions = securityToOptions(security2, securitySchemes);
+    const securityOptions = securityToOptions(
+      config.spec,
+      operation.security ?? [],
+      securitySchemes
+    );
     Object.assign(inputs, securityOptions);
     Object.entries(securityOptions).forEach(([name, value]) => {
       additionalProperties[name] = {
@@ -1215,65 +995,43 @@ function generateCode(config) {
       "application/xml": "xml",
       "text/plain": "text"
     };
-    let outgoingContentType;
-    if (!isEmpty(operation.requestBody)) {
-      const requestBody = isRef6(operation.requestBody) ? followRef5(config.spec, operation.requestBody.$ref) : operation.requestBody;
-      for (const type in requestBody.content) {
-        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}`
-          );
-          continue;
-        }
-        let objectSchema = ctSchema;
+    let outgoingContentType = "empty";
+    for (const type in operation.requestBody.content) {
+      let objectSchema = resolveRef(
+        config.spec,
+        operation.requestBody.content[type].schema
+      );
+      if (type === "application/empty") {
+        objectSchema = {
+          type: "object",
+          // properties: objectSchema['x-properties'],
+          additionalProperties: isEmpty2(objectSchema["x-properties"])
+        };
+      } else {
         if (objectSchema.type !== "object") {
           objectSchema = {
             type: "object",
-            required: [requestBody.required ? "$body" : ""],
+            required: [operation.requestBody.required ? "$body" : ""],
             properties: {
-              $body: ctSchema
+              $body: objectSchema
+              // ...objectSchema['x-properties'],
             }
           };
         }
-        const schema = merge({}, objectSchema, {
-          required: Object.values(additionalProperties).filter((p) => p.required).map((p) => p.name),
-          properties: Object.entries(additionalProperties).reduce(
-            (acc, [, p]) => ({
-              ...acc,
-              [p.name]: p.schema
-            }),
-            {}
-          )
-        });
-        Object.assign(inputs, bodyInputs(config, objectSchema));
-        schemas[shortContenTypeMap[type]] = zodDeserialzer.handle(schema, true);
-      }
-      if (requestBody.content["application/json"]) {
-        outgoingContentType = "json";
-      } else if (requestBody.content["application/x-www-form-urlencoded"]) {
-        outgoingContentType = "urlencoded";
-      } else if (requestBody.content["multipart/form-data"]) {
-        outgoingContentType = "formdata";
-      } else {
-        outgoingContentType = "json";
       }
-    } else {
-      const properties = Object.entries(additionalProperties).reduce(
-        (acc, [, p]) => ({
-          ...acc,
-          [p.name]: p.schema
-        }),
-        {}
-      );
-      schemas[shortContenTypeMap["application/json"]] = zodDeserialzer.handle(
-        {
-          type: "object",
-          required: Object.values(additionalProperties).filter((p) => p.required).map((p) => p.name),
-          properties
-        },
-        true
-      );
+      const schema = merge({}, objectSchema, {
+        required: Object.values(additionalProperties).filter((p) => p.required).map((p) => p.name),
+        properties: Object.entries(additionalProperties).reduce((acc, [, p]) => ({ ...acc, [p.name]: p.schema }), {})
+      });
+      Object.assign(inputs, bodyInputs(config.spec, objectSchema));
+      schemas[shortContenTypeMap[type]] = zodDeserialzer.handle(schema, true);
+    }
+    if (operation.requestBody.content["application/json"]) {
+      outgoingContentType = "json";
+    } else if (operation.requestBody.content["application/x-www-form-urlencoded"]) {
+      outgoingContentType = "urlencoded";
+    } else if (operation.requestBody.content["multipart/form-data"]) {
+      outgoingContentType = "formdata";
     }
     const endpoint = toEndpoint(
       entry.groupName,
@@ -1282,79 +1040,30 @@ function generateCode(config) {
       {
         outgoingContentType,
         name: operation.operationId,
-        type: "http",
-        trigger: entry,
+        method: entry.method,
+        path: entry.path,
         schemas,
         inputs
       },
-      { makeImport: config.makeImport }
-    );
-    const output = [
-      `import z from 'zod';`,
-      `import type * as http from '../http';`
-    ];
-    const responses = endpoint.responses.flatMap((it) => it.responses);
-    const responsesImports = endpoint.responses.flatMap(
-      (it) => Object.values(it.imports)
+      { makeImport: config.makeImport, style: config.style }
     );
-    if (responses.length) {
-      output.push(
-        ...responses.map(
-          (it) => `${it.description ? `
-/** 
- * ${it.description}
- */
-` : ""} export type ${it.name} = ${it.schema};`
-        )
-      );
-    } else {
-      output.push(
-        `export type ${pascalcase2(operation.operationId + " output")} = void;`
-      );
-    }
-    output.unshift(...useImports(output.join(""), ...responsesImports));
-    outputs[`${spinalcase2(operation.operationId)}.ts`] = output.join("\n");
     endpoints[entry.groupName].push(endpoint);
     groups[entry.groupName].push({
       name: operation.operationId,
-      type: "http",
       inputs,
       outgoingContentType,
       schemas,
-      trigger: entry
+      method: entry.method,
+      path: entry.path
     });
   });
-  const commonSchemas = Object.values(endpoints).reduce(
-    (acc, endpoint) => ({
-      ...acc,
-      ...endpoint.reduce(
-        (acc2, { responses }) => ({
-          ...acc2,
-          ...responses.reduce(
-            (acc3, it) => ({ ...acc3, ...it.schemas }),
-            {}
-          )
-        }),
-        {}
-      )
-    }),
-    {}
-  );
   const allSchemas = Object.keys(endpoints).map((it) => ({
-    import: `import ${camelcase3(it)} from './${config.makeImport(spinalcase2(it))}';`,
-    use: `  ...${camelcase3(it)}`
+    import: `import ${camelcase2(it)} from './${config.makeImport(spinalcase(it))}';`,
+    use: `  ...${camelcase2(it)}`
   }));
-  const imports = [
-    'import z from "zod";',
-    `import type { ParseError } from '${config.makeImport("../http/parser")}';`,
-    `import type { ServerError } from '${config.makeImport("../http/response")}';`,
-    `import type { OutputType, Parser, Type } from '../http/send-request.ts';`
-  ];
   return {
     groups,
-    commonSchemas,
     commonZod,
-    outputs,
     endpoints: {
       [join("api", "endpoints.ts")]: `
 
@@ -1364,12 +1073,9 @@ import type { ParseError } from '${config.makeImport("../http/parser")}';
 import type { ProblematicResponse, SuccessfulResponse } from '${config.makeImport(
         "../http/response"
       )}';
-import type { OutputType, Parser, Type } from '${config.makeImport(
-        "../http/send-request"
-      )}';
 
 import schemas from '${config.makeImport("./schemas")}';
-
+import type { Unionize } from '${config.makeImport("../http/dispatcher")}';
       ${template(endpoints_default)({ outputType: config.style?.outputType })}`,
       [`${join("api", "schemas.ts")}`]: `${allSchemas.map((it) => it.import).join("\n")}
 import { KIND } from "${config.makeImport("../http/index")}";
@@ -1391,14 +1097,18 @@ ${allSchemas.map((it) => it.use).join(",\n")}
           );
           return [
             [
-              join("api", `${spinalcase2(name)}.ts`),
+              join("api", `${spinalcase(name)}.ts`),
               `${[
                 ...imps,
                 `import z from 'zod';`,
                 `import * as http from '${config.makeImport("../http/response")}';`,
-                `import { toRequest, json, urlencoded, nobody, formdata, createUrl } from '${config.makeImport("../http/request")}';`,
+                `import * as outputs from '${config.makeImport("../outputs/index")}';`,
+                `import { toRequest, json, urlencoded, empty, formdata, createUrl, type HeadersInit } from '${config.makeImport("../http/request")}';`,
                 `import { chunked, buffered } from "${config.makeImport("../http/parse-response")}";`,
-                `import * as ${camelcase3(name)} from '../inputs/${config.makeImport(spinalcase2(name))}';`
+                `import * as ${camelcase2(name)} from '../inputs/${config.makeImport(spinalcase(name))}';`,
+                `import { createBaseUrlInterceptor, createHeadersInterceptor, type Interceptor } from '${config.makeImport("../http/interceptors")}';`,
+                `import { Dispatcher, fetchType, type InstanceType } from '${config.makeImport("../http/dispatcher")}';`,
+                `import { Pagination, OffsetPagination, CursorPagination } from "${config.makeImport("../pagination/index")}";`
               ].join(
                 "\n"
               )}
@@ -1413,8 +1123,8 @@ ${endpoint.flatMap((it) => it.schemas).join(",\n")}
   };
 }
 function toProps(spec, schemaOrRef, aggregator = []) {
-  if (isRef6(schemaOrRef)) {
-    const schema = followRef5(spec, schemaOrRef.$ref);
+  if (isRef4(schemaOrRef)) {
+    const schema = followRef4(spec, schemaOrRef.$ref);
     return toProps(spec, schema, aggregator);
   } else if (schemaOrRef.type === "object") {
     for (const [name] of Object.entries(schemaOrRef.properties ?? {})) {
@@ -1443,9 +1153,9 @@ function toProps(spec, schemaOrRef, aggregator = []) {
   console.warn("Unknown schema in body", schemaOrRef);
   return void 0;
 }
-function bodyInputs(config, ctSchema) {
+function bodyInputs(spec, ctSchema) {
   const props = [];
-  toProps(config.spec, ctSchema, props);
+  toProps(spec, ctSchema, props);
   return props.reduce(
     (acc, prop) => ({
       ...acc,
@@ -1458,6 +1168,9 @@ function bodyInputs(config, ctSchema) {
   );
 }
 
+// packages/typescript/src/lib/http/dispatcher.txt
+var dispatcher_default = "export type Unionize<T> = T extends [infer Single extends OutputType]\n  ? InstanceType<Single>\n  : T extends readonly [...infer Tuple extends OutputType[]]\n    ? { [I in keyof Tuple]: InstanceType<Tuple[I]> }[number]\n    : never;\n\nexport type InstanceType<T> =\n  T extends Type<infer U>\n    ? U\n    : T extends { type: Type<infer U> }\n      ? U\n      : T extends Array<unknown>\n        ? Unionize<T>\n        : never;\n\nexport 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 const fetchType = z\n  .function()\n  .args(z.instanceof(Request))\n  .returns(z.promise(z.instanceof(Response)))\n  .optional();\n\nexport async function parse<T extends OutputType[]>(\n  outputs: T,\n  response: Response,\n) <% if(!throwError) { %>\n: Promise<\n  [\n    Extract<InstanceType<T>, SuccessfulResponse>['data'],\n    Extract<InstanceType<T>, ProblematicResponse>['data'],\n  ]\n>\n  <% } %>\n\n\n\n {\n  let output: typeof APIResponse | null = null;\n  let parser: Parser = buffered;\n  for (const outputType of outputs) {\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\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 as Extract<InstanceType<T>, SuccessfulResponse><% } else { %>apiresponse as Extract<InstanceType<T>, SuccessfulResponse>;<% } %>;\n    <% } else { %>\n      return [<% if (outputType === 'default') { %>apiresponse.data as Extract<InstanceType<T>, SuccessfulResponse>['data']<% } else { %>apiresponse as Extract<InstanceType<T>, SuccessfulResponse><% } %>, 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, data] 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\nexport class Dispatcher {\n  #interceptors: Interceptor[] = [];\n  #fetch: z.infer<typeof fetchType>;\n  constructor(interceptors: Interceptor[], fetch?: z.infer<typeof fetchType>) {\n    this.#interceptors = interceptors;\n    this.#fetch = fetch;\n  }\n\n  async send<T extends OutputType[]>(\n    config: RequestConfig,\n    outputs: T,\n    signal?: AbortSignal,\n  ) {\n    for (const interceptor of this.#interceptors) {\n      if (interceptor.before) {\n        config = await interceptor.before(config);\n      }\n    }\n\n    let response = await (this.#fetch ?? fetch)(\n      new Request(config.url, config.init),\n      {\n        ...config.init,\n        signal: signal,\n      },\n    );\n\n    for (let i = this.#interceptors.length - 1; i >= 0; i--) {\n      const interceptor = this.#interceptors[i];\n      if (interceptor.after) {\n        response = await interceptor.after(response.clone());\n      }\n    }\n\n    return await parse(outputs, response);\n  }\n}\n";
+
 // packages/typescript/src/lib/http/interceptors.txt
 var interceptors_default = "export interface Interceptor {\n  before?: (config: RequestConfig) => Promise<RequestConfig> | RequestConfig;\n  after?: (response: Response) => Promise<Response> | Response;\n}\n\nexport const createHeadersInterceptor = (\n  defaultHeaders: () => Record<string, string | undefined>,\n  requestHeaders: HeadersInit,\n):Interceptor => {\n  return {\n    before({init, url}) {\n      // Priority Levels\n      // 1. Headers Input\n      // 2. Request Headers\n      // 3. Default Headers\n      const headers = defaultHeaders();\n\n      for (const [key, value] of new Headers(requestHeaders)) {\n        // Only set the header if it doesn't already exist and has a value\n        // even though these headers are passed at operation level\n        // still they are lower priority compared to the headers input\n        if (value !== undefined && !init.headers.has(key)) {\n          init.headers.set(key, value);\n        }\n      }\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 && !init.headers.has(key)) {\n          init.headers.set(key, value);\n        }\n      }\n\n      return {init, url};\n    },\n  };\n};\n\nexport const createBaseUrlInterceptor = (\n  getBaseUrl: () => string,\n): Interceptor => {\n  return {\n    before({ init, url }) {\n      const baseUrl = getBaseUrl();\n      if (url.protocol === 'local:') {\n        return {\n          init,\n          url: new URL(url.href.replace('local://', baseUrl))\n        };\n      }\n      return { init, url };\n    },\n  };\n};\n\nexport const logInterceptor: Interceptor = {\n  before({ url, init }) {\n    console.log('Request:', { url, init });\n    return { url, init };\n  },\n  after(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";
 
@@ -1468,7 +1181,7 @@ var parse_response_default = 'import { parse } from "fast-content-type-parse";\n
 var parser_default = "import { z } from 'zod';\n\nexport class ParseError<T extends z.ZodType<any, any, any>> {\n  public data: z.typeToFlattenedError<T, z.ZodIssue>;\n  constructor(data: z.typeToFlattenedError<T, z.ZodIssue>) {\n    this.data = data;\n  }\n}\n\nexport function parseInput<T extends z.ZodType<any, any, any>>(\n  schema: T,\n  input: unknown,\n) {\n  const result = schema.safeParse(input);\n  if (!result.success) {\n    const error = result.error.flatten((issue) => issue);\n    return [null, new ParseError(error)];\n  }\n  return [result.data as z.infer<T>, null];\n}\n";
 
 // packages/typescript/src/lib/http/request.txt
-var request_default = "type Init = Omit<RequestInit, 'headers'> & { headers: Headers; };\nexport type RequestConfig = { init: Init; url: URL };\nexport type Method = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';\nexport type ContentType = 'xml' | 'json' | 'urlencoded' | 'multipart' | 'formdata';\nexport type HeadersInit = [string, string][] | Record<string, string>;\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    if (\n      this.props.inputBody.length === 1 &&\n      this.props.inputBody[0] === '$body'\n    ) {\n      return JSON.stringify(this.input.$body);\n    }\n\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      'Content-Type': 'application/x-www-form-urlencoded',\n      Accept: 'application/json',\n    };\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      Accept: 'application/json',\n    };\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): RequestConfig {\n  const [method, path] = endpoint.split(' ');\n  const pathVariable = template(path, input.params);\n\n  return {\n    url: createUrl(pathVariable, input.query),\n    init: {\n      method: method,\n      headers: new Headers(input.headers),\n      body: method === 'GET' ? undefined : input.body,\n    },\n  }\n}\n";
+var request_default = "type Init = Omit<RequestInit, 'headers'> & { headers: Headers; };\nexport type RequestConfig = { init: Init; url: URL };\nexport type Method = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';\nexport type ContentType = 'xml' | 'json' | 'urlencoded' | 'multipart' | 'formdata';\nexport type HeadersInit = [string, string][] | Record<string, string>;\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    if (\n      this.props.inputBody.length === 1 &&\n      this.props.inputBody[0] === '$body'\n    ) {\n      return JSON.stringify(this.input.$body);\n    }\n\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      'Content-Type': 'application/x-www-form-urlencoded',\n      Accept: 'application/json',\n    };\n  }\n}\n\nclass EmptySerializer 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      Accept: 'application/json',\n    };\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 empty(input: Input, props: Props) {\n  return new EmptySerializer(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): RequestConfig {\n  const [method, path] = endpoint.split(' ');\n  const pathVariable = template(path, input.params);\n\n  return {\n    url: createUrl(pathVariable, input.query),\n    init: {\n      method: method,\n      headers: new Headers(input.headers),\n      body: method === 'GET' ? undefined : input.body,\n    },\n  }\n}\n";
 
 // packages/typescript/src/lib/http/response.txt
 var response_default = `export const KIND = Symbol('APIDATA');
@@ -1702,6 +1415,28 @@ export class Gone<T = { message: string }> extends APIError<T, 410> {
     return typeof value === 'object' && value !== null && KIND in value && value[KIND] === this.kind;
   }
 }
+export class PreconditionFailed<T = { message: string }> extends APIError<T, 412> {
+  static override readonly kind = Symbol.for('PreconditionFailed');
+  static override status = 412 as const;
+  constructor(data: T) {
+    super(PreconditionFailed.status, data);
+  }
+  static override create<T>(status: number, data: T) {
+    Object.defineProperty(data, KIND, { value: this.kind });
+    return new this(data);
+  }
+
+  static is<T extends { [KIND]: (typeof PreconditionFailed)['kind'] }>(
+    value: unknown,
+  ): value is T {
+    return (
+      typeof value === 'object' &&
+      value !== null &&
+      KIND in value &&
+      value[KIND] === this.kind
+    );
+  }
+}
 export class UnprocessableEntity<
   T = { message: string; errors?: Record<string, string[]> },
 > extends APIError<T, 422> {
@@ -1853,7 +1588,7 @@ export class GatewayTimeout<T = { message: string }> extends APIError<T, 504> {
 }
 
 export type ClientError =
-  | BadRequest<{ message: string }>
+  | BadRequest<unknown>
   | Unauthorized<unknown>
   | PaymentRequired<unknown>
   | Forbidden<unknown>
@@ -1862,6 +1597,9 @@ export type ClientError =
   | NotAcceptable<unknown>
   | Conflict<unknown>
   | Gone<unknown>
+  | PreconditionFailed<unknown>
+  | PayloadTooLarge<unknown>
+  | UnsupportedMediaType<unknown>
   | UnprocessableEntity<unknown>
   | TooManyRequests<unknown>;
 
@@ -1878,315 +1616,396 @@ export type SuccessfulResponse =
   | Ok<unknown>
   | Created<unknown>
   | Accepted<unknown>
-  | NoContent;
-`;
+  | NoContent;`;
 
-// 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/paginations/cursor-pagination.txt
+var cursor_pagination_default = "type CursorPaginationParams = {\n  cursor?: string;\n};\n\ninterface CursorMetadata extends Metadata {\n  nextCursor?: string;\n}\n\ninterface Metadata {\n  hasMore?: boolean;\n}\n\ntype PaginationResult<T, M extends CursorMetadata> = {\n  data: T[];\n  meta: M;\n};\n\ntype FetchFn<T, M extends CursorMetadata> = (\n  input: CursorPaginationParams,\n) => Promise<PaginationResult<T, M>>;\n\n/**\n * @experimental\n */\nexport class CursorPagination<T, M extends CursorMetadata> {\n  #meta: PaginationResult<T, M>['meta'] | null = null;\n  #params: CursorPaginationParams;\n  #currentPage: Page<T> | null = null;\n  readonly #fetchFn: FetchFn<T, M>;\n\n  constructor(\n    initialParams: PartialNullable<CursorPaginationParams>,\n    fetchFn: FetchFn<T, M>,\n  ) {\n    this.#fetchFn = fetchFn;\n    this.#params = {\n      cursor: initialParams.cursor ?? undefined,\n    };\n  }\n\n  async getNextPage() {\n    const result = await this.#fetchFn(this.#params);\n    this.#currentPage = new Page(result.data);\n    this.#meta = result.meta;\n    this.#params = {\n      ...this.#params,\n      cursor: result.meta.nextCursor,\n    };\n    return this;\n  }\n\n  getCurrentPage() {\n    if (!this.#currentPage) {\n      throw new Error(\n        'No page data available. Please call getNextPage() first.',\n      );\n    }\n    return this.#currentPage;\n  }\n\n  get hasMore() {\n    if (!this.#meta) {\n      throw new Error(\n        'No meta data available. Please call getNextPage() first.',\n      );\n    }\n    return this.#meta.hasMore;\n  }\n\n  async *[Symbol.asyncIterator]() {\n    for await (const page of this.iter()) {\n      yield page.getCurrentPage();\n    }\n  }\n\n  async *iter() {\n    if (!this.#currentPage) {\n      yield await this.getNextPage();\n    }\n\n    while (this.hasMore) {\n      yield await this.getNextPage();\n    }\n  }\n\n  get metadata() {\n    if (!this.#meta) {\n      throw new Error(\n        'No meta data available. Please call getNextPage() first.',\n      );\n    }\n    return this.#meta;\n  }\n}\n\nclass Page<T> {\n  data: T[];\n  constructor(data: T[]) {\n    this.data = data;\n  }\n}\n\ntype PartialNullable<T> = {\n  [K in keyof T]?: T[K] | null;\n};\n";
 
-// packages/typescript/src/lib/readme.ts
-import { followRef as followRef6, isRef as isRef7 } from "@sdk-it/core";
-var PropEmitter = class {
-  #spec;
+// packages/typescript/src/lib/paginations/offset-pagination.txt
+var offset_pagination_default = "type OffsetPaginationParams = {\n  offset: number;\n  limit: number;\n};\n\ninterface Metadata {\n  hasMore?: boolean;\n}\n\ntype PaginationResult<T, M extends Metadata> = {\n  data: T[];\n  meta: M;\n};\n\ntype FetchFn<T, M extends Metadata> = (\n  input: OffsetPaginationParams,\n) => Promise<PaginationResult<T, M>>;\n\n/**\n * @experimental\n */\nexport class OffsetPagination<T, M extends Metadata> {\n  #meta: PaginationResult<T, M>['meta'] | null = null;\n  #params: OffsetPaginationParams;\n  #currentPage: Page<T> | null = null;\n  readonly #fetchFn: FetchFn<T, M>;\n\n  constructor(\n    initialParams: Partial<OffsetPaginationParams>,\n    fetchFn: FetchFn<T, M>,\n  ) {\n    this.#fetchFn = fetchFn;\n    this.#params = {\n      limit: initialParams.limit ?? 0,\n      offset: initialParams.offset ?? 0,\n    };\n  }\n\n  async getNextPage() {\n    const result = await this.#fetchFn(this.#params);\n    this.#currentPage = new Page(result.data);\n    this.#meta = result.meta;\n    this.#params = {\n      ...this.#params,\n      offset: this.#params.offset + this.#params.limit,\n    };\n    return this;\n  }\n\n  getCurrentPage() {\n    if (!this.#currentPage) {\n      throw new Error(\n        'No page data available. Please call getNextPage() first.',\n      );\n    }\n    return this.#currentPage;\n  }\n\n  get hasMore() {\n    if (!this.#meta) {\n      throw new Error(\n        'No meta data available. Please call getNextPage() first.',\n      );\n    }\n    return this.#meta.hasMore;\n  }\n\n  async *[Symbol.asyncIterator]() {\n    for await (const page of this.iter()) {\n      yield page.getCurrentPage();\n    }\n  }\n\n  async *iter() {\n    if (!this.#currentPage) {\n      yield await this.getNextPage();\n    }\n\n    while (this.hasMore) {\n      yield await this.getNextPage();\n    }\n  }\n\n  get metadata() {\n    if (!this.#meta) {\n      throw new Error(\n        'No meta data available. Please call getNextPage() first.',\n      );\n    }\n    return this.#meta;\n  }\n\n  reset(params?: Partial<OffsetPaginationParams>) {\n    this.#meta = null;\n    this.#currentPage = null;\n    if (params) {\n      this.#params = { ...this.#params, ...params };\n    } else {\n      this.#params.offset = 0;\n    }\n    return this;\n  }\n}\n\nclass Page<T> {\n  data: T[];\n  constructor(data: T[]) {\n    this.data = data;\n  }\n}\n";
+
+// packages/typescript/src/lib/paginations/page-pagination.txt
+var page_pagination_default = "type InferPage<T> = T extends Page<infer U> ? U : never;\ntype PaginationParams<P extends number | bigint, S extends number | bigint> = {\n  page?: P;\n  pageSize?: S;\n};\n\ninterface Metadata {\n  hasMore?: boolean;\n}\n\ntype PaginationResult<T, M extends Metadata> = {\n  data: T[];\n  meta: M;\n};\n\ntype FetchFn<\n  T,\n  M extends Metadata,\n  P extends number | bigint,\n  S extends number | bigint,\n> = (input: Partial<PaginationParams<P, S>>) => Promise<PaginationResult<T, M>>;\n\n/**\n * @experimental\n */\nexport class Pagination<\n  T,\n  M extends Metadata,\n  P extends number | bigint,\n  S extends number | bigint,\n> {\n  #meta: PaginationResult<T, M>['meta'] | null = null;\n  #params: PaginationParams<P, S>;\n  #currentPage: Page<T> | null = null;\n  readonly #fetchFn: FetchFn<T, M, P, S>;\n\n  constructor(\n    initialParams: Partial<PaginationParams<P, S>>,\n    fetchFn: FetchFn<T, M, P, S>,\n  ) {\n    this.#fetchFn = fetchFn;\n    this.#params = { ...initialParams, page: initialParams.page };\n  }\n\n  async getNextPage() {\n    const result = await this.#fetchFn(this.#params);\n    this.#currentPage = new Page(result.data);\n    this.#meta = result.meta;\n    this.#params = {\n      ...this.#params,\n      page: ((this.#params.page as number) || 0 + 1) as never,\n    };\n    return this;\n  }\n\n  getCurrentPage() {\n    if (!this.#currentPage) {\n      throw new Error(\n        'No page data available. Please call getNextPage() first.',\n      );\n    }\n    return this.#currentPage;\n  }\n\n  get hasMore() {\n    if (!this.#meta) {\n      throw new Error(\n        'No meta data available. Please call getNextPage() first.',\n      );\n    }\n    return this.#meta.hasMore;\n  }\n\n  async *[Symbol.asyncIterator]() {\n    for await (const page of this.iter()) {\n      yield page.getCurrentPage();\n    }\n  }\n\n  async *iter() {\n    if (!this.#currentPage) {\n      yield await this.getNextPage();\n    }\n\n    while (this.hasMore) {\n      yield await this.getNextPage();\n    }\n  }\n\n  get metadata() {\n    if (!this.#meta) {\n      throw new Error(\n        'No meta data available. Please call getNextPage() first.',\n      );\n    }\n    return this.#meta;\n  }\n}\n\nclass Page<T> {\n  data: T[];\n  constructor(data: T[]) {\n    this.data = data;\n  }\n}\n";
+
+// packages/typescript/src/lib/typescript-snippet.ts
+import { camelcase as camelcase3, spinalcase as spinalcase2 } from "stringcase";
+import { isEmpty as isEmpty3, pascalcase as pascalcase4, resolveRef as resolveRef2 } from "@sdk-it/core";
+import {
+  patchParameters,
+  securityToOptions as securityToOptions2
+} from "@sdk-it/spec";
+
+// packages/typescript/src/lib/emitters/snippet.ts
+import { followRef as followRef5, isRef as isRef5 } from "@sdk-it/core";
+var SnippetEmitter = class {
+  spec;
+  generatedRefs = /* @__PURE__ */ new Set();
+  cache = /* @__PURE__ */ new Map();
   constructor(spec) {
-    this.#spec = 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));
+  object(schema) {
+    const schemaObj = isRef5(schema) ? followRef5(this.spec, schema.$ref) : schema;
+    const result = {};
+    const properties = schemaObj.properties || {};
+    for (const [propName, propSchema] of Object.entries(properties)) {
+      const isRequired = (schemaObj.required ?? []).includes(propName);
+      const resolvedProp = isRef5(propSchema) ? followRef5(this.spec, propSchema.$ref) : propSchema;
+      if (isRequired || resolvedProp.example !== void 0 || resolvedProp.default !== void 0 || Math.random() > 0.5) {
+        result[propName] = this.handle(propSchema);
       }
     }
-    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}`)
-        );
-      }
+    if (schemaObj.additionalProperties && typeof schemaObj.additionalProperties === "object") {
+      result["additionalPropExample"] = this.handle(
+        schemaObj.additionalProperties
+      );
     }
-    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;
+    return result;
   }
-  /**
-   * 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);
+  array(schema) {
+    const schemaObj = isRef5(schema) ? followRef5(this.spec, schema.$ref) : schema;
+    const itemsSchema = schemaObj.items;
+    if (!itemsSchema) {
+      return [];
     }
-    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)}\``);
+    const count = Math.min(schemaObj.minItems ?? 1, 2);
+    const result = [];
+    for (let i = 0; i < count; i++) {
+      result.push(this.handle(itemsSchema));
     }
-    return lines;
+    return result;
   }
-  #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;
+  string(schema) {
+    if (schema.example !== void 0)
+      return String(schema.example);
+    if (schema.default !== void 0)
+      return String(schema.default);
+    switch (schema.format) {
+      case "date-time":
+      case "datetime":
+        return (/* @__PURE__ */ new Date()).toISOString();
+      case "date":
+        return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      case "time":
+        return (/* @__PURE__ */ new Date()).toISOString().split("T")[1];
+      case "email":
+        return "user@example.com";
+      case "uuid":
+        return "123e4567-e89b-12d3-a456-426614174000";
+      case "uri":
+      case "url":
+        return "https://example.com";
+      case "ipv4":
+        return "192.168.1.1";
+      case "ipv6":
+        return "2001:0db8:85a3:0000:0000:8a2e:0370:7334";
+      case "hostname":
+        return "example.com";
+      case "binary":
+      case "byte":
+        return `new Blob(['example'], { type: 'text/plain' })`;
       default:
-        lines.push(`**Type:** \`${type}\`${nullableSuffix}`);
-        lines.push(...description);
+        if (schema.enum && schema.enum.length > 0) {
+          return String(schema.enum[0]);
+        }
+        return schema.pattern ? `string matching ${schema.pattern}` : "example";
     }
-    if (schema.default !== void 0) {
-      lines.push(`**Default:** \`${JSON.stringify(schema.default)}\``);
+  }
+  number(schema) {
+    if (schema.example !== void 0)
+      return Number(schema.example);
+    if (schema.default !== void 0)
+      return Number(schema.default);
+    let value;
+    if (typeof schema.exclusiveMinimum === "number") {
+      value = schema.exclusiveMinimum + 1;
+    } else if (typeof schema.minimum === "number") {
+      value = schema.minimum;
+    } else {
+      value = schema.type === "integer" ? 42 : 42.42;
+    }
+    if (typeof schema.exclusiveMaximum === "number" && value >= schema.exclusiveMaximum) {
+      value = schema.exclusiveMaximum - 1;
+    } else if (typeof schema.maximum === "number" && value > schema.maximum) {
+      value = schema.maximum;
     }
-    return lines.filter((l) => l);
+    if (typeof schema.multipleOf === "number" && value % schema.multipleOf !== 0) {
+      value = Math.floor(value / schema.multipleOf) * schema.multipleOf;
+    }
+    return schema.type === "integer" ? Math.floor(value) : value;
+  }
+  boolean(schema) {
+    if (schema.example !== void 0)
+      return Boolean(schema.example);
+    if (schema.default !== void 0)
+      return Boolean(schema.default);
+    return true;
+  }
+  null() {
+    return null;
+  }
+  ref($ref) {
+    const parts = $ref.split("/");
+    const refKey = parts[parts.length - 1] || "";
+    if (this.cache.has($ref)) {
+      return this.cache.get($ref);
+    }
+    this.cache.set($ref, { _ref: refKey });
+    const resolved = followRef5(this.spec, $ref);
+    const result = this.handle(resolved);
+    this.cache.set($ref, result);
+    return result;
+  }
+  allOf(schemas) {
+    const initial = {};
+    return schemas.reduce((result, schema) => {
+      const example = this.handle(schema);
+      if (typeof example === "object" && example !== null) {
+        return { ...result, ...example };
+      }
+      return result;
+    }, initial);
+  }
+  anyOf(schemas) {
+    if (schemas.length === 0)
+      return {};
+    return this.handle(schemas[0]);
+  }
+  oneOf(schemas) {
+    if (schemas.length === 0)
+      return {};
+    return this.handle(schemas[0]);
+  }
+  enum(schema) {
+    return Array.isArray(schema.enum) && schema.enum.length > 0 ? schema.enum[0] : void 0;
   }
-  /**
-   * Handle schemas by resolving references and delegating to appropriate handler
-   */
   handle(schemaOrRef) {
-    if (isRef7(schemaOrRef)) {
-      return this.#ref(schemaOrRef.$ref);
+    if (isRef5(schemaOrRef)) {
+      return this.ref(schemaOrRef.$ref);
+    }
+    const schema = isRef5(schemaOrRef) ? followRef5(this.spec, schemaOrRef.$ref) : schemaOrRef;
+    if (schema.example !== void 0) {
+      return schema.example;
+    }
+    if (schema.default !== void 0) {
+      return schema.default;
     }
-    const schema = schemaOrRef;
     if (schema.allOf && Array.isArray(schema.allOf)) {
-      return this.#allOf(schema.allOf);
+      return this.allOf(schema.allOf);
     }
     if (schema.anyOf && Array.isArray(schema.anyOf)) {
-      return this.#anyOf(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);
+      return this.oneOf(schema.oneOf);
     }
-    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 (schema.enum && Array.isArray(schema.enum) && schema.enum.length > 0) {
+      return this.enum(schema);
     }
+    const types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
     if (types.length === 0) {
       if (schema.properties || schema.additionalProperties) {
-        types = ["object"];
+        return this.object(schema);
       } else if (schema.items) {
-        types = ["array"];
+        return this.array(schema);
       }
+      return "example";
+    }
+    const primaryType = types.find((t) => t !== "null") || types[0];
+    switch (primaryType) {
+      case "string":
+        return this.string(schema);
+      case "number":
+      case "integer":
+        return this.number(schema);
+      case "boolean":
+        return this.boolean(schema);
+      case "object":
+        return this.object(schema);
+      case "array":
+        return this.array(schema);
+      case "null":
+        return this.null();
+      default:
+        return "unknown";
     }
-    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);
+};
+
+// packages/typescript/src/lib/typescript-snippet.ts
+var TypeScriptGenerator = class {
+  #spec;
+  #settings;
+  #snippetEmitter;
+  #clientName;
+  #packageName;
+  constructor(spec, settings) {
+    this.#spec = spec;
+    this.#settings = settings;
+    this.#snippetEmitter = new SnippetEmitter(spec);
+    this.#clientName = settings.name?.trim() ? pascalcase4(settings.name) : "Client";
+    this.#packageName = settings.name ? `@${spinalcase2(this.#clientName.toLowerCase())}/sdk` : "sdk";
+  }
+  succinct(entry, operation, values) {
+    let payload = "{}";
+    if (!isEmpty3(operation.requestBody)) {
+      const contentTypes = Object.keys(operation.requestBody.content || {});
+      const schema = resolveRef2(
+        this.#spec,
+        operation.requestBody.content[contentTypes[0]].schema
+      );
+      const examplePayload = this.#snippetEmitter.handle({
+        ...schema,
+        properties: Object.assign({}, schema.properties, schema.properties)
+      });
+      Object.assign(
+        examplePayload,
+        values.requestBody ?? {},
+        values.pathParameters ?? {},
+        values.queryParameters ?? {},
+        values.headers ?? {},
+        values.cookies ?? {}
+      );
+      payload = examplePayload;
+    } else {
+      const requestBody = { type: "object", properties: {} };
+      patchParameters(
+        this.#spec,
+        requestBody,
+        operation.parameters,
+        operation.security ?? []
+      );
+      const examplePayload = this.#snippetEmitter.handle(requestBody);
+      Object.assign(
+        examplePayload,
+        values.pathParameters ?? {},
+        values.queryParameters ?? {},
+        values.headers ?? {},
+        values.cookies ?? {}
+      );
+      payload = examplePayload;
+    }
+    payload = JSON.stringify(
+      payload,
+      (key, value) => {
+        if (value?.startsWith && value.startsWith("new")) {
+          return `__REPLACE_${Math.random().toString(36).substring(2, 11)}__${value}__REPLACE_END__`;
         }
+        return value;
+      },
+      2
+    ).replace(/"__REPLACE_[^"]*__([^"]*?)__REPLACE_END__"/g, "$1");
+    let successResponse;
+    for (const status in operation.responses) {
+      if (status.startsWith("2")) {
+        successResponse = operation.responses[status];
+        break;
+      }
+    }
+    if (successResponse) {
+      if (successResponse.headers?.["Transfer-Encoding"]) {
+        return this.#httpStreaming(entry, payload);
+      }
+      if (successResponse.content && successResponse.content["application/octet-stream"]) {
+        return this.#streamDownload(entry, payload);
       }
     }
-    return lines;
+    if (!isEmpty3(operation["x-pagination"])) {
+      return this.#pagination(operation, entry, payload);
+    }
+    return this.#normal(entry, payload);
   }
-};
-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"));
+  #pagination(opeartion, entry, payload) {
+    const pagination = opeartion["x-pagination"];
+    switch (pagination.type) {
+      case "page":
+        return {
+          content: `const result = ${this.#ddd(entry, payload)}`,
+          footer: `for await (const page of result) {
+	console.log(page);
+}`
+        };
+      case "offset":
+        return {
+          content: `const result = ${this.#ddd(entry, payload)}`,
+          footer: `for await (const page of result) {
+	console.log(page);
+}`
+        };
+      case "cursor":
+        return {
+          content: `const result = ${this.#ddd(entry, payload)}`,
+          footer: `for await (const page of result) {
+	console.log(page);
+}`
+        };
     }
-    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}_`);
+    return this.#normal(entry, payload);
+  }
+  #normal(entry, payload) {
+    return {
+      content: `const result = ${this.#ddd(entry, payload)};`,
+      footer: "console.log(result.data)"
+    };
+  }
+  #streamDownload(entry, payload) {
+    return {
+      content: `const stream = ${this.#ddd(entry, payload)}`,
+      footer: `await writeFile('./report.pdf', stream);`
+    };
+  }
+  #httpStreaming(entry, payload) {
+    return {
+      content: `const stream = ${this.#ddd(entry, payload)}`,
+      footer: `for await (const chunk of stream) {
+	console.log(chunk);
+}`
+    };
+  }
+  #ddd(entry, payload) {
+    return `await ${camelcase3(this.#clientName)}.request('${entry.method.toUpperCase()} ${entry.path}', ${payload});`;
+  }
+  snippet(entry, operation, config = {}) {
+    const payload = this.succinct(entry, operation, config);
+    const content = [
+      this.client(),
+      "",
+      payload.content,
+      "",
+      payload.footer
+    ];
+    if (config.frame !== false) {
+      content.unshift("```typescript");
+      content.push("```");
     }
-    markdown.push(`<small>${statuses.join("\n\n")}</small>`);
-  });
-  return markdown.join("\n\n");
+    return content.join("\n");
+  }
+  #authentication() {
+    return securityToOptions2(
+      this.#spec,
+      this.#spec.security ?? [],
+      this.#spec.components?.securitySchemes ?? {}
+    );
+  }
+  client() {
+    const inputs = [
+      `baseUrl: '${this.#spec.servers?.[0]?.url ?? "http://localhost:3000"}'`
+    ];
+    const authOptions = this.#authentication();
+    if (!isEmpty3(authOptions)) {
+      const [firstAuth] = authOptions;
+      inputs.push(`${firstAuth.name}: ${firstAuth.example}`);
+    }
+    return `import { ${this.#clientName} } from '${this.#packageName}';
+
+const ${camelcase3(this.#clientName)} = new ${this.#clientName}({ 
+	${inputs.join(",\n	")}
+});`;
+  }
+};
+function generateSnippet(spec, settings, entry, operation, config = {}) {
+  const generator = new TypeScriptGenerator(spec, settings);
+  return generator.snippet(entry, operation, config);
 }
 
 // packages/typescript/src/lib/generate.ts
@@ -2195,7 +2014,7 @@ function security(spec) {
   const components = spec.components || {};
   const securitySchemes = components.securitySchemes || {};
   const paths = Object.values(spec.paths ?? {});
-  const options = securityToOptions(security2, securitySchemes);
+  const options = securityToOptions(spec, security2, securitySchemes);
   for (const it of paths) {
     for (const method of methods) {
       const operation = it[method];
@@ -2204,64 +2023,82 @@ function security(spec) {
       }
       Object.assign(
         options,
-        securityToOptions(operation.security || [], securitySchemes, "input")
+        securityToOptions(
+          spec,
+          operation.security || [],
+          securitySchemes,
+          "input"
+        )
       );
     }
   }
   return options;
 }
-async function generate(spec, settings) {
+async function generate(openapi, settings) {
+  const spec = augmentSpec(
+    { spec: openapi, responses: { flattenErrorResponses: true } },
+    false
+  );
+  const generator = new TypeScriptGenerator(spec, settings);
   const style = Object.assign(
     {},
     {
-      errorAsValue: true,
+      errorAsValue: false,
       name: "github",
       outputType: "default"
     },
     settings.style ?? {}
   );
+  const output = settings.mode === "full" ? join2(settings.output, "src") : settings.output;
   settings.useTsExtension ??= true;
+  const { writer, files: writtenFiles } = createWriterProxy(
+    settings.writer ?? writeFiles,
+    output
+  );
+  settings.writer = writer;
+  settings.readFolder ??= async (folder) => {
+    const files = await readdir(folder, { withFileTypes: true });
+    return files.map((file) => ({
+      fileName: file.name,
+      filePath: join2(file.parentPath, file.name),
+      isFolder: file.isDirectory()
+    }));
+  };
   const makeImport = (moduleSpecifier) => {
     return settings.useTsExtension ? `${moduleSpecifier}.ts` : moduleSpecifier;
   };
-  const { commonSchemas, endpoints, groups, outputs, commonZod } = generateCode(
-    {
-      spec,
-      style,
-      makeImport
-    }
-  );
-  const output = settings.mode === "full" ? join2(settings.output, "src") : settings.output;
+  const { endpoints, groups, commonZod } = generateCode({
+    spec,
+    style,
+    makeImport
+  });
   const options = security(spec);
-  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, {
+  const clientName = pascalcase5((settings.name || "client").trim());
+  const packageName = settings.name ? `@${spinalcase3(settings.name.trim().toLowerCase())}/sdk` : "sdk";
+  const inputs = toInputs(groups, commonZod, makeImport);
+  const models = serializeModels(spec);
+  await settings.writer(output, {
     "outputs/.gitkeep": "",
     "inputs/.gitkeep": "",
     "models/.getkeep": ""
   });
-  await writeFiles(join2(output, "http"), {
-    "interceptors.ts": `
-    import type { RequestConfig, HeadersInit } from './${makeImport("request")}';
-    ${interceptors_default}`,
+  await settings.writer(join2(output, "http"), {
     "parse-response.ts": parse_response_default,
-    "send-request.ts": `import z from 'zod';
-import type { Interceptor } from './${makeImport("interceptors")}';
-import { buffered } from './${makeImport("parse-response")}';
-import { parseInput } from './${makeImport("parser")}';
-import type { RequestConfig } from './${makeImport("request")}';
-import { APIError, APIResponse } from './${makeImport("response")}';
-
-${template2(send_request_default, {})({ throwError: !style.errorAsValue, outputType: style.outputType })}`,
     "response.ts": response_default,
     "parser.ts": parser_default,
-    "request.ts": request_default
+    "request.ts": request_default,
+    "dispatcher.ts": `import z from 'zod';
+import { type Interceptor } from '${makeImport("../http/interceptors")}';
+import { type RequestConfig } from '${makeImport("../http/request")}';
+import { buffered } from '${makeImport("./parse-response")}';
+import { APIError, APIResponse, type SuccessfulResponse, type ProblematicResponse } from '${makeImport("./response")}';
+
+${template2(dispatcher_default, {})({ throwError: !style.errorAsValue, outputType: style.outputType })}`,
+    "interceptors.ts": `
+    import type { RequestConfig, HeadersInit } from './${makeImport("request")}';
+    ${interceptors_default}`
   });
-  await writeFiles(join2(output, "outputs"), outputs);
-  const modelsImports = Object.entries(commonSchemas).map(([name]) => name);
-  await writeFiles(output, {
+  await settings.writer(output, {
     "client.ts": client_default(
       {
         name: clientName,
@@ -2271,52 +2108,80 @@ ${template2(send_request_default, {})({ throwError: !style.errorAsValue, outputT
       },
       style
     ),
-    ...inputFiles,
-    ...endpoints,
-    ...Object.fromEntries(
-      Object.entries(commonSchemas).map(([name, schema]) => [
-        `models/${name}.ts`,
-        [
-          `import { z } from 'zod';`,
-          ...exclude(modelsImports, [name]).map(
-            (it) => `import type { ${it} } from './${it}.ts';`
-          ),
-          `export type ${name} = ${schema};`
-        ].join("\n")
-      ])
-    )
+    ...inputs,
+    ...endpoints
+  });
+  await settings.writer(output, models);
+  await settings.writer(join2(output, "pagination"), {
+    "cursor-pagination.ts": cursor_pagination_default,
+    "offset-pagination.ts": offset_pagination_default,
+    "page-pagination.ts": page_pagination_default
   });
+  const metadata = await readWriteMetadata(output, Array.from(writtenFiles));
+  if (settings.cleanup !== false && writtenFiles.size > 0) {
+    await cleanFiles(metadata.content, output, [
+      "/tsconfig*.json",
+      "/package.json",
+      "/metadata.json",
+      "/**/index.ts"
+    ]);
+  }
   const folders = [
-    getFolderExports(join2(output, "outputs"), settings.useTsExtension),
+    getFolderExports(
+      join2(output, "outputs"),
+      settings.readFolder,
+      settings.useTsExtension
+    ),
     getFolderExports(
       join2(output, "inputs"),
+      settings.readFolder,
       settings.useTsExtension,
       ["ts"],
-      (dirent) => dirent.isDirectory() && ["schemas"].includes(dirent.name)
+      (dirent) => dirent.isFolder && ["schemas"].includes(dirent.fileName)
+    ),
+    getFolderExports(
+      join2(output, "api"),
+      settings.readFolder,
+      settings.useTsExtension
     ),
-    getFolderExports(join2(output, "api"), settings.useTsExtension),
     getFolderExports(
       join2(output, "http"),
+      settings.readFolder,
       settings.useTsExtension,
       ["ts"],
-      (dirent) => !["response.ts", "parser.ts"].includes(dirent.name)
+      (dirent) => !["response.ts", "parser.ts"].includes(dirent.fileName)
+    ),
+    getFolderExports(
+      join2(output, "models"),
+      settings.readFolder,
+      settings.useTsExtension
     )
   ];
-  if (modelsImports.length) {
-    folders.push(
-      getFolderExports(join2(output, "models"), settings.useTsExtension)
-    );
-  }
   const [outputIndex, inputsIndex, apiIndex, httpIndex, modelsIndex] = await Promise.all(folders);
-  await writeFiles(output, {
+  await settings.writer(join2(output, "pagination"), {
+    "index.ts": await getFolderExports(
+      join2(output, "pagination"),
+      settings.readFolder,
+      settings.useTsExtension,
+      ["ts"]
+    )
+  });
+  await settings.writer(output, {
     "api/index.ts": apiIndex,
     "outputs/index.ts": outputIndex,
     "inputs/index.ts": inputsIndex || null,
     "http/index.ts": httpIndex,
-    ...modelsImports.length ? { "models/index.ts": modelsIndex } : {}
+    "models/index.ts": modelsIndex
+    // ...(modelsImports.length ? { 'models/index.ts': modelsIndex } : {}),
   });
-  await writeFiles(output, {
-    "index.ts": await getFolderExports(output, settings.useTsExtension, ["ts"])
+  await settings.writer(output, {
+    "index.ts": await getFolderExports(
+      output,
+      settings.readFolder,
+      settings.useTsExtension,
+      ["ts"],
+      (config) => config.fileName.endsWith("pagination")
+    )
   });
   if (settings.mode === "full") {
     const configFiles = {
@@ -2324,9 +2189,23 @@ ${template2(send_request_default, {})({ throwError: !style.errorAsValue, outputT
         ignoreIfExists: true,
         content: JSON.stringify(
           {
-            name: settings.name ? `@${spinalcase3(clientName.toLowerCase())}/sdk` : "sdk",
+            name: packageName,
+            version: "0.0.1",
             type: "module",
             main: "./src/index.ts",
+            module: "./src/index.ts",
+            types: "./src/index.ts",
+            publishConfig: {
+              access: "public"
+            },
+            exports: {
+              "./package.json": "./package.json",
+              ".": {
+                types: "./src/index.ts",
+                import: "./src/index.ts",
+                default: "./src/index.ts"
+              }
+            },
             dependencies: {
               "fast-content-type-parse": "^3.0.0",
               zod: "^3.24.2"
@@ -2359,33 +2238,104 @@ ${template2(send_request_default, {})({ throwError: !style.errorAsValue, outputT
         )
       }
     };
-    if (readme) {
+    if (settings.readme) {
       configFiles["README.md"] = {
-        ignoreIfExists: true,
-        content: readme
+        ignoreIfExists: false,
+        content: toReadme(spec, {
+          generateSnippet: (...args) => generator.snippet(...args)
+        })
       };
     }
-    await writeFiles(settings.output, configFiles);
+    await settings.writer(settings.output, configFiles);
   }
   await settings.formatCode?.({
     output,
     env: npmRunPathEnv()
   });
 }
-
-// packages/typescript/src/lib/watcher.ts
-import { watch as nodeWatch } from "node:fs/promises";
-import { debounceTime, from } from "rxjs";
-function watch(path) {
-  return from(
-    nodeWatch(path, {
-      persistent: true,
-      recursive: true
-    })
-  ).pipe(debounceTime(400));
+function serializeModels(spec) {
+  const filesMap = {};
+  const files = {};
+  for (const [name, schema] of Object.entries(spec.components.schemas)) {
+    const isResponseBody = schema["x-responsebody"];
+    const isRequestBody = schema["x-requestbody"];
+    const responseGroup = schema["x-response-group"];
+    const stream = schema["x-stream"];
+    const folder = isResponseBody ? "outputs" : "models";
+    let typeContent = "ReadableStream";
+    if (!stream) {
+      const serializer = new TypeScriptEmitter(spec);
+      typeContent = serializer.handle(schema, true);
+    }
+    const fileContent = [
+      `
+${schema.description ? `
+/** 
+ * ${schema.description}
+ */
+` : ""}`,
+      `export type ${pascalcase5(sanitizeTag4(name))} = ${typeContent};`
+    ];
+    const fileName = responseGroup ? join2(folder, `${spinalcase3(responseGroup)}.ts`) : join2(folder, `${spinalcase3(name)}.ts`);
+    filesMap[fileName] ??= [];
+    filesMap[fileName].push(fileContent.join("\n"));
+  }
+  for (const [group, contents] of Object.entries(filesMap)) {
+    let fileContent = contents.join("\n");
+    if (fileContent.includes("models.")) {
+      fileContent = `import type * as models from '../index.ts';
+${fileContent}`;
+    }
+    files[group] = fileContent;
+  }
+  return files;
+}
+function toInputs(operationsSet, commonZod, makeImport) {
+  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 = camelcase4(`${operation.name} schema`);
+      const schema = `export const ${schemaName} = ${Object.keys(operation.schemas).length === 1 ? Object.values(operation.schemas)[0] : toLitObject2(operation.schemas)};`;
+      for (const it of commonImports) {
+        if (schema.includes(it)) {
+          imports.add(
+            `import { ${it} } from './schemas/${makeImport(spinalcase3(it))}';`
+          );
+        }
+      }
+      output.push(schema);
+    }
+    inputs[`inputs/${spinalcase3(name)}.ts`] = [...imports, ...output].join("\n") + "\n";
+  }
+  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 './${makeImport(spinalcase3(schema2))}';`
+        );
+      }
+    }
+    output.push(content);
+    return [
+      [`inputs/schemas/${spinalcase3(name)}.ts`, output.join("\n")],
+      ...acc
+    ];
+  }, []);
+  return {
+    ...Object.fromEntries(schemas),
+    ...inputs
+  };
 }
 export {
+  TypeScriptGenerator,
   generate,
-  watch
+  generateSnippet,
+  toInputs
 };
 //# sourceMappingURL=index.js.map