@sdk-it/typescript 0.19.1 → 0.21.0

package/dist/index.js

@@ -1,183 +1,1348 @@
+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 { getFolderExports, methods, writeFiles } from "@sdk-it/core";
-
-// 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()"
-    }
-  };
-  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 { spinalcase as spinalcase4 } from "stringcase";
+import { methods, pascalcase as pascalcase4 } from "@sdk-it/core";
 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);
+  addLeadingSlash,
+  exist,
+  getFolderExports,
+  readFolder,
+  writeFiles
+} from "@sdk-it/core/file-system.js";
+
+// 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
+        )
+      );
+    }
   }
-
-  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']`};
+  return result;
+}
+var PropEmitter = class {
+  #spec;
+  constructor(spec) {
+    this.#spec = spec;
   }
-
-  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),
+  /**
+   * 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()})`
     ];
-    const [parsedInput, parseError] = parseInput(route.schema, input);
-    if (parseError) {
-      ${style.errorAsValue ? "return [null as never, parseError as never] as const;" : "throw parseError;"}
+    if (resolved.description) {
+      lines.push(resolved.description);
     }
-
-    let config = route.toRequest(parsedInput as never);
-    for (const interceptor of interceptors) {
-      if (interceptor.before) {
-        config = await interceptor.before(config);
+    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"];
       }
     }
-    const prepared = { ...config, parse: (response: Response) => parse(route, response) };
-    return ${style.errorAsValue ? "[prepared, null as never] as const;" : "prepared"}
+    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;
   }
-
-  get defaultHeaders() {
-    return ${defaultHeaders}
+  /**
+   * 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);
+    }
+    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");
+}
 
-  get #defaultInputs() {
-    return ${defaultInputs}
+// 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);
+      }
+    }
   }
-
-  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]!;
+  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;
+    }
+  };
+  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);
       }
     }
   }
-}`;
-};
+  if (booleanPropertyNames.length === 0) {
+    return null;
+  }
+  if (booleanPropertyNames.length === 1) {
+    return booleanPropertyNames[0];
+  }
+  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 followRef4, isEmpty, isRef as isRef5 } 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";
+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()
     );
   },
   tag: (operation, path) => {
-    return operation.tags?.[0] || determineGenericTag(path, operation);
+    return operation.tags?.[0] ? sanitizeTag(operation.tags?.[0]) : determineGenericTag(path, operation);
   }
 };
-function forEachOperation(config, callback) {
+function resolveResponses(spec, operation) {
+  const responses = operation.responses ?? {};
+  const resolved = {};
+  for (const status in responses) {
+    const response = isRef5(responses[status]) ? followRef3(spec, responses[status].$ref) : responses[status];
+    resolved[status] = response;
+  }
+  return resolved;
+}
+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
-          }
+          operation
         )
       );
     }
@@ -185,15 +1350,11 @@ function forEachOperation(config, callback) {
   return result;
 }
 var reservedKeywords = /* @__PURE__ */ new Set([
-  "abstract",
-  "arguments",
   "await",
-  "boolean",
+  // Reserved in async functions
   "break",
-  "byte",
   "case",
   "catch",
-  "char",
   "class",
   "const",
   "continue",
@@ -201,85 +1362,59 @@ var reservedKeywords = /* @__PURE__ */ new Set([
   "default",
   "delete",
   "do",
-  "double",
   "else",
   "enum",
-  "eval",
   "export",
   "extends",
   "false",
-  "final",
   "finally",
-  "float",
   "for",
   "function",
-  "goto",
   "if",
   "implements",
+  // Strict mode
   "import",
   "in",
   "instanceof",
-  "int",
   "interface",
+  // Strict mode
   "let",
-  "long",
-  "native",
+  // Strict mode
   "new",
   "null",
   "package",
+  // Strict mode
   "private",
+  // Strict mode
   "protected",
+  // Strict mode
   "public",
+  // Strict mode
   "return",
-  "short",
   "static",
+  // Strict mode
   "super",
   "switch",
-  "synchronized",
   "this",
   "throw",
-  "throws",
-  "transient",
   "true",
   "try",
   "typeof",
   "var",
   "void",
-  "volatile",
   "while",
   "with",
   "yield",
-  // Potentially problematic identifiers / Common Verbs used as tags
-  "object",
-  "string",
-  "number",
-  "any",
-  "unknown",
-  "never",
-  "get",
-  "list",
-  "create",
-  "update",
-  "delete",
-  "post",
-  "put",
-  "patch",
-  "do",
-  "send",
-  "add",
-  "remove",
-  "set",
-  "find",
-  "search",
-  "check",
-  "make"
-  // Added make, check
+  // Strict mode / Generator functions
+  // 'arguments' is not technically a reserved word, but it's a special identifier within functions
+  // and assigning to it or declaring it can cause issues or unexpected behavior.
+  "arguments"
 ]);
 function sanitizeTag(camelCasedTag) {
   if (/^\d/.test(camelCasedTag)) {
     return `_${camelCasedTag}`;
   }
-  return reservedKeywords.has(camelCasedTag) ? `${camelCasedTag}_` : camelCasedTag;
+  return reservedKeywords.has(camelcase2(camelCasedTag)) ? `${camelCasedTag}_` : camelCasedTag;
 }
 function determineGenericTag(pathString, operation) {
   const operationId = operation.operationId || "";
@@ -303,7 +1438,6 @@ function determineGenericTag(pathString, operation) {
     "search",
     "check",
     "make"
-    // Added make
   ]);
   const segments = pathString.split("/").filter(Boolean);
   const potentialCandidates = segments.filter(
@@ -312,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;
@@ -347,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)) {
@@ -366,7 +1500,7 @@ 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) {
@@ -374,32 +1508,220 @@ function determineGenericTag(pathString, operation) {
         }
       }
       if (isFirstPartVerb && validParts.length > 1 && validParts[1] && canFallbackToPathSegment) {
-        const secondPartCamel = camelcase(validParts[1]);
+        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 (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;
+    }
+  }
+  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()"
+    }
+  };
+  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']>>;
+  }
+
+  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;"}
     }
-    if (firstCandidate) {
-      return sanitizeTag(camelcase(firstCandidate));
+
+    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"}
   }
-  console.warn(
-    `Could not determine a suitable tag for path: ${pathString}, operationId: ${operationId}. Using 'unknown'.`
-  );
-  return "unknown";
-}
+
+  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, isRef, parseRef } from "@sdk-it/core";
-var ZodDeserialzer = class {
-  circularRefTracker = /* @__PURE__ */ new Set();
+import { cleanRef, followRef as followRef4, isRef as isRef6 } from "@sdk-it/core";
+var ZodEmitter = class {
+  generatedRefs = /* @__PURE__ */ new Set();
   #spec;
   #onRef;
   constructor(spec, onRef) {
@@ -473,15 +1795,14 @@ var ZodDeserialzer = class {
   }
   ref($ref, required) {
     const schemaName = cleanRef($ref).split("/").pop();
-    if (this.circularRefTracker.has(schemaName)) {
+    if (this.generatedRefs.has(schemaName)) {
       return schemaName;
     }
-    this.circularRefTracker.add(schemaName);
+    this.generatedRefs.add(schemaName);
     this.#onRef?.(
       schemaName,
-      this.handle(followRef(this.#spec, $ref), required)
+      this.handle(followRef4(this.#spec, $ref), required)
     );
-    this.circularRefTracker.delete(schemaName);
     return schemaName;
   }
   allOf(schemas, required) {
@@ -509,15 +1830,7 @@ var ZodDeserialzer = class {
     return `z.union([${anyOfSchemas.join(", ")}])${appendOptional(required)}`;
   }
   oneOf(schemas, required) {
-    const oneOfSchemas = schemas.map((sub) => {
-      if (isRef(sub)) {
-        const { model } = parseRef(sub.$ref);
-        if (this.circularRefTracker.has(model)) {
-          return `${model}${appendOptional(required)}`;
-        }
-      }
-      return this.handle(sub, true);
-    });
+    const oneOfSchemas = schemas.map((sub) => this.handle(sub, true));
     if (oneOfSchemas.length === 1) {
       return `${oneOfSchemas[0]}${appendOptional(required)}`;
     }
@@ -537,6 +1850,10 @@ var ZodDeserialzer = class {
    */
   string(schema) {
     let base = "z.string()";
+    if (schema.contentEncoding === "binary") {
+      base = "z.instanceof(Blob)";
+      return base;
+    }
     switch (schema.format) {
       case "date-time":
       case "datetime":
@@ -614,7 +1931,7 @@ var ZodDeserialzer = class {
     return { base, defaultValue };
   }
   handle(schema, required) {
-    if (isRef(schema)) {
+    if (isRef6(schema)) {
       return `${this.ref(schema.$ref, true)}${appendOptional(required)}`;
     }
     if (schema.allOf && Array.isArray(schema.allOf)) {
@@ -660,13 +1977,13 @@ function appendDefault(defaultValue) {
 
 // packages/typescript/src/lib/sdk.ts
 import { get } from "lodash-es";
-import { camelcase as camelcase2, pascalcase, spinalcase } from "stringcase";
-import { followRef as followRef3, isRef as isRef4, toLitObject as toLitObject2 } from "@sdk-it/core";
+import { 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 followRef2, isRef as isRef2, parseRef as parseRef2 } from "@sdk-it/core";
-var TypeScriptDeserialzer = class {
-  circularRefTracker = /* @__PURE__ */ new Set();
+import { cleanRef as cleanRef2, followRef as followRef5, isRef as isRef7 } from "@sdk-it/core";
+var TypeScriptEmitter = class {
+  generatedRefs = /* @__PURE__ */ new Set();
   #spec;
   #onRef;
   constructor(spec, onRef) {
@@ -677,7 +1994,7 @@ var TypeScriptDeserialzer = class {
     return `'${value}'`;
   };
   #isInternal = (schema) => {
-    return isRef2(schema) ? false : !!schema["x-internal"];
+    return isRef7(schema) ? false : !!schema["x-internal"];
   };
   /**
    * Handle objects (properties)
@@ -697,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)
@@ -739,15 +2056,14 @@ var TypeScriptDeserialzer = class {
   }
   ref($ref, required) {
     const schemaName = cleanRef2($ref).split("/").pop();
-    if (this.circularRefTracker.has(schemaName)) {
+    if (this.generatedRefs.has(schemaName)) {
       return schemaName;
     }
-    this.circularRefTracker.add(schemaName);
+    this.generatedRefs.add(schemaName);
     this.#onRef?.(
       schemaName,
-      this.handle(followRef2(this.#spec, $ref), required)
+      this.handle(followRef5(this.#spec, $ref), required)
     );
-    this.circularRefTracker.delete(schemaName);
     return appendOptional2(schemaName, required);
   }
   allOf(schemas) {
@@ -763,12 +2079,6 @@ var TypeScriptDeserialzer = class {
   }
   oneOf(schemas, required) {
     const oneOfTypes = schemas.map((sub) => {
-      if (isRef2(sub)) {
-        const { model } = parseRef2(sub.$ref);
-        if (this.circularRefTracker.has(model)) {
-          return model;
-        }
-      }
       return this.handle(sub, false);
     });
     return appendOptional2(
@@ -785,6 +2095,9 @@ var TypeScriptDeserialzer = class {
    */
   string(schema, required) {
     let type;
+    if (schema.contentEncoding === "binary") {
+      return appendOptional2("Blob", required);
+    }
     switch (schema.format) {
       case "date-time":
       case "datetime":
@@ -811,7 +2124,7 @@ var TypeScriptDeserialzer = class {
     return appendOptional2(type, required);
   }
   handle(schema, required) {
-    if (isRef2(schema)) {
+    if (isRef7(schema)) {
       return this.ref(schema.$ref, required);
     }
     if (schema.allOf && Array.isArray(schema.allOf)) {
@@ -856,8 +2169,8 @@ function appendOptional2(type, isRequired) {
 }
 
 // packages/typescript/src/lib/utils.ts
-import { isRef as isRef3, 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) {
@@ -865,10 +2178,7 @@ function securityToOptions(security2, securitySchemes, staticIn) {
     if (!name) {
       continue;
     }
-    const schema = securitySchemes[name];
-    if (isRef3(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",
@@ -954,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) {
@@ -991,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 = [];
@@ -1024,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 = isRef4(specOperation.responses[status]) ? followRef3(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,
@@ -1050,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",
@@ -1100,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;
@@ -1135,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 = !isRef4(schema) && schema.type === "object";
+    const isObject = !isRef9(schema) && schema.type === "object";
     if (isObject && schema.properties) {
       schema.properties["[http.KIND]"] = {
         "x-internal": true,
@@ -1143,7 +2550,7 @@ function handleResponse(spec, operationName, status, response, utils, numbered)
         type: "string"
       };
       schema.required ??= [];
-      schema.required.push("[KIND]");
+      schema.required.push("[http.KIND]");
     }
     responseSchema = typeScriptDeserialzer.handle(schema, true);
   }
@@ -1176,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,
@@ -1195,41 +2602,41 @@ 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 (isRef5(param)) {
-        throw new Error(`Found reference in parameter ${param.$ref}`);
-      }
+    const additionalProperties = {};
+    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,
         schema: ""
       };
-      additionalProperties.push(param);
+      additionalProperties[param.name] = param;
     }
-    const security2 = operation.security ?? [];
     const securitySchemes = config.spec.components?.securitySchemes ?? {};
-    const securityOptions = securityToOptions(security2, securitySchemes);
-    Object.assign(inputs, securityOptions);
-    additionalProperties.push(
-      ...Object.entries(securityOptions).map(
-        ([name, value]) => ({
-          name,
-          required: false,
-          schema: {
-            type: "string"
-          },
-          in: value.in
-        })
-      )
+    const securityOptions = securityToOptions2(
+      config.spec,
+      operation.security ?? [],
+      securitySchemes
     );
+    Object.assign(inputs, securityOptions);
+    Object.entries(securityOptions).forEach(([name, value]) => {
+      additionalProperties[name] = {
+        name,
+        required: false,
+        schema: {
+          type: "string"
+        },
+        in: value.in
+      };
+    });
     const schemas = {};
     const shortContenTypeMap = {
       "application/json": "json",
@@ -1243,10 +2650,12 @@ function generateCode(config) {
       "text/plain": "text"
     };
     let outgoingContentType;
-    if (!isEmpty(operation.requestBody)) {
-      const requestBody = isRef5(operation.requestBody) ? followRef4(config.spec, operation.requestBody.$ref) : operation.requestBody;
-      for (const type in requestBody.content) {
-        const ctSchema = isRef5(requestBody.content[type].schema) ? followRef4(config.spec, requestBody.content[type].schema.$ref) : requestBody.content[type].schema;
+    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}`
@@ -1257,16 +2666,16 @@ function generateCode(config) {
         if (objectSchema.type !== "object") {
           objectSchema = {
             type: "object",
-            required: [requestBody.required ? "$body" : ""],
+            required: [operation.requestBody.required ? "$body" : ""],
             properties: {
               $body: ctSchema
             }
           };
         }
         const schema = merge({}, objectSchema, {
-          required: additionalProperties.filter((p) => p.required).map((p) => p.name),
-          properties: additionalProperties.reduce(
-            (acc, p) => ({
+          required: Object.values(additionalProperties).filter((p) => p.required).map((p) => p.name),
+          properties: Object.entries(additionalProperties).reduce(
+            (acc, [, p]) => ({
               ...acc,
               [p.name]: p.schema
             }),
@@ -1276,18 +2685,18 @@ 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";
       }
     } else {
-      const properties = additionalProperties.reduce(
-        (acc, p) => ({
+      const properties = Object.entries(additionalProperties).reduce(
+        (acc, [, p]) => ({
           ...acc,
           [p.name]: p.schema
         }),
@@ -1296,7 +2705,7 @@ function generateCode(config) {
       schemas[shortContenTypeMap["application/json"]] = zodDeserialzer.handle(
         {
           type: "object",
-          required: additionalProperties.filter((p) => p.required).map((p) => p.name),
+          required: Object.values(additionalProperties).filter((p) => p.required).map((p) => p.name),
           properties
         },
         true
@@ -1314,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(
@@ -1368,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,
@@ -1391,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")}";
@@ -1421,12 +2826,14 @@ ${allSchemas.map((it) => it.use).join(",\n")}
               join("api", `${spinalcase2(name)}.ts`),
               `${[
                 ...imps,
-                // ...imports,
                 `import z from 'zod';`,
                 `import * as http from '${config.makeImport("../http/response")}';`,
-                `import { toRequest, json, urlencoded, nobody, formdata, createUrl } from '${config.makeImport("../http/request")}';`,
+                `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"
               )}
@@ -1441,8 +2848,8 @@ ${endpoint.flatMap((it) => it.schemas).join(",\n")}
   };
 }
 function toProps(spec, schemaOrRef, aggregator = []) {
-  if (isRef5(schemaOrRef)) {
-    const schema = followRef4(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 ?? {})) {
@@ -1486,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";
 
@@ -1496,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');
@@ -1909,16 +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/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;
+  }
+  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 (schemaObj.additionalProperties && typeof schemaObj.additionalProperties === "object") {
+      result["additionalPropExample"] = this.handle(
+        schemaObj.additionalProperties
+      );
+    }
+    return result;
+  }
+  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;
+  }
+  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 {
+      value = schema.type === "integer" ? 42 : 42.42;
+    }
+    if (typeof schema.exclusiveMaximum === "number" && value >= schema.exclusiveMaximum) {
+      value = schema.exclusiveMaximum - 1;
+    } else if (typeof schema.maximum === "number" && value > schema.maximum) {
+      value = schema.maximum;
+    }
+    if (typeof schema.multipleOf === "number" && value % schema.multipleOf !== 0) {
+      value = Math.floor(value / schema.multipleOf) * schema.multipleOf;
+    }
+    return schema.type === "integer" ? Math.floor(value) : value;
+  }
+  boolean(schema) {
+    if (schema.example !== void 0)
+      return Boolean(schema.example);
+    if (schema.default !== void 0)
+      return Boolean(schema.default);
+    return true;
+  }
+  null() {
+    return null;
+  }
+  ref($ref) {
+    const parts = $ref.split("/");
+    const refKey = parts[parts.length - 1] || "";
+    if (this.cache.has($ref)) {
+      return this.cache.get($ref);
+    }
+    this.cache.set($ref, { _ref: refKey });
+    const resolved = followRef8(this.spec, $ref);
+    const result = this.handle(resolved);
+    this.cache.set($ref, result);
+    return result;
+  }
+  allOf(schemas) {
+    const initial = {};
+    return schemas.reduce((result, schema) => {
+      const example = this.handle(schema);
+      if (typeof example === "object" && example !== null) {
+        return { ...result, ...example };
+      }
+      return result;
+    }, initial);
+  }
+  anyOf(schemas) {
+    if (schemas.length === 0)
+      return {};
+    return this.handle(schemas[0]);
+  }
+  oneOf(schemas) {
+    if (schemas.length === 0)
+      return {};
+    return this.handle(schemas[0]);
+  }
+  enum(schema) {
+    return Array.isArray(schema.enum) && schema.enum.length > 0 ? schema.enum[0] : void 0;
+  }
+  handle(schemaOrRef) {
+    if (isRef11(schemaOrRef)) {
+      return this.ref(schemaOrRef.$ref);
+    }
+    const schema = isRef11(schemaOrRef) ? followRef8(this.spec, schemaOrRef.$ref) : schemaOrRef;
+    if (schema.example !== void 0) {
+      return schema.example;
+    }
+    if (schema.default !== void 0) {
+      return schema.default;
+    }
+    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) && 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) {
+        return this.object(schema);
+      } else if (schema.items) {
+        return this.array(schema);
+      }
+      return "example";
+    }
+    const primaryType = types.find((t) => t !== "null") || types[0];
+    switch (primaryType) {
+      case "string":
+        return this.string(schema);
+      case "number":
+      case "integer":
+        return this.number(schema);
+      case "boolean":
+        return this.boolean(schema);
+      case "object":
+        return this.object(schema);
+      case "array":
+        return this.array(schema);
+      case "null":
+        return this.null();
+      default:
+        return "unknown";
+    }
+  }
+};
+
+// 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 `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"}',
+});`;
+  }
+};
 
 // 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];
@@ -1927,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(
     {},
     {
@@ -1943,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;
   };
@@ -1954,36 +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 || "Client";
+  const clientName = pascalcase4((settings.name || "client").trim());
+  const packageName = settings.name ? `@${spinalcase4(settings.name.trim().toLowerCase())}/sdk` : "sdk";
   const inputFiles = generateInputs(groups, commonZod, makeImport);
-  await writeFiles(output, {
+  await settings.writer(output, {
     "outputs/.gitkeep": "",
     "inputs/.gitkeep": "",
     "models/.getkeep": ""
-    // 'README.md': readme,
   });
-  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,
@@ -2008,47 +3752,114 @@ ${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") {
-    await writeFiles(settings.output, {
+    const configFiles = {
       "package.json": {
         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"
@@ -2080,27 +3891,32 @@ ${template2(send_request_default, {})({ throwError: !style.errorAsValue, outputT
           2
         )
       }
-    });
+    };
+    if (settings.readme) {
+      configFiles["README.md"] = {
+        ignoreIfExists: false,
+        content: toReadme(spec, {
+          generateSnippet: (...args) => generator.snippet(...args)
+        })
+      };
+    }
+    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