npm - @sdk-it/typescript - Versions diffs - 0.20.0 → 0.21.0 - Mend

@sdk-it/typescript 0.20.0 → 0.21.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (28) hide show

package/dist/index.d.ts +1 -1
package/dist/index.d.ts.map +1 -1
package/dist/index.js +2072 -541
package/dist/index.js.map +4 -4
package/dist/lib/client.d.ts.map +1 -1
package/dist/lib/emitters/interface.d.ts +1 -1
package/dist/lib/emitters/interface.d.ts.map +1 -1
package/dist/lib/emitters/snippet.d.ts +24 -0
package/dist/lib/emitters/snippet.d.ts.map +1 -0
package/dist/lib/emitters/zod.d.ts +1 -1
package/dist/lib/emitters/zod.d.ts.map +1 -1
package/dist/lib/generate.d.ts +6 -18
package/dist/lib/generate.d.ts.map +1 -1
package/dist/lib/generator.d.ts +2 -4
package/dist/lib/generator.d.ts.map +1 -1
package/dist/lib/options.d.ts +27 -0
package/dist/lib/options.d.ts.map +1 -0
package/dist/lib/sdk.d.ts +5 -2
package/dist/lib/sdk.d.ts.map +1 -1
package/dist/lib/style.d.ts +2 -1
package/dist/lib/style.d.ts.map +1 -1
package/dist/lib/typescript-snippet.d.ts +17 -0
package/dist/lib/typescript-snippet.d.ts.map +1 -0
package/dist/lib/utils.d.ts +2 -2
package/dist/lib/utils.d.ts.map +1 -1
package/package.json +4 -3
package/dist/lib/readme.d.ts +0 -19
package/dist/lib/readme.d.ts.map +0 -1

package/dist/index.js CHANGED Viewed

@@ -1,156 +1,1315 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+// node_modules/pluralize/pluralize.js
+var require_pluralize = __commonJS({
+  "node_modules/pluralize/pluralize.js"(exports, module) {
+    "use strict";
+    (function(root, pluralize3) {
+      if (typeof __require === "function" && typeof exports === "object" && typeof module === "object") {
+        module.exports = pluralize3();
+      } else if (typeof define === "function" && define.amd) {
+        define(function() {
+          return pluralize3();
+        });
+      } else {
+        root.pluralize = pluralize3();
+      }
+    })(exports, function() {
+      var pluralRules = [];
+      var singularRules = [];
+      var uncountables = {};
+      var irregularPlurals = {};
+      var irregularSingles = {};
+      function sanitizeRule(rule) {
+        if (typeof rule === "string") {
+          return new RegExp("^" + rule + "$", "i");
+        }
+        return rule;
+      }
+      function restoreCase(word, token) {
+        if (word === token)
+          return token;
+        if (word === word.toLowerCase())
+          return token.toLowerCase();
+        if (word === word.toUpperCase())
+          return token.toUpperCase();
+        if (word[0] === word[0].toUpperCase()) {
+          return token.charAt(0).toUpperCase() + token.substr(1).toLowerCase();
+        }
+        return token.toLowerCase();
+      }
+      function interpolate(str, args) {
+        return str.replace(/\$(\d{1,2})/g, function(match, index) {
+          return args[index] || "";
+        });
+      }
+      function replace(word, rule) {
+        return word.replace(rule[0], function(match, index) {
+          var result = interpolate(rule[1], arguments);
+          if (match === "") {
+            return restoreCase(word[index - 1], result);
+          }
+          return restoreCase(match, result);
+        });
+      }
+      function sanitizeWord(token, word, rules) {
+        if (!token.length || uncountables.hasOwnProperty(token)) {
+          return word;
+        }
+        var len = rules.length;
+        while (len--) {
+          var rule = rules[len];
+          if (rule[0].test(word))
+            return replace(word, rule);
+        }
+        return word;
+      }
+      function replaceWord(replaceMap, keepMap, rules) {
+        return function(word) {
+          var token = word.toLowerCase();
+          if (keepMap.hasOwnProperty(token)) {
+            return restoreCase(word, token);
+          }
+          if (replaceMap.hasOwnProperty(token)) {
+            return restoreCase(word, replaceMap[token]);
+          }
+          return sanitizeWord(token, word, rules);
+        };
+      }
+      function checkWord(replaceMap, keepMap, rules, bool) {
+        return function(word) {
+          var token = word.toLowerCase();
+          if (keepMap.hasOwnProperty(token))
+            return true;
+          if (replaceMap.hasOwnProperty(token))
+            return false;
+          return sanitizeWord(token, token, rules) === token;
+        };
+      }
+      function pluralize3(word, count, inclusive) {
+        var pluralized = count === 1 ? pluralize3.singular(word) : pluralize3.plural(word);
+        return (inclusive ? count + " " : "") + pluralized;
+      }
+      pluralize3.plural = replaceWord(
+        irregularSingles,
+        irregularPlurals,
+        pluralRules
+      );
+      pluralize3.isPlural = checkWord(
+        irregularSingles,
+        irregularPlurals,
+        pluralRules
+      );
+      pluralize3.singular = replaceWord(
+        irregularPlurals,
+        irregularSingles,
+        singularRules
+      );
+      pluralize3.isSingular = checkWord(
+        irregularPlurals,
+        irregularSingles,
+        singularRules
+      );
+      pluralize3.addPluralRule = function(rule, replacement) {
+        pluralRules.push([sanitizeRule(rule), replacement]);
+      };
+      pluralize3.addSingularRule = function(rule, replacement) {
+        singularRules.push([sanitizeRule(rule), replacement]);
+      };
+      pluralize3.addUncountableRule = function(word) {
+        if (typeof word === "string") {
+          uncountables[word.toLowerCase()] = true;
+          return;
+        }
+        pluralize3.addPluralRule(word, "$0");
+        pluralize3.addSingularRule(word, "$0");
+      };
+      pluralize3.addIrregularRule = function(single, plural) {
+        plural = plural.toLowerCase();
+        single = single.toLowerCase();
+        irregularSingles[single] = plural;
+        irregularPlurals[plural] = single;
+      };
+      [
+        // Pronouns.
+        ["I", "we"],
+        ["me", "us"],
+        ["he", "they"],
+        ["she", "they"],
+        ["them", "them"],
+        ["myself", "ourselves"],
+        ["yourself", "yourselves"],
+        ["itself", "themselves"],
+        ["herself", "themselves"],
+        ["himself", "themselves"],
+        ["themself", "themselves"],
+        ["is", "are"],
+        ["was", "were"],
+        ["has", "have"],
+        ["this", "these"],
+        ["that", "those"],
+        // Words ending in with a consonant and `o`.
+        ["echo", "echoes"],
+        ["dingo", "dingoes"],
+        ["volcano", "volcanoes"],
+        ["tornado", "tornadoes"],
+        ["torpedo", "torpedoes"],
+        // Ends with `us`.
+        ["genus", "genera"],
+        ["viscus", "viscera"],
+        // Ends with `ma`.
+        ["stigma", "stigmata"],
+        ["stoma", "stomata"],
+        ["dogma", "dogmata"],
+        ["lemma", "lemmata"],
+        ["schema", "schemata"],
+        ["anathema", "anathemata"],
+        // Other irregular rules.
+        ["ox", "oxen"],
+        ["axe", "axes"],
+        ["die", "dice"],
+        ["yes", "yeses"],
+        ["foot", "feet"],
+        ["eave", "eaves"],
+        ["goose", "geese"],
+        ["tooth", "teeth"],
+        ["quiz", "quizzes"],
+        ["human", "humans"],
+        ["proof", "proofs"],
+        ["carve", "carves"],
+        ["valve", "valves"],
+        ["looey", "looies"],
+        ["thief", "thieves"],
+        ["groove", "grooves"],
+        ["pickaxe", "pickaxes"],
+        ["passerby", "passersby"]
+      ].forEach(function(rule) {
+        return pluralize3.addIrregularRule(rule[0], rule[1]);
+      });
+      [
+        [/s?$/i, "s"],
+        [/[^\u0000-\u007F]$/i, "$0"],
+        [/([^aeiou]ese)$/i, "$1"],
+        [/(ax|test)is$/i, "$1es"],
+        [/(alias|[^aou]us|t[lm]as|gas|ris)$/i, "$1es"],
+        [/(e[mn]u)s?$/i, "$1s"],
+        [/([^l]ias|[aeiou]las|[ejzr]as|[iu]am)$/i, "$1"],
+        [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1i"],
+        [/(alumn|alg|vertebr)(?:a|ae)$/i, "$1ae"],
+        [/(seraph|cherub)(?:im)?$/i, "$1im"],
+        [/(her|at|gr)o$/i, "$1oes"],
+        [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|automat|quor)(?:a|um)$/i, "$1a"],
+        [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)(?:a|on)$/i, "$1a"],
+        [/sis$/i, "ses"],
+        [/(?:(kni|wi|li)fe|(ar|l|ea|eo|oa|hoo)f)$/i, "$1$2ves"],
+        [/([^aeiouy]|qu)y$/i, "$1ies"],
+        [/([^ch][ieo][ln])ey$/i, "$1ies"],
+        [/(x|ch|ss|sh|zz)$/i, "$1es"],
+        [/(matr|cod|mur|sil|vert|ind|append)(?:ix|ex)$/i, "$1ices"],
+        [/\b((?:tit)?m|l)(?:ice|ouse)$/i, "$1ice"],
+        [/(pe)(?:rson|ople)$/i, "$1ople"],
+        [/(child)(?:ren)?$/i, "$1ren"],
+        [/eaux$/i, "$0"],
+        [/m[ae]n$/i, "men"],
+        ["thou", "you"]
+      ].forEach(function(rule) {
+        return pluralize3.addPluralRule(rule[0], rule[1]);
+      });
+      [
+        [/s$/i, ""],
+        [/(ss)$/i, "$1"],
+        [/(wi|kni|(?:after|half|high|low|mid|non|night|[^\w]|^)li)ves$/i, "$1fe"],
+        [/(ar|(?:wo|[ae])l|[eo][ao])ves$/i, "$1f"],
+        [/ies$/i, "y"],
+        [/\b([pl]|zomb|(?:neck|cross)?t|coll|faer|food|gen|goon|group|lass|talk|goal|cut)ies$/i, "$1ie"],
+        [/\b(mon|smil)ies$/i, "$1ey"],
+        [/\b((?:tit)?m|l)ice$/i, "$1ouse"],
+        [/(seraph|cherub)im$/i, "$1"],
+        [/(x|ch|ss|sh|zz|tto|go|cho|alias|[^aou]us|t[lm]as|gas|(?:her|at|gr)o|[aeiou]ris)(?:es)?$/i, "$1"],
+        [/(analy|diagno|parenthe|progno|synop|the|empha|cri|ne)(?:sis|ses)$/i, "$1sis"],
+        [/(movie|twelve|abuse|e[mn]u)s$/i, "$1"],
+        [/(test)(?:is|es)$/i, "$1is"],
+        [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, "$1us"],
+        [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|quor)a$/i, "$1um"],
+        [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)a$/i, "$1on"],
+        [/(alumn|alg|vertebr)ae$/i, "$1a"],
+        [/(cod|mur|sil|vert|ind)ices$/i, "$1ex"],
+        [/(matr|append)ices$/i, "$1ix"],
+        [/(pe)(rson|ople)$/i, "$1rson"],
+        [/(child)ren$/i, "$1"],
+        [/(eau)x?$/i, "$1"],
+        [/men$/i, "man"]
+      ].forEach(function(rule) {
+        return pluralize3.addSingularRule(rule[0], rule[1]);
+      });
+      [
+        // Singular words with no plurals.
+        "adulthood",
+        "advice",
+        "agenda",
+        "aid",
+        "aircraft",
+        "alcohol",
+        "ammo",
+        "analytics",
+        "anime",
+        "athletics",
+        "audio",
+        "bison",
+        "blood",
+        "bream",
+        "buffalo",
+        "butter",
+        "carp",
+        "cash",
+        "chassis",
+        "chess",
+        "clothing",
+        "cod",
+        "commerce",
+        "cooperation",
+        "corps",
+        "debris",
+        "diabetes",
+        "digestion",
+        "elk",
+        "energy",
+        "equipment",
+        "excretion",
+        "expertise",
+        "firmware",
+        "flounder",
+        "fun",
+        "gallows",
+        "garbage",
+        "graffiti",
+        "hardware",
+        "headquarters",
+        "health",
+        "herpes",
+        "highjinks",
+        "homework",
+        "housework",
+        "information",
+        "jeans",
+        "justice",
+        "kudos",
+        "labour",
+        "literature",
+        "machinery",
+        "mackerel",
+        "mail",
+        "media",
+        "mews",
+        "moose",
+        "music",
+        "mud",
+        "manga",
+        "news",
+        "only",
+        "personnel",
+        "pike",
+        "plankton",
+        "pliers",
+        "police",
+        "pollution",
+        "premises",
+        "rain",
+        "research",
+        "rice",
+        "salmon",
+        "scissors",
+        "series",
+        "sewage",
+        "shambles",
+        "shrimp",
+        "software",
+        "species",
+        "staff",
+        "swine",
+        "tennis",
+        "traffic",
+        "transportation",
+        "trout",
+        "tuna",
+        "wealth",
+        "welfare",
+        "whiting",
+        "wildebeest",
+        "wildlife",
+        "you",
+        /pok[eé]mon$/i,
+        // Regexes.
+        /[^aeiou]ese$/i,
+        // "chinese", "japanese"
+        /deer$/i,
+        // "deer", "reindeer"
+        /fish$/i,
+        // "fish", "blowfish", "angelfish"
+        /measles$/i,
+        /o[iu]s$/i,
+        // "carnivorous"
+        /pox$/i,
+        // "chickpox", "smallpox"
+        /sheep$/i
+      ].forEach(pluralize3.addUncountableRule);
+      return pluralize3;
+    });
+  }
+});
 // packages/typescript/src/lib/generate.ts
 import { template as template2 } from "lodash-es";
-import { join as join2 } from "node:path";
+import { readFile, readdir, unlink, writeFile } from "node:fs/promises";
+import { join as join2, relative, sep } 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 { spinalcase as spinalcase4 } from "stringcase";
+import { methods, pascalcase as pascalcase4 } from "@sdk-it/core";
 import {
+  addLeadingSlash,
+  exist,
   getFolderExports,
+  readFolder,
   writeFiles
 } from "@sdk-it/core/file-system.js";
-// packages/typescript/src/lib/client.ts
-import { toLitObject } from "@sdk-it/core";
-var client_default = (spec, style) => {
-  const optionsEntries = Object.entries(spec.options).map(
-    ([key, value]) => [`'${key}'`, value]
-  );
-  const defaultHeaders = `{${optionsEntries.filter(([, value]) => value.in === "header").map(
-    ([key, value]) => `${key}: this.options[${value.optionName ? `'${value.optionName}'` : key}]`
-  ).join(",\n")}}`;
-  const defaultInputs = `{${optionsEntries.filter(([, value]) => value.in === "input").map(
-    ([key, value]) => `${key}: this.options[${value.optionName ? `'${value.optionName}'` : key}]`
-  ).join(",\n")}}`;
-  const specOptions = {
-    ...Object.fromEntries(
-      optionsEntries.map(([key, value]) => [value.optionName ?? key, value])
-    ),
-    fetch: {
-      schema: "fetchType"
-    },
-    baseUrl: {
-      schema: spec.servers.length ? `z.enum(servers).default(servers[0])` : "z.string()"
+// packages/readme/dist/index.js
+var import_pluralize = __toESM(require_pluralize(), 1);
+import { isEmpty as isEmpty2 } from "@sdk-it/core";
+import { camelcase } from "stringcase";
+import { followRef, isRef as isRef2 } from "@sdk-it/core/ref.js";
+import { isRef } from "@sdk-it/core/ref.js";
+import { isEmpty } from "@sdk-it/core/utils.js";
+import { followRef as followRef2, isRef as isRef3 } from "@sdk-it/core";
+var HAS_MORE_POSITIVE_REGEX_PATTERNS = [
+  "\\bhas_?more\\b",
+  "\\bhas_?next\\b",
+  // e.g., itemsHasNext, items_has_next
+  "\\bmore_?items\\b",
+  "\\bnext_?page\\b",
+  // e.g., userNextPageFlag
+  "\\badditional\\b",
+  // e.g., hasAdditionalData, additional_results_exist
+  "\\bcontinuation\\b",
+  // e.g., continuationAvailable, has_continuation_token
+  "\\bmore_?results\\b",
+  "\\bpage_?available\\b",
+  "\\bnext(?:_?(page))?\\b"
+];
+var COMPILED_HAS_MORE_POSITIVE_REGEXES = HAS_MORE_POSITIVE_REGEX_PATTERNS.map((p) => new RegExp(p, "i"));
+var HAS_MORE_INVERTED_REGEX_PATTERNS = [
+  "\\bis_?last\\b",
+  // e.g., pageIsLast
+  "\\blast_?page\\b",
+  // e.g., resultsAreLastPage
+  "\\bend_?of_?(data|results|list|items|stream)\\b",
+  "\\bno_?more_?(items|data|results)?\\b",
+  "\\ball_?(items_?)?loaded\\b",
+  "\\bis_?complete\\b"
+];
+var COMPILED_HAS_MORE_INVERTED_REGEXES = HAS_MORE_INVERTED_REGEX_PATTERNS.map((p) => new RegExp(p, "i"));
+function forEachOperation(config, callback) {
+  const result = [];
+  for (const [path, pathItem] of Object.entries(config.spec.paths ?? {})) {
+    const { parameters = [], ...methods2 } = pathItem;
+    for (const [method, operation] of Object.entries(methods2)) {
+      const metadata = operation["x-oaiMeta"] ?? {};
+      const operationTag = operation.tags?.[0];
+      result.push(
+        callback(
+          {
+            name: metadata.name,
+            method,
+            path,
+            groupName: operationTag,
+            tag: operationTag
+          },
+          operation
+        )
+      );
+    }
+  }
+  return result;
+}
+var PropEmitter = class {
+  #spec;
+  constructor(spec) {
+    this.#spec = spec;
+  }
+  /**
+   * Handle objects (properties)
+   */
+  #object(schema) {
+    const lines = [];
+    const properties = schema.properties || {};
+    if (Object.keys(properties).length > 0) {
+      lines.push(`**Properties:**`);
+      for (const [propName, propSchema] of Object.entries(properties)) {
+        const isRequired = (schema.required ?? []).includes(propName);
+        lines.push(...this.#property(propName, propSchema, isRequired));
+      }
+    }
+    if (schema.additionalProperties) {
+      lines.push(`**Additional Properties:**`);
+      if (typeof schema.additionalProperties === "boolean") {
+        lines.push(`- Allowed: ${schema.additionalProperties}`);
+      } else {
+        lines.push(
+          ...this.handle(schema.additionalProperties).map((l) => `  ${l}`)
+        );
+      }
+    }
+    return lines;
+  }
+  /**
+   * Format a property with its type and description
+   */
+  #property(name, schema, required) {
+    const docs = this.handle(schema);
+    const rawType = docs[0].replace("**Type:** ", "").replace(" (nullable)", "|null");
+    const defaultVal = !isRef3(schema) && schema.default !== void 0 ? ` default: ${JSON.stringify(schema.default)}` : "";
+    const reqMark = required ? " required" : "";
+    const summary = `- \`${name}\` ${rawType}${reqMark}${defaultVal}:`;
+    const detailLines = docs.slice(1).filter((l) => !l.startsWith("**Default:**")).map((l) => `  ${l}`);
+    return [summary, ...detailLines];
+  }
+  /**
+   * 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 = followRef2(this.#spec, $ref);
+    const lines = [
+      `**Type:** [\`${schemaName}\`](#${schemaName.toLowerCase()})`
+    ];
+    if (resolved.description) {
+      lines.push(resolved.description);
+    }
+    return lines;
+  }
+  #allOf(schemas) {
+    const lines = ["**All of (Intersection):**"];
+    schemas.forEach((subSchema, index) => {
+      lines.push(`- **Constraint ${index + 1}:**`);
+      const subLines = this.handle(subSchema);
+      lines.push(...subLines.map((l) => `  ${l}`));
+    });
+    return lines;
+  }
+  #anyOf(schemas) {
+    const lines = ["**Any of (Union):**"];
+    schemas.forEach((subSchema, index) => {
+      lines.push(`- **Option ${index + 1}:**`);
+      const subLines = this.handle(subSchema);
+      lines.push(...subLines.map((l) => `  ${l}`));
+    });
+    return lines;
+  }
+  #oneOf(schemas) {
+    const lines = ["**One of (Exclusive Union):**"];
+    schemas.forEach((subSchema, index) => {
+      lines.push(`- **Option ${index + 1}:**`);
+      const subLines = this.handle(subSchema);
+      lines.push(...subLines.map((l) => `  ${l}`));
+    });
+    return lines;
+  }
+  #enum(schema) {
+    const lines = [`**Type:** \`${schema.type || "unknown"}\` (enum)`];
+    if (schema.description)
+      lines.push(schema.description);
+    lines.push("**Allowed values:**");
+    lines.push(
+      ...(schema.enum || []).map((val) => `- \`${JSON.stringify(val)}\``)
+    );
+    if (schema.default !== void 0) {
+      lines.push(`**Default:** \`${JSON.stringify(schema.default)}\``);
+    }
+    return lines;
+  }
+  #normal(type, schema, nullable) {
+    const lines = [];
+    const nullableSuffix = nullable ? " (nullable)" : "";
+    const description = schema.description ? [schema.description] : [];
+    switch (type) {
+      case "string":
+        lines.push(
+          `**Type:** \`string\`${schema.format ? ` (format: ${schema.format})` : ""}${nullableSuffix}`
+        );
+        lines.push(...description);
+        if (schema.minLength !== void 0)
+          lines.push(`- Minimum length: ${schema.minLength}`);
+        if (schema.maxLength !== void 0)
+          lines.push(`- Maximum length: ${schema.maxLength}`);
+        if (schema.pattern !== void 0)
+          lines.push(`- Pattern: \`${schema.pattern}\``);
+        break;
+      case "number":
+      case "integer":
+        lines.push(
+          `**Type:** \`${type}\`${schema.format ? ` (format: ${schema.format})` : ""}${nullableSuffix}`
+        );
+        lines.push(...description);
+        if (schema.minimum !== void 0) {
+          const exclusiveMin = typeof schema.exclusiveMinimum === "number";
+          lines.push(
+            `- Minimum: ${schema.minimum}${exclusiveMin ? " (exclusive)" : ""}`
+          );
+          if (exclusiveMin) {
+            lines.push(
+              `- Must be strictly greater than: ${schema.exclusiveMinimum}`
+            );
+          }
+        } else if (typeof schema.exclusiveMinimum === "number") {
+          lines.push(
+            `- Must be strictly greater than: ${schema.exclusiveMinimum}`
+          );
+        }
+        if (schema.maximum !== void 0) {
+          const exclusiveMax = typeof schema.exclusiveMaximum === "number";
+          lines.push(
+            `- Maximum: ${schema.maximum}${exclusiveMax ? " (exclusive)" : ""}`
+          );
+          if (exclusiveMax) {
+            lines.push(
+              `- Must be strictly less than: ${schema.exclusiveMaximum}`
+            );
+          }
+        } else if (typeof schema.exclusiveMaximum === "number") {
+          lines.push(
+            `- Must be strictly less than: ${schema.exclusiveMaximum}`
+          );
+        }
+        if (schema.multipleOf !== void 0)
+          lines.push(`- Must be a multiple of: ${schema.multipleOf}`);
+        break;
+      case "boolean":
+        lines.push(`**Type:** \`boolean\`${nullableSuffix}`);
+        lines.push(...description);
+        break;
+      case "object":
+        lines.push(`**Type:** \`object\`${nullableSuffix}`);
+        lines.push(...description);
+        lines.push(...this.#object(schema));
+        break;
+      case "array":
+        lines.push(`**Type:** \`array\`${nullableSuffix}`);
+        lines.push(...description);
+        lines.push(...this.#array(schema));
+        break;
+      case "null":
+        lines.push(`**Type:** \`null\``);
+        lines.push(...description);
+        break;
+      default:
+        lines.push(`**Type:** \`${type}\`${nullableSuffix}`);
+        lines.push(...description);
+    }
+    if (schema.default !== void 0) {
+      lines.push(`**Default:** \`${JSON.stringify(schema.default)}\``);
+    }
+    return lines.filter((l) => l);
+  }
+  /**
+   * Handle schemas by resolving references and delegating to appropriate handler
+   */
+  handle(schemaOrRef) {
+    if (isRef3(schemaOrRef)) {
+      return this.#ref(schemaOrRef.$ref);
+    }
+    const schema = schemaOrRef;
+    if (schema.allOf && Array.isArray(schema.allOf)) {
+      return this.#allOf(schema.allOf);
+    }
+    if (schema.anyOf && Array.isArray(schema.anyOf)) {
+      return this.#anyOf(schema.anyOf);
+    }
+    if (schema.oneOf && Array.isArray(schema.oneOf)) {
+      return this.#oneOf(schema.oneOf);
+    }
+    if (schema.enum && Array.isArray(schema.enum)) {
+      return this.#enum(schema);
+    }
+    let types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
+    let nullable = false;
+    if (types.includes("null")) {
+      nullable = true;
+      types = types.filter((t) => t !== "null");
+    }
+    if (types.length === 0) {
+      if (schema.properties || schema.additionalProperties) {
+        types = ["object"];
+      } else if (schema.items) {
+        types = ["array"];
+      }
+    }
+    if (types.length === 0) {
+      const lines2 = ["**Type:** `unknown`"];
+      if (schema.description)
+        lines2.push(schema.description);
+      if (schema.default !== void 0)
+        lines2.push(`**Default:** \`${JSON.stringify(schema.default)}\``);
+      return lines2;
+    }
+    if (types.length === 1) {
+      return this.#normal(types[0], schema, nullable);
+    }
+    const typeString = types.join(" | ");
+    const nullableSuffix = nullable ? " (nullable)" : "";
+    const lines = [`**Type:** \`${typeString}\`${nullableSuffix}`];
+    if (schema.description)
+      lines.push(schema.description);
+    if (schema.default !== void 0)
+      lines.push(`**Default:** \`${JSON.stringify(schema.default)}\``);
+    return lines;
+  }
+  /**
+   * Process a request body and return markdown documentation
+   */
+  requestBody(requestBody) {
+    if (!requestBody)
+      return [];
+    const lines = [];
+    lines.push(`##### Request Body`);
+    if (requestBody.description) {
+      lines.push(requestBody.description);
     }
-  };
-  return `
-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 schemas from './api/${spec.makeImport("schemas")}';
-import {
-  createBaseUrlInterceptor,
-  createHeadersInterceptor,
-} from './http/${spec.makeImport("interceptors")}';
-import { parseInput, type ParseError } from './http/${spec.makeImport("parser")}';
-${spec.servers.length ? `export const servers = ${JSON.stringify(spec.servers, null, 2)} as const` : ""}
-const optionsSchema = z.object(${toLitObject(specOptions, (x) => x.schema)});
-${spec.servers.length ? `export type Servers = typeof servers[number];` : ""}
-type ${spec.name}Options = z.infer<typeof optionsSchema>;
-export class ${spec.name} {
-  public options: ${spec.name}Options
-  constructor(options: ${spec.name}Options) {
-    this.options = optionsSchema.parse(options);
+    if (requestBody.required) {
+      lines.push(`*This request body is required.*`);
+    }
+    if (requestBody.content) {
+      for (const [contentType, mediaType] of Object.entries(
+        requestBody.content
+      )) {
+        lines.push(`**Content Type:** \`${contentType}\``);
+        if (mediaType.schema) {
+          const schemaDocs = this.handle(mediaType.schema);
+          lines.push(...schemaDocs);
+        }
+      }
+    }
+    return lines;
   }
+};
+function toReadme(spec, generators) {
+  const markdown = [];
+  const propEmitter = new PropEmitter(spec);
+  forEachOperation({ spec }, (entry, operation) => {
+    const { method, path, name } = entry;
+    spec.components ??= {};
+    spec.components.schemas ??= {};
+    markdown.push(
+      `#### ${name || operation.operationId} | ${`_${method.toUpperCase()} ${path}_`}`
+    );
+    markdown.push(operation.summary || "");
+    const snippet = generators.generateSnippet(entry, operation);
+    markdown.push(`##### Example usage`);
+    markdown.push(snippet);
+    const requestBodyContent = propEmitter.requestBody(operation.requestBody);
+    if (requestBodyContent.length > 1) {
+      markdown.push(requestBodyContent.join("\n\n"));
+    }
+    markdown.push(`##### Responses`);
+    for (const status in operation.responses) {
+      const response = operation.responses[status];
+      markdown.push(`<details>`);
+      markdown.push(
+        `<summary><b>${status}</b>  <i>${response.description}</i></summary>`
+      );
+      if (!isEmpty2(response.content)) {
+        for (const [contentType, mediaType] of Object.entries(
+          response.content
+        )) {
+          markdown.push(`
+**Content Type:** \`${contentType}\``);
+          if (mediaType.schema) {
+            const schemaDocs = propEmitter.handle(mediaType.schema);
+            markdown.push(...schemaDocs.map((l) => `
+${l}`));
+          }
+        }
+      }
+      markdown.push(`</details>`);
+    }
+  });
+  return markdown.join("\n\n");
+}
-  async request<E extends keyof Endpoints>(
-    endpoint: E,
-    input: Endpoints[E]['input'],
-    options?: { signal?: AbortSignal, headers?: HeadersInit },
-  ) ${style.errorAsValue ? `: Promise<readonly [Endpoints[E]['output'], Endpoints[E]['error'] | null]>` : `: Promise<Endpoints[E]['output']>`} {
-    const route = schemas[endpoint];
-    const result = await dispatch(Object.assign(this.#defaultInputs, input), route, {
-      fetch: this.options.fetch,
-      interceptors: [
-        createHeadersInterceptor(() => this.defaultHeaders, options?.headers ?? {}),
-        createBaseUrlInterceptor(() => this.options.baseUrl),
-      ],
-      signal: options?.signal,
-    });
-    return ${style.errorAsValue ? `result as [Endpoints[E]['output'], Endpoints[E]['error'] | null]` : `result as Endpoints[E]['output']`};
+// packages/spec/dist/lib/operation.js
+import { camelcase as camelcase2 } from "stringcase";
+import { followRef as followRef3, isRef as isRef5 } from "@sdk-it/core/ref.js";
+// packages/spec/dist/lib/pagination/pagination.js
+import { isRef as isRef4 } from "@sdk-it/core/ref.js";
+import { isEmpty as isEmpty3 } from "@sdk-it/core/utils.js";
+// packages/spec/dist/lib/pagination/pagination-result.js
+var import_pluralize2 = __toESM(require_pluralize(), 1);
+var PRIMARY_TOP_TIER_KEYWORDS = [
+  "data",
+  "items",
+  "results",
+  "value"
+];
+var PRIMARY_OTHER_KEYWORDS = [
+  "records",
+  "content",
+  "list",
+  "payload",
+  "entities",
+  "collection",
+  "users",
+  "products",
+  "orders",
+  "bookings",
+  "articles",
+  "posts",
+  "documents",
+  "events"
+];
+var SECONDARY_KEYWORDS = ["entries", "rows", "elements"];
+var PLURAL_DEPRIORITIZE_LIST = [
+  "status",
+  "success",
+  "address",
+  "details",
+  "properties",
+  "params",
+  "headers",
+  "cookies",
+  "series",
+  "links",
+  "meta",
+  "metadata",
+  "statistics",
+  "settings",
+  "options",
+  "permissions",
+  "credentials",
+  "diagnostics",
+  "warnings",
+  "errors",
+  "actions",
+  "attributes",
+  "categories",
+  "features",
+  "includes",
+  "tags"
+];
+var HAS_MORE_PRIMARY_POSITIVE_EXACT = [
+  "hasmore",
+  "hasnext",
+  "hasnextpage",
+  "moreitems",
+  "moreitemsavailable",
+  "nextpage",
+  "nextpageexists",
+  "nextpageavailable",
+  "hasadditionalresults",
+  "moreresultsavailable",
+  "canloadmore",
+  "hasadditional",
+  "additionalitems",
+  "fetchmore"
+];
+var HAS_MORE_SECONDARY_POSITIVE_EXACT = ["more", "next"];
+var HAS_MORE_PRIMARY_INVERTED_EXACT = [
+  "islast",
+  "lastpage",
+  "endofresults",
+  "endoflist",
+  "nomoreitems",
+  "nomoredata",
+  "allitemsloaded",
+  "iscomplete",
+  "completed"
+];
+var HAS_MORE_POSITIVE_REGEX_PATTERNS2 = [
+  "\\bhas_?more\\b",
+  "\\bhas_?next\\b",
+  // e.g., itemsHasNext, items_has_next
+  "\\bmore_?items\\b",
+  "\\bnext_?page\\b",
+  // e.g., userNextPageFlag
+  "\\badditional\\b",
+  // e.g., hasAdditionalData, additional_results_exist
+  "\\bcontinuation\\b",
+  // e.g., continuationAvailable, has_continuation_token
+  "\\bmore_?results\\b",
+  "\\bpage_?available\\b",
+  "\\bnext(?:_?(page))?\\b"
+];
+var COMPILED_HAS_MORE_POSITIVE_REGEXES2 = HAS_MORE_POSITIVE_REGEX_PATTERNS2.map((p) => new RegExp(p, "i"));
+var HAS_MORE_INVERTED_REGEX_PATTERNS2 = [
+  "\\bis_?last\\b",
+  // e.g., pageIsLast
+  "\\blast_?page\\b",
+  // e.g., resultsAreLastPage
+  "\\bend_?of_?(data|results|list|items|stream)\\b",
+  "\\bno_?more_?(items|data|results)?\\b",
+  "\\ball_?(items_?)?loaded\\b",
+  "\\bis_?complete\\b"
+];
+var COMPILED_HAS_MORE_INVERTED_REGEXES2 = HAS_MORE_INVERTED_REGEX_PATTERNS2.map((p) => new RegExp(p, "i"));
+function getItemsName(properties) {
+  const arrayPropertyNames = [];
+  for (const propName in properties) {
+    if (propName in properties) {
+      const propSchema = properties[propName];
+      if (propSchema && propSchema.type === "array") {
+        arrayPropertyNames.push(propName);
+      }
+    }
   }
-  async prepare<E extends keyof Endpoints>(
-    endpoint: E,
-    input: Endpoints[E]['input'],
-    options?: { headers?: HeadersInit },
-  ): ${style.errorAsValue ? `Promise<
-    readonly [
-      RequestConfig & {
-        parse: (response: Response) => ReturnType<typeof parse>;
-      },
-      ParseError<(typeof schemas)[E]['schema']> | null,
-    ]
-  >` : `Promise<RequestConfig & {
-        parse: (response: Response) => ReturnType<typeof parse>;
-      }>`} {
-    const route = schemas[endpoint];
-    const interceptors = [
-      createHeadersInterceptor(
-        () => this.defaultHeaders,
-        options?.headers ?? {},
-      ),
-      createBaseUrlInterceptor(() => this.options.baseUrl),
-    ];
-    const [parsedInput, parseError] = parseInput(route.schema, input);
-    if (parseError) {
-      ${style.errorAsValue ? "return [null as never, parseError as never] as const;" : "throw parseError;"}
+  if (arrayPropertyNames.length === 0) {
+    return null;
+  }
+  if (arrayPropertyNames.length === 1) {
+    return arrayPropertyNames[0];
+  }
+  let bestCandidate = null;
+  let candidateRank = Infinity;
+  const updateCandidate = (propName, rank) => {
+    if (rank < candidateRank) {
+      bestCandidate = propName;
+      candidateRank = rank;
     }
-    let config = route.toRequest(parsedInput as never);
-    for (const interceptor of interceptors) {
-      if (interceptor.before) {
-        config = await interceptor.before(config);
+  };
+  for (const propName of arrayPropertyNames) {
+    const lowerPropName = propName.toLowerCase();
+    if (PRIMARY_TOP_TIER_KEYWORDS.includes(lowerPropName)) {
+      updateCandidate(propName, 2);
+      continue;
+    }
+    if (candidateRank > 3 && PRIMARY_OTHER_KEYWORDS.includes(lowerPropName)) {
+      updateCandidate(propName, 3);
+      continue;
+    }
+    if (candidateRank > 4 && SECONDARY_KEYWORDS.includes(lowerPropName)) {
+      updateCandidate(propName, 4);
+      continue;
+    }
+    if (candidateRank > 5 && import_pluralize2.default.isPlural(propName) && !PLURAL_DEPRIORITIZE_LIST.includes(lowerPropName)) {
+      updateCandidate(propName, 5);
+      continue;
+    }
+    if (candidateRank > 6 && import_pluralize2.default.isPlural(propName) && PLURAL_DEPRIORITIZE_LIST.includes(lowerPropName)) {
+      updateCandidate(propName, 6);
+      continue;
+    }
+  }
+  if (bestCandidate) {
+    return bestCandidate;
+  }
+  return arrayPropertyNames[0];
+}
+function guess(properties) {
+  const booleanPropertyNames = [];
+  for (const propName in properties) {
+    if (Object.prototype.hasOwnProperty.call(properties, propName)) {
+      const propSchema = properties[propName];
+      if (propSchema && propSchema.type === "boolean" || propSchema.type === "integer") {
+        booleanPropertyNames.push(propName);
       }
     }
-    const prepared = { ...config, parse: (response: Response) => parse(route, response) };
-    return ${style.errorAsValue ? "[prepared, null as never] as const;" : "prepared"}
   }
-  get defaultHeaders() {
-    return ${defaultHeaders}
+  if (booleanPropertyNames.length === 0) {
+    return null;
   }
-  get #defaultInputs() {
-    return ${defaultInputs}
+  if (booleanPropertyNames.length === 1) {
+    return booleanPropertyNames[0];
   }
-  setOptions(options: Partial<${spec.name}Options>) {
-    const validated = optionsSchema.partial().parse(options);
-    for (const key of Object.keys(validated) as (keyof ${spec.name}Options)[]) {
-      if (validated[key] !== undefined) {
-        (this.options[key] as typeof validated[typeof key]) = validated[key]!;
+  let bestCandidate = null;
+  let candidateRank = Infinity;
+  const updateCandidate = (propName, rank) => {
+    if (rank < candidateRank) {
+      bestCandidate = propName;
+      candidateRank = rank;
+    }
+  };
+  for (const propName of booleanPropertyNames) {
+    const normalizedForExactMatch = propName.toLowerCase().replace(/[-_]/g, "");
+    let currentPropRank = Infinity;
+    if (HAS_MORE_PRIMARY_POSITIVE_EXACT.includes(normalizedForExactMatch)) {
+      currentPropRank = 1;
+    } else if (HAS_MORE_SECONDARY_POSITIVE_EXACT.includes(normalizedForExactMatch)) {
+      currentPropRank = 2;
+    } else {
+      let foundPositiveRegex = false;
+      for (const regex of COMPILED_HAS_MORE_POSITIVE_REGEXES2) {
+        if (regex.test(propName)) {
+          currentPropRank = 3;
+          foundPositiveRegex = true;
+          break;
+        }
+      }
+      if (!foundPositiveRegex) {
+        if (HAS_MORE_PRIMARY_INVERTED_EXACT.includes(normalizedForExactMatch)) {
+          currentPropRank = 4;
+        } else {
+          for (const regex of COMPILED_HAS_MORE_INVERTED_REGEXES2) {
+            if (regex.test(propName)) {
+              currentPropRank = 5;
+              break;
+            }
+          }
+        }
       }
     }
+    updateCandidate(propName, currentPropRank);
   }
-}`;
-};
+  return bestCandidate;
+}
+function getHasMoreName(properties) {
+  const rootGuess = guess(properties);
+  if (rootGuess) {
+    return rootGuess;
+  }
+  for (const propName in properties) {
+    const propSchema = properties[propName];
+    if (propSchema.type === "object" && propSchema.properties) {
+      const nested = getHasMoreName(propSchema.properties);
+      if (nested) {
+        return propName + "." + nested;
+      }
+    }
+  }
+  return null;
+}
-// 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/pagination/pagination.js
+var OFFSET_PARAM_REGEXES = [
+  /\boffset\b/i,
+  /\bskip\b/i,
+  /\bstart(?:ing_at|_index)?\b/i,
+  // e.g., start, starting_at, start_index
+  /\bfrom\b/i
+];
+var GENERIC_LIMIT_PARAM_REGEXES = [
+  /\blimit\b/i,
+  /\bcount\b/i,
+  /\b(?:page_?)?size\b/i,
+  // e.g., size, page_size, pagesize
+  /\bmax_results\b/i,
+  /\bnum_results\b/i,
+  /\bshow\b/i,
+  // Can sometimes mean limit
+  /\bper_?page\b/i,
+  // e.g., per_page, perpage
+  /\bper-page\b/i,
+  /\btake\b/i
+];
+var PAGE_NUMBER_REGEXES = [
+  /^page$/i,
+  // Exact match for "page"
+  /^p$/i,
+  // Exact match for "p" (common shorthand)
+  /\bpage_?(?:number|num|idx|index)\b/i
+  // e.g., page_number, pageNumber, page_num, page_idx
+];
+var PAGE_SIZE_REGEXES = [
+  /\bpage_?size\b/i,
+  // e.g., page_size, pagesize
+  /^size$/i,
+  // Exact "size"
+  // /\bsize\b/i, // Broader "size" - can be ambiguous, prefer more specific ones first
+  /\blimit\b/i,
+  // Limit is often used for page size
+  /\bcount\b/i,
+  // Count can also be used for page size
+  /\bper_?page\b/i,
+  // e.g., per_page, perpage
+  /\bper-page\b/i,
+  /\bnum_?(?:items|records|results)\b/i,
+  // e.g., num_items, numitems
+  /\bresults_?per_?page\b/i
+];
+var CURSOR_REGEXES = [
+  /\bcursor\b/i,
+  /\bafter(?:_?cursor)?\b/i,
+  // e.g., after, after_cursor
+  /\bbefore(?:_?cursor)?\b/i,
+  // e.g., before, before_cursor
+  /\b(next|prev|previous)_?(?:page_?)?token\b/i,
+  // e.g., next_page_token, nextPageToken, prev_token
+  /\b(next|prev|previous)_?cursor\b/i,
+  // e.g., next_cursor, previousCursor
+  /\bcontinuation(?:_?token)?\b/i,
+  // e.g., continuation, continuation_token
+  /\bpage(?:_?(token|id))?\b/i,
+  // e.g., after, after_cursor
+  /\bstart_?(?:key|cursor|token|after)\b/i
+  // e.g., start_key, startCursor, startToken, startAfter
+];
+var CURSOR_LIMIT_REGEXES = [
+  /\blimit\b/i,
+  /\bcount\b/i,
+  /\bsize\b/i,
+  // General size
+  /\bfirst\b/i,
+  // Common in Relay-style cursor pagination (forward pagination)
+  /\blast\b/i,
+  // Common in Relay-style cursor pagination (backward pagination)
+  /\bpage_?size\b/i,
+  // Sometimes page_size is used with cursors
+  /\bnum_?(?:items|records|results)\b/i,
+  // e.g., num_items
+  /\bmax_?items\b/i,
+  /\btake\b/i
+];
+function findParamAndKeyword(queryParams, regexes, excludeParamName) {
+  for (const param of queryParams) {
+    if (param.name === excludeParamName) {
+      continue;
+    }
+    for (const regex of regexes) {
+      const match = param.name.match(regex);
+      if (match) {
+        return { param, keyword: match[0] };
+      }
+    }
+  }
+  return null;
+}
+function isOffsetPagination(operation, parameters) {
+  const offsetMatch = findParamAndKeyword(parameters, OFFSET_PARAM_REGEXES);
+  if (!offsetMatch)
+    return null;
+  const limitMatch = findParamAndKeyword(
+    parameters,
+    GENERIC_LIMIT_PARAM_REGEXES,
+    offsetMatch.param.name
+  );
+  if (!limitMatch)
+    return null;
+  return {
+    type: "offset",
+    offsetParamName: offsetMatch.param.name,
+    offsetKeyword: offsetMatch.keyword,
+    limitParamName: limitMatch.param.name,
+    limitKeyword: limitMatch.keyword
+  };
+}
+function isPagePagination(operation) {
+  const queryParams = operation.parameters.filter((p) => p.in === "query").filter(
+    (it) => it.schema && !isRef4(it.schema) && it.schema.type === "integer"
+  );
+  if (queryParams.length < 2)
+    return null;
+  const pageNoMatch = findParamAndKeyword(queryParams, PAGE_NUMBER_REGEXES);
+  if (!pageNoMatch)
+    return null;
+  const pageSizeMatch = findParamAndKeyword(
+    queryParams,
+    PAGE_SIZE_REGEXES,
+    pageNoMatch.param.name
+  );
+  if (!pageSizeMatch)
+    return null;
+  return {
+    type: "page",
+    pageNumberParamName: pageNoMatch.param.name,
+    pageNumberKeyword: pageNoMatch.keyword,
+    pageSizeParamName: pageSizeMatch.param.name,
+    pageSizeKeyword: pageSizeMatch.keyword
+  };
+}
+function isCursorPagination(operation) {
+  const queryParams = operation.parameters.filter((p) => p.in === "query");
+  if (queryParams.length < 2)
+    return null;
+  const cursorMatch = findParamAndKeyword(queryParams, CURSOR_REGEXES);
+  if (!cursorMatch)
+    return null;
+  const limitMatch = findParamAndKeyword(
+    queryParams,
+    CURSOR_LIMIT_REGEXES,
+    cursorMatch.param.name
+  );
+  if (!limitMatch)
+    return null;
+  return {
+    type: "cursor",
+    cursorParamName: cursorMatch.param.name,
+    cursorKeyword: cursorMatch.keyword,
+    limitParamName: limitMatch.param.name,
+    limitKeyword: limitMatch.keyword
+  };
+}
+function guessPagination(operation, body, response) {
+  const bodyParameters = body && body.properties ? Object.keys(body.properties).map((it) => ({ name: it })) : [];
+  const parameters = operation.parameters;
+  if (isEmpty3(operation.parameters) && isEmpty3(bodyParameters)) {
+    return { type: "none", reason: "no parameters" };
+  }
+  if (!response) {
+    return { type: "none", reason: "no response" };
+  }
+  if (!response.properties) {
+    return { type: "none", reason: "empty response" };
+  }
+  const properties = response.properties;
+  const itemsKey = getItemsName(properties);
+  if (!itemsKey) {
+    return { type: "none", reason: "no items key" };
+  }
+  const hasMoreKey = getHasMoreName(excludeKey(properties, itemsKey));
+  if (!hasMoreKey) {
+    return { type: "none", reason: "no hasMore key" };
+  }
+  const pagination = isOffsetPagination(operation, [...parameters, ...bodyParameters]) || isPagePagination(operation) || isCursorPagination(operation);
+  return pagination ? { ...pagination, items: itemsKey, hasMore: hasMoreKey } : { type: "none", reason: "no pagination" };
+}
+function excludeKey(obj, key) {
+  const { [key]: _, ...rest } = obj;
+  return rest;
+}
 // packages/spec/dist/lib/operation.js
-import { camelcase } from "stringcase";
-import { followRef, isRef } from "@sdk-it/core";
+function augmentSpec(config) {
+  config.spec.paths ??= {};
+  const paths = {};
+  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 operationId = formatOperationId(operation, fixedPath, method);
+      const operationTag = formatTag(operation, fixedPath);
+      const requestBody = isRef5(operation.requestBody) ? followRef3(config.spec, operation.requestBody.$ref) : operation.requestBody;
+      const tunedOperation = {
+        ...operation,
+        parameters: [...parameters, ...operation.parameters ?? []].map(
+          (it) => isRef5(it) ? followRef3(config.spec, it.$ref) : it
+        ),
+        tags: [operationTag],
+        operationId,
+        responses: resolveResponses(config.spec, operation),
+        requestBody
+      };
+      tunedOperation["x-pagination"] = toPagination(
+        config.spec,
+        tunedOperation
+      );
+      Object.assign(paths, {
+        [fixedPath]: {
+          ...paths[fixedPath],
+          [method]: tunedOperation
+        }
+      });
+    }
+  }
+  return { ...config.spec, paths };
+}
+function toPagination(spec, tunedOperation) {
+  if (tunedOperation["x-pagination"]) {
+    return tunedOperation["x-pagination"];
+  }
+  const schema = getResponseContentSchema(
+    spec,
+    tunedOperation.responses["200"],
+    "application/json"
+  );
+  const pagination = guessPagination(
+    tunedOperation,
+    tunedOperation.requestBody ? getRequestContentSchema(
+      spec,
+      tunedOperation.requestBody,
+      "application/json"
+    ) : void 0,
+    schema
+  );
+  if (pagination && pagination.type !== "none" && schema) {
+    return pagination;
+  }
+  return void 0;
+}
+function getResponseContentSchema(spec, response, type) {
+  if (!response) {
+    return void 0;
+  }
+  const content = response.content;
+  if (!content) {
+    return void 0;
+  }
+  for (const contentType in content) {
+    if (contentType.toLowerCase() === type.toLowerCase()) {
+      return isRef5(content[contentType].schema) ? followRef3(spec, content[contentType].schema.$ref) : content[contentType].schema;
+    }
+  }
+  return void 0;
+}
+function getRequestContentSchema(spec, requestBody, type) {
+  const content = requestBody.content;
+  if (!content) {
+    return void 0;
+  }
+  for (const contentType in content) {
+    if (contentType.toLowerCase() === type.toLowerCase()) {
+      return isRef5(content[contentType].schema) ? followRef3(spec, content[contentType].schema.$ref) : content[contentType].schema;
+    }
+  }
+  return void 0;
+}
 var defaults = {
   operationId: (operation, path, method) => {
     if (operation.operationId) {
-      return camelcase(operation.operationId);
+      return camelcase2(operation.operationId);
     }
     const metadata = operation["x-oaiMeta"];
     if (metadata && metadata.name) {
-      return camelcase(metadata.name);
+      return camelcase2(metadata.name);
     }
-    return camelcase(
+    return camelcase2(
       [method, ...path.replace(/[\\/\\{\\}]/g, " ").split(" ")].filter(Boolean).join(" ").trim()
     );
   },
@@ -162,37 +1321,28 @@ 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];
+    const response = isRef5(responses[status]) ? followRef3(spec, responses[status].$ref) : responses[status];
     resolved[status] = response;
   }
   return resolved;
 }
-function forEachOperation(config, callback) {
+function forEachOperation2(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"] ?? {};
+      const operationTag = operation.tags?.[0];
       result.push(
         callback(
           {
             name: metadata.name,
             method,
-            path: fixedPath,
+            path,
             groupName: operationTag,
             tag: operationTag
           },
-          {
-            ...operation,
-            parameters: [...parameters, ...operation.parameters ?? []],
-            operationId: operationName,
-            responses: resolveResponses(config.spec, operation)
-          }
+          operation
         )
       );
     }
@@ -264,7 +1414,7 @@ function sanitizeTag(camelCasedTag) {
   if (/^\d/.test(camelCasedTag)) {
     return `_${camelCasedTag}`;
   }
-  return reservedKeywords.has(camelcase(camelCasedTag)) ? `${camelCasedTag}_` : camelCasedTag;
+  return reservedKeywords.has(camelcase2(camelCasedTag)) ? `${camelCasedTag}_` : camelCasedTag;
 }
 function determineGenericTag(pathString, operation) {
   const operationId = operation.operationId || "";
@@ -296,7 +1446,7 @@ function determineGenericTag(pathString, operation) {
   for (let i = potentialCandidates.length - 1; i >= 0; i--) {
     const segment = potentialCandidates[i];
     if (!segment.startsWith("@")) {
-      return sanitizeTag(camelcase(segment));
+      return sanitizeTag(camelcase2(segment));
     }
   }
   const canFallbackToPathSegment = potentialCandidates.length > 0;
@@ -331,17 +1481,17 @@ function determineGenericTag(pathString, operation) {
         }
         if (nextPartStartIndex !== -1 && nextPartStartIndex < operationId.length) {
           const remainingOriginalSubstring = operationId.substring(nextPartStartIndex);
-          const potentialTag = camelcase(remainingOriginalSubstring);
+          const potentialTag = camelcase2(remainingOriginalSubstring);
           if (potentialTag) {
             return sanitizeTag(potentialTag);
           }
         }
-        const potentialTagJoined = camelcase(validParts.slice(1).join("_"));
+        const potentialTagJoined = camelcase2(validParts.slice(1).join("_"));
         if (potentialTagJoined) {
           return sanitizeTag(potentialTagJoined);
         }
       }
-      const potentialTagFull = camelcase(operationId);
+      const potentialTagFull = camelcase2(operationId);
       if (potentialTagFull) {
         const isResultSingleVerb = validParts.length === 1 && isFirstPartVerb;
         if (!(isResultSingleVerb && canFallbackToPathSegment)) {
@@ -350,39 +1500,227 @@ function determineGenericTag(pathString, operation) {
           }
         }
       }
-      const firstPartCamel = camelcase(firstPart);
+      const firstPartCamel = camelcase2(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);
-        }
+      if (isFirstPartVerb && validParts.length > 1 && validParts[1] && canFallbackToPathSegment) {
+        const secondPartCamel = camelcase2(validParts[1]);
+        if (secondPartCamel) {
+          return sanitizeTag(secondPartCamel);
+        }
+      }
+    }
+  }
+  if (potentialCandidates.length > 0) {
+    let firstCandidate = potentialCandidates[0];
+    if (firstCandidate.startsWith("@")) {
+      firstCandidate = firstCandidate.substring(1);
+    }
+    if (firstCandidate) {
+      return sanitizeTag(camelcase2(firstCandidate));
+    }
+  }
+  console.warn(
+    `Could not determine a suitable tag for path: ${pathString}, operationId: ${operationId}. Using 'unknown'.`
+  );
+  return "unknown";
+}
+function patchParameters(spec, objectSchema, operation) {
+  const securitySchemes = spec.components?.securitySchemes ?? {};
+  const securityOptions = securityToOptions(
+    spec,
+    operation.security ?? [],
+    securitySchemes
+  );
+  objectSchema.properties ??= {};
+  objectSchema.required ??= [];
+  for (const param of operation.parameters) {
+    if (param.required) {
+      objectSchema.required.push(param.name);
+    }
+    objectSchema.properties[param.name] = isRef5(param.schema) ? followRef3(spec, param.schema.$ref) : param.schema ?? { type: "string" };
+  }
+  for (const param of securityOptions) {
+    objectSchema.required = (objectSchema.required ?? []).filter(
+      (name) => name !== param.name
+    );
+    objectSchema.properties[param.name] = isRef5(param.schema) ? followRef3(spec, param.schema.$ref) : param.schema ?? { type: "string" };
+  }
+}
+function securityToOptions(spec, security2, securitySchemes, staticIn) {
+  securitySchemes ??= {};
+  const parameters = [];
+  for (const it of security2) {
+    const [name] = Object.keys(it);
+    if (!name) {
+      continue;
+    }
+    const schema = isRef5(securitySchemes[name]) ? followRef3(spec, securitySchemes[name].$ref) : securitySchemes[name];
+    if (schema.type === "http") {
+      parameters.push({
+        in: staticIn ?? "header",
+        name: "authorization",
+        schema: { type: "string" }
+      });
+      continue;
+    }
+    if (schema.type === "apiKey") {
+      if (!schema.in) {
+        throw new Error(`apiKey security schema must have an "in" field`);
+      }
+      if (!schema.name) {
+        throw new Error(`apiKey security schema must have a "name" field`);
       }
+      parameters.push({
+        in: staticIn ?? schema.in,
+        name: schema.name,
+        schema: { type: "string" }
+      });
+      continue;
     }
   }
-  if (potentialCandidates.length > 0) {
-    let firstCandidate = potentialCandidates[0];
-    if (firstCandidate.startsWith("@")) {
-      firstCandidate = firstCandidate.substring(1);
+  return parameters;
+}
+// packages/typescript/src/lib/client.ts
+import { toLitObject } from "@sdk-it/core";
+var client_default = (spec, style) => {
+  const optionsEntries = Object.entries(spec.options).map(
+    ([key, value]) => [`'${key}'`, value]
+  );
+  const defaultHeaders = `{${optionsEntries.filter(([, value]) => value.in === "header").map(
+    ([key, value]) => `${key}: this.options[${value.optionName ? `'${value.optionName}'` : key}]`
+  ).join(",\n")}}`;
+  const defaultInputs = `{${optionsEntries.filter(([, value]) => value.in === "input").map(
+    ([key, value]) => `${key}: this.options[${value.optionName ? `'${value.optionName}'` : key}]`
+  ).join(",\n")}}`;
+  const specOptions = {
+    ...Object.fromEntries(
+      optionsEntries.map(([key, value]) => [value.optionName ?? key, value])
+    ),
+    fetch: {
+      schema: "fetchType"
+    },
+    baseUrl: {
+      schema: spec.servers.length ? `z.enum(servers).default(servers[0])` : "z.string()"
     }
-    if (firstCandidate) {
-      return sanitizeTag(camelcase(firstCandidate));
+  };
+  return `import z from 'zod';
+import type { HeadersInit, RequestConfig } from './http/${spec.makeImport("request")}';
+import { fetchType, parse } from './http/${spec.makeImport("dispatcher")}';
+import schemas from './api/${spec.makeImport("schemas")}';
+import {
+  createBaseUrlInterceptor,
+  createHeadersInterceptor,
+} from './http/${spec.makeImport("interceptors")}';
+import { parseInput, type ParseError } from './http/${spec.makeImport("parser")}';
+${spec.servers.length ? `export const servers = ${JSON.stringify(spec.servers, null, 2)} as const` : ""}
+const optionsSchema = z.object(${toLitObject(specOptions, (x) => x.schema)});
+${spec.servers.length ? `export type Servers = typeof servers[number];` : ""}
+type ${spec.name}Options = z.infer<typeof optionsSchema>;
+export class ${spec.name} {
+  public options: ${spec.name}Options
+  constructor(options: ${spec.name}Options) {
+    this.options = optionsSchema.parse(options);
+  }
+  async request<const E extends keyof typeof schemas>(
+    endpoint: E,
+    input: z.infer<(typeof schemas)[E]['schema']>,
+    options?: { signal?: AbortSignal, headers?: HeadersInit },
+  ) ${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 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 ?? {}),
+        createBaseUrlInterceptor(() => this.options.baseUrl),
+      ],
+      signal: options?.signal,
+    });
+    return result as Awaited<ReturnType<(typeof schemas)[E]['dispatch']>>;
   }
-  console.warn(
-    `Could not determine a suitable tag for path: ${pathString}, operationId: ${operationId}. Using 'unknown'.`
-  );
-  return "unknown";
-}
+  async prepare<const E extends keyof typeof schemas>(
+    endpoint: E,
+    input: z.infer<(typeof schemas)[E]['schema']>,
+    options?: { headers?: HeadersInit },
+  ): ${style.errorAsValue ? `Promise<
+    readonly [
+      RequestConfig & {
+        parse: (response: Response) => ReturnType<typeof parse>;
+      },
+      ParseError<(typeof schemas)[E]['schema']> | null,
+    ]
+  >` : `Promise<RequestConfig & {
+        parse: (response: Response) => ReturnType<typeof parse>;
+      }>`} {
+    const route = schemas[endpoint];
+    const interceptors = [
+      createHeadersInterceptor(
+        () => this.defaultHeaders,
+        options?.headers ?? {},
+      ),
+      createBaseUrlInterceptor(() => this.options.baseUrl),
+    ];
+    const [parsedInput, parseError] = parseInput(route.schema, input);
+    if (parseError) {
+      ${style.errorAsValue ? "return [null as never, parseError as never] as const;" : "throw parseError;"}
+    }
+    let config = route.toRequest(parsedInput as never);
+    for (const interceptor of interceptors) {
+      if (interceptor.before) {
+        config = await interceptor.before(config);
+      }
+    }
+    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() {
+    return ${defaultHeaders}
+  }
+  get #defaultInputs() {
+    return ${defaultInputs}
+  }
+  setOptions(options: Partial<${spec.name}Options>) {
+    const validated = optionsSchema.partial().parse(options);
+    for (const key of Object.keys(validated) as (keyof ${spec.name}Options)[]) {
+      if (validated[key] !== undefined) {
+        (this.options[key] as typeof validated[typeof key]) = validated[key]!;
+      }
+    }
+  }
+}`;
+};
+// packages/typescript/src/lib/generator.ts
+import { merge, template } from "lodash-es";
+import { join } from "node:path";
+import { camelcase as camelcase4, pascalcase as pascalcase2, spinalcase as spinalcase2 } from "stringcase";
+import { followRef as followRef7, isEmpty as isEmpty4, isRef as isRef10 } from "@sdk-it/core";
 // packages/typescript/src/lib/emitters/zod.ts
-import { cleanRef, followRef as followRef2, isRef as isRef2 } from "@sdk-it/core";
-var ZodDeserialzer = class {
+import { cleanRef, followRef as followRef4, isRef as isRef6 } from "@sdk-it/core";
+var ZodEmitter = class {
   generatedRefs = /* @__PURE__ */ new Set();
   #spec;
   #onRef;
@@ -463,7 +1801,7 @@ var ZodDeserialzer = class {
     this.generatedRefs.add(schemaName);
     this.#onRef?.(
       schemaName,
-      this.handle(followRef2(this.#spec, $ref), required)
+      this.handle(followRef4(this.#spec, $ref), required)
     );
     return schemaName;
   }
@@ -593,7 +1931,7 @@ var ZodDeserialzer = class {
     return { base, defaultValue };
   }
   handle(schema, required) {
-    if (isRef2(schema)) {
+    if (isRef6(schema)) {
       return `${this.ref(schema.$ref, true)}${appendOptional(required)}`;
     }
     if (schema.allOf && Array.isArray(schema.allOf)) {
@@ -639,12 +1977,12 @@ function appendDefault(defaultValue) {
 // packages/typescript/src/lib/sdk.ts
 import { get } from "lodash-es";
-import { camelcase as camelcase2, pascalcase, spinalcase } from "stringcase";
-import { followRef as followRef4, isRef as isRef5, toLitObject as toLitObject2 } from "@sdk-it/core";
+import { camelcase as camelcase3, pascalcase, spinalcase } from "stringcase";
+import { isRef as isRef9, 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 {
+import { cleanRef as cleanRef2, followRef as followRef5, isRef as isRef7 } from "@sdk-it/core";
+var TypeScriptEmitter = class {
   generatedRefs = /* @__PURE__ */ new Set();
   #spec;
   #onRef;
@@ -656,7 +1994,7 @@ var TypeScriptDeserialzer = class {
     return `'${value}'`;
   };
   #isInternal = (schema) => {
-    return isRef3(schema) ? false : !!schema["x-internal"];
+    return isRef7(schema) ? false : !!schema["x-internal"];
   };
   /**
    * Handle objects (properties)
@@ -676,7 +2014,7 @@ var TypeScriptDeserialzer = class {
         propEntries.push("[key: string]: any");
       }
     }
-    return `{ ${propEntries.join("; ")} }`;
+    return `${propEntries.length ? `{ ${propEntries.join("; ")} }` : "unknown"}`;
   }
   /**
    * Handle arrays (items could be a single schema or a tuple)
@@ -724,7 +2062,7 @@ var TypeScriptDeserialzer = class {
     this.generatedRefs.add(schemaName);
     this.#onRef?.(
       schemaName,
-      this.handle(followRef3(this.#spec, $ref), required)
+      this.handle(followRef5(this.#spec, $ref), required)
     );
     return appendOptional2(schemaName, required);
   }
@@ -786,7 +2124,7 @@ var TypeScriptDeserialzer = class {
     return appendOptional2(type, required);
   }
   handle(schema, required) {
-    if (isRef3(schema)) {
+    if (isRef7(schema)) {
       return this.ref(schema.$ref, required);
     }
     if (schema.allOf && Array.isArray(schema.allOf)) {
@@ -831,8 +2169,8 @@ function appendOptional2(type, isRequired) {
 }
 // packages/typescript/src/lib/utils.ts
-import { isRef as isRef4, removeDuplicates } from "@sdk-it/core";
-function securityToOptions(security2, securitySchemes, staticIn) {
+import { followRef as followRef6, isRef as isRef8, removeDuplicates } from "@sdk-it/core";
+function securityToOptions2(spec, security2, securitySchemes, staticIn) {
   securitySchemes ??= {};
   const options = {};
   for (const it of security2) {
@@ -840,10 +2178,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 = isRef8(securitySchemes[name]) ? followRef6(spec, securitySchemes[name].$ref) : securitySchemes[name];
     if (schema.type === "http") {
       options["authorization"] = {
         in: staticIn ?? "header",
@@ -929,7 +2264,7 @@ function generateInputs(operationsSet, commonZod, makeImport) {
     const output = [];
     const imports = /* @__PURE__ */ new Set(['import { z } from "zod";']);
     for (const operation of operations) {
-      const schemaName = camelcase2(`${operation.name} schema`);
+      const schemaName = camelcase3(`${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) {
@@ -966,8 +2301,8 @@ function generateInputs(operationsSet, commonZod, makeImport) {
   };
 }
 function toEndpoint(groupName, spec, specOperation, operation, utils) {
-  const schemaName = camelcase2(`${operation.name} schema`);
-  const schemaRef = `${camelcase2(groupName)}.${schemaName}`;
+  const schemaName = camelcase3(`${operation.name} schema`);
+  const schemaRef = `${camelcase3(groupName)}.${schemaName}`;
   const inputHeaders = [];
   const inputQuery = [];
   const inputBody = [];
@@ -999,13 +2334,25 @@ function toEndpoint(groupName, spec, specOperation, operation, utils) {
     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 responseWithAtLeast200 = statusesCount ? specOperation.responses : Object.assign(
+    {
+      "200": {
+        description: "OK",
+        content: {
+          "application/json": {
+            schema: { type: "object" }
+          }
+        }
+      }
+    },
+    specOperation.responses
+  );
+  for (const status in responseWithAtLeast200) {
     const handled = handleResponse(
       spec,
       operation.name,
       status,
-      response,
+      responseWithAtLeast200[status],
       utils,
       true
       // statusesCount,
@@ -1025,19 +2372,104 @@ function toEndpoint(groupName, spec, specOperation, operation, utils) {
           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 };
 }
+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"}`}`;
+  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 ${style?.outputType === "status" ? "new http.Ok(pagination);" : "pagination"}
+      `;
+    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 ${style?.outputType === "status" ? "new http.Ok(pagination);" : "pagination"}
+      `;
+    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 ${style?.outputType === "status" ? "new http.Ok(pagination);" : "pagination"}
+      `;
+    return style?.errorAsValue ? `{try {${logic}} catch (error) {return [null as never, error] as const;}}}` : `{${logic}}}`;
+  }
+  return normalOperation(style);
+}
 var statusCodeToResponseMap = {
   "200": "Ok",
   "201": "Created",
@@ -1075,7 +2507,7 @@ function handleResponse(spec, operationName, status, response, utils, numbered)
   };
   const responses = [];
   const outputs = [];
-  const typeScriptDeserialzer = new TypeScriptDeserialzer(
+  const typeScriptDeserialzer = new TypeScriptEmitter(
     spec,
     (schemaName, zod) => {
       schemas[schemaName] = zod;
@@ -1110,7 +2542,7 @@ function handleResponse(spec, operationName, status, response, utils, numbered)
   let responseSchema = parser === "chunked" ? "ReadableStream" : "void";
   if (isJson) {
     const schema = responseContent["application/json"].schema;
-    const isObject = !isRef5(schema) && schema.type === "object";
+    const isObject = !isRef9(schema) && schema.type === "object";
     if (isObject && schema.properties) {
       schema.properties["[http.KIND]"] = {
         "x-internal": true,
@@ -1151,13 +2583,13 @@ function handleResponse(spec, operationName, status, response, utils, numbered)
 }
 // 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,
@@ -1170,18 +2602,17 @@ function generateCode(config) {
   const groups = {};
   const outputs = {};
   const endpoints = {};
-  forEachOperation(config, (entry, operation) => {
+  forEachOperation2(config, (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 +2620,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 = securityToOptions2(
+      config.spec,
+      operation.security ?? [],
+      securitySchemes
+    );
     Object.assign(inputs, securityOptions);
     Object.entries(securityOptions).forEach(([name, value]) => {
       additionalProperties[name] = {
@@ -1216,10 +2650,12 @@ function generateCode(config) {
       "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 (!isEmpty4(operation.requestBody)) {
+      for (const type in operation.requestBody.content) {
+        const ctSchema = isRef10(operation.requestBody.content[type].schema) ? followRef7(
+          config.spec,
+          operation.requestBody.content[type].schema.$ref
+        ) : operation.requestBody.content[type].schema;
         if (!ctSchema) {
           console.warn(
             `Schema not found for ${type} in ${entry.method} ${entry.path}`
@@ -1230,7 +2666,7 @@ function generateCode(config) {
         if (objectSchema.type !== "object") {
           objectSchema = {
             type: "object",
-            required: [requestBody.required ? "$body" : ""],
+            required: [operation.requestBody.required ? "$body" : ""],
             properties: {
               $body: ctSchema
             }
@@ -1249,11 +2685,11 @@ function generateCode(config) {
         Object.assign(inputs, bodyInputs(config, objectSchema));
         schemas[shortContenTypeMap[type]] = zodDeserialzer.handle(schema, true);
       }
-      if (requestBody.content["application/json"]) {
+      if (operation.requestBody.content["application/json"]) {
         outgoingContentType = "json";
-      } else if (requestBody.content["application/x-www-form-urlencoded"]) {
+      } else if (operation.requestBody.content["application/x-www-form-urlencoded"]) {
         outgoingContentType = "urlencoded";
-      } else if (requestBody.content["multipart/form-data"]) {
+      } else if (operation.requestBody.content["multipart/form-data"]) {
         outgoingContentType = "formdata";
       } else {
         outgoingContentType = "json";
@@ -1287,11 +2723,11 @@ function generateCode(config) {
         schemas,
         inputs
       },
-      { makeImport: config.makeImport }
+      { makeImport: config.makeImport, style: config.style }
     );
     const output = [
       `import z from 'zod';`,
-      `import type * as http from '../http';`
+      `import type * as http from '${config.makeImport("../http/index")}';`
     ];
     const responses = endpoint.responses.flatMap((it) => it.responses);
     const responsesImports = endpoint.responses.flatMap(
@@ -1341,14 +2777,13 @@ function generateCode(config) {
     {}
   );
   const allSchemas = Object.keys(endpoints).map((it) => ({
-    import: `import ${camelcase3(it)} from './${config.makeImport(spinalcase2(it))}';`,
-    use: `  ...${camelcase3(it)}`
+    import: `import ${camelcase4(it)} from './${config.makeImport(spinalcase2(it))}';`,
+    use: `  ...${camelcase4(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';`
+    `import type { ServerError } from '${config.makeImport("../http/response")}';`
   ];
   return {
     groups,
@@ -1364,12 +2799,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")}";
@@ -1396,9 +2828,12 @@ ${allSchemas.map((it) => it.use).join(",\n")}
                 ...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 { 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 ${camelcase4(name)} from '../inputs/${config.makeImport(spinalcase2(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 +2848,8 @@ ${endpoint.flatMap((it) => it.schemas).join(",\n")}
   };
 }
 function toProps(spec, schemaOrRef, aggregator = []) {
-  if (isRef6(schemaOrRef)) {
-    const schema = followRef5(spec, schemaOrRef.$ref);
+  if (isRef10(schemaOrRef)) {
+    const schema = followRef7(spec, schemaOrRef.$ref);
     return toProps(spec, schema, aggregator);
   } else if (schemaOrRef.type === "object") {
     for (const [name] of Object.entries(schemaOrRef.properties ?? {})) {
@@ -1458,6 +2893,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 +2906,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');
@@ -1881,321 +3319,323 @@ export type SuccessfulResponse =
   | 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 camelcase5, spinalcase as spinalcase3 } from "stringcase";
+import { followRef as followRef9, isEmpty as isEmpty5, isRef as isRef12, pascalcase as pascalcase3 } from "@sdk-it/core";
+// packages/typescript/src/lib/emitters/snippet.ts
+import { followRef as followRef8, isRef as isRef11 } 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 = isRef11(schema) ? followRef8(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 = isRef11(propSchema) ? followRef8(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;
+    return result;
   }
-  /**
-   * 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;
+  array(schema) {
+    const schemaObj = isRef11(schema) ? followRef8(this.spec, schema.$ref) : schema;
+    const itemsSchema = schemaObj.items;
+    if (!itemsSchema) {
+      return [];
+    }
+    const count = Math.min(schemaObj.minItems ?? 1, 2);
+    const result = [];
+    for (let i = 0; i < count; i++) {
+      result.push(this.handle(itemsSchema));
+    }
+    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}`));
+  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 "[binary data]";
+      default:
+        if (schema.enum && schema.enum.length > 0) {
+          return String(schema.enum[0]);
+        }
+        return schema.pattern ? `string matching ${schema.pattern}` : "example";
+    }
+  }
+  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 {
-      lines.push(`  **Type:** \`unknown\``);
+      value = schema.type === "integer" ? 42 : 42.42;
     }
-    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;
+    if (typeof schema.exclusiveMaximum === "number" && value >= schema.exclusiveMaximum) {
+      value = schema.exclusiveMaximum - 1;
+    } else if (typeof schema.maximum === "number" && value > schema.maximum) {
+      value = schema.maximum;
+    }
+    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;
   }
-  #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);
+  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);
     }
-    return lines;
+    this.cache.set($ref, { _ref: refKey });
+    const resolved = followRef8(this.spec, $ref);
+    const result = this.handle(resolved);
+    this.cache.set($ref, result);
+    return result;
   }
-  #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;
+  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) {
-    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;
+  anyOf(schemas) {
+    if (schemas.length === 0)
+      return {};
+    return this.handle(schemas[0]);
   }
-  #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;
+  oneOf(schemas) {
+    if (schemas.length === 0)
+      return {};
+    return this.handle(schemas[0]);
   }
-  #enum(schema) {
-    const lines = [`**Type:** \`${schema.type || "unknown"}\` (enum)`];
-    if (schema.description)
-      lines.push(schema.description);
-    lines.push("**Allowed values:**");
-    lines.push(
-      ...(schema.enum || []).map((val) => `- \`${JSON.stringify(val)}\``)
-    );
-    if (schema.default !== void 0) {
-      lines.push(`**Default:** \`${JSON.stringify(schema.default)}\``);
-    }
-    return lines;
+  enum(schema) {
+    return Array.isArray(schema.enum) && schema.enum.length > 0 ? schema.enum[0] : void 0;
   }
-  #normal(type, schema, nullable) {
-    const lines = [];
-    const nullableSuffix = nullable ? " (nullable)" : "";
-    const description = schema.description ? [schema.description] : [];
-    switch (type) {
-      case "string":
-        lines.push(
-          `**Type:** \`string\`${schema.format ? ` (format: ${schema.format})` : ""}${nullableSuffix}`
-        );
-        lines.push(...description);
-        if (schema.minLength !== void 0)
-          lines.push(`- Minimum length: ${schema.minLength}`);
-        if (schema.maxLength !== void 0)
-          lines.push(`- Maximum length: ${schema.maxLength}`);
-        if (schema.pattern !== void 0)
-          lines.push(`- Pattern: \`${schema.pattern}\``);
-        break;
-      case "number":
-      case "integer":
-        lines.push(
-          `**Type:** \`${type}\`${schema.format ? ` (format: ${schema.format})` : ""}${nullableSuffix}`
-        );
-        lines.push(...description);
-        if (schema.minimum !== void 0) {
-          const exclusiveMin = typeof schema.exclusiveMinimum === "number";
-          lines.push(
-            `- Minimum: ${schema.minimum}${exclusiveMin ? " (exclusive)" : ""}`
-          );
-          if (exclusiveMin) {
-            lines.push(
-              `- Must be strictly greater than: ${schema.exclusiveMinimum}`
-            );
-          }
-        } else if (typeof schema.exclusiveMinimum === "number") {
-          lines.push(
-            `- Must be strictly greater than: ${schema.exclusiveMinimum}`
-          );
-        }
-        if (schema.maximum !== void 0) {
-          const exclusiveMax = typeof schema.exclusiveMaximum === "number";
-          lines.push(
-            `- Maximum: ${schema.maximum}${exclusiveMax ? " (exclusive)" : ""}`
-          );
-          if (exclusiveMax) {
-            lines.push(
-              `- Must be strictly less than: ${schema.exclusiveMaximum}`
-            );
-          }
-        } else if (typeof schema.exclusiveMaximum === "number") {
-          lines.push(
-            `- Must be strictly less than: ${schema.exclusiveMaximum}`
-          );
-        }
-        if (schema.multipleOf !== void 0)
-          lines.push(`- Must be a multiple of: ${schema.multipleOf}`);
-        break;
-      case "boolean":
-        lines.push(`**Type:** \`boolean\`${nullableSuffix}`);
-        lines.push(...description);
-        break;
-      case "object":
-        lines.push(`**Type:** \`object\`${nullableSuffix}`);
-        lines.push(...description);
-        lines.push(...this.#object(schema));
-        break;
-      case "array":
-        lines.push(`**Type:** \`array\`${nullableSuffix}`);
-        lines.push(...description);
-        lines.push(...this.#array(schema));
-        break;
-      case "null":
-        lines.push(`**Type:** \`null\``);
-        lines.push(...description);
-        break;
-      default:
-        lines.push(`**Type:** \`${type}\`${nullableSuffix}`);
-        lines.push(...description);
+  handle(schemaOrRef) {
+    if (isRef11(schemaOrRef)) {
+      return this.ref(schemaOrRef.$ref);
     }
-    if (schema.default !== void 0) {
-      lines.push(`**Default:** \`${JSON.stringify(schema.default)}\``);
+    const schema = isRef11(schemaOrRef) ? followRef8(this.spec, schemaOrRef.$ref) : schemaOrRef;
+    if (schema.example !== void 0) {
+      return schema.example;
     }
-    return lines.filter((l) => l);
-  }
-  /**
-   * Handle schemas by resolving references and delegating to appropriate handler
-   */
-  handle(schemaOrRef) {
-    if (isRef7(schemaOrRef)) {
-      return this.#ref(schemaOrRef.$ref);
+    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);
+      return this.oneOf(schema.oneOf);
     }
-    if (schema.enum && Array.isArray(schema.enum)) {
-      return this.#enum(schema);
-    }
-    let types = Array.isArray(schema.type) ? schema.type : schema.type ? [schema.type] : [];
-    let nullable = false;
-    if (types.includes("null")) {
-      nullable = true;
-      types = types.filter((t) => t !== "null");
+    if (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";
     }
-    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 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";
     }
-    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() ? pascalcase3(settings.name) : "Client";
+    this.#packageName = settings.name ? `@${spinalcase3(this.#clientName.toLowerCase())}/sdk` : "sdk";
+  }
+  succinct(entry, operation, values) {
+    let payload = "{}";
+    if (!isEmpty5(operation.requestBody)) {
+      const contentTypes = Object.keys(operation.requestBody.content || {});
+      if (contentTypes.length > 0) {
+        const firstContent = operation.requestBody.content[contentTypes[0]];
+        let schema = isRef12(firstContent.schema) ? followRef9(this.#spec, firstContent.schema.$ref) : firstContent.schema;
+        if (schema) {
+          if (schema.type !== "object") {
+            schema = {
+              type: "object",
+              required: [operation.requestBody.required ? "$body" : ""],
+              properties: {
+                $body: schema
+              }
+            };
+          }
+          const properties = {};
+          patchParameters(
+            this.#spec,
+            { type: "object", properties },
+            operation
+          );
+          const examplePayload = this.#snippetEmitter.handle({
+            ...schema,
+            properties: Object.assign({}, properties, schema.properties)
+          });
+          Object.assign(
+            examplePayload,
+            values.requestBody ?? {},
+            values.pathParameters ?? {},
+            values.queryParameters ?? {},
+            values.headers ?? {},
+            values.cookies ?? {}
+          );
+          payload = JSON.stringify(examplePayload, null, 2);
         }
       }
+    } else {
+      const properties = {};
+      patchParameters(this.#spec, { type: "object", properties }, operation);
+      const examplePayload = this.#snippetEmitter.handle({
+        properties
+      });
+      Object.assign(
+        examplePayload,
+        values.pathParameters ?? {},
+        values.queryParameters ?? {},
+        values.headers ?? {},
+        values.cookies ?? {}
+      );
+      payload = JSON.stringify(examplePayload, null, 2);
     }
-    return lines;
+    return `const result = await ${camelcase5(this.#clientName)}.request('${entry.method.toUpperCase()} ${entry.path}', ${payload});`;
+  }
+  snippet(entry, operation) {
+    const payload = this.succinct(entry, operation, {});
+    return [
+      "```typescript",
+      `${this.client()}
+${payload}
+console.log(result.data);
+`,
+      "```"
+    ].join("\n");
+  }
+  client() {
+    return `import { ${this.#clientName} } from '${this.#packageName}';
+const ${camelcase5(this.#clientName)} = new ${this.#clientName}({
+  baseUrl: '${this.#spec.servers?.[0]?.url ?? "http://localhost:3000"}',
+});`;
   }
 };
-function toReadme(spec) {
-  const markdown = [];
-  const propEmitter = new PropEmitter(spec);
-  forEachOperation({ spec }, ({ method, path, name }, operation) => {
-    spec.components ??= {};
-    spec.components.schemas ??= {};
-    const statuses = [];
-    markdown.push(
-      `#### ${name || operation.operationId} | ${`_${method.toUpperCase()} ${path}_`}`
-    );
-    markdown.push(operation.summary || "");
-    const requestBodyContent = propEmitter.requestBody(operation.requestBody);
-    if (requestBodyContent.length > 1) {
-      markdown.push(requestBodyContent.join("\n\n"));
-    }
-    markdown.push(`##### Responses`);
-    for (const status in operation.responses) {
-      const response = operation.responses[status];
-      const resolvedResponse = isRef7(response) ? followRef6(spec, response.$ref) : response;
-      statuses.push(`**${status}**	_${resolvedResponse.description}_`);
-    }
-    markdown.push(`<small>${statuses.join("\n\n")}</small>`);
-  });
-  return markdown.join("\n\n");
-}
 // packages/typescript/src/lib/generate.ts
+var ALWAYS_AVAILABLE_FILES = [
+  /readme\.md$/i,
+  // match readme.md, case-insensitive
+  /^tsconfig.*\.json$/,
+  // match any tsconfig*.json
+  /package\.json$/,
+  // exact package.json
+  /metadata\.json$/
+  // exact metadata.json
+];
 function security(spec) {
   const security2 = spec.security || [];
   const components = spec.components || {};
   const securitySchemes = components.securitySchemes || {};
   const paths = Object.values(spec.paths ?? {});
-  const options = securityToOptions(security2, securitySchemes);
+  const options = securityToOptions2(spec, security2, securitySchemes);
   for (const it of paths) {
     for (const method of methods) {
       const operation = it[method];
@@ -2204,13 +3644,20 @@ function security(spec) {
       }
       Object.assign(
         options,
-        securityToOptions(operation.security || [], securitySchemes, "input")
+        securityToOptions2(
+          spec,
+          operation.security || [],
+          securitySchemes,
+          "input"
+        )
       );
     }
   }
   return options;
 }
 async function generate(spec, settings) {
+  spec = "x-sdk-augmented" in spec ? spec : augmentSpec({ spec });
+  const generator = new TypeScriptGenerator(spec, settings);
   const style = Object.assign(
     {},
     {
@@ -2220,7 +3667,29 @@ async function generate(spec, settings) {
     },
     settings.style ?? {}
   );
+  const output = settings.mode === "full" ? join2(settings.output, "src") : settings.output;
   settings.useTsExtension ??= true;
+  const writtenFiles = /* @__PURE__ */ new Set();
+  settings.writer ??= writeFiles;
+  const originalWriter = settings.writer;
+  settings.writer = async (dir, contents) => {
+    await originalWriter(dir, contents);
+    for (const file of Object.keys(contents)) {
+      if (contents[file] !== null) {
+        writtenFiles.add(
+          addLeadingSlash(`${relative(settings.output, dir)}/${file}`)
+        );
+      }
+    }
+  };
+  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;
   };
@@ -2231,37 +3700,34 @@ async function generate(spec, settings) {
       makeImport
     }
   );
-  const output = settings.mode === "full" ? join2(settings.output, "src") : settings.output;
   const options = security(spec);
-  const clientName = settings.name?.trim() ? pascalcase3(settings.name) : "Client";
-  const readme = settings.readme ? toReadme(spec) : "";
+  const clientName = pascalcase4((settings.name || "client").trim());
+  const packageName = settings.name ? `@${spinalcase4(settings.name.trim().toLowerCase())}/sdk` : "sdk";
   const inputFiles = generateInputs(groups, commonZod, makeImport);
-  console.log("Writing to", output);
-  await writeFiles(output, {
+  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);
+  await settings.writer(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,
@@ -2286,37 +3752,90 @@ ${template2(send_request_default, {})({ throwError: !style.errorAsValue, outputT
       ])
     )
   });
+  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 readJson(join2(settings.output, "metadata.json"));
+  metadata.content.generatedFiles = Array.from(writtenFiles);
+  metadata.content.userFiles ??= [];
+  await metadata.write(metadata.content);
+  if (settings.cleanup !== false && metadata.content.generatedFiles) {
+    const generated = metadata.content.generatedFiles;
+    const user = metadata.content.userFiles;
+    const keep = /* @__PURE__ */ new Set([...generated, ...user]);
+    const actualFiles = await readFolder(settings.output, true);
+    const toRemove = actualFiles.filter((f) => !keep.has(addLeadingSlash(f))).filter(
+      (f) => !ALWAYS_AVAILABLE_FILES.some((pattern) => pattern.test(f))
+    );
+    for (const file of toRemove) {
+      if (file.endsWith(`${sep}index.ts`)) {
+        continue;
+      }
+      const filePath = join2(settings.output, file);
+      await unlink(filePath);
+    }
+  }
   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)
     )
   ];
   if (modelsImports.length) {
     folders.push(
-      getFolderExports(join2(output, "models"), settings.useTsExtension)
+      getFolderExports(
+        join2(output, "models"),
+        settings.readFolder,
+        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 } : {}
   });
-  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 +3843,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 +3892,31 @@ ${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));
+async function readJson(path) {
+  const content = await exist(path) ? JSON.parse(await readFile(path, "utf-8")) : { content: {} };
+  return {
+    content,
+    write: (value = content) => writeFile(path, JSON.stringify(value, null, 2), "utf-8")
+  };
 }
 export {
+  TypeScriptGenerator,
   generate,
-  watch
+  readJson
 };
 //# sourceMappingURL=index.js.map