@sdk-it/dart 0.19.1 → 0.21.0

package/dist/index.js

@@ -1,30 +1,932 @@
+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, pluralize2) {
+      if (typeof __require === "function" && typeof exports === "object" && typeof module === "object") {
+        module.exports = pluralize2();
+      } else if (typeof define === "function" && define.amd) {
+        define(function() {
+          return pluralize2();
+        });
+      } else {
+        root.pluralize = pluralize2();
+      }
+    })(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 pluralize2(word, count, inclusive) {
+        var pluralized = count === 1 ? pluralize2.singular(word) : pluralize2.plural(word);
+        return (inclusive ? count + " " : "") + pluralized;
+      }
+      pluralize2.plural = replaceWord(
+        irregularSingles,
+        irregularPlurals,
+        pluralRules
+      );
+      pluralize2.isPlural = checkWord(
+        irregularSingles,
+        irregularPlurals,
+        pluralRules
+      );
+      pluralize2.singular = replaceWord(
+        irregularPlurals,
+        irregularSingles,
+        singularRules
+      );
+      pluralize2.isSingular = checkWord(
+        irregularPlurals,
+        irregularSingles,
+        singularRules
+      );
+      pluralize2.addPluralRule = function(rule, replacement) {
+        pluralRules.push([sanitizeRule(rule), replacement]);
+      };
+      pluralize2.addSingularRule = function(rule, replacement) {
+        singularRules.push([sanitizeRule(rule), replacement]);
+      };
+      pluralize2.addUncountableRule = function(word) {
+        if (typeof word === "string") {
+          uncountables[word.toLowerCase()] = true;
+          return;
+        }
+        pluralize2.addPluralRule(word, "$0");
+        pluralize2.addSingularRule(word, "$0");
+      };
+      pluralize2.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 pluralize2.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 pluralize2.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 pluralize2.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(pluralize2.addUncountableRule);
+      return pluralize2;
+    });
+  }
+});
+
 // packages/dart/src/lib/generate.ts
 import { parse as partContentType } from "fast-content-type-parse";
 import { merge as merge2 } from "lodash-es";
 import assert2 from "node:assert";
-import { writeFile } from "node:fs/promises";
+import { readdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { camelcase as camelcase3 } from "stringcase";
 import yaml from "yaml";
 import {
-  followRef as followRef2,
-  getFolderExportsV2,
-  isEmpty as isEmpty2,
-  isRef as isRef2,
+  followRef as followRef3,
+  isEmpty as isEmpty3,
+  isRef as isRef4,
   notRef as notRef2,
   pascalcase as pascalcase2,
-  snakecase as snakecase2,
-  writeFiles
+  snakecase as snakecase2
 } from "@sdk-it/core";
+import {
+  getFolderExportsV2,
+  writeFiles
+} from "@sdk-it/core/file-system.js";
 
-// packages/spec/dist/lib/loaders/local-loader.js
-import { parse } from "yaml";
+// packages/spec/dist/lib/operation.js
+import { camelcase } from "stringcase";
+import { followRef, isRef as isRef2 } from "@sdk-it/core/ref.js";
 
-// packages/spec/dist/lib/loaders/remote-loader.js
-import { parse as parse2 } from "yaml";
+// packages/spec/dist/lib/pagination/pagination.js
+import { isRef } from "@sdk-it/core/ref.js";
+import { isEmpty } from "@sdk-it/core/utils.js";
+
+// packages/spec/dist/lib/pagination/pagination-result.js
+var import_pluralize = __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_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 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);
+      }
+    }
+  }
+  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_pluralize.default.isPlural(propName) && !PLURAL_DEPRIORITIZE_LIST.includes(lowerPropName)) {
+      updateCandidate(propName, 5);
+      continue;
+    }
+    if (candidateRank > 6 && import_pluralize.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_REGEXES) {
+        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_REGEXES) {
+            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/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 && !isRef(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 (isEmpty(operation.parameters) && isEmpty(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 = [], ...methods } = pathItem;
+    const fixedPath = path.replace(/:([^/]+)/g, "{$1}");
+    for (const [method, operation] of Object.entries(methods)) {
+      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 = isRef2(operation.requestBody) ? followRef(config.spec, operation.requestBody.$ref) : operation.requestBody;
+      const tunedOperation = {
+        ...operation,
+        parameters: [...parameters, ...operation.parameters ?? []].map(
+          (it) => isRef2(it) ? followRef(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 isRef2(content[contentType].schema) ? followRef(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 isRef2(content[contentType].schema) ? followRef(spec, content[contentType].schema.$ref) : content[contentType].schema;
+    }
+  }
+  return void 0;
+}
 var defaults = {
   operationId: (operation, path, method) => {
     if (operation.operationId) {
@@ -39,34 +941,35 @@ var defaults = {
     );
   },
   tag: (operation, path) => {
-    return operation.tags?.[0] || determineGenericTag(path, operation);
+    return operation.tags?.[0] ? sanitizeTag(operation.tags?.[0]) : determineGenericTag(path, operation);
   }
 };
+function resolveResponses(spec, operation) {
+  const responses = operation.responses ?? {};
+  const resolved = {};
+  for (const status in responses) {
+    const response = isRef2(responses[status]) ? followRef(spec, responses[status].$ref) : responses[status];
+    resolved[status] = response;
+  }
+  return resolved;
+}
 function forEachOperation(config, callback) {
   const result = [];
   for (const [path, pathItem] of Object.entries(config.spec.paths ?? {})) {
     const { parameters = [], ...methods } = pathItem;
-    const fixedPath = path.replace(/:([^/]+)/g, "{$1}");
     for (const [method, operation] of Object.entries(methods)) {
-      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
         )
       );
     }
@@ -74,15 +977,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",
@@ -90,85 +989,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(camelcase(camelCasedTag)) ? `${camelCasedTag}_` : camelCasedTag;
 }
 function determineGenericTag(pathString, operation) {
   const operationId = operation.operationId || "";
@@ -192,7 +1065,6 @@ function determineGenericTag(pathString, operation) {
     "search",
     "check",
     "make"
-    // Added make
   ]);
   const segments = pathString.split("/").filter(Boolean);
   const potentialCandidates = segments.filter(
@@ -308,6 +1180,68 @@ function isSuccessStatusCode(statusCode) {
   statusCode = Number(statusCode);
   return statusCode >= 200 && statusCode < 300;
 }
+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] = isRef2(param.schema) ? followRef(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] = isRef2(param.schema) ? followRef(spec, param.schema.$ref) : param.schema ?? { type: "string" };
+  }
+}
+function securityToOptions(spec, security, securitySchemes, staticIn) {
+  securitySchemes ??= {};
+  const parameters = [];
+  for (const it of security) {
+    const [name] = Object.keys(it);
+    if (!name) {
+      continue;
+    }
+    const schema = isRef2(securitySchemes[name]) ? followRef(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/spec/dist/lib/loaders/local-loader.js
+import { parse } from "yaml";
+
+// packages/spec/dist/lib/loaders/remote-loader.js
+import { parse as parse2 } from "yaml";
 
 // packages/dart/src/lib/dart-emitter.ts
 import { merge } from "lodash-es";
@@ -315,9 +1249,9 @@ import assert from "node:assert";
 import { camelcase as camelcase2, snakecase } from "stringcase";
 import {
   cleanRef,
-  followRef,
-  isEmpty,
-  isRef,
+  followRef as followRef2,
+  isEmpty as isEmpty2,
+  isRef as isRef3,
   notRef,
   parseRef,
   pascalcase
@@ -365,7 +1299,7 @@ var DartSerializer = class {
     this.#spec.components.schemas ??= {};
     this.#spec.components.responses ??= {};
     const checkSchema = (schema) => {
-      if (isRef(schema)) {
+      if (isRef3(schema)) {
         const { model } = parseRef(schema.$ref);
         return model === schemaName;
       }
@@ -398,7 +1332,7 @@ var DartSerializer = class {
         matches: `json['${camelcase2(context.name)}'] is Map<String, dynamic>`
       };
     }
-    if (isEmpty(schema.properties)) {
+    if (isEmpty2(schema.properties)) {
       if (context.noEmit !== true) {
         this.#emit(
           className,
@@ -571,7 +1505,7 @@ return ${matches.join(" && ")};
     const schemaName = cleanRef($ref).split("/").pop();
     const serialized = this.handle(
       schemaName,
-      followRef(this.#spec, $ref),
+      followRef2(this.#spec, $ref),
       required,
       {
         ...context,
@@ -584,7 +1518,7 @@ return ${matches.join(" && ")};
   // fixme: this method should no longer be needed because the logic in it is being preprocessed before emitting begins
   #allOf(className, schemas, context) {
     const name = pascalcase(context.propName || className);
-    const refs = schemas.filter(isRef);
+    const refs = schemas.filter(isRef3);
     const nonRefs = schemas.filter(notRef);
     if (nonRefs.some((it) => it.type && it.type !== "object")) {
       assert(false, `allOf ${name} must be an object`);
@@ -592,7 +1526,7 @@ return ${matches.join(" && ")};
     const objectSchema = merge(
       {},
       ...nonRefs,
-      ...refs.map((ref) => followRef(this.#spec, ref.$ref))
+      ...refs.map((ref) => followRef2(this.#spec, ref.$ref))
     );
     delete objectSchema.allOf;
     return this.handle(name, objectSchema, true, context);
@@ -608,8 +1542,8 @@ return ${matches.join(" && ")};
       };
     }
     const nullSchemaIndex = schemas.findIndex((schema) => {
-      if (isRef(schema)) {
-        const refSchema = followRef(this.#spec, schema.$ref);
+      if (isRef3(schema)) {
+        const refSchema = followRef2(this.#spec, schema.$ref);
         return refSchema.type === "null";
       }
       return schema.type === "null";
@@ -649,7 +1583,7 @@ return ${matches.join(" && ")};
     const patterns = [];
     const objects = schemas.filter(notRef).filter((it) => it.type === "object");
     for (const schema of schemas) {
-      if (isRef(schema)) {
+      if (isRef3(schema)) {
         const refType = this.#ref(className, schema.$ref, true, context);
         patterns.push({
           pattern: `case ${refType.type || "Map<String, dynamic>"} map when ${refType.use}.matches(map): return ${refType.use}.fromJson(map);`,
@@ -900,7 +1834,7 @@ return false;
     };
   }
   #serialize(className, schema, required = true, context = {}) {
-    if (isRef(schema)) {
+    if (isRef3(schema)) {
       return this.#ref(className, schema.$ref, required, context);
     }
     if (schema.allOf && Array.isArray(schema.allOf)) {
@@ -964,14 +1898,14 @@ return false;
   }
 };
 function isObjectSchema(schema) {
-  return !isRef(schema) && (schema.type === "object" || !!schema.properties);
+  return !isRef3(schema) && (schema.type === "object" || !!schema.properties);
 }
 
 // packages/dart/src/lib/http/dispatcher.txt
 var dispatcher_default = "import 'dart:convert';\nimport 'dart:io';\n\nimport 'package:http/http.dart' as http;\nimport 'package:http_parser/http_parser.dart';\nimport 'package:mime/mime.dart' as mime;\n\nimport './interceptors.dart';\nimport './responses.dart';\n\nclass Dispatcher {\n  final List<Interceptor> interceptors;\n\n  Dispatcher(this.interceptors);\n\n  Future<http.StreamedResponse> multipart(\n    RequestConfig config,\n    Map<String, dynamic> body,\n  ) async {\n    final modifiedConfig = interceptors.fold(\n      config,\n      (acc, interceptor) => interceptor.before(acc),\n    );\n    final request = http.MultipartRequest(\n      modifiedConfig.method,\n      modifiedConfig.url,\n    );\n    request.headers.addAll(modifiedConfig.headers);\n    for (var entry in body.entries) {\n      final key = entry.key;\n      final value = entry.value;\n      if (value is File) {\n        final mimeType = mime.lookupMimeType(value.path);\n        request.files.add(\n          http.MultipartFile(\n            key,\n            value.openRead(),\n            await value.length(),\n            filename: value.uri.pathSegments.last,\n            contentType: mimeType != null ? MediaType.parse(mimeType) : null,\n          ),\n        );\n      } else {\n        request.fields[key] = value.toString();\n      }\n    }\n\n    return request.send();\n  }\n\n  Future<http.StreamedResponse> empty(RequestConfig config) {\n    final modifiedConfig = interceptors.fold(\n      config,\n      (acc, interceptor) => interceptor.before(acc),\n    );\n    final request = http.Request(modifiedConfig.method, modifiedConfig.url);\n    request.headers.addAll(modifiedConfig.headers);\n    return request.send();\n  }\n\n  Future<http.StreamedResponse> json(RequestConfig config, dynamic body) {\n    final modifiedConfig = interceptors.fold(\n      config,\n      (acc, interceptor) => interceptor.before(acc),\n    );\n    final request = http.Request(modifiedConfig.method, modifiedConfig.url);\n    request.headers.addAll(modifiedConfig.headers);\n\n    request.headers['Content-Type'] = 'application/json';\n    if ((body is Map || body is List)) {\n      request.body = jsonEncode(body);\n    } else if (body is String) {\n      request.body = body;\n    } else {\n      throw ArgumentError('Unsupported body type: ${body.runtimeType}');\n    }\n\n    return request.send();\n  }\n}\n\nclass Receiver {\n  final List<Interceptor> interceptors;\n  Receiver(this.interceptors);\n\n  dynamic _parse(http.Response response) {\n    final contentTypeHeader = response.headers['content-type'];\n    final parsed = parseContentType(contentTypeHeader);\n    if (parsed.type == 'application/json') {\n      return jsonDecode(response.body);\n    } else if (parsed.type == 'text/plain') {\n      return response.body;\n    } else if (parsed.type == 'application/octet-stream') {\n      return response.bodyBytes;\n    } else {\n      throw UnsupportedError('Unsupported content type: ${parsed.type}');\n    }\n  }\n\n  dynamic json(http.StreamedResponse stream) async {\n    if (stream.statusCode >= 200 && stream.statusCode < 300) {\n      final response = await http.Response.fromStream(stream);\n      return _parse(response);\n    }\n    switch (stream.statusCode) {\n      case 400:\n        throw BadRequestError('');\n      case 401:\n        throw UnauthorizedError('');\n      case 403:\n        throw ForbiddenError('');\n      case 404:\n        throw NotFoundError('');\n      case 500:\n        throw InternalServerError('');\n      case 402:\n        throw PaymentRequiredError('');\n      case 405:\n        throw MethodNotAllowedError('');\n      case 406:\n        throw NotAcceptableError('');\n      case 409:\n        throw ConflictError('');\n      case 410:\n        throw GoneError('');\n      case 422:\n        throw UnprocessableEntityError('');\n      case 429:\n        throw TooManyRequestsError('');\n      case 413:\n        throw PayloadTooLargeError('');\n      case 415:\n        throw UnsupportedMediaTypeError('');\n      case 501:\n        throw NotImplementedError('');\n      case 502:\n        throw BadGatewayError('');\n      case 503:\n        throw ServiceUnavailableError('');\n      case 504:\n        throw GatewayTimeoutError('');\n      default:\n        throw UnknownApiError('', stream.statusCode);\n    }\n  }\n}\n\n({String type, Map<String, String> parameters}) parseContentType(\n  String? contentTypeHeader,\n) {\n  if (contentTypeHeader == null || contentTypeHeader.isEmpty) {\n    return (type: '', parameters: {});\n  }\n  final parts = contentTypeHeader.split(';');\n  final type = parts[0].trim();\n  final parameters = <String, String>{};\n  for (var i = 1; i < parts.length; i++) {\n    final param = parts[i].split('=');\n    if (param.length == 2) {\n      parameters[param[0].trim()] = param[1].trim();\n    }\n  }\n\n  return (type: type, parameters: parameters);\n}\n";
 
 // packages/dart/src/lib/http/interceptors.txt
-var interceptors_default = "abstract class Interceptor {\n  RequestConfig before(RequestConfig config);\n  void after();\n}\n\nclass BaseUrlInterceptor extends Interceptor {\n  final String Function() getBaseUrl;\n  BaseUrlInterceptor(this.getBaseUrl);\n\n  @override\n  RequestConfig before(RequestConfig config) {\n    final baseUrl = getBaseUrl();\n    if (config.url.scheme.isEmpty) {\n      config.url = Uri.parse(baseUrl + config.url.toString());\n    }\n    return config;\n  }\n\n  @override\n  void after() {\n    //\n  }\n}\n\nclass RequestConfig {\n  final String method;\n  Uri url;\n  final Map<String, String> headers;\n  RequestConfig({required this.method, required this.url, required this.headers});\n}\n";
+var interceptors_default = "abstract class Interceptor {\n  RequestConfig before(RequestConfig config);\n  void after();\n}\n\nclass BaseUrlInterceptor extends Interceptor {\n  final String Function() getBaseUrl;\n  BaseUrlInterceptor(this.getBaseUrl);\n\n  @override\n  RequestConfig before(RequestConfig config) {\n    final baseUrl = getBaseUrl();\n    if (config.url.scheme.isEmpty) {\n      config.url = Uri.parse(baseUrl + config.url.toString());\n    }\n    return config;\n  }\n\n  @override\n  void after() {\n    //\n  }\n}\n\n\nclass LoggingInterceptor extends Interceptor {\n  // ANSI color codes\n  static const String _reset = '\\x1B[0m';\n  static const String _green = '\\x1B[32m';\n  static const String _yellow = '\\x1B[33m';\n  static const String _blue = '\\x1B[34m';\n  static const String _magenta = '\\x1B[35m';\n  static const String _cyan = '\\x1B[36m';\n\n  @override\n  RequestConfig before(RequestConfig config) {\n    print('${_cyan}[LOG] --- HTTP REQUEST ---$_reset');\n    print('${_yellow}[LOG] Method:    ${config.method.toUpperCase()}$_reset');\n    print('${_green}[LOG] URL:       ${config.url}$_reset');\n    print('${_magenta}[ContentType] ${config.headers['content-type']}$_reset');\n    if (config.headers.isNotEmpty) {\n      print('${_blue}[LOG] Headers:   ${config.headers}$_reset');\n    } else {\n      print('${_blue}[LOG] Headers:   <none>$_reset');\n    }\n    print('${_cyan}[LOG] --------------$_reset');\n    return config;\n  }\n\n  @override\n  void after() {\n    // Optionally log after the request\n  }\n}\n\nclass RequestConfig {\n  final String method;\n  Uri url;\n  final Map<String, String> headers;\n  RequestConfig({required this.method, required this.url, required this.headers});\n}\n";
 
 // packages/dart/src/lib/http/responses.txt
 var responses_default = "sealed class ApiError {\n  final String message;\n  final int? statusCode;\n  final String status;\n  const ApiError(this.message, {this.statusCode, this.status = ''});\n\n  @override\n  String toString() =>\n      'ApiError(status: $status, statusCode: $statusCode, message: $message)';\n}\n\nbase class BadRequestError extends ApiError {\n  const BadRequestError(String message)\n    : super(message, statusCode: 400, status: 'BadRequest');\n}\n\nbase class UnauthorizedError extends ApiError {\n  const UnauthorizedError(String message)\n    : super(message, statusCode: 401, status: 'Unauthorized');\n}\n\nbase class ForbiddenError extends ApiError {\n  const ForbiddenError(String message)\n    : super(message, statusCode: 403, status: 'Forbidden');\n}\n\nbase class NotFoundError extends ApiError {\n  const NotFoundError(String message)\n    : super(message, statusCode: 404, status: 'NotFound');\n}\n\nbase class InternalServerError extends ApiError {\n  const InternalServerError(String message)\n    : super(message, statusCode: 500, status: 'InternalServerError');\n}\n\nbase class UnknownApiError extends ApiError {\n  const UnknownApiError(String message, int statusCode)\n    : super(message, statusCode: statusCode, status: 'UnknownApiError');\n}\n\nbase class PaymentRequiredError extends ApiError {\n  const PaymentRequiredError(String message)\n    : super(message, statusCode: 402, status: 'PaymentRequired');\n}\n\nbase class MethodNotAllowedError extends ApiError {\n  const MethodNotAllowedError(String message)\n    : super(message, statusCode: 405, status: 'MethodNotAllowed');\n}\n\nbase class NotAcceptableError extends ApiError {\n  const NotAcceptableError(String message)\n    : super(message, statusCode: 406, status: 'NotAcceptable');\n}\n\nbase class ConflictError extends ApiError {\n  const ConflictError(String message)\n    : super(message, statusCode: 409, status: 'Conflict');\n}\n\nbase class GoneError extends ApiError {\n  const GoneError(String message)\n    : super(message, statusCode: 410, status: 'Gone');\n}\n\nbase class UnprocessableEntityError extends ApiError {\n  const UnprocessableEntityError(String message)\n    : super(message, statusCode: 422, status: 'UnprocessableEntity');\n}\n\nbase class TooManyRequestsError extends ApiError {\n  const TooManyRequestsError(String message)\n    : super(message, statusCode: 429, status: 'TooManyRequests');\n}\n\nbase class PayloadTooLargeError extends ApiError {\n  const PayloadTooLargeError(String message)\n    : super(message, statusCode: 413, status: 'PayloadTooLarge');\n}\n\nbase class UnsupportedMediaTypeError extends ApiError {\n  const UnsupportedMediaTypeError(String message)\n    : super(message, statusCode: 415, status: 'UnsupportedMediaType');\n}\n\nbase class NotImplementedError extends ApiError {\n  const NotImplementedError(String message)\n    : super(message, statusCode: 501, status: 'NotImplemented');\n}\n\nbase class BadGatewayError extends ApiError {\n  const BadGatewayError(String message)\n    : super(message, statusCode: 502, status: 'BadGateway');\n}\n\nbase class ServiceUnavailableError extends ApiError {\n  const ServiceUnavailableError(String message)\n    : super(message, statusCode: 503, status: 'ServiceUnavailable');\n}\n\nbase class GatewayTimeoutError extends ApiError {\n  const GatewayTimeoutError(String message)\n    : super(message, statusCode: 504, status: 'GatewayTimeout');\n}\n";
@@ -979,14 +1913,14 @@ var responses_default = "sealed class ApiError {\n  final String message;\n  fin
 // packages/dart/src/lib/generate.ts
 function tuneSpec(spec, schemas, refs) {
   for (const [name, schema] of Object.entries(schemas)) {
-    if (isRef2(schema))
+    if (isRef4(schema))
       continue;
-    if (!isEmpty2(schema.anyOf) && !isEmpty2(schema.oneOf)) {
+    if (!isEmpty3(schema.anyOf) && !isEmpty3(schema.oneOf)) {
       delete schema.anyOf;
     }
-    if (!isEmpty2(schema.allOf)) {
+    if (!isEmpty3(schema.allOf)) {
       const schemas2 = schema.allOf;
-      const refs2 = schemas2.filter(isRef2);
+      const refs2 = schemas2.filter(isRef4);
       const nonRefs = schemas2.filter(notRef2);
       if (nonRefs.some((it) => it.type && it.type !== "object")) {
         assert2(false, `allOf ${name} must be an object`);
@@ -994,19 +1928,19 @@ function tuneSpec(spec, schemas, refs) {
       const objectSchema = merge2(
         {},
         ...nonRefs,
-        ...refs2.map((ref) => followRef2(spec, ref.$ref))
+        ...refs2.map((ref) => followRef3(spec, ref.$ref))
       );
       delete objectSchema.allOf;
       delete schema.allOf;
       Object.assign(schema, objectSchema);
     }
     if (schema.type === "object") {
-      if (!isEmpty2(schema.oneOf)) {
+      if (!isEmpty3(schema.oneOf)) {
         for (const oneOfIdx in schema.oneOf) {
           const oneOf = schema.oneOf[oneOfIdx];
-          if (isRef2(oneOf))
+          if (isRef4(oneOf))
             continue;
-          if (!isEmpty2(oneOf.required) && schema.properties) {
+          if (!isEmpty3(oneOf.required) && schema.properties) {
             schema.oneOf[oneOfIdx] = schema.properties[oneOf.required[0]];
           }
         }
@@ -1016,7 +1950,7 @@ function tuneSpec(spec, schemas, refs) {
       }
       schema.properties ??= {};
       for (const [propName, value] of Object.entries(schema.properties)) {
-        if (isRef2(value))
+        if (isRef4(value))
           continue;
         const refName = pascalcase2(`${name} ${propName.replace("[]", "")}`);
         refs.push({ name: refName, value });
@@ -1031,7 +1965,7 @@ function tuneSpec(spec, schemas, refs) {
         tuneSpec(spec, props, refs);
       }
     } else if (schema.type === "array") {
-      if (isRef2(schema.items))
+      if (isRef4(schema.items))
         continue;
       const refName = name;
       refs.push({ name: refName, value: schema.items ?? {} });
@@ -1042,6 +1976,16 @@ function tuneSpec(spec, schemas, refs) {
   }
 }
 async function generate(spec, settings) {
+  spec = "x-sdk-augmented" in spec ? spec : augmentSpec({ spec });
+  settings.writer ??= writeFiles;
+  settings.readFolder ??= async (folder) => {
+    const files = await readdir(folder, { withFileTypes: true });
+    return files.map((file) => ({
+      fileName: file.name,
+      filePath: join(file.parentPath, file.name),
+      isFolder: file.isDirectory()
+    }));
+  };
   const clientName = settings.name || "Client";
   const output = join(settings.output, "lib");
   const groups = {};
@@ -1056,15 +2000,16 @@ async function generate(spec, settings) {
     for (const status in operation.responses) {
       if (!isSuccessStatusCode(status))
         continue;
-      const response2 = isRef2(operation.responses[status]) ? followRef2(spec, operation.responses[status].$ref) : operation.responses[status];
-      if (!isEmpty2(response2.content)) {
+      const response2 = operation.responses[status];
+      if (!isEmpty3(response2.content)) {
         for (const [contentType, mediaType] of Object.entries(
           response2.content
         )) {
           if (parseJsonContentType(contentType)) {
-            if (mediaType.schema && !isRef2(mediaType.schema)) {
+            if (mediaType.schema && !isRef4(mediaType.schema)) {
               const outputName = pascalcase2(`${operation.operationId} output`);
               spec.components.schemas[outputName] = mediaType.schema;
+              operation.responses[status].content ??= {};
               operation.responses[status].content[contentType].schema = {
                 $ref: `#/components/schemas/${outputName}`
               };
@@ -1086,7 +2031,7 @@ async function generate(spec, settings) {
     }
     group.methods.push(`
         Future<${response ? response.returnType : "http.StreamedResponse"}> ${camelcase3(operation.operationId)}(
-       ${isEmpty2(operation.requestBody) ? "" : `${input.inputName} input`}
+       ${isEmpty3(operation.requestBody) ? "" : `${input.inputName} input`}
         ) async {
           final stream = await this.dispatcher.${input.contentType}(RequestConfig(
             method: '${entry.method}',
@@ -1151,7 +2096,7 @@ import './http.dart';
 ${Object.keys(groups).map((name) => `late final ${pascalcase2(name)}Client ${camelcase3(name)};`).join("\n")}
 
   ${clientName}(this.options) {
-    final interceptors = [BaseUrlInterceptor(() => this.options.baseUrl)];
+    final interceptors = [BaseUrlInterceptor(() => this.options.baseUrl), LoggingInterceptor()];
     final dispatcher = Dispatcher(interceptors);
     final receiver = Receiver(interceptors);
     ${Object.keys(groups).map(
@@ -1174,39 +2119,55 @@ class Options {
 }
 
   `;
-  await writeFiles(output, {
+  await settings.writer(output, {
     ...models,
     ...inputs,
     ...outputs
   });
-  await writeFiles(output, {
-    "models/index.dart": await getFolderExportsV2(join(output, "models"), {
-      exportSyntax: "export",
-      extensions: "dart"
-    }),
-    "inputs/index.dart": await getFolderExportsV2(join(output, "inputs"), {
-      exportSyntax: "export",
-      extensions: "dart"
-    }),
-    "outputs/index.dart": await getFolderExportsV2(join(output, "outputs"), {
-      exportSyntax: "export",
-      extensions: "dart"
-    }),
+  await settings.writer(output, {
+    "models/index.dart": await getFolderExportsV2(
+      join(output, "models"),
+      settings.readFolder,
+      {
+        exportSyntax: "export",
+        extensions: "dart"
+      }
+    ),
+    "inputs/index.dart": await getFolderExportsV2(
+      join(output, "inputs"),
+      settings.readFolder,
+      {
+        exportSyntax: "export",
+        extensions: "dart"
+      }
+    ),
+    "outputs/index.dart": await getFolderExportsV2(
+      join(output, "outputs"),
+      settings.readFolder,
+      {
+        exportSyntax: "export",
+        extensions: "dart"
+      }
+    ),
     "interceptors.dart": interceptors_default,
     "http.dart": dispatcher_default,
     "responses.dart": responses_default,
     ...clazzez
   });
-  await writeFiles(output, {
-    "package.dart": `${await getFolderExportsV2(join(output), {
-      exportSyntax: "export",
-      extensions: "dart",
-      ignore(dirent) {
-        return dirent.isFile() && dirent.name === "package.dart";
+  await settings.writer(output, {
+    "package.dart": `${await getFolderExportsV2(
+      join(output),
+      settings.readFolder,
+      {
+        exportSyntax: "export",
+        extensions: "dart",
+        ignore(dirent) {
+          return !dirent.isFolder && dirent.fileName === "package.dart";
+        }
       }
-    })}${client}`
+    )}${client}`
   });
-  await writeFiles(settings.output, {
+  await settings.writer(settings.output, {
     "pubspec.yaml": {
       ignoreIfExists: true,
       content: yaml.stringify({
@@ -1231,16 +2192,18 @@ function toInputs(spec, { entry, operation }) {
   const inputName = pascalcase2(`${operation.operationId} input`);
   let contentType = "empty";
   let encode = "";
-  if (!isEmpty2(operation.requestBody)) {
-    const requestBody = isRef2(operation.requestBody) ? followRef2(spec, operation.requestBody.$ref) : operation.requestBody;
-    for (const type in requestBody.content) {
-      const ctSchema = isRef2(requestBody.content[type].schema) ? followRef2(spec, requestBody.content[type].schema.$ref) : requestBody.content[type].schema;
+  if (!isEmpty3(operation.requestBody)) {
+    for (const type in operation.requestBody.content) {
+      const ctSchema = isRef4(operation.requestBody.content[type].schema) ? followRef3(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}`
         );
         continue;
       }
+      ctSchema.properties ??= {};
+      ctSchema.required ??= [];
+      patchParameters(spec, ctSchema, operation);
       const serializer = new DartSerializer(spec, (name, content) => {
         inputs[join(`inputs/${name}.dart`)] = `import 'dart:io';import 'dart:typed_data';import '../models/index.dart'; import './index.dart';
 
@@ -1257,6 +2220,20 @@ ${content}`;
         contentType = mediaType;
       }
     }
+  } else {
+    const ctSchema = {
+      type: "object"
+    };
+    patchParameters(spec, ctSchema, operation);
+    const serializer = new DartSerializer(spec, (name, content) => {
+      inputs[join(`inputs/${name}.dart`)] = `import 'dart:io';import 'dart:typed_data';import '../models/index.dart'; import './index.dart';
+
+${content}`;
+    });
+    const serialized = serializer.handle(inputName, ctSchema, true, {
+      alias: isObjectSchema(ctSchema) ? void 0 : inputName
+    });
+    encode = serialized.encode;
   }
   return { inputs, inputName, contentType, encode };
 }
@@ -1265,7 +2242,7 @@ function toOutput(spec, operation) {
   operation.responses ??= {};
   const outputs = {};
   for (const status in operation.responses) {
-    const response = isRef2(operation.responses[status]) ? followRef2(spec, operation.responses[status].$ref) : operation.responses[status];
+    const response = isRef4(operation.responses[status]) ? followRef3(spec, operation.responses[status].$ref) : operation.responses[status];
     for (const type in response.content) {
       const { schema } = response.content[type];
       if (!schema) {